/**
 * @mui/material v5.16.14
 *
 * @license MIT
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('react-dom')) :
  typeof define === 'function' && define.amd ? define(['exports', 'react', 'react-dom'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.MaterialUI = {}, global.React, global.ReactDOM));
})(this, (function (exports, React, ReactDOM) { 'use strict';

  'use client';

  function _interopNamespaceDefault(e) {
    var n = Object.create(null);
    if (e) {
      Object.keys(e).forEach(function (k) {
        if (k !== 'default') {
          var d = Object.getOwnPropertyDescriptor(e, k);
          Object.defineProperty(n, k, d.get ? d : {
            enumerable: true,
            get: function () { return e[k]; }
          });
        }
      });
    }
    n.default = e;
    return Object.freeze(n);
  }

  var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
  var ReactDOM__namespace = /*#__PURE__*/_interopNamespaceDefault(ReactDOM);

  var common = {
    black: '#000',
    white: '#fff'
  };
  var common$1 = common;

  var red = {
    50: '#ffebee',
    100: '#ffcdd2',
    200: '#ef9a9a',
    300: '#e57373',
    400: '#ef5350',
    500: '#f44336',
    600: '#e53935',
    700: '#d32f2f',
    800: '#c62828',
    900: '#b71c1c',
    A100: '#ff8a80',
    A200: '#ff5252',
    A400: '#ff1744',
    A700: '#d50000'
  };
  var red$1 = red;

  var pink = {
    50: '#fce4ec',
    100: '#f8bbd0',
    200: '#f48fb1',
    300: '#f06292',
    400: '#ec407a',
    500: '#e91e63',
    600: '#d81b60',
    700: '#c2185b',
    800: '#ad1457',
    900: '#880e4f',
    A100: '#ff80ab',
    A200: '#ff4081',
    A400: '#f50057',
    A700: '#c51162'
  };
  var pink$1 = pink;

  var purple = {
    50: '#f3e5f5',
    100: '#e1bee7',
    200: '#ce93d8',
    300: '#ba68c8',
    400: '#ab47bc',
    500: '#9c27b0',
    600: '#8e24aa',
    700: '#7b1fa2',
    800: '#6a1b9a',
    900: '#4a148c',
    A100: '#ea80fc',
    A200: '#e040fb',
    A400: '#d500f9',
    A700: '#aa00ff'
  };
  var purple$1 = purple;

  var deepPurple = {
    50: '#ede7f6',
    100: '#d1c4e9',
    200: '#b39ddb',
    300: '#9575cd',
    400: '#7e57c2',
    500: '#673ab7',
    600: '#5e35b1',
    700: '#512da8',
    800: '#4527a0',
    900: '#311b92',
    A100: '#b388ff',
    A200: '#7c4dff',
    A400: '#651fff',
    A700: '#6200ea'
  };
  var deepPurple$1 = deepPurple;

  var indigo = {
    50: '#e8eaf6',
    100: '#c5cae9',
    200: '#9fa8da',
    300: '#7986cb',
    400: '#5c6bc0',
    500: '#3f51b5',
    600: '#3949ab',
    700: '#303f9f',
    800: '#283593',
    900: '#1a237e',
    A100: '#8c9eff',
    A200: '#536dfe',
    A400: '#3d5afe',
    A700: '#304ffe'
  };
  var indigo$1 = indigo;

  var blue = {
    50: '#e3f2fd',
    100: '#bbdefb',
    200: '#90caf9',
    300: '#64b5f6',
    400: '#42a5f5',
    500: '#2196f3',
    600: '#1e88e5',
    700: '#1976d2',
    800: '#1565c0',
    900: '#0d47a1',
    A100: '#82b1ff',
    A200: '#448aff',
    A400: '#2979ff',
    A700: '#2962ff'
  };
  var blue$1 = blue;

  var lightBlue = {
    50: '#e1f5fe',
    100: '#b3e5fc',
    200: '#81d4fa',
    300: '#4fc3f7',
    400: '#29b6f6',
    500: '#03a9f4',
    600: '#039be5',
    700: '#0288d1',
    800: '#0277bd',
    900: '#01579b',
    A100: '#80d8ff',
    A200: '#40c4ff',
    A400: '#00b0ff',
    A700: '#0091ea'
  };
  var lightBlue$1 = lightBlue;

  var cyan = {
    50: '#e0f7fa',
    100: '#b2ebf2',
    200: '#80deea',
    300: '#4dd0e1',
    400: '#26c6da',
    500: '#00bcd4',
    600: '#00acc1',
    700: '#0097a7',
    800: '#00838f',
    900: '#006064',
    A100: '#84ffff',
    A200: '#18ffff',
    A400: '#00e5ff',
    A700: '#00b8d4'
  };
  var cyan$1 = cyan;

  var teal = {
    50: '#e0f2f1',
    100: '#b2dfdb',
    200: '#80cbc4',
    300: '#4db6ac',
    400: '#26a69a',
    500: '#009688',
    600: '#00897b',
    700: '#00796b',
    800: '#00695c',
    900: '#004d40',
    A100: '#a7ffeb',
    A200: '#64ffda',
    A400: '#1de9b6',
    A700: '#00bfa5'
  };
  var teal$1 = teal;

  var green = {
    50: '#e8f5e9',
    100: '#c8e6c9',
    200: '#a5d6a7',
    300: '#81c784',
    400: '#66bb6a',
    500: '#4caf50',
    600: '#43a047',
    700: '#388e3c',
    800: '#2e7d32',
    900: '#1b5e20',
    A100: '#b9f6ca',
    A200: '#69f0ae',
    A400: '#00e676',
    A700: '#00c853'
  };
  var green$1 = green;

  var lightGreen = {
    50: '#f1f8e9',
    100: '#dcedc8',
    200: '#c5e1a5',
    300: '#aed581',
    400: '#9ccc65',
    500: '#8bc34a',
    600: '#7cb342',
    700: '#689f38',
    800: '#558b2f',
    900: '#33691e',
    A100: '#ccff90',
    A200: '#b2ff59',
    A400: '#76ff03',
    A700: '#64dd17'
  };
  var lightGreen$1 = lightGreen;

  var lime = {
    50: '#f9fbe7',
    100: '#f0f4c3',
    200: '#e6ee9c',
    300: '#dce775',
    400: '#d4e157',
    500: '#cddc39',
    600: '#c0ca33',
    700: '#afb42b',
    800: '#9e9d24',
    900: '#827717',
    A100: '#f4ff81',
    A200: '#eeff41',
    A400: '#c6ff00',
    A700: '#aeea00'
  };
  var lime$1 = lime;

  var yellow = {
    50: '#fffde7',
    100: '#fff9c4',
    200: '#fff59d',
    300: '#fff176',
    400: '#ffee58',
    500: '#ffeb3b',
    600: '#fdd835',
    700: '#fbc02d',
    800: '#f9a825',
    900: '#f57f17',
    A100: '#ffff8d',
    A200: '#ffff00',
    A400: '#ffea00',
    A700: '#ffd600'
  };
  var yellow$1 = yellow;

  var amber = {
    50: '#fff8e1',
    100: '#ffecb3',
    200: '#ffe082',
    300: '#ffd54f',
    400: '#ffca28',
    500: '#ffc107',
    600: '#ffb300',
    700: '#ffa000',
    800: '#ff8f00',
    900: '#ff6f00',
    A100: '#ffe57f',
    A200: '#ffd740',
    A400: '#ffc400',
    A700: '#ffab00'
  };
  var amber$1 = amber;

  var orange = {
    50: '#fff3e0',
    100: '#ffe0b2',
    200: '#ffcc80',
    300: '#ffb74d',
    400: '#ffa726',
    500: '#ff9800',
    600: '#fb8c00',
    700: '#f57c00',
    800: '#ef6c00',
    900: '#e65100',
    A100: '#ffd180',
    A200: '#ffab40',
    A400: '#ff9100',
    A700: '#ff6d00'
  };
  var orange$1 = orange;

  var deepOrange = {
    50: '#fbe9e7',
    100: '#ffccbc',
    200: '#ffab91',
    300: '#ff8a65',
    400: '#ff7043',
    500: '#ff5722',
    600: '#f4511e',
    700: '#e64a19',
    800: '#d84315',
    900: '#bf360c',
    A100: '#ff9e80',
    A200: '#ff6e40',
    A400: '#ff3d00',
    A700: '#dd2c00'
  };
  var deepOrange$1 = deepOrange;

  var brown = {
    50: '#efebe9',
    100: '#d7ccc8',
    200: '#bcaaa4',
    300: '#a1887f',
    400: '#8d6e63',
    500: '#795548',
    600: '#6d4c41',
    700: '#5d4037',
    800: '#4e342e',
    900: '#3e2723',
    A100: '#d7ccc8',
    A200: '#bcaaa4',
    A400: '#8d6e63',
    A700: '#5d4037'
  };
  var brown$1 = brown;

  var grey = {
    50: '#fafafa',
    100: '#f5f5f5',
    200: '#eeeeee',
    300: '#e0e0e0',
    400: '#bdbdbd',
    500: '#9e9e9e',
    600: '#757575',
    700: '#616161',
    800: '#424242',
    900: '#212121',
    A100: '#f5f5f5',
    A200: '#eeeeee',
    A400: '#bdbdbd',
    A700: '#616161'
  };
  var grey$1 = grey;

  var blueGrey = {
    50: '#eceff1',
    100: '#cfd8dc',
    200: '#b0bec5',
    300: '#90a4ae',
    400: '#78909c',
    500: '#607d8b',
    600: '#546e7a',
    700: '#455a64',
    800: '#37474f',
    900: '#263238',
    A100: '#cfd8dc',
    A200: '#b0bec5',
    A400: '#78909c',
    A700: '#455a64'
  };
  var blueGrey$1 = blueGrey;

  var index = /*#__PURE__*/Object.freeze({
    __proto__: null,
    amber: amber$1,
    blue: blue$1,
    blueGrey: blueGrey$1,
    brown: brown$1,
    common: common$1,
    cyan: cyan$1,
    deepOrange: deepOrange$1,
    deepPurple: deepPurple$1,
    green: green$1,
    grey: grey$1,
    indigo: indigo$1,
    lightBlue: lightBlue$1,
    lightGreen: lightGreen$1,
    lime: lime$1,
    orange: orange$1,
    pink: pink$1,
    purple: purple$1,
    red: red$1,
    teal: teal$1,
    yellow: yellow$1
  });

  var global$1 = (typeof global !== "undefined" ? global :
              typeof self !== "undefined" ? self :
              typeof window !== "undefined" ? window : {});

  // from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js
  var performance$1 = global$1.performance || {};
  performance$1.now        ||
    performance$1.mozNow     ||
    performance$1.msNow      ||
    performance$1.oNow       ||
    performance$1.webkitNow  ||
    function(){ return (new Date()).getTime() };

  var THEME_ID = '$$material';

  function _typeof(o) {
    "@babel/helpers - typeof";

    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, r) {
    if ("object" != _typeof(t) || !t) return t;
    var e = t[Symbol.toPrimitive];
    if (void 0 !== e) {
      var i = e.call(t, r || "default");
      if ("object" != _typeof(i)) return i;
      throw new TypeError("@@toPrimitive must return a primitive value.");
    }
    return ("string" === r ? String : Number)(t);
  }

  function toPropertyKey(t) {
    var i = toPrimitive(t, "string");
    return "symbol" == _typeof(i) ? i : String(i);
  }

  function _defineProperty(obj, key, value) {
    key = toPropertyKey(key);
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }
    return obj;
  }

  function _extends() {
    _extends = Object.assign ? Object.assign.bind() : function (target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];
        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }
      return target;
    };
    return _extends.apply(this, arguments);
  }

  function _objectWithoutPropertiesLoose(source, excluded) {
    if (source == null) return {};
    var target = {};
    var sourceKeys = Object.keys(source);
    var key, i;
    for (i = 0; i < sourceKeys.length; i++) {
      key = sourceKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      target[key] = source[key];
    }
    return target;
  }

  function _objectWithoutProperties(source, excluded) {
    if (source == null) return {};
    var target = _objectWithoutPropertiesLoose(source, excluded);
    var key, i;
    if (Object.getOwnPropertySymbols) {
      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
      for (i = 0; i < sourceSymbolKeys.length; i++) {
        key = sourceSymbolKeys[i];
        if (excluded.indexOf(key) >= 0) continue;
        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
        target[key] = source[key];
      }
    }
    return target;
  }

  var isDevelopment$3 = false;

  /*

  Based off glamor's StyleSheet, thanks Sunil ❤️

  high performance StyleSheet for css-in-js systems

  - uses multiple style tags behind the scenes for millions of rules
  - uses `insertRule` for appending in production for *much* faster performance

  // usage

  import { StyleSheet } from '@emotion/sheet'

  let styleSheet = new StyleSheet({ key: '', container: document.head })

  styleSheet.insert('#box { border: 1px solid red; }')
  - appends a css rule into the stylesheet

  styleSheet.flush()
  - empties the stylesheet of all its contents

  */

  function sheetForTag(tag) {
    if (tag.sheet) {
      return tag.sheet;
    } // this weirdness brought to you by firefox

    /* istanbul ignore next */


    for (var i = 0; i < document.styleSheets.length; i++) {
      if (document.styleSheets[i].ownerNode === tag) {
        return document.styleSheets[i];
      }
    } // this function should always return with a value
    // TS can't understand it though so we make it stop complaining here


    return undefined;
  }

  function createStyleElement(options) {
    var tag = document.createElement('style');
    tag.setAttribute('data-emotion', options.key);

    if (options.nonce !== undefined) {
      tag.setAttribute('nonce', options.nonce);
    }

    tag.appendChild(document.createTextNode(''));
    tag.setAttribute('data-s', '');
    return tag;
  }

  var StyleSheet = /*#__PURE__*/function () {
    // Using Node instead of HTMLElement since container may be a ShadowRoot
    function StyleSheet(options) {
      var _this = this;

      this._insertTag = function (tag) {
        var before;

        if (_this.tags.length === 0) {
          if (_this.insertionPoint) {
            before = _this.insertionPoint.nextSibling;
          } else if (_this.prepend) {
            before = _this.container.firstChild;
          } else {
            before = _this.before;
          }
        } else {
          before = _this.tags[_this.tags.length - 1].nextSibling;
        }

        _this.container.insertBefore(tag, before);

        _this.tags.push(tag);
      };

      this.isSpeedy = options.speedy === undefined ? !isDevelopment$3 : options.speedy;
      this.tags = [];
      this.ctr = 0;
      this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets

      this.key = options.key;
      this.container = options.container;
      this.prepend = options.prepend;
      this.insertionPoint = options.insertionPoint;
      this.before = null;
    }

    var _proto = StyleSheet.prototype;

    _proto.hydrate = function hydrate(nodes) {
      nodes.forEach(this._insertTag);
    };

    _proto.insert = function insert(rule) {
      // the max length is how many rules we have per style tag, it's 65000 in speedy mode
      // it's 1 in dev because we insert source maps that map a single rule to a location
      // and you can only have one source map per style tag
      if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {
        this._insertTag(createStyleElement(this));
      }

      var tag = this.tags[this.tags.length - 1];

      if (this.isSpeedy) {
        var sheet = sheetForTag(tag);

        try {
          // this is the ultrafast version, works across browsers
          // the big drawback is that the css won't be editable in devtools
          sheet.insertRule(rule, sheet.cssRules.length);
        } catch (e) {
        }
      } else {
        tag.appendChild(document.createTextNode(rule));
      }

      this.ctr++;
    };

    _proto.flush = function flush() {
      this.tags.forEach(function (tag) {
        var _tag$parentNode;

        return (_tag$parentNode = tag.parentNode) == null ? void 0 : _tag$parentNode.removeChild(tag);
      });
      this.tags = [];
      this.ctr = 0;
    };

    return StyleSheet;
  }();

  var MS = '-ms-';
  var MOZ = '-moz-';
  var WEBKIT = '-webkit-';

  var COMMENT = 'comm';
  var RULESET = 'rule';
  var DECLARATION = 'decl';
  var IMPORT = '@import';
  var KEYFRAMES = '@keyframes';
  var LAYER = '@layer';

  /**
   * @param {number}
   * @return {number}
   */
  var abs = Math.abs;

  /**
   * @param {number}
   * @return {string}
   */
  var from = String.fromCharCode;

  /**
   * @param {object}
   * @return {object}
   */
  var assign = Object.assign;

  /**
   * @param {string} value
   * @param {number} length
   * @return {number}
   */
  function hash$2 (value, length) {
  	return charat(value, 0) ^ 45 ? (((((((length << 2) ^ charat(value, 0)) << 2) ^ charat(value, 1)) << 2) ^ charat(value, 2)) << 2) ^ charat(value, 3) : 0
  }

  /**
   * @param {string} value
   * @return {string}
   */
  function trim (value) {
  	return value.trim()
  }

  /**
   * @param {string} value
   * @param {RegExp} pattern
   * @return {string?}
   */
  function match (value, pattern) {
  	return (value = pattern.exec(value)) ? value[0] : value
  }

  /**
   * @param {string} value
   * @param {(string|RegExp)} pattern
   * @param {string} replacement
   * @return {string}
   */
  function replace (value, pattern, replacement) {
  	return value.replace(pattern, replacement)
  }

  /**
   * @param {string} value
   * @param {string} search
   * @return {number}
   */
  function indexof (value, search) {
  	return value.indexOf(search)
  }

  /**
   * @param {string} value
   * @param {number} index
   * @return {number}
   */
  function charat (value, index) {
  	return value.charCodeAt(index) | 0
  }

  /**
   * @param {string} value
   * @param {number} begin
   * @param {number} end
   * @return {string}
   */
  function substr (value, begin, end) {
  	return value.slice(begin, end)
  }

  /**
   * @param {string} value
   * @return {number}
   */
  function strlen (value) {
  	return value.length
  }

  /**
   * @param {any[]} value
   * @return {number}
   */
  function sizeof (value) {
  	return value.length
  }

  /**
   * @param {any} value
   * @param {any[]} array
   * @return {any}
   */
  function append (value, array) {
  	return array.push(value), value
  }

  /**
   * @param {string[]} array
   * @param {function} callback
   * @return {string}
   */
  function combine (array, callback) {
  	return array.map(callback).join('')
  }

  var line = 1;
  var column = 1;
  var length = 0;
  var position = 0;
  var character = 0;
  var characters = '';

  /**
   * @param {string} value
   * @param {object | null} root
   * @param {object | null} parent
   * @param {string} type
   * @param {string[] | string} props
   * @param {object[] | string} children
   * @param {number} length
   */
  function node (value, root, parent, type, props, children, length) {
  	return {value: value, root: root, parent: parent, type: type, props: props, children: children, line: line, column: column, length: length, return: ''}
  }

  /**
   * @param {object} root
   * @param {object} props
   * @return {object}
   */
  function copy (root, props) {
  	return assign(node('', null, null, '', null, null, 0), root, {length: -root.length}, props)
  }

  /**
   * @return {number}
   */
  function char () {
  	return character
  }

  /**
   * @return {number}
   */
  function prev () {
  	character = position > 0 ? charat(characters, --position) : 0;

  	if (column--, character === 10)
  		column = 1, line--;

  	return character
  }

  /**
   * @return {number}
   */
  function next () {
  	character = position < length ? charat(characters, position++) : 0;

  	if (column++, character === 10)
  		column = 1, line++;

  	return character
  }

  /**
   * @return {number}
   */
  function peek () {
  	return charat(characters, position)
  }

  /**
   * @return {number}
   */
  function caret () {
  	return position
  }

  /**
   * @param {number} begin
   * @param {number} end
   * @return {string}
   */
  function slice (begin, end) {
  	return substr(characters, begin, end)
  }

  /**
   * @param {number} type
   * @return {number}
   */
  function token (type) {
  	switch (type) {
  		// \0 \t \n \r \s whitespace token
  		case 0: case 9: case 10: case 13: case 32:
  			return 5
  		// ! + , / > @ ~ isolate token
  		case 33: case 43: case 44: case 47: case 62: case 64: case 126:
  		// ; { } breakpoint token
  		case 59: case 123: case 125:
  			return 4
  		// : accompanied token
  		case 58:
  			return 3
  		// " ' ( [ opening delimit token
  		case 34: case 39: case 40: case 91:
  			return 2
  		// ) ] closing delimit token
  		case 41: case 93:
  			return 1
  	}

  	return 0
  }

  /**
   * @param {string} value
   * @return {any[]}
   */
  function alloc (value) {
  	return line = column = 1, length = strlen(characters = value), position = 0, []
  }

  /**
   * @param {any} value
   * @return {any}
   */
  function dealloc (value) {
  	return characters = '', value
  }

  /**
   * @param {number} type
   * @return {string}
   */
  function delimit (type) {
  	return trim(slice(position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)))
  }

  /**
   * @param {number} type
   * @return {string}
   */
  function whitespace (type) {
  	while (character = peek())
  		if (character < 33)
  			next();
  		else
  			break

  	return token(type) > 2 || token(character) > 3 ? '' : ' '
  }

  /**
   * @param {number} index
   * @param {number} count
   * @return {string}
   */
  function escaping (index, count) {
  	while (--count && next())
  		// not 0-9 A-F a-f
  		if (character < 48 || character > 102 || (character > 57 && character < 65) || (character > 70 && character < 97))
  			break

  	return slice(index, caret() + (count < 6 && peek() == 32 && next() == 32))
  }

  /**
   * @param {number} type
   * @return {number}
   */
  function delimiter (type) {
  	while (next())
  		switch (character) {
  			// ] ) " '
  			case type:
  				return position
  			// " '
  			case 34: case 39:
  				if (type !== 34 && type !== 39)
  					delimiter(character);
  				break
  			// (
  			case 40:
  				if (type === 41)
  					delimiter(type);
  				break
  			// \
  			case 92:
  				next();
  				break
  		}

  	return position
  }

  /**
   * @param {number} type
   * @param {number} index
   * @return {number}
   */
  function commenter (type, index) {
  	while (next())
  		// //
  		if (type + character === 47 + 10)
  			break
  		// /*
  		else if (type + character === 42 + 42 && peek() === 47)
  			break

  	return '/*' + slice(index, position - 1) + '*' + from(type === 47 ? type : next())
  }

  /**
   * @param {number} index
   * @return {string}
   */
  function identifier (index) {
  	while (!token(peek()))
  		next();

  	return slice(index, position)
  }

  /**
   * @param {string} value
   * @return {object[]}
   */
  function compile (value) {
  	return dealloc(parse('', null, null, null, [''], value = alloc(value), 0, [0], value))
  }

  /**
   * @param {string} value
   * @param {object} root
   * @param {object?} parent
   * @param {string[]} rule
   * @param {string[]} rules
   * @param {string[]} rulesets
   * @param {number[]} pseudo
   * @param {number[]} points
   * @param {string[]} declarations
   * @return {object}
   */
  function parse (value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
  	var index = 0;
  	var offset = 0;
  	var length = pseudo;
  	var atrule = 0;
  	var property = 0;
  	var previous = 0;
  	var variable = 1;
  	var scanning = 1;
  	var ampersand = 1;
  	var character = 0;
  	var type = '';
  	var props = rules;
  	var children = rulesets;
  	var reference = rule;
  	var characters = type;

  	while (scanning)
  		switch (previous = character, character = next()) {
  			// (
  			case 40:
  				if (previous != 108 && charat(characters, length - 1) == 58) {
  					if (indexof(characters += replace(delimit(character), '&', '&\f'), '&\f') != -1)
  						ampersand = -1;
  					break
  				}
  			// " ' [
  			case 34: case 39: case 91:
  				characters += delimit(character);
  				break
  			// \t \n \r \s
  			case 9: case 10: case 13: case 32:
  				characters += whitespace(previous);
  				break
  			// \
  			case 92:
  				characters += escaping(caret() - 1, 7);
  				continue
  			// /
  			case 47:
  				switch (peek()) {
  					case 42: case 47:
  						append(comment(commenter(next(), caret()), root, parent), declarations);
  						break
  					default:
  						characters += '/';
  				}
  				break
  			// {
  			case 123 * variable:
  				points[index++] = strlen(characters) * ampersand;
  			// } ; \0
  			case 125 * variable: case 59: case 0:
  				switch (character) {
  					// \0 }
  					case 0: case 125: scanning = 0;
  					// ;
  					case 59 + offset: if (ampersand == -1) characters = replace(characters, /\f/g, '');
  						if (property > 0 && (strlen(characters) - length))
  							append(property > 32 ? declaration(characters + ';', rule, parent, length - 1) : declaration(replace(characters, ' ', '') + ';', rule, parent, length - 2), declarations);
  						break
  					// @ ;
  					case 59: characters += ';';
  					// { rule/at-rule
  					default:
  						append(reference = ruleset(characters, root, parent, index, offset, rules, points, type, props = [], children = [], length), rulesets);

  						if (character === 123)
  							if (offset === 0)
  								parse(characters, root, reference, reference, props, rulesets, length, points, children);
  							else
  								switch (atrule === 99 && charat(characters, 3) === 110 ? 100 : atrule) {
  									// d l m s
  									case 100: case 108: case 109: case 115:
  										parse(value, reference, reference, rule && append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length), children), rules, children, length, points, rule ? props : children);
  										break
  									default:
  										parse(characters, reference, reference, reference, [''], children, 0, points, children);
  								}
  				}

  				index = offset = property = 0, variable = ampersand = 1, type = characters = '', length = pseudo;
  				break
  			// :
  			case 58:
  				length = 1 + strlen(characters), property = previous;
  			default:
  				if (variable < 1)
  					if (character == 123)
  						--variable;
  					else if (character == 125 && variable++ == 0 && prev() == 125)
  						continue

  				switch (characters += from(character), character * variable) {
  					// &
  					case 38:
  						ampersand = offset > 0 ? 1 : (characters += '\f', -1);
  						break
  					// ,
  					case 44:
  						points[index++] = (strlen(characters) - 1) * ampersand, ampersand = 1;
  						break
  					// @
  					case 64:
  						// -
  						if (peek() === 45)
  							characters += delimit(next());

  						atrule = peek(), offset = length = strlen(type = characters += identifier(caret())), character++;
  						break
  					// -
  					case 45:
  						if (previous === 45 && strlen(characters) == 2)
  							variable = 0;
  				}
  		}

  	return rulesets
  }

  /**
   * @param {string} value
   * @param {object} root
   * @param {object?} parent
   * @param {number} index
   * @param {number} offset
   * @param {string[]} rules
   * @param {number[]} points
   * @param {string} type
   * @param {string[]} props
   * @param {string[]} children
   * @param {number} length
   * @return {object}
   */
  function ruleset (value, root, parent, index, offset, rules, points, type, props, children, length) {
  	var post = offset - 1;
  	var rule = offset === 0 ? rules : [''];
  	var size = sizeof(rule);

  	for (var i = 0, j = 0, k = 0; i < index; ++i)
  		for (var x = 0, y = substr(value, post + 1, post = abs(j = points[i])), z = value; x < size; ++x)
  			if (z = trim(j > 0 ? rule[x] + ' ' + y : replace(y, /&\f/g, rule[x])))
  				props[k++] = z;

  	return node(value, root, parent, offset === 0 ? RULESET : type, props, children, length)
  }

  /**
   * @param {number} value
   * @param {object} root
   * @param {object?} parent
   * @return {object}
   */
  function comment (value, root, parent) {
  	return node(value, root, parent, COMMENT, from(char()), substr(value, 2, -2), 0)
  }

  /**
   * @param {string} value
   * @param {object} root
   * @param {object?} parent
   * @param {number} length
   * @return {object}
   */
  function declaration (value, root, parent, length) {
  	return node(value, root, parent, DECLARATION, substr(value, 0, length), substr(value, length + 1, -1), length)
  }

  /**
   * @param {object[]} children
   * @param {function} callback
   * @return {string}
   */
  function serialize (children, callback) {
  	var output = '';
  	var length = sizeof(children);

  	for (var i = 0; i < length; i++)
  		output += callback(children[i], i, children, callback) || '';

  	return output
  }

  /**
   * @param {object} element
   * @param {number} index
   * @param {object[]} children
   * @param {function} callback
   * @return {string}
   */
  function stringify (element, index, children, callback) {
  	switch (element.type) {
  		case LAYER: if (element.children.length) break
  		case IMPORT: case DECLARATION: return element.return = element.return || element.value
  		case COMMENT: return ''
  		case KEYFRAMES: return element.return = element.value + '{' + serialize(element.children, callback) + '}'
  		case RULESET: element.value = element.props.join(',');
  	}

  	return strlen(children = serialize(element.children, callback)) ? element.return = element.value + '{' + children + '}' : ''
  }

  /**
   * @param {function[]} collection
   * @return {function}
   */
  function middleware (collection) {
  	var length = sizeof(collection);

  	return function (element, index, children, callback) {
  		var output = '';

  		for (var i = 0; i < length; i++)
  			output += collection[i](element, index, children, callback) || '';

  		return output
  	}
  }

  /**
   * @param {function} callback
   * @return {function}
   */
  function rulesheet (callback) {
  	return function (element) {
  		if (!element.root)
  			if (element = element.return)
  				callback(element);
  	}
  }

  var weakMemoize = function weakMemoize(func) {
    var cache = new WeakMap();
    return function (arg) {
      if (cache.has(arg)) {
        // Use non-null assertion because we just checked that the cache `has` it
        // This allows us to remove `undefined` from the return value
        return cache.get(arg);
      }

      var ret = func(arg);
      cache.set(arg, ret);
      return ret;
    };
  };

  function memoize$1(fn) {
    var cache = Object.create(null);
    return function (arg) {
      if (cache[arg] === undefined) cache[arg] = fn(arg);
      return cache[arg];
    };
  }

  var isBrowser$4 = typeof document !== 'undefined';

  var identifierWithPointTracking = function identifierWithPointTracking(begin, points, index) {
    var previous = 0;
    var character = 0;

    while (true) {
      previous = character;
      character = peek(); // &\f

      if (previous === 38 && character === 12) {
        points[index] = 1;
      }

      if (token(character)) {
        break;
      }

      next();
    }

    return slice(begin, position);
  };

  var toRules = function toRules(parsed, points) {
    // pretend we've started with a comma
    var index = -1;
    var character = 44;

    do {
      switch (token(character)) {
        case 0:
          // &\f
          if (character === 38 && peek() === 12) {
            // this is not 100% correct, we don't account for literal sequences here - like for example quoted strings
            // stylis inserts \f after & to know when & where it should replace this sequence with the context selector
            // and when it should just concatenate the outer and inner selectors
            // it's very unlikely for this sequence to actually appear in a different context, so we just leverage this fact here
            points[index] = 1;
          }

          parsed[index] += identifierWithPointTracking(position - 1, points, index);
          break;

        case 2:
          parsed[index] += delimit(character);
          break;

        case 4:
          // comma
          if (character === 44) {
            // colon
            parsed[++index] = peek() === 58 ? '&\f' : '';
            points[index] = parsed[index].length;
            break;
          }

        // fallthrough

        default:
          parsed[index] += from(character);
      }
    } while (character = next());

    return parsed;
  };

  var getRules = function getRules(value, points) {
    return dealloc(toRules(alloc(value), points));
  }; // WeakSet would be more appropriate, but only WeakMap is supported in IE11


  var fixedElements = /* #__PURE__ */new WeakMap();
  var compat = function compat(element) {
    if (element.type !== 'rule' || !element.parent || // positive .length indicates that this rule contains pseudo
    // negative .length indicates that this rule has been already prefixed
    element.length < 1) {
      return;
    }

    var value = element.value;
    var parent = element.parent;
    var isImplicitRule = element.column === parent.column && element.line === parent.line;

    while (parent.type !== 'rule') {
      parent = parent.parent;
      if (!parent) return;
    } // short-circuit for the simplest case


    if (element.props.length === 1 && value.charCodeAt(0) !== 58
    /* colon */
    && !fixedElements.get(parent)) {
      return;
    } // if this is an implicitly inserted rule (the one eagerly inserted at the each new nested level)
    // then the props has already been manipulated beforehand as they that array is shared between it and its "rule parent"


    if (isImplicitRule) {
      return;
    }

    fixedElements.set(element, true);
    var points = [];
    var rules = getRules(value, points);
    var parentRules = parent.props;

    for (var i = 0, k = 0; i < rules.length; i++) {
      for (var j = 0; j < parentRules.length; j++, k++) {
        element.props[k] = points[i] ? rules[i].replace(/&\f/g, parentRules[j]) : parentRules[j] + " " + rules[i];
      }
    }
  };
  var removeLabel = function removeLabel(element) {
    if (element.type === 'decl') {
      var value = element.value;

      if ( // charcode for l
      value.charCodeAt(0) === 108 && // charcode for b
      value.charCodeAt(2) === 98) {
        // this ignores label
        element["return"] = '';
        element.value = '';
      }
    }
  };

  /* eslint-disable no-fallthrough */

  function prefix(value, length) {
    switch (hash$2(value, length)) {
      // color-adjust
      case 5103:
        return WEBKIT + 'print-' + value + value;
      // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)

      case 5737:
      case 4201:
      case 3177:
      case 3433:
      case 1641:
      case 4457:
      case 2921: // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break

      case 5572:
      case 6356:
      case 5844:
      case 3191:
      case 6645:
      case 3005: // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,

      case 6391:
      case 5879:
      case 5623:
      case 6135:
      case 4599:
      case 4855: // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)

      case 4215:
      case 6389:
      case 5109:
      case 5365:
      case 5621:
      case 3829:
        return WEBKIT + value + value;
      // appearance, user-select, transform, hyphens, text-size-adjust

      case 5349:
      case 4246:
      case 4810:
      case 6968:
      case 2756:
        return WEBKIT + value + MOZ + value + MS + value + value;
      // flex, flex-direction

      case 6828:
      case 4268:
        return WEBKIT + value + MS + value + value;
      // order

      case 6165:
        return WEBKIT + value + MS + 'flex-' + value + value;
      // align-items

      case 5187:
        return WEBKIT + value + replace(value, /(\w+).+(:[^]+)/, WEBKIT + 'box-$1$2' + MS + 'flex-$1$2') + value;
      // align-self

      case 5443:
        return WEBKIT + value + MS + 'flex-item-' + replace(value, /flex-|-self/, '') + value;
      // align-content

      case 4675:
        return WEBKIT + value + MS + 'flex-line-pack' + replace(value, /align-content|flex-|-self/, '') + value;
      // flex-shrink

      case 5548:
        return WEBKIT + value + MS + replace(value, 'shrink', 'negative') + value;
      // flex-basis

      case 5292:
        return WEBKIT + value + MS + replace(value, 'basis', 'preferred-size') + value;
      // flex-grow

      case 6060:
        return WEBKIT + 'box-' + replace(value, '-grow', '') + WEBKIT + value + MS + replace(value, 'grow', 'positive') + value;
      // transition

      case 4554:
        return WEBKIT + replace(value, /([^-])(transform)/g, '$1' + WEBKIT + '$2') + value;
      // cursor

      case 6187:
        return replace(replace(replace(value, /(zoom-|grab)/, WEBKIT + '$1'), /(image-set)/, WEBKIT + '$1'), value, '') + value;
      // background, background-image

      case 5495:
      case 3959:
        return replace(value, /(image-set\([^]*)/, WEBKIT + '$1' + '$`$1');
      // justify-content

      case 4968:
        return replace(replace(value, /(.+:)(flex-)?(.*)/, WEBKIT + 'box-pack:$3' + MS + 'flex-pack:$3'), /s.+-b[^;]+/, 'justify') + WEBKIT + value + value;
      // (margin|padding)-inline-(start|end)

      case 4095:
      case 3583:
      case 4068:
      case 2532:
        return replace(value, /(.+)-inline(.+)/, WEBKIT + '$1$2') + value;
      // (min|max)?(width|height|inline-size|block-size)

      case 8116:
      case 7059:
      case 5753:
      case 5535:
      case 5445:
      case 5701:
      case 4933:
      case 4677:
      case 5533:
      case 5789:
      case 5021:
      case 4765:
        // stretch, max-content, min-content, fill-available
        if (strlen(value) - 1 - length > 6) switch (charat(value, length + 1)) {
          // (m)ax-content, (m)in-content
          case 109:
            // -
            if (charat(value, length + 4) !== 45) break;
          // (f)ill-available, (f)it-content

          case 102:
            return replace(value, /(.+:)(.+)-([^]+)/, '$1' + WEBKIT + '$2-$3' + '$1' + MOZ + (charat(value, length + 3) == 108 ? '$3' : '$2-$3')) + value;
          // (s)tretch

          case 115:
            return ~indexof(value, 'stretch') ? prefix(replace(value, 'stretch', 'fill-available'), length) + value : value;
        }
        break;
      // position: sticky

      case 4949:
        // (s)ticky?
        if (charat(value, length + 1) !== 115) break;
      // display: (flex|inline-flex)

      case 6444:
        switch (charat(value, strlen(value) - 3 - (~indexof(value, '!important') && 10))) {
          // stic(k)y
          case 107:
            return replace(value, ':', ':' + WEBKIT) + value;
          // (inline-)?fl(e)x

          case 101:
            return replace(value, /(.+:)([^;!]+)(;|!.+)?/, '$1' + WEBKIT + (charat(value, 14) === 45 ? 'inline-' : '') + 'box$3' + '$1' + WEBKIT + '$2$3' + '$1' + MS + '$2box$3') + value;
        }

        break;
      // writing-mode

      case 5936:
        switch (charat(value, length + 11)) {
          // vertical-l(r)
          case 114:
            return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, 'tb') + value;
          // vertical-r(l)

          case 108:
            return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, 'tb-rl') + value;
          // horizontal(-)tb

          case 45:
            return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, 'lr') + value;
        }

        return WEBKIT + value + MS + value + value;
    }

    return value;
  }

  var prefixer = function prefixer(element, index, children, callback) {
    if (element.length > -1) if (!element["return"]) switch (element.type) {
      case DECLARATION:
        element["return"] = prefix(element.value, element.length);
        break;

      case KEYFRAMES:
        return serialize([copy(element, {
          value: replace(element.value, '@', '@' + WEBKIT)
        })], callback);

      case RULESET:
        if (element.length) return combine(element.props, function (value) {
          switch (match(value, /(::plac\w+|:read-\w+)/)) {
            // :read-(only|write)
            case ':read-only':
            case ':read-write':
              return serialize([copy(element, {
                props: [replace(value, /:(read-\w+)/, ':' + MOZ + '$1')]
              })], callback);
            // :placeholder

            case '::placeholder':
              return serialize([copy(element, {
                props: [replace(value, /:(plac\w+)/, ':' + WEBKIT + 'input-$1')]
              }), copy(element, {
                props: [replace(value, /:(plac\w+)/, ':' + MOZ + '$1')]
              }), copy(element, {
                props: [replace(value, /:(plac\w+)/, MS + 'input-$1')]
              })], callback);
          }

          return '';
        });
    }
  };

  var getServerStylisCache = isBrowser$4 ? undefined : weakMemoize(function () {
    return memoize$1(function () {
      return {};
    });
  });
  var defaultStylisPlugins = [prefixer];

  var createCache = function createCache(options) {
    var key = options.key;

    if (isBrowser$4 && key === 'css') {
      var ssrStyles = document.querySelectorAll("style[data-emotion]:not([data-s])"); // get SSRed styles out of the way of React's hydration
      // document.head is a safe place to move them to(though note document.head is not necessarily the last place they will be)
      // note this very very intentionally targets all style elements regardless of the key to ensure
      // that creating a cache works inside of render of a React component

      Array.prototype.forEach.call(ssrStyles, function (node) {
        // we want to only move elements which have a space in the data-emotion attribute value
        // because that indicates that it is an Emotion 11 server-side rendered style elements
        // while we will already ignore Emotion 11 client-side inserted styles because of the :not([data-s]) part in the selector
        // Emotion 10 client-side inserted styles did not have data-s (but importantly did not have a space in their data-emotion attributes)
        // so checking for the space ensures that loading Emotion 11 after Emotion 10 has inserted some styles
        // will not result in the Emotion 10 styles being destroyed
        var dataEmotionAttribute = node.getAttribute('data-emotion');

        if (dataEmotionAttribute.indexOf(' ') === -1) {
          return;
        }

        document.head.appendChild(node);
        node.setAttribute('data-s', '');
      });
    }

    var stylisPlugins = options.stylisPlugins || defaultStylisPlugins;

    var inserted = {};
    var container;
    var nodesToHydrate = [];

    if (isBrowser$4) {
      container = options.container || document.head;
      Array.prototype.forEach.call( // this means we will ignore elements which don't have a space in them which
      // means that the style elements we're looking at are only Emotion 11 server-rendered style elements
      document.querySelectorAll("style[data-emotion^=\"" + key + " \"]"), function (node) {
        var attrib = node.getAttribute("data-emotion").split(' ');

        for (var i = 1; i < attrib.length; i++) {
          inserted[attrib[i]] = true;
        }

        nodesToHydrate.push(node);
      });
    }

    var _insert;

    var omnipresentPlugins = [compat, removeLabel];

    if (!getServerStylisCache) {
      var currentSheet;
      var finalizingPlugins = [stringify, rulesheet(function (rule) {
        currentSheet.insert(rule);
      })];
      var serializer = middleware(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins));

      var stylis = function stylis(styles) {
        return serialize(compile(styles), serializer);
      };

      _insert = function insert(selector, serialized, sheet, shouldCache) {
        currentSheet = sheet;

        stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);

        if (shouldCache) {
          cache.inserted[serialized.name] = true;
        }
      };
    } else {
      var _finalizingPlugins = [stringify];

      var _serializer = middleware(omnipresentPlugins.concat(stylisPlugins, _finalizingPlugins));

      var _stylis = function _stylis(styles) {
        return serialize(compile(styles), _serializer);
      };

      var serverStylisCache = getServerStylisCache(stylisPlugins)(key);

      var getRules = function getRules(selector, serialized) {
        var name = serialized.name;

        if (serverStylisCache[name] === undefined) {
          serverStylisCache[name] = _stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);
        }

        return serverStylisCache[name];
      };

      _insert = function _insert(selector, serialized, sheet, shouldCache) {
        var name = serialized.name;
        var rules = getRules(selector, serialized);

        if (cache.compat === undefined) {
          // in regular mode, we don't set the styles on the inserted cache
          // since we don't need to and that would be wasting memory
          // we return them so that they are rendered in a style tag
          if (shouldCache) {
            cache.inserted[name] = true;
          }

          return rules;
        } else {
          // in compat mode, we put the styles on the inserted cache so
          // that emotion-server can pull out the styles
          // except when we don't want to cache it which was in Global but now
          // is nowhere but we don't want to do a major right now
          // and just in case we're going to leave the case here
          // it's also not affecting client side bundle size
          // so it's really not a big deal
          if (shouldCache) {
            cache.inserted[name] = rules;
          } else {
            return rules;
          }
        }
      };
    }

    var cache = {
      key: key,
      sheet: new StyleSheet({
        key: key,
        container: container,
        nonce: options.nonce,
        speedy: options.speedy,
        prepend: options.prepend,
        insertionPoint: options.insertionPoint
      }),
      nonce: options.nonce,
      inserted: inserted,
      registered: {},
      insert: _insert
    };
    cache.sheet.hydrate(nodesToHydrate);
    return cache;
  };

  function getDefaultExportFromCjs (x) {
  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
  }

  var reactIs$1 = {exports: {}};

  var reactIs_development$1 = {};

  var hasRequiredReactIs_development$1;

  function requireReactIs_development$1 () {
  	if (hasRequiredReactIs_development$1) return reactIs_development$1;
  	hasRequiredReactIs_development$1 = 1;



  	{
  	  (function() {

  	// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
  	// nor polyfill, then a plain number is used for performance.
  	var hasSymbol = typeof Symbol === 'function' && 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; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
  	// (unstable) APIs that have been removed. Can we remove the symbols?

  	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 typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
  	  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 || typeof type === 'object' && type !== null && (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 (typeof object === 'object' && object !== null) {
  	    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;
  	    }
  	  }

  	  return undefined;
  	} // AsyncMode is deprecated along with isAsyncMode

  	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; // AsyncMode should be deprecated

  	function isAsyncMode(object) {
  	  {
  	    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
  	      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint

  	      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 typeof object === 'object' && object !== null && 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;
  	}

  	reactIs_development$1.AsyncMode = AsyncMode;
  	reactIs_development$1.ConcurrentMode = ConcurrentMode;
  	reactIs_development$1.ContextConsumer = ContextConsumer;
  	reactIs_development$1.ContextProvider = ContextProvider;
  	reactIs_development$1.Element = Element;
  	reactIs_development$1.ForwardRef = ForwardRef;
  	reactIs_development$1.Fragment = Fragment;
  	reactIs_development$1.Lazy = Lazy;
  	reactIs_development$1.Memo = Memo;
  	reactIs_development$1.Portal = Portal;
  	reactIs_development$1.Profiler = Profiler;
  	reactIs_development$1.StrictMode = StrictMode;
  	reactIs_development$1.Suspense = Suspense;
  	reactIs_development$1.isAsyncMode = isAsyncMode;
  	reactIs_development$1.isConcurrentMode = isConcurrentMode;
  	reactIs_development$1.isContextConsumer = isContextConsumer;
  	reactIs_development$1.isContextProvider = isContextProvider;
  	reactIs_development$1.isElement = isElement;
  	reactIs_development$1.isForwardRef = isForwardRef;
  	reactIs_development$1.isFragment = isFragment;
  	reactIs_development$1.isLazy = isLazy;
  	reactIs_development$1.isMemo = isMemo;
  	reactIs_development$1.isPortal = isPortal;
  	reactIs_development$1.isProfiler = isProfiler;
  	reactIs_development$1.isStrictMode = isStrictMode;
  	reactIs_development$1.isSuspense = isSuspense;
  	reactIs_development$1.isValidElementType = isValidElementType;
  	reactIs_development$1.typeOf = typeOf;
  	  })();
  	}
  	return reactIs_development$1;
  }

  var hasRequiredReactIs$1;

  function requireReactIs$1 () {
  	if (hasRequiredReactIs$1) return reactIs$1.exports;
  	hasRequiredReactIs$1 = 1;

  	{
  	  reactIs$1.exports = requireReactIs_development$1();
  	}
  	return reactIs$1.exports;
  }

  var hoistNonReactStatics_cjs;
  var hasRequiredHoistNonReactStatics_cjs;

  function requireHoistNonReactStatics_cjs () {
  	if (hasRequiredHoistNonReactStatics_cjs) return hoistNonReactStatics_cjs;
  	hasRequiredHoistNonReactStatics_cjs = 1;

  	var reactIs = requireReactIs$1();

  	/**
  	 * Copyright 2015, Yahoo! Inc.
  	 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
  	 */
  	var REACT_STATICS = {
  	  childContextTypes: true,
  	  contextType: true,
  	  contextTypes: true,
  	  defaultProps: true,
  	  displayName: true,
  	  getDefaultProps: true,
  	  getDerivedStateFromError: true,
  	  getDerivedStateFromProps: true,
  	  mixins: true,
  	  propTypes: true,
  	  type: true
  	};
  	var KNOWN_STATICS = {
  	  name: true,
  	  length: true,
  	  prototype: true,
  	  caller: true,
  	  callee: true,
  	  arguments: true,
  	  arity: true
  	};
  	var FORWARD_REF_STATICS = {
  	  '$$typeof': true,
  	  render: true,
  	  defaultProps: true,
  	  displayName: true,
  	  propTypes: true
  	};
  	var MEMO_STATICS = {
  	  '$$typeof': true,
  	  compare: true,
  	  defaultProps: true,
  	  displayName: true,
  	  propTypes: true,
  	  type: true
  	};
  	var TYPE_STATICS = {};
  	TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
  	TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;

  	function getStatics(component) {
  	  // React v16.11 and below
  	  if (reactIs.isMemo(component)) {
  	    return MEMO_STATICS;
  	  } // React v16.12 and above


  	  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;
  	}

  	var defineProperty = Object.defineProperty;
  	var getOwnPropertyNames = Object.getOwnPropertyNames;
  	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
  	var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
  	var getPrototypeOf = Object.getPrototypeOf;
  	var objectPrototype = Object.prototype;
  	function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
  	  if (typeof sourceComponent !== 'string') {
  	    // don't hoist over string (html) components
  	    if (objectPrototype) {
  	      var inheritedComponent = getPrototypeOf(sourceComponent);

  	      if (inheritedComponent && inheritedComponent !== objectPrototype) {
  	        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
  	      }
  	    }

  	    var keys = getOwnPropertyNames(sourceComponent);

  	    if (getOwnPropertySymbols) {
  	      keys = keys.concat(getOwnPropertySymbols(sourceComponent));
  	    }

  	    var targetStatics = getStatics(targetComponent);
  	    var sourceStatics = getStatics(sourceComponent);

  	    for (var i = 0; i < keys.length; ++i) {
  	      var key = keys[i];

  	      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
  	        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);

  	        try {
  	          // Avoid failures from read-only properties
  	          defineProperty(targetComponent, key, descriptor);
  	        } catch (e) {}
  	      }
  	    }
  	  }

  	  return targetComponent;
  	}

  	hoistNonReactStatics_cjs = hoistNonReactStatics;
  	return hoistNonReactStatics_cjs;
  }

  requireHoistNonReactStatics_cjs();

  var isBrowser$3 = typeof document !== 'undefined';

  function getRegisteredStyles(registered, registeredStyles, classNames) {
    var rawClassName = '';
    classNames.split(' ').forEach(function (className) {
      if (registered[className] !== undefined) {
        registeredStyles.push(registered[className] + ";");
      } else if (className) {
        rawClassName += className + " ";
      }
    });
    return rawClassName;
  }
  var registerStyles = function registerStyles(cache, serialized, isStringTag) {
    var className = cache.key + "-" + serialized.name;

    if ( // we only need to add the styles to the registered cache if the
    // class name could be used further down
    // the tree but if it's a string tag, we know it won't
    // so we don't have to add it to registered cache.
    // this improves memory usage since we can avoid storing the whole style string
    (isStringTag === false || // we need to always store it if we're in compat mode and
    // in node since emotion-server relies on whether a style is in
    // the registered cache to know whether a style is global or not
    // also, note that this check will be dead code eliminated in the browser
    isBrowser$3 === false && cache.compat !== undefined) && cache.registered[className] === undefined) {
      cache.registered[className] = serialized.styles;
    }
  };
  var insertStyles = function insertStyles(cache, serialized, isStringTag) {
    registerStyles(cache, serialized, isStringTag);
    var className = cache.key + "-" + serialized.name;

    if (cache.inserted[serialized.name] === undefined) {
      var stylesForSSR = '';
      var current = serialized;

      do {
        var maybeStyles = cache.insert(serialized === current ? "." + className : '', current, cache.sheet, true);

        if (!isBrowser$3 && maybeStyles !== undefined) {
          stylesForSSR += maybeStyles;
        }

        current = current.next;
      } while (current !== undefined);

      if (!isBrowser$3 && stylesForSSR.length !== 0) {
        return stylesForSSR;
      }
    }
  };

  /* eslint-disable */
  // Inspired by https://github.com/garycourt/murmurhash-js
  // Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86
  function murmur2(str) {
    // 'm' and 'r' are mixing constants generated offline.
    // They're not really 'magic', they just happen to work well.
    // const m = 0x5bd1e995;
    // const r = 24;
    // Initialize the hash
    var h = 0; // Mix 4 bytes at a time into the hash

    var k,
        i = 0,
        len = str.length;

    for (; len >= 4; ++i, len -= 4) {
      k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;
      k =
      /* Math.imul(k, m): */
      (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16);
      k ^=
      /* k >>> r: */
      k >>> 24;
      h =
      /* Math.imul(k, m): */
      (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^
      /* Math.imul(h, m): */
      (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
    } // Handle the last few bytes of the input array


    switch (len) {
      case 3:
        h ^= (str.charCodeAt(i + 2) & 0xff) << 16;

      case 2:
        h ^= (str.charCodeAt(i + 1) & 0xff) << 8;

      case 1:
        h ^= str.charCodeAt(i) & 0xff;
        h =
        /* Math.imul(h, m): */
        (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
    } // Do a few final mixes of the hash to ensure the last few
    // bytes are well-incorporated.


    h ^= h >>> 13;
    h =
    /* Math.imul(h, m): */
    (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
    return ((h ^ h >>> 15) >>> 0).toString(36);
  }

  var unitlessKeys = {
    animationIterationCount: 1,
    aspectRatio: 1,
    borderImageOutset: 1,
    borderImageSlice: 1,
    borderImageWidth: 1,
    boxFlex: 1,
    boxFlexGroup: 1,
    boxOrdinalGroup: 1,
    columnCount: 1,
    columns: 1,
    flex: 1,
    flexGrow: 1,
    flexPositive: 1,
    flexShrink: 1,
    flexNegative: 1,
    flexOrder: 1,
    gridRow: 1,
    gridRowEnd: 1,
    gridRowSpan: 1,
    gridRowStart: 1,
    gridColumn: 1,
    gridColumnEnd: 1,
    gridColumnSpan: 1,
    gridColumnStart: 1,
    msGridRow: 1,
    msGridRowSpan: 1,
    msGridColumn: 1,
    msGridColumnSpan: 1,
    fontWeight: 1,
    lineHeight: 1,
    opacity: 1,
    order: 1,
    orphans: 1,
    scale: 1,
    tabSize: 1,
    widows: 1,
    zIndex: 1,
    zoom: 1,
    WebkitLineClamp: 1,
    // SVG-related properties
    fillOpacity: 1,
    floodOpacity: 1,
    stopOpacity: 1,
    strokeDasharray: 1,
    strokeDashoffset: 1,
    strokeMiterlimit: 1,
    strokeOpacity: 1,
    strokeWidth: 1
  };

  var isDevelopment$2 = false;

  var hyphenateRegex = /[A-Z]|^ms/g;
  var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;

  var isCustomProperty = function isCustomProperty(property) {
    return property.charCodeAt(1) === 45;
  };

  var isProcessableValue = function isProcessableValue(value) {
    return value != null && typeof value !== 'boolean';
  };

  var processStyleName = /* #__PURE__ */memoize$1(function (styleName) {
    return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, '-$&').toLowerCase();
  });

  var processStyleValue = function processStyleValue(key, value) {
    switch (key) {
      case 'animation':
      case 'animationName':
        {
          if (typeof value === 'string') {
            return value.replace(animationRegex, function (match, p1, p2) {
              cursor = {
                name: p1,
                styles: p2,
                next: cursor
              };
              return p1;
            });
          }
        }
    }

    if (unitlessKeys[key] !== 1 && !isCustomProperty(key) && typeof value === 'number' && value !== 0) {
      return value + 'px';
    }

    return value;
  };

  var noComponentSelectorMessage = 'Component selectors can only be used in conjunction with ' + '@emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware ' + 'compiler transform.';

  function handleInterpolation(mergedProps, registered, interpolation) {
    if (interpolation == null) {
      return '';
    }

    var componentSelector = interpolation;

    if (componentSelector.__emotion_styles !== undefined) {

      return componentSelector;
    }

    switch (typeof interpolation) {
      case 'boolean':
        {
          return '';
        }

      case 'object':
        {
          var keyframes = interpolation;

          if (keyframes.anim === 1) {
            cursor = {
              name: keyframes.name,
              styles: keyframes.styles,
              next: cursor
            };
            return keyframes.name;
          }

          var serializedStyles = interpolation;

          if (serializedStyles.styles !== undefined) {
            var next = serializedStyles.next;

            if (next !== undefined) {
              // not the most efficient thing ever but this is a pretty rare case
              // and there will be very few iterations of this generally
              while (next !== undefined) {
                cursor = {
                  name: next.name,
                  styles: next.styles,
                  next: cursor
                };
                next = next.next;
              }
            }

            var styles = serializedStyles.styles + ";";
            return styles;
          }

          return createStringFromObject(mergedProps, registered, interpolation);
        }

      case 'function':
        {
          if (mergedProps !== undefined) {
            var previousCursor = cursor;
            var result = interpolation(mergedProps);
            cursor = previousCursor;
            return handleInterpolation(mergedProps, registered, result);
          }

          break;
        }
    } // finalize string values (regular strings and functions interpolated into css calls)


    var asString = interpolation;

    if (registered == null) {
      return asString;
    }

    var cached = registered[asString];
    return cached !== undefined ? cached : asString;
  }

  function createStringFromObject(mergedProps, registered, obj) {
    var string = '';

    if (Array.isArray(obj)) {
      for (var i = 0; i < obj.length; i++) {
        string += handleInterpolation(mergedProps, registered, obj[i]) + ";";
      }
    } else {
      for (var key in obj) {
        var value = obj[key];

        if (typeof value !== 'object') {
          var asString = value;

          if (registered != null && registered[asString] !== undefined) {
            string += key + "{" + registered[asString] + "}";
          } else if (isProcessableValue(asString)) {
            string += processStyleName(key) + ":" + processStyleValue(key, asString) + ";";
          }
        } else {
          if (key === 'NO_COMPONENT_SELECTOR' && isDevelopment$2) {
            throw new Error(noComponentSelectorMessage);
          }

          if (Array.isArray(value) && typeof value[0] === 'string' && (registered == null || registered[value[0]] === undefined)) {
            for (var _i = 0; _i < value.length; _i++) {
              if (isProcessableValue(value[_i])) {
                string += processStyleName(key) + ":" + processStyleValue(key, value[_i]) + ";";
              }
            }
          } else {
            var interpolated = handleInterpolation(mergedProps, registered, value);

            switch (key) {
              case 'animation':
              case 'animationName':
                {
                  string += processStyleName(key) + ":" + interpolated + ";";
                  break;
                }

              default:
                {

                  string += key + "{" + interpolated + "}";
                }
            }
          }
        }
      }
    }

    return string;
  }

  var labelPattern = /label:\s*([^\s;{]+)\s*(;|$)/g; // this is the cursor for keyframes
  // keyframes are stored on the SerializedStyles object as a linked list

  var cursor;
  function serializeStyles(args, registered, mergedProps) {
    if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && args[0].styles !== undefined) {
      return args[0];
    }

    var stringMode = true;
    var styles = '';
    cursor = undefined;
    var strings = args[0];

    if (strings == null || strings.raw === undefined) {
      stringMode = false;
      styles += handleInterpolation(mergedProps, registered, strings);
    } else {
      var asTemplateStringsArr = strings;

      styles += asTemplateStringsArr[0];
    } // we start at 1 since we've already handled the first arg


    for (var i = 1; i < args.length; i++) {
      styles += handleInterpolation(mergedProps, registered, args[i]);

      if (stringMode) {
        var templateStringsArr = strings;

        styles += templateStringsArr[i];
      }
    } // using a global regex with .exec is stateful so lastIndex has to be reset each time


    labelPattern.lastIndex = 0;
    var identifierName = '';
    var match; // https://esbench.com/bench/5b809c2cf2949800a0f61fb5

    while ((match = labelPattern.exec(styles)) !== null) {
      identifierName += '-' + match[1];
    }

    var name = murmur2(styles) + identifierName;

    return {
      name: name,
      styles: styles,
      next: cursor
    };
  }

  var isBrowser$2 = typeof document !== 'undefined';

  var syncFallback = function syncFallback(create) {
    return create();
  };

  var useInsertionEffect = React__namespace['useInsertion' + 'Effect'] ? React__namespace['useInsertion' + 'Effect'] : false;
  var useInsertionEffectAlwaysWithSyncFallback = !isBrowser$2 ? syncFallback : useInsertionEffect || syncFallback;
  var useInsertionEffectWithLayoutFallback = useInsertionEffect || React__namespace.useLayoutEffect;

  var isDevelopment$1 = false;

  var isBrowser$1 = typeof document !== 'undefined';

  var EmotionCacheContext = /* #__PURE__ */React__namespace.createContext( // we're doing this to avoid preconstruct's dead code elimination in this one case
  // because this module is primarily intended for the browser and node
  // but it's also required in react native and similar environments sometimes
  // and we could have a special build just for that
  // but this is much easier and the native packages
  // might use a different theme context in the future anyway
  typeof HTMLElement !== 'undefined' ? /* #__PURE__ */createCache({
    key: 'css'
  }) : null);

  var CacheProvider = EmotionCacheContext.Provider;

  var withEmotionCache = function withEmotionCache(func) {
    return /*#__PURE__*/React.forwardRef(function (props, ref) {
      // the cache will never be null in the browser
      var cache = React.useContext(EmotionCacheContext);
      return func(props, cache, ref);
    });
  };

  if (!isBrowser$1) {
    withEmotionCache = function withEmotionCache(func) {
      return function (props) {
        var cache = React.useContext(EmotionCacheContext);

        if (cache === null) {
          // yes, we're potentially creating this on every render
          // it doesn't actually matter though since it's only on the server
          // so there will only every be a single render
          // that could change in the future because of suspense and etc. but for now,
          // this works and i don't want to optimise for a future thing that we aren't sure about
          cache = createCache({
            key: 'css'
          });
          return /*#__PURE__*/React__namespace.createElement(EmotionCacheContext.Provider, {
            value: cache
          }, func(props, cache));
        } else {
          return func(props, cache);
        }
      };
    };
  }

  var ThemeContext$2 = /* #__PURE__ */React__namespace.createContext({});

  var hasOwn = {}.hasOwnProperty;

  var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
  var createEmotionProps = function createEmotionProps(type, props) {

    var newProps = {};

    for (var _key in props) {
      if (hasOwn.call(props, _key)) {
        newProps[_key] = props[_key];
      }
    }

    newProps[typePropName] = type; // Runtime labeling is an opt-in feature because:

    return newProps;
  };

  var Insertion$1 = function Insertion(_ref) {
    var cache = _ref.cache,
        serialized = _ref.serialized,
        isStringTag = _ref.isStringTag;
    registerStyles(cache, serialized, isStringTag);
    var rules = useInsertionEffectAlwaysWithSyncFallback(function () {
      return insertStyles(cache, serialized, isStringTag);
    });

    if (!isBrowser$1 && rules !== undefined) {
      var _ref2;

      var serializedNames = serialized.name;
      var next = serialized.next;

      while (next !== undefined) {
        serializedNames += ' ' + next.name;
        next = next.next;
      }

      return /*#__PURE__*/React__namespace.createElement("style", (_ref2 = {}, _ref2["data-emotion"] = cache.key + " " + serializedNames, _ref2.dangerouslySetInnerHTML = {
        __html: rules
      }, _ref2.nonce = cache.sheet.nonce, _ref2));
    }

    return null;
  };

  var Emotion = /* #__PURE__ */withEmotionCache(function (props, cache, ref) {
    var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
    // not passing the registered cache to serializeStyles because it would
    // make certain babel optimisations not possible

    if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
      cssProp = cache.registered[cssProp];
    }

    var WrappedComponent = props[typePropName];
    var registeredStyles = [cssProp];
    var className = '';

    if (typeof props.className === 'string') {
      className = getRegisteredStyles(cache.registered, registeredStyles, props.className);
    } else if (props.className != null) {
      className = props.className + " ";
    }

    var serialized = serializeStyles(registeredStyles, undefined, React__namespace.useContext(ThemeContext$2));

    className += cache.key + "-" + serialized.name;
    var newProps = {};

    for (var _key2 in props) {
      if (hasOwn.call(props, _key2) && _key2 !== 'css' && _key2 !== typePropName && (!isDevelopment$1 )) {
        newProps[_key2] = props[_key2];
      }
    }

    newProps.className = className;

    if (ref) {
      newProps.ref = ref;
    }

    return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(Insertion$1, {
      cache: cache,
      serialized: serialized,
      isStringTag: typeof WrappedComponent === 'string'
    }), /*#__PURE__*/React__namespace.createElement(WrappedComponent, newProps));
  });

  var Emotion$1 = Emotion;

  var jsx = function jsx(type, props) {
    // eslint-disable-next-line prefer-rest-params
    var args = arguments;

    if (props == null || !hasOwn.call(props, 'css')) {
      return React__namespace.createElement.apply(undefined, args);
    }

    var argsLength = args.length;
    var createElementArgArray = new Array(argsLength);
    createElementArgArray[0] = Emotion$1;
    createElementArgArray[1] = createEmotionProps(type, props);

    for (var i = 2; i < argsLength; i++) {
      createElementArgArray[i] = args[i];
    }

    return React__namespace.createElement.apply(null, createElementArgArray);
  };

  (function (_jsx) {
    var JSX;

    (function (_JSX) {})(JSX || (JSX = _jsx.JSX || (_jsx.JSX = {})));
  })(jsx || (jsx = {}));

  // initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild
  // initial client-side render from SSR, use place of hydrating tag

  var Global = /* #__PURE__ */withEmotionCache(function (props, cache) {

    var styles = props.styles;
    var serialized = serializeStyles([styles], undefined, React__namespace.useContext(ThemeContext$2));

    if (!isBrowser$1) {
      var _ref;

      var serializedNames = serialized.name;
      var serializedStyles = serialized.styles;
      var next = serialized.next;

      while (next !== undefined) {
        serializedNames += ' ' + next.name;
        serializedStyles += next.styles;
        next = next.next;
      }

      var shouldCache = cache.compat === true;
      var rules = cache.insert("", {
        name: serializedNames,
        styles: serializedStyles
      }, cache.sheet, shouldCache);

      if (shouldCache) {
        return null;
      }

      return /*#__PURE__*/React__namespace.createElement("style", (_ref = {}, _ref["data-emotion"] = cache.key + "-global " + serializedNames, _ref.dangerouslySetInnerHTML = {
        __html: rules
      }, _ref.nonce = cache.sheet.nonce, _ref));
    } // yes, i know these hooks are used conditionally
    // but it is based on a constant that will never change at runtime
    // it's effectively like having two implementations and switching them out
    // so it's not actually breaking anything


    var sheetRef = React__namespace.useRef();
    useInsertionEffectWithLayoutFallback(function () {
      var key = cache.key + "-global"; // use case of https://github.com/emotion-js/emotion/issues/2675

      var sheet = new cache.sheet.constructor({
        key: key,
        nonce: cache.sheet.nonce,
        container: cache.sheet.container,
        speedy: cache.sheet.isSpeedy
      });
      var rehydrating = false;
      var node = document.querySelector("style[data-emotion=\"" + key + " " + serialized.name + "\"]");

      if (cache.sheet.tags.length) {
        sheet.before = cache.sheet.tags[0];
      }

      if (node !== null) {
        rehydrating = true; // clear the hash so this node won't be recognizable as rehydratable by other <Global/>s

        node.setAttribute('data-emotion', key);
        sheet.hydrate([node]);
      }

      sheetRef.current = [sheet, rehydrating];
      return function () {
        sheet.flush();
      };
    }, [cache]);
    useInsertionEffectWithLayoutFallback(function () {
      var sheetRefCurrent = sheetRef.current;
      var sheet = sheetRefCurrent[0],
          rehydrating = sheetRefCurrent[1];

      if (rehydrating) {
        sheetRefCurrent[1] = false;
        return;
      }

      if (serialized.next !== undefined) {
        // insert keyframes
        insertStyles(cache, serialized.next, true);
      }

      if (sheet.tags.length) {
        // if this doesn't exist then it will be null so the style element will be appended
        var element = sheet.tags[sheet.tags.length - 1].nextElementSibling;
        sheet.before = element;
        sheet.flush();
      }

      cache.insert("", serialized, sheet, false);
    }, [cache, serialized.name]);
    return null;
  });

  function css() {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return serializeStyles(args);
  }

  function keyframes() {
    var insertable = css.apply(void 0, arguments);
    var name = "animation-" + insertable.name;
    return {
      name: name,
      styles: "@keyframes " + name + "{" + insertable.styles + "}",
      anim: 1,
      toString: function toString() {
        return "_EMO_" + this.name + "_" + this.styles + "_EMO_";
      }
    };
  }

  // eslint-disable-next-line no-undef
  var reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|disableRemotePlayback|download|draggable|encType|enterKeyHint|fetchpriority|fetchPriority|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23

  var isPropValid = /* #__PURE__ */memoize$1(function (prop) {
    return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111
    /* o */
    && prop.charCodeAt(1) === 110
    /* n */
    && prop.charCodeAt(2) < 91;
  }
  /* Z+1 */
  );

  var isBrowser = typeof document !== 'undefined';

  var isDevelopment = false;

  var testOmitPropsOnStringTag = isPropValid;

  var testOmitPropsOnComponent = function testOmitPropsOnComponent(key) {
    return key !== 'theme';
  };

  var getDefaultShouldForwardProp = function getDefaultShouldForwardProp(tag) {
    return typeof tag === 'string' && // 96 is one less than the char code
    // for "a" so this is checking that
    // it's a lowercase character
    tag.charCodeAt(0) > 96 ? testOmitPropsOnStringTag : testOmitPropsOnComponent;
  };
  var composeShouldForwardProps = function composeShouldForwardProps(tag, options, isReal) {
    var shouldForwardProp;

    if (options) {
      var optionsShouldForwardProp = options.shouldForwardProp;
      shouldForwardProp = tag.__emotion_forwardProp && optionsShouldForwardProp ? function (propName) {
        return tag.__emotion_forwardProp(propName) && optionsShouldForwardProp(propName);
      } : optionsShouldForwardProp;
    }

    if (typeof shouldForwardProp !== 'function' && isReal) {
      shouldForwardProp = tag.__emotion_forwardProp;
    }

    return shouldForwardProp;
  };

  var Insertion = function Insertion(_ref) {
    var cache = _ref.cache,
        serialized = _ref.serialized,
        isStringTag = _ref.isStringTag;
    registerStyles(cache, serialized, isStringTag);
    var rules = useInsertionEffectAlwaysWithSyncFallback(function () {
      return insertStyles(cache, serialized, isStringTag);
    });

    if (!isBrowser && rules !== undefined) {
      var _ref2;

      var serializedNames = serialized.name;
      var next = serialized.next;

      while (next !== undefined) {
        serializedNames += ' ' + next.name;
        next = next.next;
      }

      return /*#__PURE__*/React__namespace.createElement("style", (_ref2 = {}, _ref2["data-emotion"] = cache.key + " " + serializedNames, _ref2.dangerouslySetInnerHTML = {
        __html: rules
      }, _ref2.nonce = cache.sheet.nonce, _ref2));
    }

    return null;
  };

  var createStyled$1 = function createStyled(tag, options) {

    var isReal = tag.__emotion_real === tag;
    var baseTag = isReal && tag.__emotion_base || tag;
    var identifierName;
    var targetClassName;

    if (options !== undefined) {
      identifierName = options.label;
      targetClassName = options.target;
    }

    var shouldForwardProp = composeShouldForwardProps(tag, options, isReal);
    var defaultShouldForwardProp = shouldForwardProp || getDefaultShouldForwardProp(baseTag);
    var shouldUseAs = !defaultShouldForwardProp('as');
    return function () {
      // eslint-disable-next-line prefer-rest-params
      var args = arguments;
      var styles = isReal && tag.__emotion_styles !== undefined ? tag.__emotion_styles.slice(0) : [];

      if (identifierName !== undefined) {
        styles.push("label:" + identifierName + ";");
      }

      if (args[0] == null || args[0].raw === undefined) {
        // eslint-disable-next-line prefer-spread
        styles.push.apply(styles, args);
      } else {
        var templateStringsArr = args[0];

        styles.push(templateStringsArr[0]);
        var len = args.length;
        var i = 1;

        for (; i < len; i++) {

          styles.push(args[i], templateStringsArr[i]);
        }
      }

      var Styled = withEmotionCache(function (props, cache, ref) {
        var FinalTag = shouldUseAs && props.as || baseTag;
        var className = '';
        var classInterpolations = [];
        var mergedProps = props;

        if (props.theme == null) {
          mergedProps = {};

          for (var key in props) {
            mergedProps[key] = props[key];
          }

          mergedProps.theme = React__namespace.useContext(ThemeContext$2);
        }

        if (typeof props.className === 'string') {
          className = getRegisteredStyles(cache.registered, classInterpolations, props.className);
        } else if (props.className != null) {
          className = props.className + " ";
        }

        var serialized = serializeStyles(styles.concat(classInterpolations), cache.registered, mergedProps);
        className += cache.key + "-" + serialized.name;

        if (targetClassName !== undefined) {
          className += " " + targetClassName;
        }

        var finalShouldForwardProp = shouldUseAs && shouldForwardProp === undefined ? getDefaultShouldForwardProp(FinalTag) : defaultShouldForwardProp;
        var newProps = {};

        for (var _key in props) {
          if (shouldUseAs && _key === 'as') continue;

          if (finalShouldForwardProp(_key)) {
            newProps[_key] = props[_key];
          }
        }

        newProps.className = className;

        if (ref) {
          newProps.ref = ref;
        }

        return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(Insertion, {
          cache: cache,
          serialized: serialized,
          isStringTag: typeof FinalTag === 'string'
        }), /*#__PURE__*/React__namespace.createElement(FinalTag, newProps));
      });
      Styled.displayName = identifierName !== undefined ? identifierName : "Styled(" + (typeof baseTag === 'string' ? baseTag : baseTag.displayName || baseTag.name || 'Component') + ")";
      Styled.defaultProps = tag.defaultProps;
      Styled.__emotion_real = Styled;
      Styled.__emotion_base = baseTag;
      Styled.__emotion_styles = styles;
      Styled.__emotion_forwardProp = shouldForwardProp;
      Object.defineProperty(Styled, 'toString', {
        value: function value() {
          if (targetClassName === undefined && isDevelopment) {
            return 'NO_COMPONENT_SELECTOR';
          }

          return "." + targetClassName;
        }
      });

      Styled.withComponent = function (nextTag, nextOptions) {
        var newStyled = createStyled(nextTag, _extends({}, options, nextOptions, {
          shouldForwardProp: composeShouldForwardProps(Styled, nextOptions, true)
        }));
        return newStyled.apply(void 0, styles);
      };

      return Styled;
    };
  };

  var tags = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'big', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr', // SVG
  'circle', 'clipPath', 'defs', 'ellipse', 'foreignObject', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan'];

  // bind it to avoid mutating the original function
  var newStyled = createStyled$1.bind(null);
  tags.forEach(function (tagName) {
    newStyled[tagName] = newStyled(tagName);
  });

  var propTypes = {exports: {}};

  /*
  object-assign
  (c) Sindre Sorhus
  @license MIT
  */

  var objectAssign;
  var hasRequiredObjectAssign;

  function requireObjectAssign () {
  	if (hasRequiredObjectAssign) return objectAssign;
  	hasRequiredObjectAssign = 1;
  	/* eslint-disable no-unused-vars */
  	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
  	var hasOwnProperty = Object.prototype.hasOwnProperty;
  	var propIsEnumerable = Object.prototype.propertyIsEnumerable;

  	function toObject(val) {
  		if (val === null || val === undefined) {
  			throw new TypeError('Object.assign cannot be called with null or undefined');
  		}

  		return Object(val);
  	}

  	function shouldUseNative() {
  		try {
  			if (!Object.assign) {
  				return false;
  			}

  			// Detect buggy property enumeration order in older V8 versions.

  			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
  			var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
  			test1[5] = 'de';
  			if (Object.getOwnPropertyNames(test1)[0] === '5') {
  				return false;
  			}

  			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
  			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 (order2.join('') !== '0123456789') {
  				return false;
  			}

  			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
  			var test3 = {};
  			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
  				test3[letter] = letter;
  			});
  			if (Object.keys(Object.assign({}, test3)).join('') !==
  					'abcdefghijklmnopqrst') {
  				return false;
  			}

  			return true;
  		} catch (err) {
  			// We don't expect any of the above to throw, but better to be safe.
  			return false;
  		}
  	}

  	objectAssign = 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;
  	};
  	return objectAssign;
  }

  /**
   * Copyright (c) 2013-present, Facebook, Inc.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   */

  var ReactPropTypesSecret_1;
  var hasRequiredReactPropTypesSecret;

  function requireReactPropTypesSecret () {
  	if (hasRequiredReactPropTypesSecret) return ReactPropTypesSecret_1;
  	hasRequiredReactPropTypesSecret = 1;

  	var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';

  	ReactPropTypesSecret_1 = ReactPropTypesSecret;
  	return ReactPropTypesSecret_1;
  }

  var has;
  var hasRequiredHas;

  function requireHas () {
  	if (hasRequiredHas) return has;
  	hasRequiredHas = 1;
  	has = Function.call.bind(Object.prototype.hasOwnProperty);
  	return has;
  }

  var checkPropTypes_1;
  var hasRequiredCheckPropTypes;

  function requireCheckPropTypes () {
  	if (hasRequiredCheckPropTypes) return checkPropTypes_1;
  	hasRequiredCheckPropTypes = 1;

  	var printWarning = function() {};

  	{
  	  var ReactPropTypesSecret = /*@__PURE__*/ requireReactPropTypesSecret();
  	  var loggedTypeFailures = {};
  	  var has = /*@__PURE__*/ requireHas();

  	  printWarning = function(text) {
  	    var message = 'Warning: ' + text;
  	    if (typeof console !== 'undefined') {
  	      console.error(message);
  	    }
  	    try {
  	      // --- Welcome to debugging React ---
  	      // This error was thrown as a convenience so that you can use this stack
  	      // to find the callsite that caused this warning to fire.
  	      throw new Error(message);
  	    } catch (x) { /**/ }
  	  };
  	}

  	/**
  	 * Assert that the values match with the type specs.
  	 * Error messages are memorized and will only be shown once.
  	 *
  	 * @param {object} typeSpecs Map of name to a ReactPropType
  	 * @param {object} values Runtime values that need to be type-checked
  	 * @param {string} location e.g. "prop", "context", "child context"
  	 * @param {string} componentName Name of the component for error messages.
  	 * @param {?Function} getStack Returns the component stack.
  	 * @private
  	 */
  	function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
  	  {
  	    for (var typeSpecName in typeSpecs) {
  	      if (has(typeSpecs, typeSpecName)) {
  	        var error;
  	        // Prop type validation may throw. In case they do, we don't want to
  	        // fail the render phase where it didn't fail before. So we log it.
  	        // After these have been cleaned up, we'll let them throw.
  	        try {
  	          // This is intentionally an invariant that gets caught. It's the same
  	          // behavior as without this statement except with a better message.
  	          if (typeof typeSpecs[typeSpecName] !== 'function') {
  	            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)) {
  	          // Only monitor this failure once because there tends to be a lot of the
  	          // same error.
  	          loggedTypeFailures[error.message] = true;

  	          var stack = getStack ? getStack() : '';

  	          printWarning(
  	            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
  	          );
  	        }
  	      }
  	    }
  	  }
  	}

  	/**
  	 * Resets warning cache when testing.
  	 *
  	 * @private
  	 */
  	checkPropTypes.resetWarningCache = function() {
  	  {
  	    loggedTypeFailures = {};
  	  }
  	};

  	checkPropTypes_1 = checkPropTypes;
  	return checkPropTypes_1;
  }

  var factoryWithTypeCheckers;
  var hasRequiredFactoryWithTypeCheckers;

  function requireFactoryWithTypeCheckers () {
  	if (hasRequiredFactoryWithTypeCheckers) return factoryWithTypeCheckers;
  	hasRequiredFactoryWithTypeCheckers = 1;

  	var ReactIs = requireReactIs$1();
  	var assign = requireObjectAssign();

  	var ReactPropTypesSecret = /*@__PURE__*/ requireReactPropTypesSecret();
  	var has = /*@__PURE__*/ requireHas();
  	var checkPropTypes = /*@__PURE__*/ requireCheckPropTypes();

  	var printWarning = function() {};

  	{
  	  printWarning = function(text) {
  	    var message = 'Warning: ' + text;
  	    if (typeof console !== 'undefined') {
  	      console.error(message);
  	    }
  	    try {
  	      // --- Welcome to debugging React ---
  	      // This error was thrown as a convenience so that you can use this stack
  	      // to find the callsite that caused this warning to fire.
  	      throw new Error(message);
  	    } catch (x) {}
  	  };
  	}

  	function emptyFunctionThatReturnsNull() {
  	  return null;
  	}

  	factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
  	  /* global Symbol */
  	  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
  	  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.

  	  /**
  	   * Returns the iterator method function contained on the iterable object.
  	   *
  	   * Be sure to invoke the function with the iterable as context:
  	   *
  	   *     var iteratorFn = getIteratorFn(myIterable);
  	   *     if (iteratorFn) {
  	   *       var iterator = iteratorFn.call(myIterable);
  	   *       ...
  	   *     }
  	   *
  	   * @param {?object} maybeIterable
  	   * @return {?function}
  	   */
  	  function getIteratorFn(maybeIterable) {
  	    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
  	    if (typeof iteratorFn === 'function') {
  	      return iteratorFn;
  	    }
  	  }

  	  /**
  	   * Collection of methods that allow declaration and validation of props that are
  	   * supplied to React components. Example usage:
  	   *
  	   *   var Props = require('ReactPropTypes');
  	   *   var MyArticle = React.createClass({
  	   *     propTypes: {
  	   *       // An optional string prop named "description".
  	   *       description: Props.string,
  	   *
  	   *       // A required enum prop named "category".
  	   *       category: Props.oneOf(['News','Photos']).isRequired,
  	   *
  	   *       // A prop named "dialog" that requires an instance of Dialog.
  	   *       dialog: Props.instanceOf(Dialog).isRequired
  	   *     },
  	   *     render: function() { ... }
  	   *   });
  	   *
  	   * A more formal specification of how these methods are used:
  	   *
  	   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
  	   *   decl := ReactPropTypes.{type}(.isRequired)?
  	   *
  	   * Each and every declaration produces a function with the same signature. This
  	   * allows the creation of custom validation functions. For example:
  	   *
  	   *  var MyLink = React.createClass({
  	   *    propTypes: {
  	   *      // An optional string or URI prop named "href".
  	   *      href: function(props, propName, componentName) {
  	   *        var propValue = props[propName];
  	   *        if (propValue != null && typeof propValue !== 'string' &&
  	   *            !(propValue instanceof URI)) {
  	   *          return new Error(
  	   *            'Expected a string or an URI for ' + propName + ' in ' +
  	   *            componentName
  	   *          );
  	   *        }
  	   *      }
  	   *    },
  	   *    render: function() {...}
  	   *  });
  	   *
  	   * @internal
  	   */

  	  var ANONYMOUS = '<<anonymous>>';

  	  // Important!
  	  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
  	  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,
  	  };

  	  /**
  	   * inlined Object.is polyfill to avoid requiring consumers ship their own
  	   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
  	   */
  	  /*eslint-disable no-self-compare*/
  	  function is(x, y) {
  	    // SameValue algorithm
  	    if (x === y) {
  	      // Steps 1-5, 7-10
  	      // Steps 6.b-6.e: +0 != -0
  	      return x !== 0 || 1 / x === 1 / y;
  	    } else {
  	      // Step 6.a: NaN == NaN
  	      return x !== x && y !== y;
  	    }
  	  }
  	  /*eslint-enable no-self-compare*/

  	  /**
  	   * We use an Error-like object for backward compatibility as people may call
  	   * PropTypes directly and inspect their output. However, we don't use real
  	   * Errors anymore. We don't inspect their stack anyway, and creating them
  	   * is prohibitively expensive if they are created too often, such as what
  	   * happens in oneOfType() for any type before the one that matched.
  	   */
  	  function PropTypeError(message, data) {
  	    this.message = message;
  	    this.data = data && typeof data === 'object' ? data: {};
  	    this.stack = '';
  	  }
  	  // Make `instanceof Error` still work for returned errors.
  	  PropTypeError.prototype = Error.prototype;

  	  function createChainableTypeChecker(validate) {
  	    {
  	      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) {
  	          // New behavior only for users of `prop-types` package
  	          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 (typeof console !== 'undefined') {
  	          // Old behavior for people using React.PropTypes
  	          var cacheKey = componentName + ':' + propName;
  	          if (
  	            !manualPropTypeCallCache[cacheKey] &&
  	            // Avoid spamming the console because they are often not actionable except for lib authors
  	            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 (props[propName] == null) {
  	        if (isRequired) {
  	          if (props[propName] === null) {
  	            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;
  	      } else {
  	        return validate(props, propName, componentName, location, propFullName);
  	      }
  	    }

  	    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) {
  	        // `propValue` being instance of, say, date/regexp, pass the 'object'
  	        // check, but we can offer a more precise error message here rather than
  	        // 'of type `object`'.
  	        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 (typeof typeChecker !== 'function') {
  	        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 (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]).'
  	          );
  	        } else {
  	          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 replacer(key, value) {
  	        var type = getPreciseType(value);
  	        if (type === 'symbol') {
  	          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 (typeof typeChecker !== 'function') {
  	        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
  	      }
  	      var propValue = props[propName];
  	      var propType = getPropType(propValue);
  	      if (propType !== 'object') {
  	        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)) {
  	      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 (typeof checker !== 'function') {
  	        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 (checkerResult == null) {
  	          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 (propType !== 'object') {
  	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
  	      }
  	      for (var key in shapeTypes) {
  	        var checker = shapeTypes[key];
  	        if (typeof checker !== 'function') {
  	          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 (propType !== 'object') {
  	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
  	      }
  	      // We need to check all keys in case some are required but missing from props.
  	      var allKeys = assign({}, props[propName], shapeTypes);
  	      for (var key in allKeys) {
  	        var checker = shapeTypes[key];
  	        if (has(shapeTypes, key) && typeof checker !== 'function') {
  	          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 (propValue === null || isValidElement(propValue)) {
  	          return true;
  	        }

  	        var iteratorFn = getIteratorFn(propValue);
  	        if (iteratorFn) {
  	          var iterator = iteratorFn.call(propValue);
  	          var step;
  	          if (iteratorFn !== propValue.entries) {
  	            while (!(step = iterator.next()).done) {
  	              if (!isNode(step.value)) {
  	                return false;
  	              }
  	            }
  	          } else {
  	            // Iterator will provide entry [k,v] tuples rather than values.
  	            while (!(step = iterator.next()).done) {
  	              var entry = step.value;
  	              if (entry) {
  	                if (!isNode(entry[1])) {
  	                  return false;
  	                }
  	              }
  	            }
  	          }
  	        } else {
  	          return false;
  	        }

  	        return true;
  	      default:
  	        return false;
  	    }
  	  }

  	  function isSymbol(propType, propValue) {
  	    // Native Symbol.
  	    if (propType === 'symbol') {
  	      return true;
  	    }

  	    // falsy value can't be a Symbol
  	    if (!propValue) {
  	      return false;
  	    }

  	    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
  	    if (propValue['@@toStringTag'] === 'Symbol') {
  	      return true;
  	    }

  	    // Fallback for non-spec compliant Symbols which are polyfilled.
  	    if (typeof Symbol === 'function' && propValue instanceof Symbol) {
  	      return true;
  	    }

  	    return false;
  	  }

  	  // Equivalent of `typeof` but with special handling for array and regexp.
  	  function getPropType(propValue) {
  	    var propType = typeof propValue;
  	    if (Array.isArray(propValue)) {
  	      return 'array';
  	    }
  	    if (propValue instanceof RegExp) {
  	      // Old webkits (at least until Android 4.0) return 'function' rather than
  	      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
  	      // passes PropTypes.object.
  	      return 'object';
  	    }
  	    if (isSymbol(propType, propValue)) {
  	      return 'symbol';
  	    }
  	    return propType;
  	  }

  	  // This handles more types than `getPropType`. Only used for error messages.
  	  // See `createPrimitiveTypeChecker`.
  	  function getPreciseType(propValue) {
  	    if (typeof propValue === 'undefined' || propValue === null) {
  	      return '' + propValue;
  	    }
  	    var propType = getPropType(propValue);
  	    if (propType === 'object') {
  	      if (propValue instanceof Date) {
  	        return 'date';
  	      } else if (propValue instanceof RegExp) {
  	        return 'regexp';
  	      }
  	    }
  	    return propType;
  	  }

  	  // Returns a string that is postfixed to a warning about an invalid type.
  	  // For example, "undefined" or "of type array"
  	  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;
  	    }
  	  }

  	  // Returns class name of the object, if any.
  	  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;
  	};
  	return factoryWithTypeCheckers;
  }

  var hasRequiredPropTypes;

  function requirePropTypes () {
  	if (hasRequiredPropTypes) return propTypes.exports;
  	hasRequiredPropTypes = 1;
  	{
  	  var ReactIs = requireReactIs$1();

  	  // By explicitly using `prop-types` you are opting into new development behavior.
  	  // http://fb.me/prop-types-in-prod
  	  var throwOnDirectAccess = true;
  	  propTypes.exports = /*@__PURE__*/ requireFactoryWithTypeCheckers()(ReactIs.isElement, throwOnDirectAccess);
  	}
  	return propTypes.exports;
  }

  var propTypesExports = /*@__PURE__*/ requirePropTypes();
  var PropTypes = /*@__PURE__*/getDefaultExportFromCjs(propTypesExports);

  var jsxRuntime = {exports: {}};

  var reactJsxRuntime_development = {};

  var hasRequiredReactJsxRuntime_development;

  function requireReactJsxRuntime_development () {
  	if (hasRequiredReactJsxRuntime_development) return reactJsxRuntime_development;
  	hasRequiredReactJsxRuntime_development = 1;

  	{
  	  (function() {

  	var React$1 = React;

  	// ATTENTION
  	// When adding new symbols to this file,
  	// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
  	// The Symbol used to tag the ReactElement-like types.
  	var REACT_ELEMENT_TYPE = Symbol.for('react.element');
  	var REACT_PORTAL_TYPE = Symbol.for('react.portal');
  	var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
  	var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
  	var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
  	var REACT_PROVIDER_TYPE = Symbol.for('react.provider');
  	var REACT_CONTEXT_TYPE = Symbol.for('react.context');
  	var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
  	var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
  	var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
  	var REACT_MEMO_TYPE = Symbol.for('react.memo');
  	var REACT_LAZY_TYPE = Symbol.for('react.lazy');
  	var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
  	var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
  	var FAUX_ITERATOR_SYMBOL = '@@iterator';
  	function getIteratorFn(maybeIterable) {
  	  if (maybeIterable === null || typeof maybeIterable !== 'object') {
  	    return null;
  	  }

  	  var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];

  	  if (typeof maybeIterator === 'function') {
  	    return maybeIterator;
  	  }

  	  return null;
  	}

  	var ReactSharedInternals = React$1.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;

  	function error(format) {
  	  {
  	    {
  	      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
  	        args[_key2 - 1] = arguments[_key2];
  	      }

  	      printWarning('error', format, args);
  	    }
  	  }
  	}

  	function printWarning(level, format, args) {
  	  // When changing this logic, you might want to also
  	  // update consoleWithStackDev.www.js as well.
  	  {
  	    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
  	    var stack = ReactDebugCurrentFrame.getStackAddendum();

  	    if (stack !== '') {
  	      format += '%s';
  	      args = args.concat([stack]);
  	    } // eslint-disable-next-line react-internal/safe-string-coercion


  	    var argsWithFormat = args.map(function (item) {
  	      return String(item);
  	    }); // Careful: RN currently depends on this prefix

  	    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
  	    // breaks IE9: https://github.com/facebook/react/issues/13610
  	    // eslint-disable-next-line react-internal/no-production-logging

  	    Function.prototype.apply.call(console[level], console, argsWithFormat);
  	  }
  	}

  	// -----------------------------------------------------------------------------

  	var enableScopeAPI = false; // Experimental Create Event Handle API.
  	var enableCacheElement = false;
  	var enableTransitionTracing = false; // No known bugs, but needs performance testing

  	var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
  	// stuff. Intended to enable React core members to more easily debug scheduling
  	// issues in DEV builds.

  	var enableDebugTracing = false; // Track which Fiber(s) schedule render work.

  	var REACT_MODULE_REFERENCE;

  	{
  	  REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
  	}

  	function isValidElementType(type) {
  	  if (typeof type === 'string' || typeof type === 'function') {
  	    return true;
  	  } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).


  	  if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing  || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden  || type === REACT_OFFSCREEN_TYPE || enableScopeAPI  || enableCacheElement  || enableTransitionTracing ) {
  	    return true;
  	  }

  	  if (typeof type === 'object' && type !== null) {
  	    if (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 || // This needs to include all possible module reference object
  	    // types supported by any Flight configuration anywhere since
  	    // we don't know which Flight build this will end up being used
  	    // with.
  	    type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {
  	      return true;
  	    }
  	  }

  	  return false;
  	}

  	function getWrappedName(outerType, innerType, wrapperName) {
  	  var displayName = outerType.displayName;

  	  if (displayName) {
  	    return displayName;
  	  }

  	  var functionName = innerType.displayName || innerType.name || '';
  	  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
  	} // Keep in sync with react-reconciler/getComponentNameFromFiber


  	function getContextName(type) {
  	  return type.displayName || 'Context';
  	} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.


  	function getComponentNameFromType(type) {
  	  if (type == null) {
  	    // Host root, text node or just invalid type.
  	    return null;
  	  }

  	  {
  	    if (typeof type.tag === 'number') {
  	      error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.');
  	    }
  	  }

  	  if (typeof type === 'function') {
  	    return type.displayName || type.name || null;
  	  }

  	  if (typeof type === 'string') {
  	    return type;
  	  }

  	  switch (type) {
  	    case REACT_FRAGMENT_TYPE:
  	      return 'Fragment';

  	    case REACT_PORTAL_TYPE:
  	      return 'Portal';

  	    case REACT_PROFILER_TYPE:
  	      return 'Profiler';

  	    case REACT_STRICT_MODE_TYPE:
  	      return 'StrictMode';

  	    case REACT_SUSPENSE_TYPE:
  	      return 'Suspense';

  	    case REACT_SUSPENSE_LIST_TYPE:
  	      return 'SuspenseList';

  	  }

  	  if (typeof type === 'object') {
  	    switch (type.$$typeof) {
  	      case REACT_CONTEXT_TYPE:
  	        var context = type;
  	        return getContextName(context) + '.Consumer';

  	      case REACT_PROVIDER_TYPE:
  	        var provider = type;
  	        return getContextName(provider._context) + '.Provider';

  	      case REACT_FORWARD_REF_TYPE:
  	        return getWrappedName(type, type.render, 'ForwardRef');

  	      case REACT_MEMO_TYPE:
  	        var outerName = type.displayName || null;

  	        if (outerName !== null) {
  	          return outerName;
  	        }

  	        return getComponentNameFromType(type.type) || 'Memo';

  	      case REACT_LAZY_TYPE:
  	        {
  	          var lazyComponent = type;
  	          var payload = lazyComponent._payload;
  	          var init = lazyComponent._init;

  	          try {
  	            return getComponentNameFromType(init(payload));
  	          } catch (x) {
  	            return null;
  	          }
  	        }

  	      // eslint-disable-next-line no-fallthrough
  	    }
  	  }

  	  return null;
  	}

  	var assign = Object.assign;

  	// Helpers to patch console.logs to avoid logging during side-effect free
  	// replaying on render function. This currently only patches the object
  	// lazily which won't cover if the log function was extracted eagerly.
  	// We could also eagerly patch the method.
  	var disabledDepth = 0;
  	var prevLog;
  	var prevInfo;
  	var prevWarn;
  	var prevError;
  	var prevGroup;
  	var prevGroupCollapsed;
  	var prevGroupEnd;

  	function disabledLog() {}

  	disabledLog.__reactDisabledLog = true;
  	function disableLogs() {
  	  {
  	    if (disabledDepth === 0) {
  	      /* eslint-disable react-internal/no-production-logging */
  	      prevLog = console.log;
  	      prevInfo = console.info;
  	      prevWarn = console.warn;
  	      prevError = console.error;
  	      prevGroup = console.group;
  	      prevGroupCollapsed = console.groupCollapsed;
  	      prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099

  	      var props = {
  	        configurable: true,
  	        enumerable: true,
  	        value: disabledLog,
  	        writable: true
  	      }; // $FlowFixMe Flow thinks console is immutable.

  	      Object.defineProperties(console, {
  	        info: props,
  	        log: props,
  	        warn: props,
  	        error: props,
  	        group: props,
  	        groupCollapsed: props,
  	        groupEnd: props
  	      });
  	      /* eslint-enable react-internal/no-production-logging */
  	    }

  	    disabledDepth++;
  	  }
  	}
  	function reenableLogs() {
  	  {
  	    disabledDepth--;

  	    if (disabledDepth === 0) {
  	      /* eslint-disable react-internal/no-production-logging */
  	      var props = {
  	        configurable: true,
  	        enumerable: true,
  	        writable: true
  	      }; // $FlowFixMe Flow thinks console is immutable.

  	      Object.defineProperties(console, {
  	        log: assign({}, props, {
  	          value: prevLog
  	        }),
  	        info: assign({}, props, {
  	          value: prevInfo
  	        }),
  	        warn: assign({}, props, {
  	          value: prevWarn
  	        }),
  	        error: assign({}, props, {
  	          value: prevError
  	        }),
  	        group: assign({}, props, {
  	          value: prevGroup
  	        }),
  	        groupCollapsed: assign({}, props, {
  	          value: prevGroupCollapsed
  	        }),
  	        groupEnd: assign({}, props, {
  	          value: prevGroupEnd
  	        })
  	      });
  	      /* eslint-enable react-internal/no-production-logging */
  	    }

  	    if (disabledDepth < 0) {
  	      error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');
  	    }
  	  }
  	}

  	var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
  	var prefix;
  	function describeBuiltInComponentFrame(name, source, ownerFn) {
  	  {
  	    if (prefix === undefined) {
  	      // Extract the VM specific prefix used by each line.
  	      try {
  	        throw Error();
  	      } catch (x) {
  	        var match = x.stack.trim().match(/\n( *(at )?)/);
  	        prefix = match && match[1] || '';
  	      }
  	    } // We use the prefix to ensure our stacks line up with native stack frames.


  	    return '\n' + prefix + name;
  	  }
  	}
  	var reentry = false;
  	var componentFrameCache;

  	{
  	  var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
  	  componentFrameCache = new PossiblyWeakMap();
  	}

  	function describeNativeComponentFrame(fn, construct) {
  	  // If something asked for a stack inside a fake render, it should get ignored.
  	  if ( !fn || reentry) {
  	    return '';
  	  }

  	  {
  	    var frame = componentFrameCache.get(fn);

  	    if (frame !== undefined) {
  	      return frame;
  	    }
  	  }

  	  var control;
  	  reentry = true;
  	  var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.

  	  Error.prepareStackTrace = undefined;
  	  var previousDispatcher;

  	  {
  	    previousDispatcher = ReactCurrentDispatcher.current; // Set the dispatcher in DEV because this might be call in the render function
  	    // for warnings.

  	    ReactCurrentDispatcher.current = null;
  	    disableLogs();
  	  }

  	  try {
  	    // This should throw.
  	    if (construct) {
  	      // Something should be setting the props in the constructor.
  	      var Fake = function () {
  	        throw Error();
  	      }; // $FlowFixMe


  	      Object.defineProperty(Fake.prototype, 'props', {
  	        set: function () {
  	          // We use a throwing setter instead of frozen or non-writable props
  	          // because that won't throw in a non-strict mode function.
  	          throw Error();
  	        }
  	      });

  	      if (typeof Reflect === 'object' && Reflect.construct) {
  	        // We construct a different control for this case to include any extra
  	        // frames added by the construct call.
  	        try {
  	          Reflect.construct(Fake, []);
  	        } catch (x) {
  	          control = x;
  	        }

  	        Reflect.construct(fn, [], Fake);
  	      } else {
  	        try {
  	          Fake.call();
  	        } catch (x) {
  	          control = x;
  	        }

  	        fn.call(Fake.prototype);
  	      }
  	    } else {
  	      try {
  	        throw Error();
  	      } catch (x) {
  	        control = x;
  	      }

  	      fn();
  	    }
  	  } catch (sample) {
  	    // This is inlined manually because closure doesn't do it for us.
  	    if (sample && control && typeof sample.stack === 'string') {
  	      // This extracts the first frame from the sample that isn't also in the control.
  	      // Skipping one frame that we assume is the frame that calls the two.
  	      var sampleLines = sample.stack.split('\n');
  	      var controlLines = control.stack.split('\n');
  	      var s = sampleLines.length - 1;
  	      var c = controlLines.length - 1;

  	      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
  	        // We expect at least one stack frame to be shared.
  	        // Typically this will be the root most one. However, stack frames may be
  	        // cut off due to maximum stack limits. In this case, one maybe cut off
  	        // earlier than the other. We assume that the sample is longer or the same
  	        // and there for cut off earlier. So we should find the root most frame in
  	        // the sample somewhere in the control.
  	        c--;
  	      }

  	      for (; s >= 1 && c >= 0; s--, c--) {
  	        // Next we find the first one that isn't the same which should be the
  	        // frame that called our sample function and the control.
  	        if (sampleLines[s] !== controlLines[c]) {
  	          // In V8, the first line is describing the message but other VMs don't.
  	          // If we're about to return the first line, and the control is also on the same
  	          // line, that's a pretty good indicator that our sample threw at same line as
  	          // the control. I.e. before we entered the sample frame. So we ignore this result.
  	          // This can happen if you passed a class to function component, or non-function.
  	          if (s !== 1 || c !== 1) {
  	            do {
  	              s--;
  	              c--; // We may still have similar intermediate frames from the construct call.
  	              // The next one that isn't the same should be our match though.

  	              if (c < 0 || sampleLines[s] !== controlLines[c]) {
  	                // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
  	                var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
  	                // but we have a user-provided "displayName"
  	                // splice it in to make the stack more readable.


  	                if (fn.displayName && _frame.includes('<anonymous>')) {
  	                  _frame = _frame.replace('<anonymous>', fn.displayName);
  	                }

  	                {
  	                  if (typeof fn === 'function') {
  	                    componentFrameCache.set(fn, _frame);
  	                  }
  	                } // Return the line we found.


  	                return _frame;
  	              }
  	            } while (s >= 1 && c >= 0);
  	          }

  	          break;
  	        }
  	      }
  	    }
  	  } finally {
  	    reentry = false;

  	    {
  	      ReactCurrentDispatcher.current = previousDispatcher;
  	      reenableLogs();
  	    }

  	    Error.prepareStackTrace = previousPrepareStackTrace;
  	  } // Fallback to just using the name if we couldn't make it throw.


  	  var name = fn ? fn.displayName || fn.name : '';
  	  var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';

  	  {
  	    if (typeof fn === 'function') {
  	      componentFrameCache.set(fn, syntheticFrame);
  	    }
  	  }

  	  return syntheticFrame;
  	}
  	function describeFunctionComponentFrame(fn, source, ownerFn) {
  	  {
  	    return describeNativeComponentFrame(fn, false);
  	  }
  	}

  	function shouldConstruct(Component) {
  	  var prototype = Component.prototype;
  	  return !!(prototype && prototype.isReactComponent);
  	}

  	function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {

  	  if (type == null) {
  	    return '';
  	  }

  	  if (typeof type === 'function') {
  	    {
  	      return describeNativeComponentFrame(type, shouldConstruct(type));
  	    }
  	  }

  	  if (typeof type === 'string') {
  	    return describeBuiltInComponentFrame(type);
  	  }

  	  switch (type) {
  	    case REACT_SUSPENSE_TYPE:
  	      return describeBuiltInComponentFrame('Suspense');

  	    case REACT_SUSPENSE_LIST_TYPE:
  	      return describeBuiltInComponentFrame('SuspenseList');
  	  }

  	  if (typeof type === 'object') {
  	    switch (type.$$typeof) {
  	      case REACT_FORWARD_REF_TYPE:
  	        return describeFunctionComponentFrame(type.render);

  	      case REACT_MEMO_TYPE:
  	        // Memo may contain any component type so we recursively resolve it.
  	        return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);

  	      case REACT_LAZY_TYPE:
  	        {
  	          var lazyComponent = type;
  	          var payload = lazyComponent._payload;
  	          var init = lazyComponent._init;

  	          try {
  	            // Lazy may contain any component type so we recursively resolve it.
  	            return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
  	          } catch (x) {}
  	        }
  	    }
  	  }

  	  return '';
  	}

  	var hasOwnProperty = Object.prototype.hasOwnProperty;

  	var loggedTypeFailures = {};
  	var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;

  	function setCurrentlyValidatingElement(element) {
  	  {
  	    if (element) {
  	      var owner = element._owner;
  	      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
  	      ReactDebugCurrentFrame.setExtraStackFrame(stack);
  	    } else {
  	      ReactDebugCurrentFrame.setExtraStackFrame(null);
  	    }
  	  }
  	}

  	function checkPropTypes(typeSpecs, values, location, componentName, element) {
  	  {
  	    // $FlowFixMe This is okay but Flow doesn't know it.
  	    var has = Function.call.bind(hasOwnProperty);

  	    for (var typeSpecName in typeSpecs) {
  	      if (has(typeSpecs, typeSpecName)) {
  	        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
  	        // fail the render phase where it didn't fail before. So we log it.
  	        // After these have been cleaned up, we'll let them throw.

  	        try {
  	          // This is intentionally an invariant that gets caught. It's the same
  	          // behavior as without this statement except with a better message.
  	          if (typeof typeSpecs[typeSpecName] !== 'function') {
  	            // eslint-disable-next-line react-internal/prod-error-codes
  	            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$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');
  	        } catch (ex) {
  	          error$1 = ex;
  	        }

  	        if (error$1 && !(error$1 instanceof Error)) {
  	          setCurrentlyValidatingElement(element);

  	          error('%s: type specification of %s' + ' `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error$1);

  	          setCurrentlyValidatingElement(null);
  	        }

  	        if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
  	          // Only monitor this failure once because there tends to be a lot of the
  	          // same error.
  	          loggedTypeFailures[error$1.message] = true;
  	          setCurrentlyValidatingElement(element);

  	          error('Failed %s type: %s', location, error$1.message);

  	          setCurrentlyValidatingElement(null);
  	        }
  	      }
  	    }
  	  }
  	}

  	var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare

  	function isArray(a) {
  	  return isArrayImpl(a);
  	}

  	/*
  	 * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol
  	 * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
  	 *
  	 * The functions in this module will throw an easier-to-understand,
  	 * easier-to-debug exception with a clear errors message message explaining the
  	 * problem. (Instead of a confusing exception thrown inside the implementation
  	 * of the `value` object).
  	 */
  	// $FlowFixMe only called in DEV, so void return is not possible.
  	function typeName(value) {
  	  {
  	    // toStringTag is needed for namespaced types like Temporal.Instant
  	    var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
  	    var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object';
  	    return type;
  	  }
  	} // $FlowFixMe only called in DEV, so void return is not possible.


  	function willCoercionThrow(value) {
  	  {
  	    try {
  	      testStringCoercion(value);
  	      return false;
  	    } catch (e) {
  	      return true;
  	    }
  	  }
  	}

  	function testStringCoercion(value) {
  	  // If you ended up here by following an exception call stack, here's what's
  	  // happened: you supplied an object or symbol value to React (as a prop, key,
  	  // DOM attribute, CSS property, string ref, etc.) and when React tried to
  	  // coerce it to a string using `'' + value`, an exception was thrown.
  	  //
  	  // The most common types that will cause this exception are `Symbol` instances
  	  // and Temporal objects like `Temporal.Instant`. But any object that has a
  	  // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
  	  // exception. (Library authors do this to prevent users from using built-in
  	  // numeric operators like `+` or comparison operators like `>=` because custom
  	  // methods are needed to perform accurate arithmetic or comparison.)
  	  //
  	  // To fix the problem, coerce this object or symbol value to a string before
  	  // passing it to React. The most reliable way is usually `String(value)`.
  	  //
  	  // To find which value is throwing, check the browser or debugger console.
  	  // Before this exception was thrown, there should be `console.error` output
  	  // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
  	  // problem and how that type was used: key, atrribute, input value prop, etc.
  	  // In most cases, this console output also shows the component and its
  	  // ancestor components where the exception happened.
  	  //
  	  // eslint-disable-next-line react-internal/safe-string-coercion
  	  return '' + value;
  	}
  	function checkKeyStringCoercion(value) {
  	  {
  	    if (willCoercionThrow(value)) {
  	      error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value));

  	      return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
  	    }
  	  }
  	}

  	var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
  	var RESERVED_PROPS = {
  	  key: true,
  	  ref: true,
  	  __self: true,
  	  __source: true
  	};
  	var specialPropKeyWarningShown;
  	var specialPropRefWarningShown;
  	var didWarnAboutStringRefs;

  	{
  	  didWarnAboutStringRefs = {};
  	}

  	function hasValidRef(config) {
  	  {
  	    if (hasOwnProperty.call(config, 'ref')) {
  	      var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;

  	      if (getter && getter.isReactWarning) {
  	        return false;
  	      }
  	    }
  	  }

  	  return config.ref !== undefined;
  	}

  	function hasValidKey(config) {
  	  {
  	    if (hasOwnProperty.call(config, 'key')) {
  	      var getter = Object.getOwnPropertyDescriptor(config, 'key').get;

  	      if (getter && getter.isReactWarning) {
  	        return false;
  	      }
  	    }
  	  }

  	  return config.key !== undefined;
  	}

  	function warnIfStringRefCannotBeAutoConverted(config, self) {
  	  {
  	    if (typeof config.ref === 'string' && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) {
  	      var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);

  	      if (!didWarnAboutStringRefs[componentName]) {
  	        error('Component "%s" contains the string ref "%s". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-string-ref', getComponentNameFromType(ReactCurrentOwner.current.type), config.ref);

  	        didWarnAboutStringRefs[componentName] = true;
  	      }
  	    }
  	  }
  	}

  	function defineKeyPropWarningGetter(props, displayName) {
  	  {
  	    var warnAboutAccessingKey = function () {
  	      if (!specialPropKeyWarningShown) {
  	        specialPropKeyWarningShown = true;

  	        error('%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);
  	      }
  	    };

  	    warnAboutAccessingKey.isReactWarning = true;
  	    Object.defineProperty(props, 'key', {
  	      get: warnAboutAccessingKey,
  	      configurable: true
  	    });
  	  }
  	}

  	function defineRefPropWarningGetter(props, displayName) {
  	  {
  	    var warnAboutAccessingRef = function () {
  	      if (!specialPropRefWarningShown) {
  	        specialPropRefWarningShown = true;

  	        error('%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);
  	      }
  	    };

  	    warnAboutAccessingRef.isReactWarning = true;
  	    Object.defineProperty(props, 'ref', {
  	      get: warnAboutAccessingRef,
  	      configurable: true
  	    });
  	  }
  	}
  	/**
  	 * Factory method to create a new React element. This no longer adheres to
  	 * the class pattern, so do not use new to call it. Also, instanceof check
  	 * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
  	 * if something is a React Element.
  	 *
  	 * @param {*} type
  	 * @param {*} props
  	 * @param {*} key
  	 * @param {string|object} ref
  	 * @param {*} owner
  	 * @param {*} self A *temporary* helper to detect places where `this` is
  	 * different from the `owner` when React.createElement is called, so that we
  	 * can warn. We want to get rid of owner and replace string `ref`s with arrow
  	 * functions, and as long as `this` and owner are the same, there will be no
  	 * change in behavior.
  	 * @param {*} source An annotation object (added by a transpiler or otherwise)
  	 * indicating filename, line number, and/or other information.
  	 * @internal
  	 */


  	var ReactElement = function (type, key, ref, self, source, owner, props) {
  	  var element = {
  	    // This tag allows us to uniquely identify this as a React Element
  	    $$typeof: REACT_ELEMENT_TYPE,
  	    // Built-in properties that belong on the element
  	    type: type,
  	    key: key,
  	    ref: ref,
  	    props: props,
  	    // Record the component responsible for creating this element.
  	    _owner: owner
  	  };

  	  {
  	    // The validation flag is currently mutative. We put it on
  	    // an external backing store so that we can freeze the whole object.
  	    // This can be replaced with a WeakMap once they are implemented in
  	    // commonly used development environments.
  	    element._store = {}; // To make comparing ReactElements easier for testing purposes, we make
  	    // the validation flag non-enumerable (where possible, which should
  	    // include every environment we run tests in), so the test framework
  	    // ignores it.

  	    Object.defineProperty(element._store, 'validated', {
  	      configurable: false,
  	      enumerable: false,
  	      writable: true,
  	      value: false
  	    }); // self and source are DEV only properties.

  	    Object.defineProperty(element, '_self', {
  	      configurable: false,
  	      enumerable: false,
  	      writable: false,
  	      value: self
  	    }); // Two elements created in two different places should be considered
  	    // equal for testing purposes and therefore we hide it from enumeration.

  	    Object.defineProperty(element, '_source', {
  	      configurable: false,
  	      enumerable: false,
  	      writable: false,
  	      value: source
  	    });

  	    if (Object.freeze) {
  	      Object.freeze(element.props);
  	      Object.freeze(element);
  	    }
  	  }

  	  return element;
  	};
  	/**
  	 * https://github.com/reactjs/rfcs/pull/107
  	 * @param {*} type
  	 * @param {object} props
  	 * @param {string} key
  	 */

  	function jsxDEV(type, config, maybeKey, source, self) {
  	  {
  	    var propName; // Reserved names are extracted

  	    var props = {};
  	    var key = null;
  	    var ref = null; // Currently, key can be spread in as a prop. This causes a potential
  	    // issue if key is also explicitly declared (ie. <div {...props} key="Hi" />
  	    // or <div key="Hi" {...props} /> ). We want to deprecate key spread,
  	    // but as an intermediary step, we will use jsxDEV for everything except
  	    // <div {...props} key="Hi" />, because we aren't currently able to tell if
  	    // key is explicitly declared to be undefined or not.

  	    if (maybeKey !== undefined) {
  	      {
  	        checkKeyStringCoercion(maybeKey);
  	      }

  	      key = '' + maybeKey;
  	    }

  	    if (hasValidKey(config)) {
  	      {
  	        checkKeyStringCoercion(config.key);
  	      }

  	      key = '' + config.key;
  	    }

  	    if (hasValidRef(config)) {
  	      ref = config.ref;
  	      warnIfStringRefCannotBeAutoConverted(config, self);
  	    } // Remaining properties are added to a new props object


  	    for (propName in config) {
  	      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
  	        props[propName] = config[propName];
  	      }
  	    } // Resolve default props


  	    if (type && type.defaultProps) {
  	      var defaultProps = type.defaultProps;

  	      for (propName in defaultProps) {
  	        if (props[propName] === undefined) {
  	          props[propName] = defaultProps[propName];
  	        }
  	      }
  	    }

  	    if (key || ref) {
  	      var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;

  	      if (key) {
  	        defineKeyPropWarningGetter(props, displayName);
  	      }

  	      if (ref) {
  	        defineRefPropWarningGetter(props, displayName);
  	      }
  	    }

  	    return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
  	  }
  	}

  	var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
  	var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;

  	function setCurrentlyValidatingElement$1(element) {
  	  {
  	    if (element) {
  	      var owner = element._owner;
  	      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
  	      ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
  	    } else {
  	      ReactDebugCurrentFrame$1.setExtraStackFrame(null);
  	    }
  	  }
  	}

  	var propTypesMisspellWarningShown;

  	{
  	  propTypesMisspellWarningShown = false;
  	}
  	/**
  	 * Verifies the object is a ReactElement.
  	 * See https://reactjs.org/docs/react-api.html#isvalidelement
  	 * @param {?object} object
  	 * @return {boolean} True if `object` is a ReactElement.
  	 * @final
  	 */


  	function isValidElement(object) {
  	  {
  	    return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
  	  }
  	}

  	function getDeclarationErrorAddendum() {
  	  {
  	    if (ReactCurrentOwner$1.current) {
  	      var name = getComponentNameFromType(ReactCurrentOwner$1.current.type);

  	      if (name) {
  	        return '\n\nCheck the render method of `' + name + '`.';
  	      }
  	    }

  	    return '';
  	  }
  	}

  	function getSourceInfoErrorAddendum(source) {
  	  {
  	    if (source !== undefined) {
  	      var fileName = source.fileName.replace(/^.*[\\\/]/, '');
  	      var lineNumber = source.lineNumber;
  	      return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
  	    }

  	    return '';
  	  }
  	}
  	/**
  	 * Warn if there's no key explicitly set on dynamic arrays of children or
  	 * object keys are not valid. This allows us to keep track of children between
  	 * updates.
  	 */


  	var ownerHasKeyUseWarning = {};

  	function getCurrentComponentErrorInfo(parentType) {
  	  {
  	    var info = getDeclarationErrorAddendum();

  	    if (!info) {
  	      var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;

  	      if (parentName) {
  	        info = "\n\nCheck the top-level render call using <" + parentName + ">.";
  	      }
  	    }

  	    return info;
  	  }
  	}
  	/**
  	 * Warn if the element doesn't have an explicit key assigned to it.
  	 * This element is in an array. The array could grow and shrink or be
  	 * reordered. All children that haven't already been validated are required to
  	 * have a "key" property assigned to it. Error statuses are cached so a warning
  	 * will only be shown once.
  	 *
  	 * @internal
  	 * @param {ReactElement} element Element that requires a key.
  	 * @param {*} parentType element's parent's type.
  	 */


  	function validateExplicitKey(element, parentType) {
  	  {
  	    if (!element._store || element._store.validated || element.key != null) {
  	      return;
  	    }

  	    element._store.validated = true;
  	    var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);

  	    if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
  	      return;
  	    }

  	    ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a
  	    // property, it may be the creator of the child that's responsible for
  	    // assigning it a key.

  	    var childOwner = '';

  	    if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) {
  	      // Give the component that originally created this child.
  	      childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
  	    }

  	    setCurrentlyValidatingElement$1(element);

  	    error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);

  	    setCurrentlyValidatingElement$1(null);
  	  }
  	}
  	/**
  	 * Ensure that every element either is passed in a static location, in an
  	 * array with an explicit keys property defined, or in an object literal
  	 * with valid key property.
  	 *
  	 * @internal
  	 * @param {ReactNode} node Statically passed child of any type.
  	 * @param {*} parentType node's parent's type.
  	 */


  	function validateChildKeys(node, parentType) {
  	  {
  	    if (typeof node !== 'object') {
  	      return;
  	    }

  	    if (isArray(node)) {
  	      for (var i = 0; i < node.length; i++) {
  	        var child = node[i];

  	        if (isValidElement(child)) {
  	          validateExplicitKey(child, parentType);
  	        }
  	      }
  	    } else if (isValidElement(node)) {
  	      // This element was passed in a valid location.
  	      if (node._store) {
  	        node._store.validated = true;
  	      }
  	    } else if (node) {
  	      var iteratorFn = getIteratorFn(node);

  	      if (typeof iteratorFn === 'function') {
  	        // Entry iterators used to provide implicit keys,
  	        // but now we print a separate warning for them later.
  	        if (iteratorFn !== node.entries) {
  	          var iterator = iteratorFn.call(node);
  	          var step;

  	          while (!(step = iterator.next()).done) {
  	            if (isValidElement(step.value)) {
  	              validateExplicitKey(step.value, parentType);
  	            }
  	          }
  	        }
  	      }
  	    }
  	  }
  	}
  	/**
  	 * Given an element, validate that its props follow the propTypes definition,
  	 * provided by the type.
  	 *
  	 * @param {ReactElement} element
  	 */


  	function validatePropTypes(element) {
  	  {
  	    var type = element.type;

  	    if (type === null || type === undefined || typeof type === 'string') {
  	      return;
  	    }

  	    var propTypes;

  	    if (typeof type === 'function') {
  	      propTypes = type.propTypes;
  	    } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
  	    // Inner props are checked in the reconciler.
  	    type.$$typeof === REACT_MEMO_TYPE)) {
  	      propTypes = type.propTypes;
  	    } else {
  	      return;
  	    }

  	    if (propTypes) {
  	      // Intentionally inside to avoid triggering lazy initializers:
  	      var name = getComponentNameFromType(type);
  	      checkPropTypes(propTypes, element.props, 'prop', name, element);
  	    } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
  	      propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:

  	      var _name = getComponentNameFromType(type);

  	      error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown');
  	    }

  	    if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) {
  	      error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');
  	    }
  	  }
  	}
  	/**
  	 * Given a fragment, validate that it can only be provided with fragment props
  	 * @param {ReactElement} fragment
  	 */


  	function validateFragmentProps(fragment) {
  	  {
  	    var keys = Object.keys(fragment.props);

  	    for (var i = 0; i < keys.length; i++) {
  	      var key = keys[i];

  	      if (key !== 'children' && key !== 'key') {
  	        setCurrentlyValidatingElement$1(fragment);

  	        error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);

  	        setCurrentlyValidatingElement$1(null);
  	        break;
  	      }
  	    }

  	    if (fragment.ref !== null) {
  	      setCurrentlyValidatingElement$1(fragment);

  	      error('Invalid attribute `ref` supplied to `React.Fragment`.');

  	      setCurrentlyValidatingElement$1(null);
  	    }
  	  }
  	}

  	var didWarnAboutKeySpread = {};
  	function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
  	  {
  	    var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
  	    // succeed and there will likely be errors in render.

  	    if (!validType) {
  	      var info = '';

  	      if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
  	        info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports.";
  	      }

  	      var sourceInfo = getSourceInfoErrorAddendum(source);

  	      if (sourceInfo) {
  	        info += sourceInfo;
  	      } else {
  	        info += getDeclarationErrorAddendum();
  	      }

  	      var typeString;

  	      if (type === null) {
  	        typeString = 'null';
  	      } else if (isArray(type)) {
  	        typeString = 'array';
  	      } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
  	        typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />";
  	        info = ' Did you accidentally export a JSX literal instead of a component?';
  	      } else {
  	        typeString = typeof type;
  	      }

  	      error('React.jsx: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
  	    }

  	    var element = jsxDEV(type, props, key, source, self); // The result can be nullish if a mock or a custom function is used.
  	    // TODO: Drop this when these are no longer allowed as the type argument.

  	    if (element == null) {
  	      return element;
  	    } // Skip key warning if the type isn't valid since our key validation logic
  	    // doesn't expect a non-string/function type and can throw confusing errors.
  	    // We don't want exception behavior to differ between dev and prod.
  	    // (Rendering will throw with a helpful message and as soon as the type is
  	    // fixed, the key warnings will appear.)


  	    if (validType) {
  	      var children = props.children;

  	      if (children !== undefined) {
  	        if (isStaticChildren) {
  	          if (isArray(children)) {
  	            for (var i = 0; i < children.length; i++) {
  	              validateChildKeys(children[i], type);
  	            }

  	            if (Object.freeze) {
  	              Object.freeze(children);
  	            }
  	          } else {
  	            error('React.jsx: Static children should always be an array. ' + 'You are likely explicitly calling React.jsxs or React.jsxDEV. ' + 'Use the Babel transform instead.');
  	          }
  	        } else {
  	          validateChildKeys(children, type);
  	        }
  	      }
  	    }

  	    {
  	      if (hasOwnProperty.call(props, 'key')) {
  	        var componentName = getComponentNameFromType(type);
  	        var keys = Object.keys(props).filter(function (k) {
  	          return k !== 'key';
  	        });
  	        var beforeExample = keys.length > 0 ? '{key: someKey, ' + keys.join(': ..., ') + ': ...}' : '{key: someKey}';

  	        if (!didWarnAboutKeySpread[componentName + beforeExample]) {
  	          var afterExample = keys.length > 0 ? '{' + keys.join(': ..., ') + ': ...}' : '{}';

  	          error('A props object containing a "key" prop is being spread into JSX:\n' + '  let props = %s;\n' + '  <%s {...props} />\n' + 'React keys must be passed directly to JSX without using spread:\n' + '  let props = %s;\n' + '  <%s key={someKey} {...props} />', beforeExample, componentName, afterExample, componentName);

  	          didWarnAboutKeySpread[componentName + beforeExample] = true;
  	        }
  	      }
  	    }

  	    if (type === REACT_FRAGMENT_TYPE) {
  	      validateFragmentProps(element);
  	    } else {
  	      validatePropTypes(element);
  	    }

  	    return element;
  	  }
  	} // These two functions exist to still get child warnings in dev
  	// even with the prod transform. This means that jsxDEV is purely
  	// opt-in behavior for better messages but that we won't stop
  	// giving you warnings if you use production apis.

  	function jsxWithValidationStatic(type, props, key) {
  	  {
  	    return jsxWithValidation(type, props, key, true);
  	  }
  	}
  	function jsxWithValidationDynamic(type, props, key) {
  	  {
  	    return jsxWithValidation(type, props, key, false);
  	  }
  	}

  	var jsx =  jsxWithValidationDynamic ; // we may want to special case jsxs internally to take advantage of static children.
  	// for now we can ship identical prod functions

  	var jsxs =  jsxWithValidationStatic ;

  	reactJsxRuntime_development.Fragment = REACT_FRAGMENT_TYPE;
  	reactJsxRuntime_development.jsx = jsx;
  	reactJsxRuntime_development.jsxs = jsxs;
  	  })();
  	}
  	return reactJsxRuntime_development;
  }

  var hasRequiredJsxRuntime;

  function requireJsxRuntime () {
  	if (hasRequiredJsxRuntime) return jsxRuntime.exports;
  	hasRequiredJsxRuntime = 1;

  	{
  	  jsxRuntime.exports = requireReactJsxRuntime_development();
  	}
  	return jsxRuntime.exports;
  }

  var jsxRuntimeExports = requireJsxRuntime();

  var cache;
  if ((typeof document === "undefined" ? "undefined" : _typeof(document)) === 'object') {
    cache = createCache({
      key: 'css',
      prepend: true
    });
  }
  function StyledEngineProvider(props) {
    var injectFirst = props.injectFirst,
      children = props.children;
    return injectFirst && cache ? /*#__PURE__*/jsxRuntimeExports.jsx(CacheProvider, {
      value: cache,
      children: children
    }) : children;
  }
  StyledEngineProvider.propTypes = {
    /**
     * Your component tree.
     */
    children: PropTypes.node,
    /**
     * By default, the styles are injected last in the <head> element of the page.
     * As a result, they gain more specificity than any other style sheet.
     * If you want to override MUI's styles, set this prop.
     */
    injectFirst: PropTypes.bool
  } ;

  function isEmpty$3(obj) {
    return obj === undefined || obj === null || Object.keys(obj).length === 0;
  }
  function GlobalStyles$2(props) {
    var styles = props.styles,
      _props$defaultTheme = props.defaultTheme,
      defaultTheme = _props$defaultTheme === void 0 ? {} : _props$defaultTheme;
    var globalStyles = typeof styles === 'function' ? function (themeInput) {
      return styles(isEmpty$3(themeInput) ? defaultTheme : themeInput);
    } : styles;
    return /*#__PURE__*/jsxRuntimeExports.jsx(Global, {
      styles: globalStyles
    });
  }
  GlobalStyles$2.propTypes = {
    defaultTheme: PropTypes.object,
    styles: PropTypes.oneOfType([PropTypes.array, PropTypes.string, PropTypes.object, PropTypes.func])
  } ;

  function styled$3(tag, options) {
    var stylesFactory = newStyled(tag, options);
    {
      return function () {
        var component = typeof tag === 'string' ? "\"".concat(tag, "\"") : 'component';
        for (var _len = arguments.length, styles = new Array(_len), _key = 0; _key < _len; _key++) {
          styles[_key] = arguments[_key];
        }
        if (styles.length === 0) {
          console.error(["MUI: Seems like you called `styled(".concat(component, ")()` without a `style` argument."), 'You must provide a `styles` argument: `styled("div")(styleYouForgotToPass)`.'].join('\n'));
        } else if (styles.some(function (style) {
          return style === undefined;
        })) {
          console.error("MUI: the styled(".concat(component, ")(...args) API requires all its args to be defined."));
        }
        return stylesFactory.apply(void 0, styles);
      };
    }
  }

  // eslint-disable-next-line @typescript-eslint/naming-convention
  var internal_processStyles = function internal_processStyles(tag, processor) {
    // Emotion attaches all the styles as `__emotion_styles`.
    // Ref: https://github.com/emotion-js/emotion/blob/16d971d0da229596d6bcc39d282ba9753c9ee7cf/packages/styled/src/base.js#L186
    if (Array.isArray(tag.__emotion_styles)) {
      tag.__emotion_styles = processor(tag.__emotion_styles);
    }
  };

  // https://github.com/sindresorhus/is-plain-obj/blob/main/index.js
  function isPlainObject(item) {
    if (_typeof(item) !== 'object' || item === null) {
      return false;
    }
    var prototype = Object.getPrototypeOf(item);
    return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in item) && !(Symbol.iterator in item);
  }
  function deepClone(source) {
    if ( /*#__PURE__*/React__namespace.isValidElement(source) || !isPlainObject(source)) {
      return source;
    }
    var output = {};
    Object.keys(source).forEach(function (key) {
      output[key] = deepClone(source[key]);
    });
    return output;
  }
  function deepmerge(target, source) {
    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
      clone: true
    };
    var output = options.clone ? _extends({}, target) : target;
    if (isPlainObject(target) && isPlainObject(source)) {
      Object.keys(source).forEach(function (key) {
        if ( /*#__PURE__*/React__namespace.isValidElement(source[key])) {
          output[key] = source[key];
        } else if (isPlainObject(source[key]) &&
        // Avoid prototype pollution
        Object.prototype.hasOwnProperty.call(target, key) && isPlainObject(target[key])) {
          // Since `output` is a clone of `target` and we have narrowed `target` in this block we can cast to the same type.
          output[key] = deepmerge(target[key], source[key], options);
        } else if (options.clone) {
          output[key] = isPlainObject(source[key]) ? deepClone(source[key]) : source[key];
        } else {
          output[key] = source[key];
        }
      });
    }
    return output;
  }

  var sortBreakpointsValues = function sortBreakpointsValues(values) {
    var breakpointsAsArray = Object.keys(values).map(function (key) {
      return {
        key: key,
        val: values[key]
      };
    }) || [];
    // Sort in ascending order
    breakpointsAsArray.sort(function (breakpoint1, breakpoint2) {
      return breakpoint1.val - breakpoint2.val;
    });
    return breakpointsAsArray.reduce(function (acc, obj) {
      return _extends({}, acc, _defineProperty({}, obj.key, obj.val));
    }, {});
  };

  // Keep in mind that @media is inclusive by the CSS specification.
  function createBreakpoints(breakpoints) {
    var _breakpoints$values = breakpoints.values,
      values = _breakpoints$values === void 0 ? {
        xs: 0,
        // phone
        sm: 600,
        // tablet
        md: 900,
        // small laptop
        lg: 1200,
        // desktop
        xl: 1536 // large screen
      } : _breakpoints$values,
      _breakpoints$unit = breakpoints.unit,
      unit = _breakpoints$unit === void 0 ? 'px' : _breakpoints$unit,
      _breakpoints$step = breakpoints.step,
      step = _breakpoints$step === void 0 ? 5 : _breakpoints$step,
      other = _objectWithoutProperties(breakpoints, ["values", "unit", "step"]);
    var sortedValues = sortBreakpointsValues(values);
    var keys = Object.keys(sortedValues);
    function up(key) {
      var value = typeof values[key] === 'number' ? values[key] : key;
      return "@media (min-width:".concat(value).concat(unit, ")");
    }
    function down(key) {
      var value = typeof values[key] === 'number' ? values[key] : key;
      return "@media (max-width:".concat(value - step / 100).concat(unit, ")");
    }
    function between(start, end) {
      var endIndex = keys.indexOf(end);
      return "@media (min-width:".concat(typeof values[start] === 'number' ? values[start] : start).concat(unit, ") and ") + "(max-width:".concat((endIndex !== -1 && typeof values[keys[endIndex]] === 'number' ? values[keys[endIndex]] : end) - step / 100).concat(unit, ")");
    }
    function only(key) {
      if (keys.indexOf(key) + 1 < keys.length) {
        return between(key, keys[keys.indexOf(key) + 1]);
      }
      return up(key);
    }
    function not(key) {
      // handle first and last key separately, for better readability
      var keyIndex = keys.indexOf(key);
      if (keyIndex === 0) {
        return up(keys[1]);
      }
      if (keyIndex === keys.length - 1) {
        return down(keys[keyIndex]);
      }
      return between(key, keys[keys.indexOf(key) + 1]).replace('@media', '@media not all and');
    }
    return _extends({
      keys: keys,
      values: sortedValues,
      up: up,
      down: down,
      between: between,
      only: only,
      not: not,
      unit: unit
    }, other);
  }

  var shape = {
    borderRadius: 4
  };
  var shape$1 = shape;

  function _arrayWithHoles(arr) {
    if (Array.isArray(arr)) return arr;
  }

  function _iterableToArrayLimit(r, l) {
    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
    if (null != t) {
      var e,
        n,
        i,
        u,
        a = [],
        f = !0,
        o = !1;
      try {
        if (i = (t = t.call(r)).next, 0 === l) {
          if (Object(t) !== t) return;
          f = !1;
        } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
      } catch (r) {
        o = !0, n = r;
      } finally {
        try {
          if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
        } finally {
          if (o) throw n;
        }
      }
      return a;
    }
  }

  function _arrayLikeToArray(arr, len) {
    if (len == null || len > arr.length) len = arr.length;
    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
    return arr2;
  }

  function _unsupportedIterableToArray(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
  }

  function _nonIterableRest() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  function _slicedToArray(arr, i) {
    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
  }

  var responsivePropType = PropTypes.oneOfType([PropTypes.number, PropTypes.string, PropTypes.object, PropTypes.array]) ;
  var responsivePropType$1 = responsivePropType;

  function _arrayWithoutHoles(arr) {
    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
  }

  function _iterableToArray(iter) {
    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
  }

  function _nonIterableSpread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  function _toConsumableArray(arr) {
    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
  }

  function merge(acc, item) {
    if (!item) {
      return acc;
    }
    return deepmerge(acc, item, {
      clone: false // No need to clone deep, it's way faster.
    });
  }

  // The breakpoint **start** at this value.
  // For instance with the first breakpoint xs: [xs, sm[.
  var values$1 = {
    xs: 0,
    // phone
    sm: 600,
    // tablet
    md: 900,
    // small laptop
    lg: 1200,
    // desktop
    xl: 1536 // large screen
  };
  var defaultBreakpoints = {
    // Sorted ASC by size. That's important.
    // It can't be configured as it's used statically for propTypes.
    keys: ['xs', 'sm', 'md', 'lg', 'xl'],
    up: function up(key) {
      return "@media (min-width:".concat(values$1[key], "px)");
    }
  };
  function handleBreakpoints(props, propValue, styleFromPropValue) {
    var theme = props.theme || {};
    if (Array.isArray(propValue)) {
      var themeBreakpoints = theme.breakpoints || defaultBreakpoints;
      return propValue.reduce(function (acc, item, index) {
        acc[themeBreakpoints.up(themeBreakpoints.keys[index])] = styleFromPropValue(propValue[index]);
        return acc;
      }, {});
    }
    if (_typeof(propValue) === 'object') {
      var _themeBreakpoints = theme.breakpoints || defaultBreakpoints;
      return Object.keys(propValue).reduce(function (acc, breakpoint) {
        // key is breakpoint
        if (Object.keys(_themeBreakpoints.values || values$1).indexOf(breakpoint) !== -1) {
          var mediaKey = _themeBreakpoints.up(breakpoint);
          acc[mediaKey] = styleFromPropValue(propValue[breakpoint], breakpoint);
        } else {
          var cssKey = breakpoint;
          acc[cssKey] = propValue[cssKey];
        }
        return acc;
      }, {});
    }
    var output = styleFromPropValue(propValue);
    return output;
  }
  function createEmptyBreakpointObject() {
    var _breakpointsInput$key;
    var breakpointsInput = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var breakpointsInOrder = (_breakpointsInput$key = breakpointsInput.keys) == null ? void 0 : _breakpointsInput$key.reduce(function (acc, key) {
      var breakpointStyleKey = breakpointsInput.up(key);
      acc[breakpointStyleKey] = {};
      return acc;
    }, {});
    return breakpointsInOrder || {};
  }
  function removeUnusedBreakpoints(breakpointKeys, style) {
    return breakpointKeys.reduce(function (acc, key) {
      var breakpointOutput = acc[key];
      var isBreakpointUnused = !breakpointOutput || Object.keys(breakpointOutput).length === 0;
      if (isBreakpointUnused) {
        delete acc[key];
      }
      return acc;
    }, style);
  }
  function mergeBreakpointsInOrder(breakpointsInput) {
    var emptyBreakpoints = createEmptyBreakpointObject(breakpointsInput);
    for (var _len = arguments.length, styles = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      styles[_key - 1] = arguments[_key];
    }
    var mergedOutput = [emptyBreakpoints].concat(styles).reduce(function (prev, next) {
      return deepmerge(prev, next);
    }, {});
    return removeUnusedBreakpoints(Object.keys(emptyBreakpoints), mergedOutput);
  }

  // compute base for responsive values; e.g.,
  // [1,2,3] => {xs: true, sm: true, md: true}
  // {xs: 1, sm: 2, md: 3} => {xs: true, sm: true, md: true}
  function computeBreakpointsBase(breakpointValues, themeBreakpoints) {
    // fixed value
    if (_typeof(breakpointValues) !== 'object') {
      return {};
    }
    var base = {};
    var breakpointsKeys = Object.keys(themeBreakpoints);
    if (Array.isArray(breakpointValues)) {
      breakpointsKeys.forEach(function (breakpoint, i) {
        if (i < breakpointValues.length) {
          base[breakpoint] = true;
        }
      });
    } else {
      breakpointsKeys.forEach(function (breakpoint) {
        if (breakpointValues[breakpoint] != null) {
          base[breakpoint] = true;
        }
      });
    }
    return base;
  }
  function resolveBreakpointValues(_ref) {
    var breakpointValues = _ref.values,
      themeBreakpoints = _ref.breakpoints,
      customBase = _ref.base;
    var base = customBase || computeBreakpointsBase(breakpointValues, themeBreakpoints);
    var keys = Object.keys(base);
    if (keys.length === 0) {
      return breakpointValues;
    }
    var previous;
    return keys.reduce(function (acc, breakpoint, i) {
      if (Array.isArray(breakpointValues)) {
        acc[breakpoint] = breakpointValues[i] != null ? breakpointValues[i] : breakpointValues[previous];
        previous = i;
      } else if (_typeof(breakpointValues) === 'object') {
        acc[breakpoint] = breakpointValues[breakpoint] != null ? breakpointValues[breakpoint] : breakpointValues[previous];
        previous = breakpoint;
      } else {
        acc[breakpoint] = breakpointValues;
      }
      return acc;
    }, {});
  }

  // It should to be noted that this function isn't equivalent to `text-transform: capitalize`.
  //
  // A strict capitalization should uppercase the first letter of each word in the sentence.
  // We only handle the first word.
  function capitalize(string) {
    if (typeof string !== 'string') {
      throw new Error("MUI: `capitalize(string)` expects a string argument." );
    }
    return string.charAt(0).toUpperCase() + string.slice(1);
  }

  function getPath(obj, path) {
    var checkVars = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
    if (!path || typeof path !== 'string') {
      return null;
    }

    // Check if CSS variables are used
    if (obj && obj.vars && checkVars) {
      var val = "vars.".concat(path).split('.').reduce(function (acc, item) {
        return acc && acc[item] ? acc[item] : null;
      }, obj);
      if (val != null) {
        return val;
      }
    }
    return path.split('.').reduce(function (acc, item) {
      if (acc && acc[item] != null) {
        return acc[item];
      }
      return null;
    }, obj);
  }
  function getStyleValue$1(themeMapping, transform, propValueFinal) {
    var userValue = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : propValueFinal;
    var value;
    if (typeof themeMapping === 'function') {
      value = themeMapping(propValueFinal);
    } else if (Array.isArray(themeMapping)) {
      value = themeMapping[propValueFinal] || userValue;
    } else {
      value = getPath(themeMapping, propValueFinal) || userValue;
    }
    if (transform) {
      value = transform(value, userValue, themeMapping);
    }
    return value;
  }
  function style$2(options) {
    var prop = options.prop,
      _options$cssProperty = options.cssProperty,
      cssProperty = _options$cssProperty === void 0 ? options.prop : _options$cssProperty,
      themeKey = options.themeKey,
      transform = options.transform; // false positive
    // eslint-disable-next-line react/function-component-definition
    var fn = function fn(props) {
      if (props[prop] == null) {
        return null;
      }
      var propValue = props[prop];
      var theme = props.theme;
      var themeMapping = getPath(theme, themeKey) || {};
      var styleFromPropValue = function styleFromPropValue(propValueFinal) {
        var value = getStyleValue$1(themeMapping, transform, propValueFinal);
        if (propValueFinal === value && typeof propValueFinal === 'string') {
          // Haven't found value
          value = getStyleValue$1(themeMapping, transform, "".concat(prop).concat(propValueFinal === 'default' ? '' : capitalize(propValueFinal)), propValueFinal);
        }
        if (cssProperty === false) {
          return value;
        }
        return _defineProperty({}, cssProperty, value);
      };
      return handleBreakpoints(props, propValue, styleFromPropValue);
    };
    fn.propTypes = _defineProperty({}, prop, responsivePropType$1) ;
    fn.filterProps = [prop];
    return fn;
  }

  function memoize(fn) {
    var cache = {};
    return function (arg) {
      if (cache[arg] === undefined) {
        cache[arg] = fn(arg);
      }
      return cache[arg];
    };
  }

  var properties = {
    m: 'margin',
    p: 'padding'
  };
  var directions = {
    t: 'Top',
    r: 'Right',
    b: 'Bottom',
    l: 'Left',
    x: ['Left', 'Right'],
    y: ['Top', 'Bottom']
  };
  var aliases = {
    marginX: 'mx',
    marginY: 'my',
    paddingX: 'px',
    paddingY: 'py'
  };

  // memoize() impact:
  // From 300,000 ops/sec
  // To 350,000 ops/sec
  var getCssProperties = memoize(function (prop) {
    // It's not a shorthand notation.
    if (prop.length > 2) {
      if (aliases[prop]) {
        prop = aliases[prop];
      } else {
        return [prop];
      }
    }
    var _prop$split = prop.split(''),
      _prop$split2 = _slicedToArray(_prop$split, 2),
      a = _prop$split2[0],
      b = _prop$split2[1];
    var property = properties[a];
    var direction = directions[b] || '';
    return Array.isArray(direction) ? direction.map(function (dir) {
      return property + dir;
    }) : [property + direction];
  });
  var marginKeys = ['m', 'mt', 'mr', 'mb', 'ml', 'mx', 'my', 'margin', 'marginTop', 'marginRight', 'marginBottom', 'marginLeft', 'marginX', 'marginY', 'marginInline', 'marginInlineStart', 'marginInlineEnd', 'marginBlock', 'marginBlockStart', 'marginBlockEnd'];
  var paddingKeys = ['p', 'pt', 'pr', 'pb', 'pl', 'px', 'py', 'padding', 'paddingTop', 'paddingRight', 'paddingBottom', 'paddingLeft', 'paddingX', 'paddingY', 'paddingInline', 'paddingInlineStart', 'paddingInlineEnd', 'paddingBlock', 'paddingBlockStart', 'paddingBlockEnd'];
  var spacingKeys = [].concat(marginKeys, paddingKeys);
  function createUnaryUnit(theme, themeKey, defaultValue, propName) {
    var _getPath;
    var themeSpacing = (_getPath = getPath(theme, themeKey, false)) != null ? _getPath : defaultValue;
    if (typeof themeSpacing === 'number') {
      return function (abs) {
        if (typeof abs === 'string') {
          return abs;
        }
        {
          if (typeof abs !== 'number') {
            console.error("MUI: Expected ".concat(propName, " argument to be a number or a string, got ").concat(abs, "."));
          }
        }
        return themeSpacing * abs;
      };
    }
    if (Array.isArray(themeSpacing)) {
      return function (abs) {
        if (typeof abs === 'string') {
          return abs;
        }
        {
          if (!Number.isInteger(abs)) {
            console.error(["MUI: The `theme.".concat(themeKey, "` array type cannot be combined with non integer values.") + "You should either use an integer value that can be used as index, or define the `theme.".concat(themeKey, "` as a number.")].join('\n'));
          } else if (abs > themeSpacing.length - 1) {
            console.error(["MUI: The value provided (".concat(abs, ") overflows."), "The supported values are: ".concat(JSON.stringify(themeSpacing), "."), "".concat(abs, " > ").concat(themeSpacing.length - 1, ", you need to add the missing values.")].join('\n'));
          }
        }
        return themeSpacing[abs];
      };
    }
    if (typeof themeSpacing === 'function') {
      return themeSpacing;
    }
    {
      console.error(["MUI: The `theme.".concat(themeKey, "` value (").concat(themeSpacing, ") is invalid."), 'It should be a number, an array or a function.'].join('\n'));
    }
    return function () {
      return undefined;
    };
  }
  function createUnarySpacing(theme) {
    return createUnaryUnit(theme, 'spacing', 8, 'spacing');
  }
  function getValue(transformer, propValue) {
    if (typeof propValue === 'string' || propValue == null) {
      return propValue;
    }
    var abs = Math.abs(propValue);
    var transformed = transformer(abs);
    if (propValue >= 0) {
      return transformed;
    }
    if (typeof transformed === 'number') {
      return -transformed;
    }
    return "-".concat(transformed);
  }
  function getStyleFromPropValue(cssProperties, transformer) {
    return function (propValue) {
      return cssProperties.reduce(function (acc, cssProperty) {
        acc[cssProperty] = getValue(transformer, propValue);
        return acc;
      }, {});
    };
  }
  function resolveCssProperty(props, keys, prop, transformer) {
    // Using a hash computation over an array iteration could be faster, but with only 28 items,
    // it's doesn't worth the bundle size.
    if (keys.indexOf(prop) === -1) {
      return null;
    }
    var cssProperties = getCssProperties(prop);
    var styleFromPropValue = getStyleFromPropValue(cssProperties, transformer);
    var propValue = props[prop];
    return handleBreakpoints(props, propValue, styleFromPropValue);
  }
  function style$1(props, keys) {
    var transformer = createUnarySpacing(props.theme);
    return Object.keys(props).map(function (prop) {
      return resolveCssProperty(props, keys, prop, transformer);
    }).reduce(merge, {});
  }
  function margin(props) {
    return style$1(props, marginKeys);
  }
  margin.propTypes = marginKeys.reduce(function (obj, key) {
    obj[key] = responsivePropType$1;
    return obj;
  }, {}) ;
  margin.filterProps = marginKeys;
  function padding(props) {
    return style$1(props, paddingKeys);
  }
  padding.propTypes = paddingKeys.reduce(function (obj, key) {
    obj[key] = responsivePropType$1;
    return obj;
  }, {}) ;
  padding.filterProps = paddingKeys;
  spacingKeys.reduce(function (obj, key) {
    obj[key] = responsivePropType$1;
    return obj;
  }, {}) ;

  // The different signatures imply different meaning for their arguments that can't be expressed structurally.
  // We express the difference with variable names.

  function createSpacing() {
    var spacingInput = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 8;
    // Already transformed.
    if (spacingInput.mui) {
      return spacingInput;
    }

    // Material Design layouts are visually balanced. Most measurements align to an 8dp grid, which aligns both spacing and the overall layout.
    // Smaller components, such as icons, can align to a 4dp grid.
    // https://m2.material.io/design/layout/understanding-layout.html
    var transform = createUnarySpacing({
      spacing: spacingInput
    });
    var spacing = function spacing() {
      for (var _len = arguments.length, argsInput = new Array(_len), _key = 0; _key < _len; _key++) {
        argsInput[_key] = arguments[_key];
      }
      {
        if (!(argsInput.length <= 4)) {
          console.error("MUI: Too many arguments provided, expected between 0 and 4, got ".concat(argsInput.length));
        }
      }
      var args = argsInput.length === 0 ? [1] : argsInput;
      return args.map(function (argument) {
        var output = transform(argument);
        return typeof output === 'number' ? "".concat(output, "px") : output;
      }).join(' ');
    };
    spacing.mui = true;
    return spacing;
  }

  function compose() {
    for (var _len = arguments.length, styles = new Array(_len), _key = 0; _key < _len; _key++) {
      styles[_key] = arguments[_key];
    }
    var handlers = styles.reduce(function (acc, style) {
      style.filterProps.forEach(function (prop) {
        acc[prop] = style;
      });
      return acc;
    }, {});

    // false positive
    // eslint-disable-next-line react/function-component-definition
    var fn = function fn(props) {
      return Object.keys(props).reduce(function (acc, prop) {
        if (handlers[prop]) {
          return merge(acc, handlers[prop](props));
        }
        return acc;
      }, {});
    };
    fn.propTypes = styles.reduce(function (acc, style) {
      return Object.assign(acc, style.propTypes);
    }, {}) ;
    fn.filterProps = styles.reduce(function (acc, style) {
      return acc.concat(style.filterProps);
    }, []);
    return fn;
  }

  function borderTransform(value) {
    if (typeof value !== 'number') {
      return value;
    }
    return "".concat(value, "px solid");
  }
  function createBorderStyle(prop, transform) {
    return style$2({
      prop: prop,
      themeKey: 'borders',
      transform: transform
    });
  }
  var border = createBorderStyle('border', borderTransform);
  var borderTop = createBorderStyle('borderTop', borderTransform);
  var borderRight = createBorderStyle('borderRight', borderTransform);
  var borderBottom = createBorderStyle('borderBottom', borderTransform);
  var borderLeft = createBorderStyle('borderLeft', borderTransform);
  var borderColor = createBorderStyle('borderColor');
  var borderTopColor = createBorderStyle('borderTopColor');
  var borderRightColor = createBorderStyle('borderRightColor');
  var borderBottomColor = createBorderStyle('borderBottomColor');
  var borderLeftColor = createBorderStyle('borderLeftColor');
  var outline = createBorderStyle('outline', borderTransform);
  var outlineColor = createBorderStyle('outlineColor');

  // false positive
  // eslint-disable-next-line react/function-component-definition
  var borderRadius = function borderRadius(props) {
    if (props.borderRadius !== undefined && props.borderRadius !== null) {
      var transformer = createUnaryUnit(props.theme, 'shape.borderRadius', 4, 'borderRadius');
      var styleFromPropValue = function styleFromPropValue(propValue) {
        return {
          borderRadius: getValue(transformer, propValue)
        };
      };
      return handleBreakpoints(props, props.borderRadius, styleFromPropValue);
    }
    return null;
  };
  borderRadius.propTypes = {
    borderRadius: responsivePropType$1
  } ;
  borderRadius.filterProps = ['borderRadius'];
  compose(border, borderTop, borderRight, borderBottom, borderLeft, borderColor, borderTopColor, borderRightColor, borderBottomColor, borderLeftColor, borderRadius, outline, outlineColor);

  // false positive
  // eslint-disable-next-line react/function-component-definition
  var gap = function gap(props) {
    if (props.gap !== undefined && props.gap !== null) {
      var transformer = createUnaryUnit(props.theme, 'spacing', 8, 'gap');
      var styleFromPropValue = function styleFromPropValue(propValue) {
        return {
          gap: getValue(transformer, propValue)
        };
      };
      return handleBreakpoints(props, props.gap, styleFromPropValue);
    }
    return null;
  };
  gap.propTypes = {
    gap: responsivePropType$1
  } ;
  gap.filterProps = ['gap'];

  // false positive
  // eslint-disable-next-line react/function-component-definition
  var columnGap = function columnGap(props) {
    if (props.columnGap !== undefined && props.columnGap !== null) {
      var transformer = createUnaryUnit(props.theme, 'spacing', 8, 'columnGap');
      var styleFromPropValue = function styleFromPropValue(propValue) {
        return {
          columnGap: getValue(transformer, propValue)
        };
      };
      return handleBreakpoints(props, props.columnGap, styleFromPropValue);
    }
    return null;
  };
  columnGap.propTypes = {
    columnGap: responsivePropType$1
  } ;
  columnGap.filterProps = ['columnGap'];

  // false positive
  // eslint-disable-next-line react/function-component-definition
  var rowGap = function rowGap(props) {
    if (props.rowGap !== undefined && props.rowGap !== null) {
      var transformer = createUnaryUnit(props.theme, 'spacing', 8, 'rowGap');
      var styleFromPropValue = function styleFromPropValue(propValue) {
        return {
          rowGap: getValue(transformer, propValue)
        };
      };
      return handleBreakpoints(props, props.rowGap, styleFromPropValue);
    }
    return null;
  };
  rowGap.propTypes = {
    rowGap: responsivePropType$1
  } ;
  rowGap.filterProps = ['rowGap'];
  var gridColumn = style$2({
    prop: 'gridColumn'
  });
  var gridRow = style$2({
    prop: 'gridRow'
  });
  var gridAutoFlow = style$2({
    prop: 'gridAutoFlow'
  });
  var gridAutoColumns = style$2({
    prop: 'gridAutoColumns'
  });
  var gridAutoRows = style$2({
    prop: 'gridAutoRows'
  });
  var gridTemplateColumns = style$2({
    prop: 'gridTemplateColumns'
  });
  var gridTemplateRows = style$2({
    prop: 'gridTemplateRows'
  });
  var gridTemplateAreas = style$2({
    prop: 'gridTemplateAreas'
  });
  var gridArea = style$2({
    prop: 'gridArea'
  });
  compose(gap, columnGap, rowGap, gridColumn, gridRow, gridAutoFlow, gridAutoColumns, gridAutoRows, gridTemplateColumns, gridTemplateRows, gridTemplateAreas, gridArea);

  function paletteTransform(value, userValue) {
    if (userValue === 'grey') {
      return userValue;
    }
    return value;
  }
  var color = style$2({
    prop: 'color',
    themeKey: 'palette',
    transform: paletteTransform
  });
  var bgcolor = style$2({
    prop: 'bgcolor',
    cssProperty: 'backgroundColor',
    themeKey: 'palette',
    transform: paletteTransform
  });
  var backgroundColor = style$2({
    prop: 'backgroundColor',
    themeKey: 'palette',
    transform: paletteTransform
  });
  compose(color, bgcolor, backgroundColor);

  function sizingTransform(value) {
    return value <= 1 && value !== 0 ? "".concat(value * 100, "%") : value;
  }
  var width = style$2({
    prop: 'width',
    transform: sizingTransform
  });
  var maxWidth = function maxWidth(props) {
    if (props.maxWidth !== undefined && props.maxWidth !== null) {
      var styleFromPropValue = function styleFromPropValue(propValue) {
        var _props$theme, _props$theme2;
        var breakpoint = ((_props$theme = props.theme) == null || (_props$theme = _props$theme.breakpoints) == null || (_props$theme = _props$theme.values) == null ? void 0 : _props$theme[propValue]) || values$1[propValue];
        if (!breakpoint) {
          return {
            maxWidth: sizingTransform(propValue)
          };
        }
        if (((_props$theme2 = props.theme) == null || (_props$theme2 = _props$theme2.breakpoints) == null ? void 0 : _props$theme2.unit) !== 'px') {
          return {
            maxWidth: "".concat(breakpoint).concat(props.theme.breakpoints.unit)
          };
        }
        return {
          maxWidth: breakpoint
        };
      };
      return handleBreakpoints(props, props.maxWidth, styleFromPropValue);
    }
    return null;
  };
  maxWidth.filterProps = ['maxWidth'];
  var minWidth = style$2({
    prop: 'minWidth',
    transform: sizingTransform
  });
  var height = style$2({
    prop: 'height',
    transform: sizingTransform
  });
  var maxHeight = style$2({
    prop: 'maxHeight',
    transform: sizingTransform
  });
  var minHeight = style$2({
    prop: 'minHeight',
    transform: sizingTransform
  });
  style$2({
    prop: 'size',
    cssProperty: 'width',
    transform: sizingTransform
  });
  style$2({
    prop: 'size',
    cssProperty: 'height',
    transform: sizingTransform
  });
  var boxSizing = style$2({
    prop: 'boxSizing'
  });
  compose(width, maxWidth, minWidth, height, maxHeight, minHeight, boxSizing);

  var defaultSxConfig = {
    // borders
    border: {
      themeKey: 'borders',
      transform: borderTransform
    },
    borderTop: {
      themeKey: 'borders',
      transform: borderTransform
    },
    borderRight: {
      themeKey: 'borders',
      transform: borderTransform
    },
    borderBottom: {
      themeKey: 'borders',
      transform: borderTransform
    },
    borderLeft: {
      themeKey: 'borders',
      transform: borderTransform
    },
    borderColor: {
      themeKey: 'palette'
    },
    borderTopColor: {
      themeKey: 'palette'
    },
    borderRightColor: {
      themeKey: 'palette'
    },
    borderBottomColor: {
      themeKey: 'palette'
    },
    borderLeftColor: {
      themeKey: 'palette'
    },
    outline: {
      themeKey: 'borders',
      transform: borderTransform
    },
    outlineColor: {
      themeKey: 'palette'
    },
    borderRadius: {
      themeKey: 'shape.borderRadius',
      style: borderRadius
    },
    // palette
    color: {
      themeKey: 'palette',
      transform: paletteTransform
    },
    bgcolor: {
      themeKey: 'palette',
      cssProperty: 'backgroundColor',
      transform: paletteTransform
    },
    backgroundColor: {
      themeKey: 'palette',
      transform: paletteTransform
    },
    // spacing
    p: {
      style: padding
    },
    pt: {
      style: padding
    },
    pr: {
      style: padding
    },
    pb: {
      style: padding
    },
    pl: {
      style: padding
    },
    px: {
      style: padding
    },
    py: {
      style: padding
    },
    padding: {
      style: padding
    },
    paddingTop: {
      style: padding
    },
    paddingRight: {
      style: padding
    },
    paddingBottom: {
      style: padding
    },
    paddingLeft: {
      style: padding
    },
    paddingX: {
      style: padding
    },
    paddingY: {
      style: padding
    },
    paddingInline: {
      style: padding
    },
    paddingInlineStart: {
      style: padding
    },
    paddingInlineEnd: {
      style: padding
    },
    paddingBlock: {
      style: padding
    },
    paddingBlockStart: {
      style: padding
    },
    paddingBlockEnd: {
      style: padding
    },
    m: {
      style: margin
    },
    mt: {
      style: margin
    },
    mr: {
      style: margin
    },
    mb: {
      style: margin
    },
    ml: {
      style: margin
    },
    mx: {
      style: margin
    },
    my: {
      style: margin
    },
    margin: {
      style: margin
    },
    marginTop: {
      style: margin
    },
    marginRight: {
      style: margin
    },
    marginBottom: {
      style: margin
    },
    marginLeft: {
      style: margin
    },
    marginX: {
      style: margin
    },
    marginY: {
      style: margin
    },
    marginInline: {
      style: margin
    },
    marginInlineStart: {
      style: margin
    },
    marginInlineEnd: {
      style: margin
    },
    marginBlock: {
      style: margin
    },
    marginBlockStart: {
      style: margin
    },
    marginBlockEnd: {
      style: margin
    },
    // display
    displayPrint: {
      cssProperty: false,
      transform: function transform(value) {
        return {
          '@media print': {
            display: value
          }
        };
      }
    },
    display: {},
    overflow: {},
    textOverflow: {},
    visibility: {},
    whiteSpace: {},
    // flexbox
    flexBasis: {},
    flexDirection: {},
    flexWrap: {},
    justifyContent: {},
    alignItems: {},
    alignContent: {},
    order: {},
    flex: {},
    flexGrow: {},
    flexShrink: {},
    alignSelf: {},
    justifyItems: {},
    justifySelf: {},
    // grid
    gap: {
      style: gap
    },
    rowGap: {
      style: rowGap
    },
    columnGap: {
      style: columnGap
    },
    gridColumn: {},
    gridRow: {},
    gridAutoFlow: {},
    gridAutoColumns: {},
    gridAutoRows: {},
    gridTemplateColumns: {},
    gridTemplateRows: {},
    gridTemplateAreas: {},
    gridArea: {},
    // positions
    position: {},
    zIndex: {
      themeKey: 'zIndex'
    },
    top: {},
    right: {},
    bottom: {},
    left: {},
    // shadows
    boxShadow: {
      themeKey: 'shadows'
    },
    // sizing
    width: {
      transform: sizingTransform
    },
    maxWidth: {
      style: maxWidth
    },
    minWidth: {
      transform: sizingTransform
    },
    height: {
      transform: sizingTransform
    },
    maxHeight: {
      transform: sizingTransform
    },
    minHeight: {
      transform: sizingTransform
    },
    boxSizing: {},
    // typography
    fontFamily: {
      themeKey: 'typography'
    },
    fontSize: {
      themeKey: 'typography'
    },
    fontStyle: {
      themeKey: 'typography'
    },
    fontWeight: {
      themeKey: 'typography'
    },
    letterSpacing: {},
    textTransform: {},
    lineHeight: {},
    textAlign: {},
    typography: {
      cssProperty: false,
      themeKey: 'typography'
    }
  };
  var defaultSxConfig$1 = defaultSxConfig;

  function objectsHaveSameKeys() {
    for (var _len = arguments.length, objects = new Array(_len), _key = 0; _key < _len; _key++) {
      objects[_key] = arguments[_key];
    }
    var allKeys = objects.reduce(function (keys, object) {
      return keys.concat(Object.keys(object));
    }, []);
    var union = new Set(allKeys);
    return objects.every(function (object) {
      return union.size === Object.keys(object).length;
    });
  }
  function callIfFn(maybeFn, arg) {
    return typeof maybeFn === 'function' ? maybeFn(arg) : maybeFn;
  }

  // eslint-disable-next-line @typescript-eslint/naming-convention
  function unstable_createStyleFunctionSx() {
    function getThemeValue(prop, val, theme, config) {
      var props = _defineProperty(_defineProperty({}, prop, val), "theme", theme);
      var options = config[prop];
      if (!options) {
        return _defineProperty({}, prop, val);
      }
      var _options$cssProperty = options.cssProperty,
        cssProperty = _options$cssProperty === void 0 ? prop : _options$cssProperty,
        themeKey = options.themeKey,
        transform = options.transform,
        style = options.style;
      if (val == null) {
        return null;
      }

      // TODO v6: remove, see https://github.com/mui/material-ui/pull/38123
      if (themeKey === 'typography' && val === 'inherit') {
        return _defineProperty({}, prop, val);
      }
      var themeMapping = getPath(theme, themeKey) || {};
      if (style) {
        return style(props);
      }
      var styleFromPropValue = function styleFromPropValue(propValueFinal) {
        var value = getStyleValue$1(themeMapping, transform, propValueFinal);
        if (propValueFinal === value && typeof propValueFinal === 'string') {
          // Haven't found value
          value = getStyleValue$1(themeMapping, transform, "".concat(prop).concat(propValueFinal === 'default' ? '' : capitalize(propValueFinal)), propValueFinal);
        }
        if (cssProperty === false) {
          return value;
        }
        return _defineProperty({}, cssProperty, value);
      };
      return handleBreakpoints(props, val, styleFromPropValue);
    }
    function styleFunctionSx(props) {
      var _theme$unstable_sxCon;
      var _ref4 = props || {},
        sx = _ref4.sx,
        _ref4$theme = _ref4.theme,
        theme = _ref4$theme === void 0 ? {} : _ref4$theme;
      if (!sx) {
        return null; // Emotion & styled-components will neglect null
      }
      var config = (_theme$unstable_sxCon = theme.unstable_sxConfig) != null ? _theme$unstable_sxCon : defaultSxConfig$1;

      /*
       * Receive `sxInput` as object or callback
       * and then recursively check keys & values to create media query object styles.
       * (the result will be used in `styled`)
       */
      function traverse(sxInput) {
        var sxObject = sxInput;
        if (typeof sxInput === 'function') {
          sxObject = sxInput(theme);
        } else if (_typeof(sxInput) !== 'object') {
          // value
          return sxInput;
        }
        if (!sxObject) {
          return null;
        }
        var emptyBreakpoints = createEmptyBreakpointObject(theme.breakpoints);
        var breakpointsKeys = Object.keys(emptyBreakpoints);
        var css = emptyBreakpoints;
        Object.keys(sxObject).forEach(function (styleKey) {
          var value = callIfFn(sxObject[styleKey], theme);
          if (value !== null && value !== undefined) {
            if (_typeof(value) === 'object') {
              if (config[styleKey]) {
                css = merge(css, getThemeValue(styleKey, value, theme, config));
              } else {
                var breakpointsValues = handleBreakpoints({
                  theme: theme
                }, value, function (x) {
                  return _defineProperty({}, styleKey, x);
                });
                if (objectsHaveSameKeys(breakpointsValues, value)) {
                  css[styleKey] = styleFunctionSx({
                    sx: value,
                    theme: theme
                  });
                } else {
                  css = merge(css, breakpointsValues);
                }
              }
            } else {
              css = merge(css, getThemeValue(styleKey, value, theme, config));
            }
          }
        });
        return removeUnusedBreakpoints(breakpointsKeys, css);
      }
      return Array.isArray(sx) ? sx.map(traverse) : traverse(sx);
    }
    return styleFunctionSx;
  }
  var styleFunctionSx = unstable_createStyleFunctionSx();
  styleFunctionSx.filterProps = ['sx'];
  var styleFunctionSx$1 = styleFunctionSx;

  /**
   * A universal utility to style components with multiple color modes. Always use it from the theme object.
   * It works with:
   *  - [Basic theme](https://mui.com/material-ui/customization/dark-mode/)
   *  - [CSS theme variables](https://mui.com/material-ui/experimental-api/css-theme-variables/overview/)
   *  - Zero-runtime engine
   *
   * Tips: Use an array over object spread and place `theme.applyStyles()` last.
   *
   * ✅ [{ background: '#e5e5e5' }, theme.applyStyles('dark', { background: '#1c1c1c' })]
   *
   * 🚫 { background: '#e5e5e5', ...theme.applyStyles('dark', { background: '#1c1c1c' })}
   *
   * @example
   * 1. using with `styled`:
   * ```jsx
   *   const Component = styled('div')(({ theme }) => [
   *     { background: '#e5e5e5' },
   *     theme.applyStyles('dark', {
   *       background: '#1c1c1c',
   *       color: '#fff',
   *     }),
   *   ]);
   * ```
   *
   * @example
   * 2. using with `sx` prop:
   * ```jsx
   *   <Box sx={theme => [
   *     { background: '#e5e5e5' },
   *     theme.applyStyles('dark', {
   *        background: '#1c1c1c',
   *        color: '#fff',
   *      }),
   *     ]}
   *   />
   * ```
   *
   * @example
   * 3. theming a component:
   * ```jsx
   *   extendTheme({
   *     components: {
   *       MuiButton: {
   *         styleOverrides: {
   *           root: ({ theme }) => [
   *             { background: '#e5e5e5' },
   *             theme.applyStyles('dark', {
   *               background: '#1c1c1c',
   *               color: '#fff',
   *             }),
   *           ],
   *         },
   *       }
   *     }
   *   })
   *```
   */
  function applyStyles$2(key, styles) {
    // @ts-expect-error this is 'any' type
    var theme = this;
    if (theme.vars && typeof theme.getColorSchemeSelector === 'function') {
      // If CssVarsProvider is used as a provider,
      // returns '* :where([data-mui-color-scheme="light|dark"]) &'
      var selector = theme.getColorSchemeSelector(key).replace(/(\[[^\]]+\])/, '*:where($1)');
      return _defineProperty({}, selector, styles);
    }
    if (theme.palette.mode === key) {
      return styles;
    }
    return {};
  }

  function createTheme$1() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var _options$breakpoints = options.breakpoints,
      breakpointsInput = _options$breakpoints === void 0 ? {} : _options$breakpoints,
      _options$palette = options.palette,
      paletteInput = _options$palette === void 0 ? {} : _options$palette,
      spacingInput = options.spacing,
      _options$shape = options.shape,
      shapeInput = _options$shape === void 0 ? {} : _options$shape,
      other = _objectWithoutProperties(options, ["breakpoints", "palette", "spacing", "shape"]);
    var breakpoints = createBreakpoints(breakpointsInput);
    var spacing = createSpacing(spacingInput);
    var muiTheme = deepmerge({
      breakpoints: breakpoints,
      direction: 'ltr',
      components: {},
      // Inject component definitions.
      palette: _extends({
        mode: 'light'
      }, paletteInput),
      spacing: spacing,
      shape: _extends({}, shape$1, shapeInput)
    }, other);
    muiTheme.applyStyles = applyStyles$2;
    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }
    muiTheme = args.reduce(function (acc, argument) {
      return deepmerge(acc, argument);
    }, muiTheme);
    muiTheme.unstable_sxConfig = _extends({}, defaultSxConfig$1, other == null ? void 0 : other.unstable_sxConfig);
    muiTheme.unstable_sx = function sx(props) {
      return styleFunctionSx$1({
        sx: props,
        theme: this
      });
    };
    return muiTheme;
  }

  function isObjectEmpty(obj) {
    return Object.keys(obj).length === 0;
  }
  function useTheme$3() {
    var defaultTheme = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
    var contextTheme = React__namespace.useContext(ThemeContext$2);
    return !contextTheme || isObjectEmpty(contextTheme) ? defaultTheme : contextTheme;
  }

  var systemDefaultTheme$1 = createTheme$1();
  function useTheme$2() {
    var defaultTheme = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : systemDefaultTheme$1;
    return useTheme$3(defaultTheme);
  }

  function GlobalStyles$1(_ref) {
    var styles = _ref.styles,
      themeId = _ref.themeId,
      _ref$defaultTheme = _ref.defaultTheme,
      defaultTheme = _ref$defaultTheme === void 0 ? {} : _ref$defaultTheme;
    var upperTheme = useTheme$2(defaultTheme);
    var globalStyles = typeof styles === 'function' ? styles(themeId ? upperTheme[themeId] || upperTheme : upperTheme) : styles;
    return /*#__PURE__*/jsxRuntimeExports.jsx(GlobalStyles$2, {
      styles: globalStyles
    });
  }
  GlobalStyles$1.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * @ignore
     */
    defaultTheme: PropTypes.object,
    /**
     * @ignore
     */
    styles: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.array, PropTypes.func, PropTypes.number, PropTypes.object, PropTypes.string, PropTypes.bool]),
    /**
     * @ignore
     */
    themeId: PropTypes.string
  } ;

  var splitProps = function splitProps(props) {
    var _props$theme$unstable, _props$theme;
    var result = {
      systemProps: {},
      otherProps: {}
    };
    var config = (_props$theme$unstable = props == null || (_props$theme = props.theme) == null ? void 0 : _props$theme.unstable_sxConfig) != null ? _props$theme$unstable : defaultSxConfig$1;
    Object.keys(props).forEach(function (prop) {
      if (config[prop]) {
        result.systemProps[prop] = props[prop];
      } else {
        result.otherProps[prop] = props[prop];
      }
    });
    return result;
  };
  function extendSxProp(props) {
    var inSx = props.sx,
      other = _objectWithoutProperties(props, ["sx"]);
    var _splitProps = splitProps(other),
      systemProps = _splitProps.systemProps,
      otherProps = _splitProps.otherProps;
    var finalSx;
    if (Array.isArray(inSx)) {
      finalSx = [systemProps].concat(_toConsumableArray(inSx));
    } else if (typeof inSx === 'function') {
      finalSx = function finalSx() {
        var result = inSx.apply(void 0, arguments);
        if (!isPlainObject(result)) {
          return systemProps;
        }
        return _extends({}, systemProps, result);
      };
    } else {
      finalSx = _extends({}, systemProps, inSx);
    }
    return _extends({}, otherProps, {
      sx: finalSx
    });
  }

  var defaultGenerator = function defaultGenerator(componentName) {
    return componentName;
  };
  var createClassNameGenerator = function createClassNameGenerator() {
    var _generate = defaultGenerator;
    return {
      configure: function configure(generator) {
        _generate = generator;
      },
      generate: function generate(componentName) {
        return _generate(componentName);
      },
      reset: function reset() {
        _generate = defaultGenerator;
      }
    };
  };
  var ClassNameGenerator = createClassNameGenerator();
  var ClassNameGenerator$1 = ClassNameGenerator;

  function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}

  function createBox() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var themeId = options.themeId,
      defaultTheme = options.defaultTheme,
      _options$defaultClass = options.defaultClassName,
      defaultClassName = _options$defaultClass === void 0 ? 'MuiBox-root' : _options$defaultClass,
      generateClassName = options.generateClassName;
    var BoxRoot = styled$3('div', {
      shouldForwardProp: function shouldForwardProp(prop) {
        return prop !== 'theme' && prop !== 'sx' && prop !== 'as';
      }
    })(styleFunctionSx$1);
    var Box = /*#__PURE__*/React__namespace.forwardRef(function Box(inProps, ref) {
      var theme = useTheme$2(defaultTheme);
      var _extendSxProp = extendSxProp(inProps),
        className = _extendSxProp.className,
        _extendSxProp$compone = _extendSxProp.component,
        component = _extendSxProp$compone === void 0 ? 'div' : _extendSxProp$compone,
        other = _objectWithoutProperties(_extendSxProp, ["className", "component"]);
      return /*#__PURE__*/jsxRuntimeExports.jsx(BoxRoot, _extends({
        as: component,
        ref: ref,
        className: clsx(className, generateClassName ? generateClassName(defaultClassName) : defaultClassName),
        theme: themeId ? theme[themeId] || theme : theme
      }, other));
    });
    return Box;
  }

  var globalStateClasses = {
    active: 'active',
    checked: 'checked',
    completed: 'completed',
    disabled: 'disabled',
    error: 'error',
    expanded: 'expanded',
    focused: 'focused',
    focusVisible: 'focusVisible',
    open: 'open',
    readOnly: 'readOnly',
    required: 'required',
    selected: 'selected'
  };
  function generateUtilityClass(componentName, slot) {
    var globalStatePrefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'Mui';
    var globalStateClass = globalStateClasses[slot];
    return globalStateClass ? "".concat(globalStatePrefix, "-").concat(globalStateClass) : "".concat(ClassNameGenerator$1.generate(componentName), "-").concat(slot);
  }

  function generateUtilityClasses(componentName, slots) {
    var globalStatePrefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'Mui';
    var result = {};
    slots.forEach(function (slot) {
      result[slot] = generateUtilityClass(componentName, slot, globalStatePrefix);
    });
    return result;
  }

  var reactIs = {exports: {}};

  var reactIs_development = {};

  var hasRequiredReactIs_development;

  function requireReactIs_development () {
  	if (hasRequiredReactIs_development) return reactIs_development;
  	hasRequiredReactIs_development = 1;
  	((function () {
  	    function typeOf(object) {
  	      if ("object" === typeof object && null !== object) {
  	        var $$typeof = object.$$typeof;
  	        switch ($$typeof) {
  	          case REACT_ELEMENT_TYPE:
  	            switch (((object = object.type), object)) {
  	              case REACT_FRAGMENT_TYPE:
  	              case REACT_PROFILER_TYPE:
  	              case REACT_STRICT_MODE_TYPE:
  	              case REACT_SUSPENSE_TYPE:
  	              case REACT_SUSPENSE_LIST_TYPE:
  	                return object;
  	              default:
  	                switch (((object = object && object.$$typeof), object)) {
  	                  case REACT_CONTEXT_TYPE:
  	                  case REACT_FORWARD_REF_TYPE:
  	                  case REACT_LAZY_TYPE:
  	                  case REACT_MEMO_TYPE:
  	                    return object;
  	                  case REACT_CONSUMER_TYPE:
  	                    return object;
  	                  default:
  	                    return $$typeof;
  	                }
  	            }
  	          case REACT_PORTAL_TYPE:
  	            return $$typeof;
  	        }
  	      }
  	    }
  	    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
  	      REACT_PORTAL_TYPE = Symbol.for("react.portal"),
  	      REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
  	      REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
  	      REACT_PROFILER_TYPE = Symbol.for("react.profiler");
  	    var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
  	      REACT_CONTEXT_TYPE = Symbol.for("react.context"),
  	      REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
  	      REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
  	      REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
  	      REACT_MEMO_TYPE = Symbol.for("react.memo"),
  	      REACT_LAZY_TYPE = Symbol.for("react.lazy"),
  	      REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"),
  	      REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
  	    reactIs_development.ContextConsumer = REACT_CONSUMER_TYPE;
  	    reactIs_development.ContextProvider = REACT_CONTEXT_TYPE;
  	    reactIs_development.Element = REACT_ELEMENT_TYPE;
  	    reactIs_development.ForwardRef = REACT_FORWARD_REF_TYPE;
  	    reactIs_development.Fragment = REACT_FRAGMENT_TYPE;
  	    reactIs_development.Lazy = REACT_LAZY_TYPE;
  	    reactIs_development.Memo = REACT_MEMO_TYPE;
  	    reactIs_development.Portal = REACT_PORTAL_TYPE;
  	    reactIs_development.Profiler = REACT_PROFILER_TYPE;
  	    reactIs_development.StrictMode = REACT_STRICT_MODE_TYPE;
  	    reactIs_development.Suspense = REACT_SUSPENSE_TYPE;
  	    reactIs_development.SuspenseList = REACT_SUSPENSE_LIST_TYPE;
  	    reactIs_development.isContextConsumer = function (object) {
  	      return typeOf(object) === REACT_CONSUMER_TYPE;
  	    };
  	    reactIs_development.isContextProvider = function (object) {
  	      return typeOf(object) === REACT_CONTEXT_TYPE;
  	    };
  	    reactIs_development.isElement = function (object) {
  	      return (
  	        "object" === typeof object &&
  	        null !== object &&
  	        object.$$typeof === REACT_ELEMENT_TYPE
  	      );
  	    };
  	    reactIs_development.isForwardRef = function (object) {
  	      return typeOf(object) === REACT_FORWARD_REF_TYPE;
  	    };
  	    reactIs_development.isFragment = function (object) {
  	      return typeOf(object) === REACT_FRAGMENT_TYPE;
  	    };
  	    reactIs_development.isLazy = function (object) {
  	      return typeOf(object) === REACT_LAZY_TYPE;
  	    };
  	    reactIs_development.isMemo = function (object) {
  	      return typeOf(object) === REACT_MEMO_TYPE;
  	    };
  	    reactIs_development.isPortal = function (object) {
  	      return typeOf(object) === REACT_PORTAL_TYPE;
  	    };
  	    reactIs_development.isProfiler = function (object) {
  	      return typeOf(object) === REACT_PROFILER_TYPE;
  	    };
  	    reactIs_development.isStrictMode = function (object) {
  	      return typeOf(object) === REACT_STRICT_MODE_TYPE;
  	    };
  	    reactIs_development.isSuspense = function (object) {
  	      return typeOf(object) === REACT_SUSPENSE_TYPE;
  	    };
  	    reactIs_development.isSuspenseList = function (object) {
  	      return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
  	    };
  	    reactIs_development.isValidElementType = function (type) {
  	      return "string" === typeof type ||
  	        "function" === typeof type ||
  	        type === REACT_FRAGMENT_TYPE ||
  	        type === REACT_PROFILER_TYPE ||
  	        type === REACT_STRICT_MODE_TYPE ||
  	        type === REACT_SUSPENSE_TYPE ||
  	        type === REACT_SUSPENSE_LIST_TYPE ||
  	        type === REACT_OFFSCREEN_TYPE ||
  	        ("object" === typeof type &&
  	          null !== type &&
  	          (type.$$typeof === REACT_LAZY_TYPE ||
  	            type.$$typeof === REACT_MEMO_TYPE ||
  	            type.$$typeof === REACT_CONTEXT_TYPE ||
  	            type.$$typeof === REACT_CONSUMER_TYPE ||
  	            type.$$typeof === REACT_FORWARD_REF_TYPE ||
  	            type.$$typeof === REACT_CLIENT_REFERENCE ||
  	            void 0 !== type.getModuleId))
  	        ? !0
  	        : !1;
  	    };
  	    reactIs_development.typeOf = typeOf;
  	  }))();
  	return reactIs_development;
  }

  var hasRequiredReactIs;

  function requireReactIs () {
  	if (hasRequiredReactIs) return reactIs.exports;
  	hasRequiredReactIs = 1;

  	{
  	  reactIs.exports = /*@__PURE__*/ requireReactIs_development();
  	}
  	return reactIs.exports;
  }

  var reactIsExports = /*@__PURE__*/ requireReactIs();

  // Simplified polyfill for IE11 support
  // https://github.com/JamesMGreene/Function.name/blob/58b314d4a983110c3682f1228f845d39ccca1817/Function.name.js#L3
  var fnNameMatchRegex = /^\s*function(?:\s|\s*\/\*.*\*\/\s*)+([^(\s/]*)\s*/;
  function getFunctionName(fn) {
    var match = "".concat(fn).match(fnNameMatchRegex);
    var name = match && match[1];
    return name || '';
  }
  function getFunctionComponentName(Component) {
    var fallback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
    return Component.displayName || Component.name || getFunctionName(Component) || fallback;
  }
  function getWrappedName(outerType, innerType, wrapperName) {
    var functionName = getFunctionComponentName(innerType);
    return outerType.displayName || (functionName !== '' ? "".concat(wrapperName, "(").concat(functionName, ")") : wrapperName);
  }

  /**
   * cherry-pick from
   * https://github.com/facebook/react/blob/769b1f270e1251d9dbdce0fcbd9e92e502d059b8/packages/shared/getComponentName.js
   * originally forked from recompose/getDisplayName with added IE11 support
   */
  function getDisplayName(Component) {
    if (Component == null) {
      return undefined;
    }
    if (typeof Component === 'string') {
      return Component;
    }
    if (typeof Component === 'function') {
      return getFunctionComponentName(Component, 'Component');
    }

    // TypeScript can't have components as objects but they exist in the form of `memo` or `Suspense`
    if (_typeof(Component) === 'object') {
      switch (Component.$$typeof) {
        case reactIsExports.ForwardRef:
          return getWrappedName(Component, Component.render, 'ForwardRef');
        case reactIsExports.Memo:
          return getWrappedName(Component, Component.type, 'memo');
        default:
          return undefined;
      }
    }
    return undefined;
  }

  function isEmpty$2(obj) {
    return Object.keys(obj).length === 0;
  }

  // https://github.com/emotion-js/emotion/blob/26ded6109fcd8ca9875cc2ce4564fee678a3f3c5/packages/styled/src/utils.js#L40
  function isStringTag(tag) {
    return typeof tag === 'string' &&
    // 96 is one less than the char code
    // for "a" so this is checking that
    // it's a lowercase character
    tag.charCodeAt(0) > 96;
  }

  // Update /system/styled/#api in case if this changes
  function shouldForwardProp(prop) {
    return prop !== 'ownerState' && prop !== 'theme' && prop !== 'sx' && prop !== 'as';
  }
  var systemDefaultTheme = createTheme$1();
  var lowercaseFirstLetter = function lowercaseFirstLetter(string) {
    if (!string) {
      return string;
    }
    return string.charAt(0).toLowerCase() + string.slice(1);
  };
  function resolveTheme(_ref) {
    var defaultTheme = _ref.defaultTheme,
      theme = _ref.theme,
      themeId = _ref.themeId;
    return isEmpty$2(theme) ? defaultTheme : theme[themeId] || theme;
  }
  function defaultOverridesResolver(slot) {
    if (!slot) {
      return null;
    }
    return function (props, styles) {
      return styles[slot];
    };
  }
  function processStyleArg(callableStyle, _ref2) {
    var ownerState = _ref2.ownerState,
      props = _objectWithoutProperties(_ref2, ["ownerState"]);
    var resolvedStylesArg = typeof callableStyle === 'function' ? callableStyle(_extends({
      ownerState: ownerState
    }, props)) : callableStyle;
    if (Array.isArray(resolvedStylesArg)) {
      return resolvedStylesArg.flatMap(function (resolvedStyle) {
        return processStyleArg(resolvedStyle, _extends({
          ownerState: ownerState
        }, props));
      });
    }
    if (!!resolvedStylesArg && _typeof(resolvedStylesArg) === 'object' && Array.isArray(resolvedStylesArg.variants)) {
      var _resolvedStylesArg$va = resolvedStylesArg.variants,
        variants = _resolvedStylesArg$va === void 0 ? [] : _resolvedStylesArg$va,
        otherStyles = _objectWithoutProperties(resolvedStylesArg, ["variants"]);
      var result = otherStyles;
      variants.forEach(function (variant) {
        var isMatch = true;
        if (typeof variant.props === 'function') {
          isMatch = variant.props(_extends({
            ownerState: ownerState
          }, props, ownerState));
        } else {
          Object.keys(variant.props).forEach(function (key) {
            if ((ownerState == null ? void 0 : ownerState[key]) !== variant.props[key] && props[key] !== variant.props[key]) {
              isMatch = false;
            }
          });
        }
        if (isMatch) {
          if (!Array.isArray(result)) {
            result = [result];
          }
          result.push(typeof variant.style === 'function' ? variant.style(_extends({
            ownerState: ownerState
          }, props, ownerState)) : variant.style);
        }
      });
      return result;
    }
    return resolvedStylesArg;
  }
  function createStyled() {
    var input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var themeId = input.themeId,
      _input$defaultTheme = input.defaultTheme,
      defaultTheme = _input$defaultTheme === void 0 ? systemDefaultTheme : _input$defaultTheme,
      _input$rootShouldForw = input.rootShouldForwardProp,
      rootShouldForwardProp = _input$rootShouldForw === void 0 ? shouldForwardProp : _input$rootShouldForw,
      _input$slotShouldForw = input.slotShouldForwardProp,
      slotShouldForwardProp = _input$slotShouldForw === void 0 ? shouldForwardProp : _input$slotShouldForw;
    var systemSx = function systemSx(props) {
      return styleFunctionSx$1(_extends({}, props, {
        theme: resolveTheme(_extends({}, props, {
          defaultTheme: defaultTheme,
          themeId: themeId
        }))
      }));
    };
    systemSx.__mui_systemSx = true;
    return function (tag) {
      var inputOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      // Filter out the `sx` style function from the previous styled component to prevent unnecessary styles generated by the composite components.
      internal_processStyles(tag, function (styles) {
        return styles.filter(function (style) {
          return !(style != null && style.__mui_systemSx);
        });
      });
      var componentName = inputOptions.name,
        componentSlot = inputOptions.slot,
        inputSkipVariantsResolver = inputOptions.skipVariantsResolver,
        inputSkipSx = inputOptions.skipSx,
        _inputOptions$overrid = inputOptions.overridesResolver,
        overridesResolver = _inputOptions$overrid === void 0 ? defaultOverridesResolver(lowercaseFirstLetter(componentSlot)) : _inputOptions$overrid,
        options = _objectWithoutProperties(inputOptions, ["name", "slot", "skipVariantsResolver", "skipSx", "overridesResolver"]); // if skipVariantsResolver option is defined, take the value, otherwise, true for root and false for other slots.
      var skipVariantsResolver = inputSkipVariantsResolver !== undefined ? inputSkipVariantsResolver :
      // TODO v6: remove `Root` in the next major release
      // For more details: https://github.com/mui/material-ui/pull/37908
      componentSlot && componentSlot !== 'Root' && componentSlot !== 'root' || false;
      var skipSx = inputSkipSx || false;
      var label;
      {
        if (componentName) {
          // TODO v6: remove `lowercaseFirstLetter()` in the next major release
          // For more details: https://github.com/mui/material-ui/pull/37908
          label = "".concat(componentName, "-").concat(lowercaseFirstLetter(componentSlot || 'Root'));
        }
      }
      var shouldForwardPropOption = shouldForwardProp;

      // TODO v6: remove `Root` in the next major release
      // For more details: https://github.com/mui/material-ui/pull/37908
      if (componentSlot === 'Root' || componentSlot === 'root') {
        shouldForwardPropOption = rootShouldForwardProp;
      } else if (componentSlot) {
        // any other slot specified
        shouldForwardPropOption = slotShouldForwardProp;
      } else if (isStringTag(tag)) {
        // for string (html) tag, preserve the behavior in emotion & styled-components.
        shouldForwardPropOption = undefined;
      }
      var defaultStyledResolver = styled$3(tag, _extends({
        shouldForwardProp: shouldForwardPropOption,
        label: label
      }, options));
      var transformStyleArg = function transformStyleArg(stylesArg) {
        // On the server Emotion doesn't use React.forwardRef for creating components, so the created
        // component stays as a function. This condition makes sure that we do not interpolate functions
        // which are basically components used as a selectors.
        if (typeof stylesArg === 'function' && stylesArg.__emotion_real !== stylesArg || isPlainObject(stylesArg)) {
          return function (props) {
            return processStyleArg(stylesArg, _extends({}, props, {
              theme: resolveTheme({
                theme: props.theme,
                defaultTheme: defaultTheme,
                themeId: themeId
              })
            }));
          };
        }
        return stylesArg;
      };
      var muiStyledResolver = function muiStyledResolver(styleArg) {
        var transformedStyleArg = transformStyleArg(styleArg);
        for (var _len = arguments.length, expressions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          expressions[_key - 1] = arguments[_key];
        }
        var expressionsWithDefaultTheme = expressions ? expressions.map(transformStyleArg) : [];
        if (componentName && overridesResolver) {
          expressionsWithDefaultTheme.push(function (props) {
            var theme = resolveTheme(_extends({}, props, {
              defaultTheme: defaultTheme,
              themeId: themeId
            }));
            if (!theme.components || !theme.components[componentName] || !theme.components[componentName].styleOverrides) {
              return null;
            }
            var styleOverrides = theme.components[componentName].styleOverrides;
            var resolvedStyleOverrides = {};
            // TODO: v7 remove iteration and use `resolveStyleArg(styleOverrides[slot])` directly
            Object.entries(styleOverrides).forEach(function (_ref3) {
              var _ref4 = _slicedToArray(_ref3, 2),
                slotKey = _ref4[0],
                slotStyle = _ref4[1];
              resolvedStyleOverrides[slotKey] = processStyleArg(slotStyle, _extends({}, props, {
                theme: theme
              }));
            });
            return overridesResolver(props, resolvedStyleOverrides);
          });
        }
        if (componentName && !skipVariantsResolver) {
          expressionsWithDefaultTheme.push(function (props) {
            var _theme$components;
            var theme = resolveTheme(_extends({}, props, {
              defaultTheme: defaultTheme,
              themeId: themeId
            }));
            var themeVariants = theme == null || (_theme$components = theme.components) == null || (_theme$components = _theme$components[componentName]) == null ? void 0 : _theme$components.variants;
            return processStyleArg({
              variants: themeVariants
            }, _extends({}, props, {
              theme: theme
            }));
          });
        }
        if (!skipSx) {
          expressionsWithDefaultTheme.push(systemSx);
        }
        var numOfCustomFnsApplied = expressionsWithDefaultTheme.length - expressions.length;
        if (Array.isArray(styleArg) && numOfCustomFnsApplied > 0) {
          var placeholders = new Array(numOfCustomFnsApplied).fill('');
          // If the type is array, than we need to add placeholders in the template for the overrides, variants and the sx styles.
          transformedStyleArg = [].concat(_toConsumableArray(styleArg), _toConsumableArray(placeholders));
          transformedStyleArg.raw = [].concat(_toConsumableArray(styleArg.raw), _toConsumableArray(placeholders));
        }
        var Component = defaultStyledResolver.apply(void 0, [transformedStyleArg].concat(_toConsumableArray(expressionsWithDefaultTheme)));
        {
          var displayName;
          if (componentName) {
            displayName = "".concat(componentName).concat(capitalize(componentSlot || ''));
          }
          if (displayName === undefined) {
            displayName = "Styled(".concat(getDisplayName(tag), ")");
          }
          Component.displayName = displayName;
        }
        if (tag.muiName) {
          Component.muiName = tag.muiName;
        }
        return Component;
      };
      if (defaultStyledResolver.withConfig) {
        muiStyledResolver.withConfig = defaultStyledResolver.withConfig;
      }
      return muiStyledResolver;
    };
  }

  var styled$2 = createStyled();
  var systemStyled = styled$2;

  /**
   * Add keys, values of `defaultProps` that does not exist in `props`
   * @param {object} defaultProps
   * @param {object} props
   * @returns {object} resolved props
   */
  function resolveProps(defaultProps, props) {
    var output = _extends({}, props);
    Object.keys(defaultProps).forEach(function (propName) {
      if (propName.toString().match(/^(components|slots)$/)) {
        output[propName] = _extends({}, defaultProps[propName], output[propName]);
      } else if (propName.toString().match(/^(componentsProps|slotProps)$/)) {
        var defaultSlotProps = defaultProps[propName] || {};
        var slotProps = props[propName];
        output[propName] = {};
        if (!slotProps || !Object.keys(slotProps)) {
          // Reduce the iteration if the slot props is empty
          output[propName] = defaultSlotProps;
        } else if (!defaultSlotProps || !Object.keys(defaultSlotProps)) {
          // Reduce the iteration if the default slot props is empty
          output[propName] = slotProps;
        } else {
          output[propName] = _extends({}, slotProps);
          Object.keys(defaultSlotProps).forEach(function (slotPropName) {
            output[propName][slotPropName] = resolveProps(defaultSlotProps[slotPropName], slotProps[slotPropName]);
          });
        }
      } else if (output[propName] === undefined) {
        output[propName] = defaultProps[propName];
      }
    });
    return output;
  }

  function getThemeProps$1(params) {
    var theme = params.theme,
      name = params.name,
      props = params.props;
    if (!theme || !theme.components || !theme.components[name] || !theme.components[name].defaultProps) {
      return props;
    }
    return resolveProps(theme.components[name].defaultProps, props);
  }

  function useThemeProps$1(_ref) {
    var props = _ref.props,
      name = _ref.name,
      defaultTheme = _ref.defaultTheme,
      themeId = _ref.themeId;
    var theme = useTheme$2(defaultTheme);
    if (themeId) {
      theme = theme[themeId] || theme;
    }
    var mergedProps = getThemeProps$1({
      theme: theme,
      name: name,
      props: props
    });
    return mergedProps;
  }

  /**
   * A version of `React.useLayoutEffect` that does not show a warning when server-side rendering.
   * This is useful for effects that are only needed for client-side rendering but not for SSR.
   *
   * Before you use this hook, make sure to read https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85
   * and confirm it doesn't apply to your use-case.
   */
  var useEnhancedEffect = typeof window !== 'undefined' ? React__namespace.useLayoutEffect : React__namespace.useEffect;
  var useEnhancedEffect$1 = useEnhancedEffect;

  /**
   * @deprecated Not used internally. Use `MediaQueryListEvent` from lib.dom.d.ts instead.
   */

  /**
   * @deprecated Not used internally. Use `MediaQueryList` from lib.dom.d.ts instead.
   */

  /**
   * @deprecated Not used internally. Use `(event: MediaQueryListEvent) => void` instead.
   */

  function useMediaQueryOld(query, defaultMatches, matchMedia, ssrMatchMedia, noSsr) {
    var _React$useState = React__namespace.useState(function () {
        if (noSsr && matchMedia) {
          return matchMedia(query).matches;
        }
        if (ssrMatchMedia) {
          return ssrMatchMedia(query).matches;
        }

        // Once the component is mounted, we rely on the
        // event listeners to return the correct matches value.
        return defaultMatches;
      }),
      match = _React$useState[0],
      setMatch = _React$useState[1];
    useEnhancedEffect$1(function () {
      var active = true;
      if (!matchMedia) {
        return undefined;
      }
      var queryList = matchMedia(query);
      var updateMatch = function updateMatch() {
        // Workaround Safari wrong implementation of matchMedia
        // TODO can we remove it?
        // https://github.com/mui/material-ui/pull/17315#issuecomment-528286677
        if (active) {
          setMatch(queryList.matches);
        }
      };
      updateMatch();
      // TODO: Use `addEventListener` once support for Safari < 14 is dropped
      queryList.addListener(updateMatch);
      return function () {
        active = false;
        queryList.removeListener(updateMatch);
      };
    }, [query, matchMedia]);
    return match;
  }

  // eslint-disable-next-line no-useless-concat -- Workaround for https://github.com/webpack/webpack/issues/14814
  var maybeReactUseSyncExternalStore = React__namespace['useSyncExternalStore' + ''];
  function useMediaQueryNew(query, defaultMatches, matchMedia, ssrMatchMedia, noSsr) {
    var getDefaultSnapshot = React__namespace.useCallback(function () {
      return defaultMatches;
    }, [defaultMatches]);
    var getServerSnapshot = React__namespace.useMemo(function () {
      if (noSsr && matchMedia) {
        return function () {
          return matchMedia(query).matches;
        };
      }
      if (ssrMatchMedia !== null) {
        var _ssrMatchMedia = ssrMatchMedia(query),
          matches = _ssrMatchMedia.matches;
        return function () {
          return matches;
        };
      }
      return getDefaultSnapshot;
    }, [getDefaultSnapshot, query, ssrMatchMedia, noSsr, matchMedia]);
    var _React$useMemo = React__namespace.useMemo(function () {
        if (matchMedia === null) {
          return [getDefaultSnapshot, function () {
            return function () {};
          }];
        }
        var mediaQueryList = matchMedia(query);
        return [function () {
          return mediaQueryList.matches;
        }, function (notify) {
          // TODO: Use `addEventListener` once support for Safari < 14 is dropped
          mediaQueryList.addListener(notify);
          return function () {
            mediaQueryList.removeListener(notify);
          };
        }];
      }, [getDefaultSnapshot, matchMedia, query]),
      _React$useMemo2 = _slicedToArray(_React$useMemo, 2),
      getSnapshot = _React$useMemo2[0],
      subscribe = _React$useMemo2[1];
    var match = maybeReactUseSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
    return match;
  }
  function useMediaQuery(queryInput) {
    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    var theme = useTheme$3();
    // Wait for jsdom to support the match media feature.
    // All the browsers MUI support have this built-in.
    // This defensive check is here for simplicity.
    // Most of the time, the match media logic isn't central to people tests.
    var supportMatchMedia = typeof window !== 'undefined' && typeof window.matchMedia !== 'undefined';
    var _getThemeProps = getThemeProps$1({
        name: 'MuiUseMediaQuery',
        props: options,
        theme: theme
      }),
      _getThemeProps$defaul = _getThemeProps.defaultMatches,
      defaultMatches = _getThemeProps$defaul === void 0 ? false : _getThemeProps$defaul,
      _getThemeProps$matchM = _getThemeProps.matchMedia,
      matchMedia = _getThemeProps$matchM === void 0 ? supportMatchMedia ? window.matchMedia : null : _getThemeProps$matchM,
      _getThemeProps$ssrMat = _getThemeProps.ssrMatchMedia,
      ssrMatchMedia = _getThemeProps$ssrMat === void 0 ? null : _getThemeProps$ssrMat,
      _getThemeProps$noSsr = _getThemeProps.noSsr,
      noSsr = _getThemeProps$noSsr === void 0 ? false : _getThemeProps$noSsr;
    {
      if (typeof queryInput === 'function' && theme === null) {
        console.error(['MUI: The `query` argument provided is invalid.', 'You are providing a function without a theme in the context.', 'One of the parent elements needs to use a ThemeProvider.'].join('\n'));
      }
    }
    var query = typeof queryInput === 'function' ? queryInput(theme) : queryInput;
    query = query.replace(/^@media( ?)/m, '');

    // TODO: Drop `useMediaQueryOld` and use  `use-sync-external-store` shim in `useMediaQueryNew` once the package is stable
    var useMediaQueryImplementation = maybeReactUseSyncExternalStore !== undefined ? useMediaQueryNew : useMediaQueryOld;
    var match = useMediaQueryImplementation(query, defaultMatches, matchMedia, ssrMatchMedia, noSsr);
    {
      // eslint-disable-next-line react-hooks/rules-of-hooks
      React__namespace.useDebugValue({
        query: query,
        match: match
      });
    }
    return match;
  }

  function clamp(val) {
    var min = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Number.MIN_SAFE_INTEGER;
    var max = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Number.MAX_SAFE_INTEGER;
    return Math.max(min, Math.min(val, max));
  }

  /**
   * Returns a number whose value is limited to the given range.
   * @param {number} value The value to be clamped
   * @param {number} min The lower boundary of the output range
   * @param {number} max The upper boundary of the output range
   * @returns {number} A number in the range [min, max]
   */
  function clampWrapper(value) {
    var min = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
    var max = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
    {
      if (value < min || value > max) {
        console.error("MUI: The value provided ".concat(value, " is out of range [").concat(min, ", ").concat(max, "]."));
      }
    }
    return clamp(value, min, max);
  }

  /**
   * Converts a color from CSS hex format to CSS rgb format.
   * @param {string} color - Hex color, i.e. #nnn or #nnnnnn
   * @returns {string} A CSS rgb color string
   */
  function hexToRgb(color) {
    color = color.slice(1);
    var re = new RegExp(".{1,".concat(color.length >= 6 ? 2 : 1, "}"), 'g');
    var colors = color.match(re);
    if (colors && colors[0].length === 1) {
      colors = colors.map(function (n) {
        return n + n;
      });
    }
    return colors ? "rgb".concat(colors.length === 4 ? 'a' : '', "(").concat(colors.map(function (n, index) {
      return index < 3 ? parseInt(n, 16) : Math.round(parseInt(n, 16) / 255 * 1000) / 1000;
    }).join(', '), ")") : '';
  }
  function intToHex(_int) {
    var hex = _int.toString(16);
    return hex.length === 1 ? "0".concat(hex) : hex;
  }

  /**
   * Returns an object with the type and values of a color.
   *
   * Note: Does not support rgb % values.
   * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()
   * @returns {object} - A MUI color object: {type: string, values: number[]}
   */
  function decomposeColor(color) {
    // Idempotent
    if (color.type) {
      return color;
    }
    if (color.charAt(0) === '#') {
      return decomposeColor(hexToRgb(color));
    }
    var marker = color.indexOf('(');
    var type = color.substring(0, marker);
    if (['rgb', 'rgba', 'hsl', 'hsla', 'color'].indexOf(type) === -1) {
      throw new Error("MUI: Unsupported `".concat(color, "` color.\nThe following formats are supported: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color().") );
    }
    var values = color.substring(marker + 1, color.length - 1);
    var colorSpace;
    if (type === 'color') {
      values = values.split(' ');
      colorSpace = values.shift();
      if (values.length === 4 && values[3].charAt(0) === '/') {
        values[3] = values[3].slice(1);
      }
      if (['srgb', 'display-p3', 'a98-rgb', 'prophoto-rgb', 'rec-2020'].indexOf(colorSpace) === -1) {
        throw new Error("MUI: unsupported `".concat(colorSpace, "` color space.\nThe following color spaces are supported: srgb, display-p3, a98-rgb, prophoto-rgb, rec-2020.") );
      }
    } else {
      values = values.split(',');
    }
    values = values.map(function (value) {
      return parseFloat(value);
    });
    return {
      type: type,
      values: values,
      colorSpace: colorSpace
    };
  }

  /**
   * Returns a channel created from the input color.
   *
   * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()
   * @returns {string} - The channel for the color, that can be used in rgba or hsla colors
   */
  var colorChannel = function colorChannel(color) {
    var decomposedColor = decomposeColor(color);
    return decomposedColor.values.slice(0, 3).map(function (val, idx) {
      return decomposedColor.type.indexOf('hsl') !== -1 && idx !== 0 ? "".concat(val, "%") : val;
    }).join(' ');
  };
  var private_safeColorChannel = function private_safeColorChannel(color, warning) {
    try {
      return colorChannel(color);
    } catch (error) {
      if (warning && "development" !== 'production') {
        console.warn(warning);
      }
      return color;
    }
  };

  /**
   * Converts a color object with type and values to a string.
   * @param {object} color - Decomposed color
   * @param {string} color.type - One of: 'rgb', 'rgba', 'hsl', 'hsla', 'color'
   * @param {array} color.values - [n,n,n] or [n,n,n,n]
   * @returns {string} A CSS color string
   */
  function recomposeColor(color) {
    var type = color.type,
      colorSpace = color.colorSpace;
    var values = color.values;
    if (type.indexOf('rgb') !== -1) {
      // Only convert the first 3 values to int (i.e. not alpha)
      values = values.map(function (n, i) {
        return i < 3 ? parseInt(n, 10) : n;
      });
    } else if (type.indexOf('hsl') !== -1) {
      values[1] = "".concat(values[1], "%");
      values[2] = "".concat(values[2], "%");
    }
    if (type.indexOf('color') !== -1) {
      values = "".concat(colorSpace, " ").concat(values.join(' '));
    } else {
      values = "".concat(values.join(', '));
    }
    return "".concat(type, "(").concat(values, ")");
  }

  /**
   * Converts a color from CSS rgb format to CSS hex format.
   * @param {string} color - RGB color, i.e. rgb(n, n, n)
   * @returns {string} A CSS rgb color string, i.e. #nnnnnn
   */
  function rgbToHex(color) {
    // Idempotent
    if (color.indexOf('#') === 0) {
      return color;
    }
    var _decomposeColor = decomposeColor(color),
      values = _decomposeColor.values;
    return "#".concat(values.map(function (n, i) {
      return intToHex(i === 3 ? Math.round(255 * n) : n);
    }).join(''));
  }

  /**
   * Converts a color from hsl format to rgb format.
   * @param {string} color - HSL color values
   * @returns {string} rgb color values
   */
  function hslToRgb(color) {
    color = decomposeColor(color);
    var _color = color,
      values = _color.values;
    var h = values[0];
    var s = values[1] / 100;
    var l = values[2] / 100;
    var a = s * Math.min(l, 1 - l);
    var f = function f(n) {
      var k = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (n + h / 30) % 12;
      return l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
    };
    var type = 'rgb';
    var rgb = [Math.round(f(0) * 255), Math.round(f(8) * 255), Math.round(f(4) * 255)];
    if (color.type === 'hsla') {
      type += 'a';
      rgb.push(values[3]);
    }
    return recomposeColor({
      type: type,
      values: rgb
    });
  }
  /**
   * The relative brightness of any point in a color space,
   * normalized to 0 for darkest black and 1 for lightest white.
   *
   * Formula: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests
   * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()
   * @returns {number} The relative brightness of the color in the range 0 - 1
   */
  function getLuminance(color) {
    color = decomposeColor(color);
    var rgb = color.type === 'hsl' || color.type === 'hsla' ? decomposeColor(hslToRgb(color)).values : color.values;
    rgb = rgb.map(function (val) {
      if (color.type !== 'color') {
        val /= 255; // normalized
      }
      return val <= 0.03928 ? val / 12.92 : Math.pow((val + 0.055) / 1.055, 2.4);
    });

    // Truncate at 3 digits
    return Number((0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]).toFixed(3));
  }

  /**
   * Calculates the contrast ratio between two colors.
   *
   * Formula: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests
   * @param {string} foreground - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()
   * @param {string} background - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()
   * @returns {number} A contrast ratio value in the range 0 - 21.
   */
  function getContrastRatio(foreground, background) {
    var lumA = getLuminance(foreground);
    var lumB = getLuminance(background);
    return (Math.max(lumA, lumB) + 0.05) / (Math.min(lumA, lumB) + 0.05);
  }

  /**
   * Sets the absolute transparency of a color.
   * Any existing alpha values are overwritten.
   * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()
   * @param {number} value - value to set the alpha channel to in the range 0 - 1
   * @returns {string} A CSS color string. Hex input values are returned as rgb
   */
  function alpha(color, value) {
    color = decomposeColor(color);
    value = clampWrapper(value);
    if (color.type === 'rgb' || color.type === 'hsl') {
      color.type += 'a';
    }
    if (color.type === 'color') {
      color.values[3] = "/".concat(value);
    } else {
      color.values[3] = value;
    }
    return recomposeColor(color);
  }
  function private_safeAlpha(color, value, warning) {
    try {
      return alpha(color, value);
    } catch (error) {
      if (warning && "development" !== 'production') {
        console.warn(warning);
      }
      return color;
    }
  }

  /**
   * Darkens a color.
   * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()
   * @param {number} coefficient - multiplier in the range 0 - 1
   * @returns {string} A CSS color string. Hex input values are returned as rgb
   */
  function darken(color, coefficient) {
    color = decomposeColor(color);
    coefficient = clampWrapper(coefficient);
    if (color.type.indexOf('hsl') !== -1) {
      color.values[2] *= 1 - coefficient;
    } else if (color.type.indexOf('rgb') !== -1 || color.type.indexOf('color') !== -1) {
      for (var i = 0; i < 3; i += 1) {
        color.values[i] *= 1 - coefficient;
      }
    }
    return recomposeColor(color);
  }
  function private_safeDarken(color, coefficient, warning) {
    try {
      return darken(color, coefficient);
    } catch (error) {
      if (warning && "development" !== 'production') {
        console.warn(warning);
      }
      return color;
    }
  }

  /**
   * Lightens a color.
   * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()
   * @param {number} coefficient - multiplier in the range 0 - 1
   * @returns {string} A CSS color string. Hex input values are returned as rgb
   */
  function lighten(color, coefficient) {
    color = decomposeColor(color);
    coefficient = clampWrapper(coefficient);
    if (color.type.indexOf('hsl') !== -1) {
      color.values[2] += (100 - color.values[2]) * coefficient;
    } else if (color.type.indexOf('rgb') !== -1) {
      for (var i = 0; i < 3; i += 1) {
        color.values[i] += (255 - color.values[i]) * coefficient;
      }
    } else if (color.type.indexOf('color') !== -1) {
      for (var _i = 0; _i < 3; _i += 1) {
        color.values[_i] += (1 - color.values[_i]) * coefficient;
      }
    }
    return recomposeColor(color);
  }
  function private_safeLighten(color, coefficient, warning) {
    try {
      return lighten(color, coefficient);
    } catch (error) {
      if (warning && "development" !== 'production') {
        console.warn(warning);
      }
      return color;
    }
  }

  /**
   * Darken or lighten a color, depending on its luminance.
   * Light colors are darkened, dark colors are lightened.
   * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color()
   * @param {number} coefficient=0.15 - multiplier in the range 0 - 1
   * @returns {string} A CSS color string. Hex input values are returned as rgb
   */
  function emphasize(color) {
    var coefficient = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.15;
    return getLuminance(color) > 0.5 ? darken(color, coefficient) : lighten(color, coefficient);
  }
  function private_safeEmphasize(color, coefficient, warning) {
    try {
      return emphasize(color, coefficient);
    } catch (error) {
      if (warning && "development" !== 'production') {
        console.warn(warning);
      }
      return color;
    }
  }

  function chainPropTypes(propType1, propType2) {
    return function validate() {
      return propType1.apply(void 0, arguments) || propType2.apply(void 0, arguments);
    };
  }

  function isClassComponent$1(elementType) {
    // elementType.prototype?.isReactComponent
    var _elementType$prototyp = elementType.prototype,
      prototype = _elementType$prototyp === void 0 ? {} : _elementType$prototyp;
    return Boolean(prototype.isReactComponent);
  }
  function acceptingRef(props, propName, componentName, location, propFullName) {
    var element = props[propName];
    var safePropName = propFullName || propName;
    if (element == null ||
    // When server-side rendering React doesn't warn either.
    // This is not an accurate check for SSR.
    // This is only in place for Emotion compat.
    // TODO: Revisit once https://github.com/facebook/react/issues/20047 is resolved.
    typeof window === 'undefined') {
      return null;
    }
    var warningHint;
    var elementType = element.type;
    /**
     * Blacklisting instead of whitelisting
     *
     * Blacklisting will miss some components, such as React.Fragment. Those will at least
     * trigger a warning in React.
     * We can't whitelist because there is no safe way to detect React.forwardRef
     * or class components. "Safe" means there's no public API.
     *
     */
    if (typeof elementType === 'function' && !isClassComponent$1(elementType)) {
      warningHint = 'Did you accidentally use a plain function component for an element instead?';
    }
    if (warningHint !== undefined) {
      return new Error("Invalid ".concat(location, " `").concat(safePropName, "` supplied to `").concat(componentName, "`. ") + "Expected an element that can hold a ref. ".concat(warningHint, " ") + 'For more information see https://mui.com/r/caveat-with-refs-guide');
    }
    return null;
  }
  var elementAcceptingRef = chainPropTypes(PropTypes.element, acceptingRef);
  elementAcceptingRef.isRequired = chainPropTypes(PropTypes.element.isRequired, acceptingRef);
  var elementAcceptingRef$1 = elementAcceptingRef;

  function isClassComponent(elementType) {
    // elementType.prototype?.isReactComponent
    var _elementType$prototyp = elementType.prototype,
      prototype = _elementType$prototyp === void 0 ? {} : _elementType$prototyp;
    return Boolean(prototype.isReactComponent);
  }
  function elementTypeAcceptingRef(props, propName, componentName, location, propFullName) {
    var propValue = props[propName];
    var safePropName = propFullName || propName;
    if (propValue == null ||
    // When server-side rendering React doesn't warn either.
    // This is not an accurate check for SSR.
    // This is only in place for emotion compat.
    // TODO: Revisit once https://github.com/facebook/react/issues/20047 is resolved.
    typeof window === 'undefined') {
      return null;
    }
    var warningHint;

    /**
     * Blacklisting instead of whitelisting
     *
     * Blacklisting will miss some components, such as React.Fragment. Those will at least
     * trigger a warning in React.
     * We can't whitelist because there is no safe way to detect React.forwardRef
     * or class components. "Safe" means there's no public API.
     *
     */
    if (typeof propValue === 'function' && !isClassComponent(propValue)) {
      warningHint = 'Did you accidentally provide a plain function component instead?';
    }
    if (warningHint !== undefined) {
      return new Error("Invalid ".concat(location, " `").concat(safePropName, "` supplied to `").concat(componentName, "`. ") + "Expected an element type that can hold a ref. ".concat(warningHint, " ") + 'For more information see https://mui.com/r/caveat-with-refs-guide');
    }
    return null;
  }
  var elementTypeAcceptingRef$1 = chainPropTypes(PropTypes.elementType, elementTypeAcceptingRef);

  // This module is based on https://github.com/airbnb/prop-types-exact repository.
  // However, in order to reduce the number of dependencies and to remove some extra safe checks
  // the module was forked.

  var specialProperty = "exact-prop: \u200B";
  function exactProp(propTypes) {
    return _extends({}, propTypes, _defineProperty({}, specialProperty, function (props) {
      var unsupportedProps = Object.keys(props).filter(function (prop) {
        return !propTypes.hasOwnProperty(prop);
      });
      if (unsupportedProps.length > 0) {
        return new Error("The following props are not supported: ".concat(unsupportedProps.map(function (prop) {
          return "`".concat(prop, "`");
        }).join(', '), ". Please remove them."));
      }
      return null;
    }));
  }

  function HTMLElementType(props, propName, componentName, location, propFullName) {
    var propValue = props[propName];
    var safePropName = propFullName || propName;
    if (propValue == null) {
      return null;
    }
    if (propValue && propValue.nodeType !== 1) {
      return new Error("Invalid ".concat(location, " `").concat(safePropName, "` supplied to `").concat(componentName, "`. ") + "Expected an HTMLElement.");
    }
    return null;
  }

  var refType = PropTypes.oneOfType([PropTypes.func, PropTypes.object]);
  var refType$1 = refType;

  /**
   * Safe chained function.
   *
   * Will only create a new function if needed,
   * otherwise will pass back existing functions or null.
   */
  function createChainedFunction() {
    for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
      funcs[_key] = arguments[_key];
    }
    return funcs.reduce(function (acc, func) {
      if (func == null) {
        return acc;
      }
      return function chainedFunction() {
        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
          args[_key2] = arguments[_key2];
        }
        acc.apply(this, args);
        func.apply(this, args);
      };
    }, function () {});
  }

  // Corresponds to 10 frames at 60 Hz.
  // A few bytes payload overhead when lodash/debounce is ~3 kB and debounce ~300 B.
  function debounce$1(func) {
    var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 166;
    var timeout;
    function debounced() {
      var _this = this;
      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
      var later = function later() {
        // @ts-ignore
        func.apply(_this, args);
      };
      clearTimeout(timeout);
      timeout = setTimeout(later, wait);
    }
    debounced.clear = function () {
      clearTimeout(timeout);
    };
    return debounced;
  }

  function deprecatedPropType(validator, reason) {
    return function (props, propName, componentName, location, propFullName) {
      var componentNameSafe = componentName || '<<anonymous>>';
      var propFullNameSafe = propFullName || propName;
      if (typeof props[propName] !== 'undefined') {
        return new Error("The ".concat(location, " `").concat(propFullNameSafe, "` of ") + "`".concat(componentNameSafe, "` is deprecated. ").concat(reason));
      }
      return null;
    };
  }

  function isMuiElement(element, muiNames) {
    var _muiName, _element$type;
    return /*#__PURE__*/React__namespace.isValidElement(element) && muiNames.indexOf( // For server components `muiName` is avaialble in element.type._payload.value.muiName
    // relevant info - https://github.com/facebook/react/blob/2807d781a08db8e9873687fccc25c0f12b4fb3d4/packages/react/src/ReactLazy.js#L45
    // eslint-disable-next-line no-underscore-dangle
    (_muiName = element.type.muiName) != null ? _muiName : (_element$type = element.type) == null || (_element$type = _element$type._payload) == null || (_element$type = _element$type.value) == null ? void 0 : _element$type.muiName) !== -1;
  }

  function ownerDocument(node) {
    return node && node.ownerDocument || document;
  }

  function ownerWindow(node) {
    var doc = ownerDocument(node);
    return doc.defaultView || window;
  }

  function requirePropFactory(componentNameInError, Component) {

    // eslint-disable-next-line react/forbid-foreign-prop-types
    var prevPropTypes = Component ? _extends({}, Component.propTypes) : null;
    var requireProp = function requireProp(requiredProp) {
      return function (props, propName, componentName, location, propFullName) {
        var propFullNameSafe = propFullName || propName;
        var defaultTypeChecker = prevPropTypes == null ? void 0 : prevPropTypes[propFullNameSafe];
        if (defaultTypeChecker) {
          for (var _len = arguments.length, args = new Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
            args[_key - 5] = arguments[_key];
          }
          var typeCheckerResult = defaultTypeChecker.apply(void 0, [props, propName, componentName, location, propFullName].concat(args));
          if (typeCheckerResult) {
            return typeCheckerResult;
          }
        }
        if (typeof props[propName] !== 'undefined' && !props[requiredProp]) {
          return new Error("The prop `".concat(propFullNameSafe, "` of ") + "`".concat(componentNameInError, "` can only be used together with the `").concat(requiredProp, "` prop."));
        }
        return null;
      };
    };
    return requireProp;
  }

  /**
   * TODO v5: consider making it private
   *
   * passes {value} to {ref}
   *
   * WARNING: Be sure to only call this inside a callback that is passed as a ref.
   * Otherwise, make sure to cleanup the previous {ref} if it changes. See
   * https://github.com/mui/material-ui/issues/13539
   *
   * Useful if you want to expose the ref of an inner component to the public API
   * while still using it inside the component.
   * @param ref A ref callback or ref object. If anything falsy, this is a no-op.
   */
  function setRef(ref, value) {
    if (typeof ref === 'function') {
      ref(value);
    } else if (ref) {
      ref.current = value;
    }
  }

  var globalId = 0;
  function useGlobalId(idOverride) {
    var _React$useState = React__namespace.useState(idOverride),
      defaultId = _React$useState[0],
      setDefaultId = _React$useState[1];
    var id = idOverride || defaultId;
    React__namespace.useEffect(function () {
      if (defaultId == null) {
        // Fallback to this default id when possible.
        // Use the incrementing value for client-side rendering only.
        // We can't use it server-side.
        // If you want to use random values please consider the Birthday Problem: https://en.wikipedia.org/wiki/Birthday_problem
        globalId += 1;
        setDefaultId("mui-".concat(globalId));
      }
    }, [defaultId]);
    return id;
  }

  // downstream bundlers may remove unnecessary concatenation, but won't remove toString call -- Workaround for https://github.com/webpack/webpack/issues/14814
  var maybeReactUseId = React__namespace['useId'.toString()];
  /**
   *
   * @example <div id={useId()} />
   * @param idOverride
   * @returns {string}
   */
  function useId(idOverride) {
    if (maybeReactUseId !== undefined) {
      var reactId = maybeReactUseId();
      return idOverride != null ? idOverride : reactId;
    }
    // eslint-disable-next-line react-hooks/rules-of-hooks -- `React.useId` is invariant at runtime.
    return useGlobalId(idOverride);
  }

  function unsupportedProp(props, propName, componentName, location, propFullName) {
    var propFullNameSafe = propFullName || propName;
    if (typeof props[propName] !== 'undefined') {
      return new Error("The prop `".concat(propFullNameSafe, "` is not supported. Please remove it."));
    }
    return null;
  }

  function useControlled(_ref) {
    var controlled = _ref.controlled,
      defaultProp = _ref["default"],
      name = _ref.name,
      _ref$state = _ref.state,
      state = _ref$state === void 0 ? 'value' : _ref$state;
    // isControlled is ignored in the hook dependency lists as it should never change.
    var _React$useRef = React__namespace.useRef(controlled !== undefined),
      isControlled = _React$useRef.current;
    var _React$useState = React__namespace.useState(defaultProp),
      valueState = _React$useState[0],
      setValue = _React$useState[1];
    var value = isControlled ? controlled : valueState;
    {
      React__namespace.useEffect(function () {
        if (isControlled !== (controlled !== undefined)) {
          console.error(["MUI: A component is changing the ".concat(isControlled ? '' : 'un', "controlled ").concat(state, " state of ").concat(name, " to be ").concat(isControlled ? 'un' : '', "controlled."), 'Elements should not switch from uncontrolled to controlled (or vice versa).', "Decide between using a controlled or uncontrolled ".concat(name, " ") + 'element for the lifetime of the component.', "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", 'More info: https://fb.me/react-controlled-components'].join('\n'));
        }
      }, [state, name, controlled]);
      var _React$useRef2 = React__namespace.useRef(defaultProp),
        defaultValue = _React$useRef2.current;
      React__namespace.useEffect(function () {
        if (!isControlled && !Object.is(defaultValue, defaultProp)) {
          console.error(["MUI: A component is changing the default ".concat(state, " state of an uncontrolled ").concat(name, " after being initialized. ") + "To suppress this warning opt to use a controlled ".concat(name, ".")].join('\n'));
        }
      }, [JSON.stringify(defaultProp)]);
    }
    var setValueIfUncontrolled = React__namespace.useCallback(function (newValue) {
      if (!isControlled) {
        setValue(newValue);
      }
    }, []);
    return [value, setValueIfUncontrolled];
  }

  /**
   * Inspired by https://github.com/facebook/react/issues/14099#issuecomment-440013892
   * See RFC in https://github.com/reactjs/rfcs/pull/220
   */

  function useEventCallback(fn) {
    var ref = React__namespace.useRef(fn);
    useEnhancedEffect$1(function () {
      ref.current = fn;
    });
    return React__namespace.useRef(function () {
      return (
        // @ts-expect-error hide `this`
        (ref.current).apply(void 0, arguments)
      );
    }).current;
  }

  function useForkRef() {
    for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
      refs[_key] = arguments[_key];
    }
    /**
     * This will create a new function if the refs passed to this hook change and are all defined.
     * This means react will call the old forkRef with `null` and the new forkRef
     * with the ref. Cleanup naturally emerges from this behavior.
     */
    return React__namespace.useMemo(function () {
      if (refs.every(function (ref) {
        return ref == null;
      })) {
        return null;
      }
      return function (instance) {
        refs.forEach(function (ref) {
          setRef(ref, instance);
        });
      };
      // eslint-disable-next-line react-hooks/exhaustive-deps
    }, refs);
  }

  var UNINITIALIZED = {};

  /**
   * A React.useRef() that is initialized lazily with a function. Note that it accepts an optional
   * initialization argument, so the initialization function doesn't need to be an inline closure.
   *
   * @usage
   *   const ref = useLazyRef(sortColumns, columns)
   */
  function useLazyRef(init, initArg) {
    var ref = React__namespace.useRef(UNINITIALIZED);
    if (ref.current === UNINITIALIZED) {
      ref.current = init(initArg);
    }
    return ref;
  }

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);
    }
  }
  function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    Object.defineProperty(Constructor, "prototype", {
      writable: false
    });
    return Constructor;
  }

  var EMPTY = [];

  /**
   * A React.useEffect equivalent that runs once, when the component is mounted.
   */
  function useOnMount(fn) {
    /* eslint-disable react-hooks/exhaustive-deps */
    React__namespace.useEffect(fn, EMPTY);
    /* eslint-enable react-hooks/exhaustive-deps */
  }

  var Timeout = /*#__PURE__*/function () {
    function Timeout() {
      var _this = this;
      _classCallCheck(this, Timeout);
      this.currentId = null;
      this.clear = function () {
        if (_this.currentId !== null) {
          clearTimeout(_this.currentId);
          _this.currentId = null;
        }
      };
      this.disposeEffect = function () {
        return _this.clear;
      };
    }
    _createClass(Timeout, [{
      key: "start",
      value:
      /**
       * Executes `fn` after `delay`, clearing any previously scheduled call.
       */
      function start(delay, fn) {
        var _this2 = this;
        this.clear();
        this.currentId = setTimeout(function () {
          _this2.currentId = null;
          fn();
        }, delay);
      }
    }], [{
      key: "create",
      value: function create() {
        return new Timeout();
      }
    }]);
    return Timeout;
  }();
  function useTimeout() {
    var timeout = useLazyRef(Timeout.create).current;
    useOnMount(timeout.disposeEffect);
    return timeout;
  }

  var hadKeyboardEvent = true;
  var hadFocusVisibleRecently = false;
  var hadFocusVisibleRecentlyTimeout = new Timeout();
  var inputTypesWhitelist = {
    text: true,
    search: true,
    url: true,
    tel: true,
    email: true,
    password: true,
    number: true,
    date: true,
    month: true,
    week: true,
    time: true,
    datetime: true,
    'datetime-local': true
  };

  /**
   * Computes whether the given element should automatically trigger the
   * `focus-visible` class being added, i.e. whether it should always match
   * `:focus-visible` when focused.
   * @param {Element} node
   * @returns {boolean}
   */
  function focusTriggersKeyboardModality(node) {
    var _ref = node,
      type = _ref.type,
      tagName = _ref.tagName;
    if (tagName === 'INPUT' && inputTypesWhitelist[type] && !node.readOnly) {
      return true;
    }
    if (tagName === 'TEXTAREA' && !node.readOnly) {
      return true;
    }
    if (node.isContentEditable) {
      return true;
    }
    return false;
  }

  /**
   * Keep track of our keyboard modality state with `hadKeyboardEvent`.
   * If the most recent user interaction was via the keyboard;
   * and the key press did not include a meta, alt/option, or control key;
   * then the modality is keyboard. Otherwise, the modality is not keyboard.
   * @param {KeyboardEvent} event
   */
  function handleKeyDown(event) {
    if (event.metaKey || event.altKey || event.ctrlKey) {
      return;
    }
    hadKeyboardEvent = true;
  }

  /**
   * If at any point a user clicks with a pointing device, ensure that we change
   * the modality away from keyboard.
   * This avoids the situation where a user presses a key on an already focused
   * element, and then clicks on a different element, focusing it with a
   * pointing device, while we still think we're in keyboard modality.
   */
  function handlePointerDown() {
    hadKeyboardEvent = false;
  }
  function handleVisibilityChange() {
    if (this.visibilityState === 'hidden') {
      // If the tab becomes active again, the browser will handle calling focus
      // on the element (Safari actually calls it twice).
      // If this tab change caused a blur on an element with focus-visible,
      // re-apply the class when the user switches back to the tab.
      if (hadFocusVisibleRecently) {
        hadKeyboardEvent = true;
      }
    }
  }
  function prepare(doc) {
    doc.addEventListener('keydown', handleKeyDown, true);
    doc.addEventListener('mousedown', handlePointerDown, true);
    doc.addEventListener('pointerdown', handlePointerDown, true);
    doc.addEventListener('touchstart', handlePointerDown, true);
    doc.addEventListener('visibilitychange', handleVisibilityChange, true);
  }
  function isFocusVisible(event) {
    var target = event.target;
    try {
      return target.matches(':focus-visible');
    } catch (error) {
      // Browsers not implementing :focus-visible will throw a SyntaxError.
      // We use our own heuristic for those browsers.
      // Rethrow might be better if it's not the expected error but do we really
      // want to crash if focus-visible malfunctioned?
    }

    // No need for validFocusTarget check. The user does that by attaching it to
    // focusable events only.
    return hadKeyboardEvent || focusTriggersKeyboardModality(target);
  }
  function useIsFocusVisible() {
    var ref = React__namespace.useCallback(function (node) {
      if (node != null) {
        prepare(node.ownerDocument);
      }
    }, []);
    var isFocusVisibleRef = React__namespace.useRef(false);

    /**
     * Should be called if a blur event is fired
     */
    function handleBlurVisible() {
      // checking against potential state variable does not suffice if we focus and blur synchronously.
      // React wouldn't have time to trigger a re-render so `focusVisible` would be stale.
      // Ideally we would adjust `isFocusVisible(event)` to look at `relatedTarget` for blur events.
      // This doesn't work in IE11 due to https://github.com/facebook/react/issues/3751
      // TODO: check again if React releases their internal changes to focus event handling (https://github.com/facebook/react/pull/19186).
      if (isFocusVisibleRef.current) {
        // To detect a tab/window switch, we look for a blur event followed
        // rapidly by a visibility change.
        // If we don't see a visibility change within 100ms, it's probably a
        // regular focus change.
        hadFocusVisibleRecently = true;
        hadFocusVisibleRecentlyTimeout.start(100, function () {
          hadFocusVisibleRecently = false;
        });
        isFocusVisibleRef.current = false;
        return true;
      }
      return false;
    }

    /**
     * Should be called if a blur event is fired
     */
    function handleFocusVisible(event) {
      if (isFocusVisible(event)) {
        isFocusVisibleRef.current = true;
        return true;
      }
      return false;
    }
    return {
      isFocusVisibleRef: isFocusVisibleRef,
      onFocus: handleFocusVisible,
      onBlur: handleBlurVisible,
      ref: ref
    };
  }

  // A change of the browser zoom change the scrollbar size.
  // Credit https://github.com/twbs/bootstrap/blob/488fd8afc535ca3a6ad4dc581f5e89217b6a36ac/js/src/util/scrollbar.js#L14-L18
  function getScrollbarSize(doc) {
    // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
    var documentWidth = doc.documentElement.clientWidth;
    return Math.abs(window.innerWidth - documentWidth);
  }

  // Source from https://github.com/alitaheri/normalize-scroll-left
  var cachedType;

  /**
   * Based on the jquery plugin https://github.com/othree/jquery.rtl-scroll-type
   *
   * Types of scrollLeft, assuming scrollWidth=100 and direction is rtl.
   *
   * Type             | <- Most Left | Most Right -> | Initial
   * ---------------- | ------------ | ------------- | -------
   * default          | 0            | 100           | 100
   * negative (spec*) | -100         | 0             | 0
   * reverse          | 100          | 0             | 0
   *
   * Edge 85: default
   * Safari 14: negative
   * Chrome 85: negative
   * Firefox 81: negative
   * IE11: reverse
   *
   * spec* https://drafts.csswg.org/cssom-view/#dom-window-scroll
   */
  function detectScrollType() {
    if (cachedType) {
      return cachedType;
    }
    var dummy = document.createElement('div');
    var container = document.createElement('div');
    container.style.width = '10px';
    container.style.height = '1px';
    dummy.appendChild(container);
    dummy.dir = 'rtl';
    dummy.style.fontSize = '14px';
    dummy.style.width = '4px';
    dummy.style.height = '1px';
    dummy.style.position = 'absolute';
    dummy.style.top = '-1000px';
    dummy.style.overflow = 'scroll';
    document.body.appendChild(dummy);
    cachedType = 'reverse';
    if (dummy.scrollLeft > 0) {
      cachedType = 'default';
    } else {
      dummy.scrollLeft = 1;
      if (dummy.scrollLeft === 0) {
        cachedType = 'negative';
      }
    }
    document.body.removeChild(dummy);
    return cachedType;
  }

  // Based on https://stackoverflow.com/a/24394376
  function getNormalizedScrollLeft(element, direction) {
    var scrollLeft = element.scrollLeft;

    // Perform the calculations only when direction is rtl to avoid messing up the ltr behavior
    if (direction !== 'rtl') {
      return scrollLeft;
    }
    var type = detectScrollType();
    switch (type) {
      case 'negative':
        return element.scrollWidth - element.clientWidth + scrollLeft;
      case 'reverse':
        return element.scrollWidth - element.clientWidth - scrollLeft;
      default:
        return scrollLeft;
    }
  }

  var usePreviousProps = function usePreviousProps(value) {
    var ref = React__namespace.useRef({});
    React__namespace.useEffect(function () {
      ref.current = value;
    });
    return ref.current;
  };
  var usePreviousProps$1 = usePreviousProps;

  /**
   * Gets only the valid children of a component,
   * and ignores any nullish or falsy child.
   *
   * @param children the children
   */
  function getValidReactChildren(children) {
    return React__namespace.Children.toArray(children).filter(function (child) {
      return /*#__PURE__*/React__namespace.isValidElement(child);
    });
  }

  var visuallyHidden = {
    border: 0,
    clip: 'rect(0 0 0 0)',
    height: '1px',
    margin: '-1px',
    overflow: 'hidden',
    padding: 0,
    position: 'absolute',
    whiteSpace: 'nowrap',
    width: '1px'
  };
  var visuallyHidden$1 = visuallyHidden;

  function getTypeByValue(value) {
    var valueType = _typeof(value);
    switch (valueType) {
      case 'number':
        if (Number.isNaN(value)) {
          return 'NaN';
        }
        if (!Number.isFinite(value)) {
          return 'Infinity';
        }
        if (value !== Math.floor(value)) {
          return 'float';
        }
        return 'number';
      case 'object':
        if (value === null) {
          return 'null';
        }
        return value.constructor.name;
      default:
        return valueType;
    }
  }

  // IE 11 support
  function ponyfillIsInteger(x) {
    // eslint-disable-next-line no-restricted-globals
    return typeof x === 'number' && isFinite(x) && Math.floor(x) === x;
  }
  var isInteger = Number.isInteger || ponyfillIsInteger;
  function requiredInteger(props, propName, componentName, location) {
    var propValue = props[propName];
    if (propValue == null || !isInteger(propValue)) {
      var propType = getTypeByValue(propValue);
      return new RangeError("Invalid ".concat(location, " `").concat(propName, "` of type `").concat(propType, "` supplied to `").concat(componentName, "`, expected `integer`."));
    }
    return null;
  }
  function validator(props, propName) {
    var propValue = props[propName];
    if (propValue === undefined) {
      return null;
    }
    for (var _len = arguments.length, other = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
      other[_key - 2] = arguments[_key];
    }
    return requiredInteger.apply(void 0, [props, propName].concat(other));
  }
  function validatorNoop() {
    return null;
  }
  validator.isRequired = requiredInteger;
  validatorNoop.isRequired = validatorNoop;
  var integerPropType = validator;

  function composeClasses(slots, getUtilityClass) {
    var classes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
    var output = {};
    Object.keys(slots).forEach(
    // `Object.keys(slots)` can't be wider than `T` because we infer `T` from `slots`.
    // @ts-expect-error https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208
    function (slot) {
      output[slot] = slots[slot].reduce(function (acc, key) {
        if (key) {
          var utilityClass = getUtilityClass(key);
          if (utilityClass !== '') {
            acc.push(utilityClass);
          }
          if (classes && classes[key]) {
            acc.push(classes[key]);
          }
        }
        return acc;
      }, []).join(' ');
    });
    return output;
  }

  /**
   * Determines if a given element is a DOM element name (i.e. not a React component).
   */
  function isHostComponent(element) {
    return typeof element === 'string';
  }

  /**
   * Type of the ownerState based on the type of an element it applies to.
   * This resolves to the provided OwnerState for React components and `undefined` for host components.
   * Falls back to `OwnerState | undefined` when the exact type can't be determined in development time.
   */

  /**
   * Appends the ownerState object to the props, merging with the existing one if necessary.
   *
   * @param elementType Type of the element that owns the `existingProps`. If the element is a DOM node or undefined, `ownerState` is not applied.
   * @param otherProps Props of the element.
   * @param ownerState
   */
  function appendOwnerState(elementType, otherProps, ownerState) {
    if (elementType === undefined || isHostComponent(elementType)) {
      return otherProps;
    }
    return _extends({}, otherProps, {
      ownerState: _extends({}, otherProps.ownerState, ownerState)
    });
  }

  /**
   * Extracts event handlers from a given object.
   * A prop is considered an event handler if it is a function and its name starts with `on`.
   *
   * @param object An object to extract event handlers from.
   * @param excludeKeys An array of keys to exclude from the returned object.
   */
  function extractEventHandlers(object) {
    var excludeKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
    if (object === undefined) {
      return {};
    }
    var result = {};
    Object.keys(object).filter(function (prop) {
      return prop.match(/^on[A-Z]/) && typeof object[prop] === 'function' && !excludeKeys.includes(prop);
    }).forEach(function (prop) {
      result[prop] = object[prop];
    });
    return result;
  }

  /**
   * Removes event handlers from the given object.
   * A field is considered an event handler if it is a function with a name beginning with `on`.
   *
   * @param object Object to remove event handlers from.
   * @returns Object with event handlers removed.
   */
  function omitEventHandlers(object) {
    if (object === undefined) {
      return {};
    }
    var result = {};
    Object.keys(object).filter(function (prop) {
      return !(prop.match(/^on[A-Z]/) && typeof object[prop] === 'function');
    }).forEach(function (prop) {
      result[prop] = object[prop];
    });
    return result;
  }

  /**
   * Merges the slot component internal props (usually coming from a hook)
   * with the externally provided ones.
   *
   * The merge order is (the latter overrides the former):
   * 1. The internal props (specified as a getter function to work with get*Props hook result)
   * 2. Additional props (specified internally on a Base UI component)
   * 3. External props specified on the owner component. These should only be used on a root slot.
   * 4. External props specified in the `slotProps.*` prop.
   * 5. The `className` prop - combined from all the above.
   * @param parameters
   * @returns
   */
  function mergeSlotProps(parameters) {
    var getSlotProps = parameters.getSlotProps,
      additionalProps = parameters.additionalProps,
      externalSlotProps = parameters.externalSlotProps,
      externalForwardedProps = parameters.externalForwardedProps,
      className = parameters.className;
    if (!getSlotProps) {
      // The simpler case - getSlotProps is not defined, so no internal event handlers are defined,
      // so we can simply merge all the props without having to worry about extracting event handlers.
      var _joinedClasses = clsx(additionalProps == null ? void 0 : additionalProps.className, className, externalForwardedProps == null ? void 0 : externalForwardedProps.className, externalSlotProps == null ? void 0 : externalSlotProps.className);
      var _mergedStyle = _extends({}, additionalProps == null ? void 0 : additionalProps.style, externalForwardedProps == null ? void 0 : externalForwardedProps.style, externalSlotProps == null ? void 0 : externalSlotProps.style);
      var _props = _extends({}, additionalProps, externalForwardedProps, externalSlotProps);
      if (_joinedClasses.length > 0) {
        _props.className = _joinedClasses;
      }
      if (Object.keys(_mergedStyle).length > 0) {
        _props.style = _mergedStyle;
      }
      return {
        props: _props,
        internalRef: undefined
      };
    }

    // In this case, getSlotProps is responsible for calling the external event handlers.
    // We don't need to include them in the merged props because of this.

    var eventHandlers = extractEventHandlers(_extends({}, externalForwardedProps, externalSlotProps));
    var componentsPropsWithoutEventHandlers = omitEventHandlers(externalSlotProps);
    var otherPropsWithoutEventHandlers = omitEventHandlers(externalForwardedProps);
    var internalSlotProps = getSlotProps(eventHandlers);

    // The order of classes is important here.
    // Emotion (that we use in libraries consuming Base UI) depends on this order
    // to properly override style. It requires the most important classes to be last
    // (see https://github.com/mui/material-ui/pull/33205) for the related discussion.
    var joinedClasses = clsx(internalSlotProps == null ? void 0 : internalSlotProps.className, additionalProps == null ? void 0 : additionalProps.className, className, externalForwardedProps == null ? void 0 : externalForwardedProps.className, externalSlotProps == null ? void 0 : externalSlotProps.className);
    var mergedStyle = _extends({}, internalSlotProps == null ? void 0 : internalSlotProps.style, additionalProps == null ? void 0 : additionalProps.style, externalForwardedProps == null ? void 0 : externalForwardedProps.style, externalSlotProps == null ? void 0 : externalSlotProps.style);
    var props = _extends({}, internalSlotProps, additionalProps, otherPropsWithoutEventHandlers, componentsPropsWithoutEventHandlers);
    if (joinedClasses.length > 0) {
      props.className = joinedClasses;
    }
    if (Object.keys(mergedStyle).length > 0) {
      props.style = mergedStyle;
    }
    return {
      props: props,
      internalRef: internalSlotProps.ref
    };
  }

  /**
   * If `componentProps` is a function, calls it with the provided `ownerState`.
   * Otherwise, just returns `componentProps`.
   */
  function resolveComponentProps(componentProps, ownerState, slotState) {
    if (typeof componentProps === 'function') {
      return componentProps(ownerState, slotState);
    }
    return componentProps;
  }

  /**
   * @ignore - do not document.
   * Builds the props to be passed into the slot of an unstyled component.
   * It merges the internal props of the component with the ones supplied by the user, allowing to customize the behavior.
   * If the slot component is not a host component, it also merges in the `ownerState`.
   *
   * @param parameters.getSlotProps - A function that returns the props to be passed to the slot component.
   */
  function useSlotProps(parameters) {
    var _parameters$additiona;
    var elementType = parameters.elementType,
      externalSlotProps = parameters.externalSlotProps,
      ownerState = parameters.ownerState,
      _parameters$skipResol = parameters.skipResolvingSlotProps,
      skipResolvingSlotProps = _parameters$skipResol === void 0 ? false : _parameters$skipResol,
      rest = _objectWithoutProperties(parameters, ["elementType", "externalSlotProps", "ownerState", "skipResolvingSlotProps"]);
    var resolvedComponentsProps = skipResolvingSlotProps ? {} : resolveComponentProps(externalSlotProps, ownerState);
    var _mergeSlotProps = mergeSlotProps(_extends({}, rest, {
        externalSlotProps: resolvedComponentsProps
      })),
      mergedProps = _mergeSlotProps.props,
      internalRef = _mergeSlotProps.internalRef;
    var ref = useForkRef(internalRef, resolvedComponentsProps == null ? void 0 : resolvedComponentsProps.ref, (_parameters$additiona = parameters.additionalProps) == null ? void 0 : _parameters$additiona.ref);
    var props = appendOwnerState(elementType, _extends({}, mergedProps, {
      ref: ref
    }), ownerState);
    return props;
  }

  /**
   * Returns the ref of a React element handling differences between React 19 and older versions.
   * It will throw runtime error if the element is not a valid React element.
   *
   * @param element React.ReactElement
   * @returns React.Ref<any> | null
   */
  function getReactElementRef(element) {
    // 'ref' is passed as prop in React 19, whereas 'ref' is directly attached to children in older versions
    if (parseInt(React__namespace.version, 10) >= 19) {
      var _element$props;
      return (element == null || (_element$props = element.props) == null ? void 0 : _element$props.ref) || null;
    }
    // @ts-expect-error element.ref is not included in the ReactElement type
    // https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/70189
    return (element == null ? void 0 : element.ref) || null;
  }

  var ThemeContext = /*#__PURE__*/React__namespace.createContext(null);
  {
    ThemeContext.displayName = 'ThemeContext';
  }
  var ThemeContext$1 = ThemeContext;

  function useTheme$1() {
    var theme = React__namespace.useContext(ThemeContext$1);
    {
      // eslint-disable-next-line react-hooks/rules-of-hooks
      React__namespace.useDebugValue(theme);
    }
    return theme;
  }

  var hasSymbol = typeof Symbol === 'function' && Symbol["for"];
  var nested = hasSymbol ? Symbol["for"]('mui.nested') : '__THEME_NESTED__';

  function mergeOuterLocalTheme(outerTheme, localTheme) {
    if (typeof localTheme === 'function') {
      var mergedTheme = localTheme(outerTheme);
      {
        if (!mergedTheme) {
          console.error(['MUI: You should return an object from your theme function, i.e.', '<ThemeProvider theme={() => ({})} />'].join('\n'));
        }
      }
      return mergedTheme;
    }
    return _extends({}, outerTheme, localTheme);
  }

  /**
   * This component takes a `theme` prop.
   * It makes the `theme` available down the React tree thanks to React context.
   * This component should preferably be used at **the root of your component tree**.
   */
  function ThemeProvider$2(props) {
    var children = props.children,
      localTheme = props.theme;
    var outerTheme = useTheme$1();
    {
      if (outerTheme === null && typeof localTheme === 'function') {
        console.error(['MUI: You are providing a theme function prop to the ThemeProvider component:', '<ThemeProvider theme={outerTheme => outerTheme} />', '', 'However, no outer theme is present.', 'Make sure a theme is already injected higher in the React tree ' + 'or provide a theme object.'].join('\n'));
      }
    }
    var theme = React__namespace.useMemo(function () {
      var output = outerTheme === null ? localTheme : mergeOuterLocalTheme(outerTheme, localTheme);
      if (output != null) {
        output[nested] = outerTheme !== null;
      }
      return output;
    }, [localTheme, outerTheme]);
    return /*#__PURE__*/jsxRuntimeExports.jsx(ThemeContext$1.Provider, {
      value: theme,
      children: children
    });
  }
  ThemeProvider$2.propTypes = {
    /**
     * Your component tree.
     */
    children: PropTypes.node,
    /**
     * A theme object. You can provide a function to extend the outer theme.
     */
    theme: PropTypes.oneOfType([PropTypes.object, PropTypes.func]).isRequired
  } ;
  {
    ThemeProvider$2.propTypes = exactProp(ThemeProvider$2.propTypes) ;
  }

  var RtlContext = /*#__PURE__*/React__namespace.createContext();
  function RtlProvider(_ref) {
    var value = _ref.value,
      props = _objectWithoutProperties(_ref, ["value"]);
    return /*#__PURE__*/jsxRuntimeExports.jsx(RtlContext.Provider, _extends({
      value: value != null ? value : true
    }, props));
  }
  RtlProvider.propTypes = {
    children: PropTypes.node,
    value: PropTypes.bool
  } ;
  var useRtl = function useRtl() {
    var value = React__namespace.useContext(RtlContext);
    return value != null ? value : false;
  };

  var PropsContext = /*#__PURE__*/React__namespace.createContext(undefined);
  function DefaultPropsProvider(_ref) {
    var value = _ref.value,
      children = _ref.children;
    return /*#__PURE__*/jsxRuntimeExports.jsx(PropsContext.Provider, {
      value: value,
      children: children
    });
  }
  DefaultPropsProvider.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * @ignore
     */
    children: PropTypes.node,
    /**
     * @ignore
     */
    value: PropTypes.object
  } ;
  function getThemeProps(params) {
    var theme = params.theme,
      name = params.name,
      props = params.props;
    if (!theme || !theme.components || !theme.components[name]) {
      return props;
    }
    var config = theme.components[name];
    if (config.defaultProps) {
      // compatible with v5 signature
      return resolveProps(config.defaultProps, props);
    }
    if (!config.styleOverrides && !config.variants) {
      // v6 signature, no property 'defaultProps'
      return resolveProps(config, props);
    }
    return props;
  }
  function useDefaultProps$1(_ref2) {
    var props = _ref2.props,
      name = _ref2.name;
    var ctx = React__namespace.useContext(PropsContext);
    return getThemeProps({
      props: props,
      name: name,
      theme: {
        components: ctx
      }
    });
  }

  var EMPTY_THEME = {};
  function useThemeScoping(themeId, upperTheme, localTheme) {
    var isPrivate = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
    return React__namespace.useMemo(function () {
      var resolvedTheme = themeId ? upperTheme[themeId] || upperTheme : upperTheme;
      if (typeof localTheme === 'function') {
        var mergedTheme = localTheme(resolvedTheme);
        var result = themeId ? _extends({}, upperTheme, _defineProperty({}, themeId, mergedTheme)) : mergedTheme;
        // must return a function for the private theme to NOT merge with the upper theme.
        // see the test case "use provided theme from a callback" in ThemeProvider.test.js
        if (isPrivate) {
          return function () {
            return result;
          };
        }
        return result;
      }
      return themeId ? _extends({}, upperTheme, _defineProperty({}, themeId, localTheme)) : _extends({}, upperTheme, localTheme);
    }, [themeId, upperTheme, localTheme, isPrivate]);
  }

  /**
   * This component makes the `theme` available down the React tree.
   * It should preferably be used at **the root of your component tree**.
   *
   * <ThemeProvider theme={theme}> // existing use case
   * <ThemeProvider theme={{ id: theme }}> // theme scoping
   */
  function ThemeProvider$1(props) {
    var children = props.children,
      localTheme = props.theme,
      themeId = props.themeId;
    var upperTheme = useTheme$3(EMPTY_THEME);
    var upperPrivateTheme = useTheme$1() || EMPTY_THEME;
    {
      if (upperTheme === null && typeof localTheme === 'function' || themeId && upperTheme && !upperTheme[themeId] && typeof localTheme === 'function') {
        console.error(['MUI: You are providing a theme function prop to the ThemeProvider component:', '<ThemeProvider theme={outerTheme => outerTheme} />', '', 'However, no outer theme is present.', 'Make sure a theme is already injected higher in the React tree ' + 'or provide a theme object.'].join('\n'));
      }
    }
    var engineTheme = useThemeScoping(themeId, upperTheme, localTheme);
    var privateTheme = useThemeScoping(themeId, upperPrivateTheme, localTheme, true);
    var rtlValue = engineTheme.direction === 'rtl';
    return /*#__PURE__*/jsxRuntimeExports.jsx(ThemeProvider$2, {
      theme: privateTheme,
      children: /*#__PURE__*/jsxRuntimeExports.jsx(ThemeContext$2.Provider, {
        value: engineTheme,
        children: /*#__PURE__*/jsxRuntimeExports.jsx(RtlProvider, {
          value: rtlValue,
          children: /*#__PURE__*/jsxRuntimeExports.jsx(DefaultPropsProvider, {
            value: engineTheme == null ? void 0 : engineTheme.components,
            children: children
          })
        })
      })
    });
  }
  ThemeProvider$1.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Your component tree.
     */
    children: PropTypes.node,
    /**
     * A theme object. You can provide a function to extend the outer theme.
     */
    theme: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).isRequired,
    /**
     * The design system's unique id for getting the corresponded theme when there are multiple design systems.
     */
    themeId: PropTypes.string
  } ;
  {
    ThemeProvider$1.propTypes = exactProp(ThemeProvider$1.propTypes) ;
  }

  /**
   * Split this component for RSC import
   */
  var DEFAULT_MODE_STORAGE_KEY = 'mode';
  var DEFAULT_COLOR_SCHEME_STORAGE_KEY = 'color-scheme';
  var DEFAULT_ATTRIBUTE = 'data-color-scheme';
  function InitColorSchemeScript(options) {
    var _ref = options || {},
      _ref$defaultMode = _ref.defaultMode,
      defaultMode = _ref$defaultMode === void 0 ? 'light' : _ref$defaultMode,
      _ref$defaultLightColo = _ref.defaultLightColorScheme,
      defaultLightColorScheme = _ref$defaultLightColo === void 0 ? 'light' : _ref$defaultLightColo,
      _ref$defaultDarkColor = _ref.defaultDarkColorScheme,
      defaultDarkColorScheme = _ref$defaultDarkColor === void 0 ? 'dark' : _ref$defaultDarkColor,
      _ref$modeStorageKey = _ref.modeStorageKey,
      modeStorageKey = _ref$modeStorageKey === void 0 ? DEFAULT_MODE_STORAGE_KEY : _ref$modeStorageKey,
      _ref$colorSchemeStora = _ref.colorSchemeStorageKey,
      colorSchemeStorageKey = _ref$colorSchemeStora === void 0 ? DEFAULT_COLOR_SCHEME_STORAGE_KEY : _ref$colorSchemeStora,
      _ref$attribute = _ref.attribute,
      attribute = _ref$attribute === void 0 ? DEFAULT_ATTRIBUTE : _ref$attribute,
      _ref$colorSchemeNode = _ref.colorSchemeNode,
      colorSchemeNode = _ref$colorSchemeNode === void 0 ? 'document.documentElement' : _ref$colorSchemeNode,
      nonce = _ref.nonce;
    return /*#__PURE__*/jsxRuntimeExports.jsx("script", {
      suppressHydrationWarning: true,
      nonce: typeof window === 'undefined' ? nonce : ''
      // eslint-disable-next-line react/no-danger
      ,
      dangerouslySetInnerHTML: {
        __html: "(function() {\ntry {\n  var mode = localStorage.getItem('".concat(modeStorageKey, "') || '").concat(defaultMode, "';\n  var colorScheme = '';\n  if (mode === 'system') {\n    // handle system mode\n    var mql = window.matchMedia('(prefers-color-scheme: dark)');\n    if (mql.matches) {\n      colorScheme = localStorage.getItem('").concat(colorSchemeStorageKey, "-dark') || '").concat(defaultDarkColorScheme, "';\n    } else {\n      colorScheme = localStorage.getItem('").concat(colorSchemeStorageKey, "-light') || '").concat(defaultLightColorScheme, "';\n    }\n  }\n  if (mode === 'light') {\n    colorScheme = localStorage.getItem('").concat(colorSchemeStorageKey, "-light') || '").concat(defaultLightColorScheme, "';\n  }\n  if (mode === 'dark') {\n    colorScheme = localStorage.getItem('").concat(colorSchemeStorageKey, "-dark') || '").concat(defaultDarkColorScheme, "';\n  }\n  if (colorScheme) {\n    ").concat(colorSchemeNode, ".setAttribute('").concat(attribute, "', colorScheme);\n  }\n} catch(e){}})();")
      }
    }, "mui-color-scheme-init");
  }

  function getSystemMode(mode) {
    if (typeof window !== 'undefined' && mode === 'system') {
      var mql = window.matchMedia('(prefers-color-scheme: dark)');
      if (mql.matches) {
        return 'dark';
      }
      return 'light';
    }
    return undefined;
  }
  function processState(state, callback) {
    if (state.mode === 'light' || state.mode === 'system' && state.systemMode === 'light') {
      return callback('light');
    }
    if (state.mode === 'dark' || state.mode === 'system' && state.systemMode === 'dark') {
      return callback('dark');
    }
    return undefined;
  }
  function getColorScheme(state) {
    return processState(state, function (mode) {
      if (mode === 'light') {
        return state.lightColorScheme;
      }
      if (mode === 'dark') {
        return state.darkColorScheme;
      }
      return undefined;
    });
  }
  function initializeValue(key, defaultValue) {
    if (typeof window === 'undefined') {
      return undefined;
    }
    var value;
    try {
      value = localStorage.getItem(key) || undefined;
      if (!value) {
        // the first time that user enters the site.
        localStorage.setItem(key, defaultValue);
      }
    } catch (e) {
      // Unsupported
    }
    return value || defaultValue;
  }
  function useCurrentColorScheme(options) {
    var _options$defaultMode = options.defaultMode,
      defaultMode = _options$defaultMode === void 0 ? 'light' : _options$defaultMode,
      defaultLightColorScheme = options.defaultLightColorScheme,
      defaultDarkColorScheme = options.defaultDarkColorScheme,
      _options$supportedCol = options.supportedColorSchemes,
      supportedColorSchemes = _options$supportedCol === void 0 ? [] : _options$supportedCol,
      _options$modeStorageK = options.modeStorageKey,
      modeStorageKey = _options$modeStorageK === void 0 ? DEFAULT_MODE_STORAGE_KEY : _options$modeStorageK,
      _options$colorSchemeS = options.colorSchemeStorageKey,
      colorSchemeStorageKey = _options$colorSchemeS === void 0 ? DEFAULT_COLOR_SCHEME_STORAGE_KEY : _options$colorSchemeS,
      _options$storageWindo = options.storageWindow,
      storageWindow = _options$storageWindo === void 0 ? typeof window === 'undefined' ? undefined : window : _options$storageWindo;
    var joinedColorSchemes = supportedColorSchemes.join(',');
    var _React$useState = React__namespace.useState(function () {
        var initialMode = initializeValue(modeStorageKey, defaultMode);
        var lightColorScheme = initializeValue("".concat(colorSchemeStorageKey, "-light"), defaultLightColorScheme);
        var darkColorScheme = initializeValue("".concat(colorSchemeStorageKey, "-dark"), defaultDarkColorScheme);
        return {
          mode: initialMode,
          systemMode: getSystemMode(initialMode),
          lightColorScheme: lightColorScheme,
          darkColorScheme: darkColorScheme
        };
      }),
      state = _React$useState[0],
      setState = _React$useState[1];
    var colorScheme = getColorScheme(state);
    var setMode = React__namespace.useCallback(function (mode) {
      setState(function (currentState) {
        if (mode === currentState.mode) {
          // do nothing if mode does not change
          return currentState;
        }
        var newMode = mode != null ? mode : defaultMode;
        try {
          localStorage.setItem(modeStorageKey, newMode);
        } catch (e) {
          // Unsupported
        }
        return _extends({}, currentState, {
          mode: newMode,
          systemMode: getSystemMode(newMode)
        });
      });
    }, [modeStorageKey, defaultMode]);
    var setColorScheme = React__namespace.useCallback(function (value) {
      if (!value) {
        setState(function (currentState) {
          try {
            localStorage.setItem("".concat(colorSchemeStorageKey, "-light"), defaultLightColorScheme);
            localStorage.setItem("".concat(colorSchemeStorageKey, "-dark"), defaultDarkColorScheme);
          } catch (e) {
            // Unsupported
          }
          return _extends({}, currentState, {
            lightColorScheme: defaultLightColorScheme,
            darkColorScheme: defaultDarkColorScheme
          });
        });
      } else if (typeof value === 'string') {
        if (value && !joinedColorSchemes.includes(value)) {
          console.error("`".concat(value, "` does not exist in `theme.colorSchemes`."));
        } else {
          setState(function (currentState) {
            var newState = _extends({}, currentState);
            processState(currentState, function (mode) {
              try {
                localStorage.setItem("".concat(colorSchemeStorageKey, "-").concat(mode), value);
              } catch (e) {
                // Unsupported
              }
              if (mode === 'light') {
                newState.lightColorScheme = value;
              }
              if (mode === 'dark') {
                newState.darkColorScheme = value;
              }
            });
            return newState;
          });
        }
      } else {
        setState(function (currentState) {
          var newState = _extends({}, currentState);
          var newLightColorScheme = value.light === null ? defaultLightColorScheme : value.light;
          var newDarkColorScheme = value.dark === null ? defaultDarkColorScheme : value.dark;
          if (newLightColorScheme) {
            if (!joinedColorSchemes.includes(newLightColorScheme)) {
              console.error("`".concat(newLightColorScheme, "` does not exist in `theme.colorSchemes`."));
            } else {
              newState.lightColorScheme = newLightColorScheme;
              try {
                localStorage.setItem("".concat(colorSchemeStorageKey, "-light"), newLightColorScheme);
              } catch (error) {
                // Unsupported
              }
            }
          }
          if (newDarkColorScheme) {
            if (!joinedColorSchemes.includes(newDarkColorScheme)) {
              console.error("`".concat(newDarkColorScheme, "` does not exist in `theme.colorSchemes`."));
            } else {
              newState.darkColorScheme = newDarkColorScheme;
              try {
                localStorage.setItem("".concat(colorSchemeStorageKey, "-dark"), newDarkColorScheme);
              } catch (error) {
                // Unsupported
              }
            }
          }
          return newState;
        });
      }
    }, [joinedColorSchemes, colorSchemeStorageKey, defaultLightColorScheme, defaultDarkColorScheme]);
    var handleMediaQuery = React__namespace.useCallback(function (event) {
      if (state.mode === 'system') {
        setState(function (currentState) {
          var systemMode = event != null && event.matches ? 'dark' : 'light';

          // Early exit, nothing changed.
          if (currentState.systemMode === systemMode) {
            return currentState;
          }
          return _extends({}, currentState, {
            systemMode: systemMode
          });
        });
      }
    }, [state.mode]);

    // Ref hack to avoid adding handleMediaQuery as a dep
    var mediaListener = React__namespace.useRef(handleMediaQuery);
    mediaListener.current = handleMediaQuery;
    React__namespace.useEffect(function () {
      var handler = function handler() {
        return mediaListener.current.apply(mediaListener, arguments);
      };

      // Always listen to System preference
      var media = window.matchMedia('(prefers-color-scheme: dark)');

      // Intentionally use deprecated listener methods to support iOS & old browsers
      media.addListener(handler);
      handler(media);
      return function () {
        media.removeListener(handler);
      };
    }, []);

    // Handle when localStorage has changed
    React__namespace.useEffect(function () {
      if (storageWindow) {
        var handleStorage = function handleStorage(event) {
          var value = event.newValue;
          if (typeof event.key === 'string' && event.key.startsWith(colorSchemeStorageKey) && (!value || joinedColorSchemes.match(value))) {
            // If the key is deleted, value will be null then reset color scheme to the default one.
            if (event.key.endsWith('light')) {
              setColorScheme({
                light: value
              });
            }
            if (event.key.endsWith('dark')) {
              setColorScheme({
                dark: value
              });
            }
          }
          if (event.key === modeStorageKey && (!value || ['light', 'dark', 'system'].includes(value))) {
            setMode(value || defaultMode);
          }
        };
        // For syncing color-scheme changes between iframes
        storageWindow.addEventListener('storage', handleStorage);
        return function () {
          storageWindow.removeEventListener('storage', handleStorage);
        };
      }
      return undefined;
    }, [setColorScheme, setMode, modeStorageKey, colorSchemeStorageKey, joinedColorSchemes, defaultMode, storageWindow]);
    return _extends({}, state, {
      colorScheme: colorScheme,
      setMode: setMode,
      setColorScheme: setColorScheme
    });
  }

  var DISABLE_CSS_TRANSITION = '*{-webkit-transition:none!important;-moz-transition:none!important;-o-transition:none!important;-ms-transition:none!important;transition:none!important}';
  function createCssVarsProvider(options) {
    var themeId = options.themeId,
      _options$theme = options.theme,
      defaultTheme = _options$theme === void 0 ? {} : _options$theme,
      _options$attribute = options.attribute,
      defaultAttribute = _options$attribute === void 0 ? DEFAULT_ATTRIBUTE : _options$attribute,
      _options$modeStorageK = options.modeStorageKey,
      defaultModeStorageKey = _options$modeStorageK === void 0 ? DEFAULT_MODE_STORAGE_KEY : _options$modeStorageK,
      _options$colorSchemeS = options.colorSchemeStorageKey,
      defaultColorSchemeStorageKey = _options$colorSchemeS === void 0 ? DEFAULT_COLOR_SCHEME_STORAGE_KEY : _options$colorSchemeS,
      _options$defaultMode = options.defaultMode,
      designSystemMode = _options$defaultMode === void 0 ? 'light' : _options$defaultMode,
      designSystemColorScheme = options.defaultColorScheme,
      _options$disableTrans = options.disableTransitionOnChange,
      designSystemTransitionOnChange = _options$disableTrans === void 0 ? false : _options$disableTrans,
      resolveTheme = options.resolveTheme,
      excludeVariablesFromRoot = options.excludeVariablesFromRoot;
    if (!defaultTheme.colorSchemes || typeof designSystemColorScheme === 'string' && !defaultTheme.colorSchemes[designSystemColorScheme] || _typeof(designSystemColorScheme) === 'object' && !defaultTheme.colorSchemes[designSystemColorScheme == null ? void 0 : designSystemColorScheme.light] || _typeof(designSystemColorScheme) === 'object' && !defaultTheme.colorSchemes[designSystemColorScheme == null ? void 0 : designSystemColorScheme.dark]) {
      console.error("MUI: `".concat(designSystemColorScheme, "` does not exist in `theme.colorSchemes`."));
    }
    var ColorSchemeContext = /*#__PURE__*/React__namespace.createContext(undefined);
    {
      ColorSchemeContext.displayName = 'ColorSchemeContext';
    }
    var useColorScheme = function useColorScheme() {
      var value = React__namespace.useContext(ColorSchemeContext);
      if (!value) {
        throw new Error("MUI: `useColorScheme` must be called under <CssVarsProvider />" );
      }
      return value;
    };
    function CssVarsProvider(props) {
      var children = props.children,
        _props$theme = props.theme,
        themeProp = _props$theme === void 0 ? defaultTheme : _props$theme,
        _props$modeStorageKey = props.modeStorageKey,
        modeStorageKey = _props$modeStorageKey === void 0 ? defaultModeStorageKey : _props$modeStorageKey,
        _props$colorSchemeSto = props.colorSchemeStorageKey,
        colorSchemeStorageKey = _props$colorSchemeSto === void 0 ? defaultColorSchemeStorageKey : _props$colorSchemeSto,
        _props$attribute = props.attribute,
        attribute = _props$attribute === void 0 ? defaultAttribute : _props$attribute,
        _props$defaultMode = props.defaultMode,
        defaultMode = _props$defaultMode === void 0 ? designSystemMode : _props$defaultMode,
        _props$defaultColorSc = props.defaultColorScheme,
        defaultColorScheme = _props$defaultColorSc === void 0 ? designSystemColorScheme : _props$defaultColorSc,
        _props$disableTransit = props.disableTransitionOnChange,
        disableTransitionOnChange = _props$disableTransit === void 0 ? designSystemTransitionOnChange : _props$disableTransit,
        _props$storageWindow = props.storageWindow,
        storageWindow = _props$storageWindow === void 0 ? typeof window === 'undefined' ? undefined : window : _props$storageWindow,
        _props$documentNode = props.documentNode,
        documentNode = _props$documentNode === void 0 ? typeof document === 'undefined' ? undefined : document : _props$documentNode,
        _props$colorSchemeNod = props.colorSchemeNode,
        colorSchemeNode = _props$colorSchemeNod === void 0 ? typeof document === 'undefined' ? undefined : document.documentElement : _props$colorSchemeNod,
        _props$colorSchemeSel = props.colorSchemeSelector,
        colorSchemeSelector = _props$colorSchemeSel === void 0 ? ':root' : _props$colorSchemeSel,
        _props$disableNestedC = props.disableNestedContext,
        disableNestedContext = _props$disableNestedC === void 0 ? false : _props$disableNestedC,
        _props$disableStyleSh = props.disableStyleSheetGeneration,
        disableStyleSheetGeneration = _props$disableStyleSh === void 0 ? false : _props$disableStyleSh;
      var hasMounted = React__namespace.useRef(false);
      var upperTheme = useTheme$1();
      var ctx = React__namespace.useContext(ColorSchemeContext);
      var nested = !!ctx && !disableNestedContext;
      var scopedTheme = themeProp[themeId];
      var _ref = scopedTheme || themeProp,
        _ref$colorSchemes = _ref.colorSchemes,
        colorSchemes = _ref$colorSchemes === void 0 ? {} : _ref$colorSchemes,
        _ref$components = _ref.components,
        components = _ref$components === void 0 ? {} : _ref$components,
        _ref$generateCssVars = _ref.generateCssVars,
        generateCssVars = _ref$generateCssVars === void 0 ? function () {
          return {
            vars: {},
            css: {}
          };
        } : _ref$generateCssVars,
        cssVarPrefix = _ref.cssVarPrefix,
        restThemeProp = _objectWithoutProperties(_ref, ["colorSchemes", "components", "generateCssVars", "cssVarPrefix"]);
      var allColorSchemes = Object.keys(colorSchemes);
      var defaultLightColorScheme = typeof defaultColorScheme === 'string' ? defaultColorScheme : defaultColorScheme.light;
      var defaultDarkColorScheme = typeof defaultColorScheme === 'string' ? defaultColorScheme : defaultColorScheme.dark;

      // 1. Get the data about the `mode`, `colorScheme`, and setter functions.
      var _useCurrentColorSchem = useCurrentColorScheme({
          supportedColorSchemes: allColorSchemes,
          defaultLightColorScheme: defaultLightColorScheme,
          defaultDarkColorScheme: defaultDarkColorScheme,
          modeStorageKey: modeStorageKey,
          colorSchemeStorageKey: colorSchemeStorageKey,
          defaultMode: defaultMode,
          storageWindow: storageWindow
        }),
        stateMode = _useCurrentColorSchem.mode,
        setMode = _useCurrentColorSchem.setMode,
        systemMode = _useCurrentColorSchem.systemMode,
        lightColorScheme = _useCurrentColorSchem.lightColorScheme,
        darkColorScheme = _useCurrentColorSchem.darkColorScheme,
        stateColorScheme = _useCurrentColorSchem.colorScheme,
        setColorScheme = _useCurrentColorSchem.setColorScheme;
      var mode = stateMode;
      var colorScheme = stateColorScheme;
      if (nested) {
        mode = ctx.mode;
        colorScheme = ctx.colorScheme;
      }
      var calculatedMode = function () {
        if (mode) {
          return mode;
        }
        // This scope occurs on the server
        if (defaultMode === 'system') {
          return designSystemMode;
        }
        return defaultMode;
      }();
      var calculatedColorScheme = function () {
        if (!colorScheme) {
          // This scope occurs on the server
          if (calculatedMode === 'dark') {
            return defaultDarkColorScheme;
          }
          // use light color scheme, if default mode is 'light' | 'system'
          return defaultLightColorScheme;
        }
        return colorScheme;
      }();

      // 2. Create CSS variables and store them in objects (to be generated in stylesheets in the final step)
      var _generateCssVars = generateCssVars(),
        rootCss = _generateCssVars.css,
        rootVars = _generateCssVars.vars; // 3. Start composing the theme object
      var theme = _extends({}, restThemeProp, {
        components: components,
        colorSchemes: colorSchemes,
        cssVarPrefix: cssVarPrefix,
        vars: rootVars,
        getColorSchemeSelector: function getColorSchemeSelector(targetColorScheme) {
          return "[".concat(attribute, "=\"").concat(targetColorScheme, "\"] &");
        }
      });

      // 4. Create color CSS variables and store them in objects (to be generated in stylesheets in the final step)
      //    The default color scheme stylesheet is constructed to have the least CSS specificity.
      //    The other color schemes uses selector, default as data attribute, to increase the CSS specificity so that they can override the default color scheme stylesheet.
      var defaultColorSchemeStyleSheet = {};
      var otherColorSchemesStyleSheet = {};
      Object.entries(colorSchemes).forEach(function (_ref2) {
        var _ref3 = _slicedToArray(_ref2, 2),
          key = _ref3[0],
          scheme = _ref3[1];
        var _generateCssVars2 = generateCssVars(key),
          css = _generateCssVars2.css,
          vars = _generateCssVars2.vars;
        theme.vars = deepmerge(theme.vars, vars);
        if (key === calculatedColorScheme) {
          // 4.1 Merge the selected color scheme to the theme
          Object.keys(scheme).forEach(function (schemeKey) {
            if (scheme[schemeKey] && _typeof(scheme[schemeKey]) === 'object') {
              // shallow merge the 1st level structure of the theme.
              theme[schemeKey] = _extends({}, theme[schemeKey], scheme[schemeKey]);
            } else {
              theme[schemeKey] = scheme[schemeKey];
            }
          });
          if (theme.palette) {
            theme.palette.colorScheme = key;
          }
        }
        var resolvedDefaultColorScheme = function () {
          if (typeof defaultColorScheme === 'string') {
            return defaultColorScheme;
          }
          if (defaultMode === 'dark') {
            return defaultColorScheme.dark;
          }
          return defaultColorScheme.light;
        }();
        if (key === resolvedDefaultColorScheme) {
          if (excludeVariablesFromRoot) {
            var excludedVariables = {};
            excludeVariablesFromRoot(cssVarPrefix).forEach(function (cssVar) {
              excludedVariables[cssVar] = css[cssVar];
              delete css[cssVar];
            });
            defaultColorSchemeStyleSheet["[".concat(attribute, "=\"").concat(key, "\"]")] = excludedVariables;
          }
          defaultColorSchemeStyleSheet["".concat(colorSchemeSelector, ", [").concat(attribute, "=\"").concat(key, "\"]")] = css;
        } else {
          otherColorSchemesStyleSheet["".concat(colorSchemeSelector === ':root' ? '' : colorSchemeSelector, "[").concat(attribute, "=\"").concat(key, "\"]")] = css;
        }
      });
      theme.vars = deepmerge(theme.vars, rootVars);

      // 5. Declaring effects
      // 5.1 Updates the selector value to use the current color scheme which tells CSS to use the proper stylesheet.
      React__namespace.useEffect(function () {
        if (colorScheme && colorSchemeNode) {
          // attaches attribute to <html> because the css variables are attached to :root (html)
          colorSchemeNode.setAttribute(attribute, colorScheme);
        }
      }, [colorScheme, attribute, colorSchemeNode]);

      // 5.2 Remove the CSS transition when color scheme changes to create instant experience.
      // credit: https://github.com/pacocoursey/next-themes/blob/b5c2bad50de2d61ad7b52a9c5cdc801a78507d7a/index.tsx#L313
      React__namespace.useEffect(function () {
        var timer;
        if (disableTransitionOnChange && hasMounted.current && documentNode) {
          var css = documentNode.createElement('style');
          css.appendChild(documentNode.createTextNode(DISABLE_CSS_TRANSITION));
          documentNode.head.appendChild(css);

          // Force browser repaint
          (function () {
            return window.getComputedStyle(documentNode.body);
          })();
          timer = setTimeout(function () {
            documentNode.head.removeChild(css);
          }, 1);
        }
        return function () {
          clearTimeout(timer);
        };
      }, [colorScheme, disableTransitionOnChange, documentNode]);
      React__namespace.useEffect(function () {
        hasMounted.current = true;
        return function () {
          hasMounted.current = false;
        };
      }, []);
      var contextValue = React__namespace.useMemo(function () {
        return {
          allColorSchemes: allColorSchemes,
          colorScheme: colorScheme,
          darkColorScheme: darkColorScheme,
          lightColorScheme: lightColorScheme,
          mode: mode,
          setColorScheme: setColorScheme,
          setMode: setMode,
          systemMode: systemMode
        };
      }, [allColorSchemes, colorScheme, darkColorScheme, lightColorScheme, mode, setColorScheme, setMode, systemMode]);
      var shouldGenerateStyleSheet = true;
      if (disableStyleSheetGeneration || nested && (upperTheme == null ? void 0 : upperTheme.cssVarPrefix) === cssVarPrefix) {
        shouldGenerateStyleSheet = false;
      }
      var element = /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
        children: [shouldGenerateStyleSheet && /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
          children: [/*#__PURE__*/jsxRuntimeExports.jsx(GlobalStyles$2, {
            styles: _defineProperty({}, colorSchemeSelector, rootCss)
          }), /*#__PURE__*/jsxRuntimeExports.jsx(GlobalStyles$2, {
            styles: defaultColorSchemeStyleSheet
          }), /*#__PURE__*/jsxRuntimeExports.jsx(GlobalStyles$2, {
            styles: otherColorSchemesStyleSheet
          })]
        }), /*#__PURE__*/jsxRuntimeExports.jsx(ThemeProvider$1, {
          themeId: scopedTheme ? themeId : undefined,
          theme: resolveTheme ? resolveTheme(theme) : theme,
          children: children
        })]
      });
      if (nested) {
        return element;
      }
      return /*#__PURE__*/jsxRuntimeExports.jsx(ColorSchemeContext.Provider, {
        value: contextValue,
        children: element
      });
    }
    CssVarsProvider.propTypes = {
      /**
       * The body attribute name to attach colorScheme.
       */
      attribute: PropTypes.string,
      /**
       * The component tree.
       */
      children: PropTypes.node,
      /**
       * The node used to attach the color-scheme attribute
       */
      colorSchemeNode: PropTypes.any,
      /**
       * The CSS selector for attaching the generated custom properties
       */
      colorSchemeSelector: PropTypes.string,
      /**
       * localStorage key used to store `colorScheme`
       */
      colorSchemeStorageKey: PropTypes.string,
      /**
       * The initial color scheme used.
       */
      defaultColorScheme: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),
      /**
       * The initial mode used.
       */
      defaultMode: PropTypes.string,
      /**
       * If `true`, the provider creates its own context and generate stylesheet as if it is a root `CssVarsProvider`.
       */
      disableNestedContext: PropTypes.bool,
      /**
       * If `true`, the style sheet won't be generated.
       *
       * This is useful for controlling nested CssVarsProvider behavior.
       */
      disableStyleSheetGeneration: PropTypes.bool,
      /**
       * Disable CSS transitions when switching between modes or color schemes.
       */
      disableTransitionOnChange: PropTypes.bool,
      /**
       * The document to attach the attribute to.
       */
      documentNode: PropTypes.any,
      /**
       * The key in the local storage used to store current color scheme.
       */
      modeStorageKey: PropTypes.string,
      /**
       * The window that attaches the 'storage' event listener.
       * @default window
       */
      storageWindow: PropTypes.any,
      /**
       * The calculated theme object that will be passed through context.
       */
      theme: PropTypes.object
    } ;
    var defaultLightColorScheme = typeof designSystemColorScheme === 'string' ? designSystemColorScheme : designSystemColorScheme.light;
    var defaultDarkColorScheme = typeof designSystemColorScheme === 'string' ? designSystemColorScheme : designSystemColorScheme.dark;
    var getInitColorSchemeScript = function getInitColorSchemeScript(params) {
      return InitColorSchemeScript(_extends({
        attribute: defaultAttribute,
        colorSchemeStorageKey: defaultColorSchemeStorageKey,
        defaultMode: designSystemMode,
        defaultLightColorScheme: defaultLightColorScheme,
        defaultDarkColorScheme: defaultDarkColorScheme,
        modeStorageKey: defaultModeStorageKey
      }, params));
    };
    return {
      CssVarsProvider: CssVarsProvider,
      useColorScheme: useColorScheme,
      getInitColorSchemeScript: getInitColorSchemeScript
    };
  }

  /**
   * The benefit of this function is to help developers get CSS var from theme without specifying the whole variable
   * and they does not need to remember the prefix (defined once).
   */
  function createGetCssVar$1() {
    var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
    function appendVar() {
      for (var _len = arguments.length, vars = new Array(_len), _key = 0; _key < _len; _key++) {
        vars[_key] = arguments[_key];
      }
      if (!vars.length) {
        return '';
      }
      var value = vars[0];
      if (typeof value === 'string' && !value.match(/(#|\(|\)|(-?(\d*\.)?\d+)(px|em|%|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc))|^(-?(\d*\.)?\d+)$|(\d+ \d+ \d+)/)) {
        return ", var(--".concat(prefix ? "".concat(prefix, "-") : '').concat(value).concat(appendVar.apply(void 0, _toConsumableArray(vars.slice(1))), ")");
      }
      return ", ".concat(value);
    }

    // AdditionalVars makes `getCssVar` less strict, so it can be use like this `getCssVar('non-mui-variable')` without type error.
    var getCssVar = function getCssVar(field) {
      for (var _len2 = arguments.length, fallbacks = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
        fallbacks[_key2 - 1] = arguments[_key2];
      }
      return "var(--".concat(prefix ? "".concat(prefix, "-") : '').concat(field).concat(appendVar.apply(void 0, fallbacks), ")");
    };
    return getCssVar;
  }

  /**
   * This function create an object from keys, value and then assign to target
   *
   * @param {Object} obj : the target object to be assigned
   * @param {string[]} keys
   * @param {string | number} value
   *
   * @example
   * const source = {}
   * assignNestedKeys(source, ['palette', 'primary'], 'var(--palette-primary)')
   * console.log(source) // { palette: { primary: 'var(--palette-primary)' } }
   *
   * @example
   * const source = { palette: { primary: 'var(--palette-primary)' } }
   * assignNestedKeys(source, ['palette', 'secondary'], 'var(--palette-secondary)')
   * console.log(source) // { palette: { primary: 'var(--palette-primary)', secondary: 'var(--palette-secondary)' } }
   */
  var assignNestedKeys = function assignNestedKeys(obj, keys, value) {
    var arrayKeys = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
    var temp = obj;
    keys.forEach(function (k, index) {
      if (index === keys.length - 1) {
        if (Array.isArray(temp)) {
          temp[Number(k)] = value;
        } else if (temp && _typeof(temp) === 'object') {
          temp[k] = value;
        }
      } else if (temp && _typeof(temp) === 'object') {
        if (!temp[k]) {
          temp[k] = arrayKeys.includes(k) ? [] : {};
        }
        temp = temp[k];
      }
    });
  };

  /**
   *
   * @param {Object} obj : source object
   * @param {Function} callback : a function that will be called when
   *                   - the deepest key in source object is reached
   *                   - the value of the deepest key is NOT `undefined` | `null`
   *
   * @example
   * walkObjectDeep({ palette: { primary: { main: '#000000' } } }, console.log)
   * // ['palette', 'primary', 'main'] '#000000'
   */
  var walkObjectDeep = function walkObjectDeep(obj, callback, shouldSkipPaths) {
    function recurse(object) {
      var parentKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
      var arrayKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
      Object.entries(object).forEach(function (_ref) {
        var _ref2 = _slicedToArray(_ref, 2),
          key = _ref2[0],
          value = _ref2[1];
        if (!shouldSkipPaths || shouldSkipPaths && !shouldSkipPaths([].concat(_toConsumableArray(parentKeys), [key]))) {
          if (value !== undefined && value !== null) {
            if (_typeof(value) === 'object' && Object.keys(value).length > 0) {
              recurse(value, [].concat(_toConsumableArray(parentKeys), [key]), Array.isArray(value) ? [].concat(_toConsumableArray(arrayKeys), [key]) : arrayKeys);
            } else {
              callback([].concat(_toConsumableArray(parentKeys), [key]), value, arrayKeys);
            }
          }
        }
      });
    }
    recurse(obj);
  };
  var getCssValue = function getCssValue(keys, value) {
    if (typeof value === 'number') {
      if (['lineHeight', 'fontWeight', 'opacity', 'zIndex'].some(function (prop) {
        return keys.includes(prop);
      })) {
        // CSS property that are unitless
        return value;
      }
      var lastKey = keys[keys.length - 1];
      if (lastKey.toLowerCase().indexOf('opacity') >= 0) {
        // opacity values are unitless
        return value;
      }
      return "".concat(value, "px");
    }
    return value;
  };

  /**
   * a function that parse theme and return { css, vars }
   *
   * @param {Object} theme
   * @param {{
   *  prefix?: string,
   *  shouldSkipGeneratingVar?: (objectPathKeys: Array<string>, value: string | number) => boolean
   * }} options.
   *  `prefix`: The prefix of the generated CSS variables. This function does not change the value.
   *
   * @returns {{ css: Object, vars: Object }} `css` is the stylesheet, `vars` is an object to get css variable (same structure as theme).
   *
   * @example
   * const { css, vars } = parser({
   *   fontSize: 12,
   *   lineHeight: 1.2,
   *   palette: { primary: { 500: 'var(--color)' } }
   * }, { prefix: 'foo' })
   *
   * console.log(css) // { '--foo-fontSize': '12px', '--foo-lineHeight': 1.2, '--foo-palette-primary-500': 'var(--color)' }
   * console.log(vars) // { fontSize: 'var(--foo-fontSize)', lineHeight: 'var(--foo-lineHeight)', palette: { primary: { 500: 'var(--foo-palette-primary-500)' } } }
   */
  function cssVarsParser(theme, options) {
    var _ref3 = options || {},
      prefix = _ref3.prefix,
      shouldSkipGeneratingVar = _ref3.shouldSkipGeneratingVar;
    var css = {};
    var vars = {};
    var varsWithDefaults = {};
    walkObjectDeep(theme, function (keys, value, arrayKeys) {
      if (typeof value === 'string' || typeof value === 'number') {
        if (!shouldSkipGeneratingVar || !shouldSkipGeneratingVar(keys, value)) {
          // only create css & var if `shouldSkipGeneratingVar` return false
          var cssVar = "--".concat(prefix ? "".concat(prefix, "-") : '').concat(keys.join('-'));
          Object.assign(css, _defineProperty({}, cssVar, getCssValue(keys, value)));
          assignNestedKeys(vars, keys, "var(".concat(cssVar, ")"), arrayKeys);
          assignNestedKeys(varsWithDefaults, keys, "var(".concat(cssVar, ", ").concat(value, ")"), arrayKeys);
        }
      }
    }, function (keys) {
      return keys[0] === 'vars';
    } // skip 'vars/*' paths
    );
    return {
      css: css,
      vars: vars,
      varsWithDefaults: varsWithDefaults
    };
  }

  function prepareCssVars(theme, parserConfig) {
    // @ts-ignore - ignore components do not exist
    var _theme$colorSchemes = theme.colorSchemes,
      colorSchemes = _theme$colorSchemes === void 0 ? {} : _theme$colorSchemes;
      theme.components;
      var _theme$defaultColorSc = theme.defaultColorScheme,
      defaultColorScheme = _theme$defaultColorSc === void 0 ? 'light' : _theme$defaultColorSc,
      otherTheme = _objectWithoutProperties(theme, ["colorSchemes", "components", "defaultColorScheme"]);
    var _cssVarsParser = cssVarsParser(otherTheme, parserConfig),
      rootVars = _cssVarsParser.vars,
      rootCss = _cssVarsParser.css,
      rootVarsWithDefaults = _cssVarsParser.varsWithDefaults;
    var themeVars = rootVarsWithDefaults;
    var colorSchemesMap = {};
    var light = colorSchemes[defaultColorScheme],
      otherColorSchemes = _objectWithoutProperties(colorSchemes, [defaultColorScheme].map(toPropertyKey));
    Object.entries(otherColorSchemes || {}).forEach(function (_ref) {
      var _ref2 = _slicedToArray(_ref, 2),
        key = _ref2[0],
        scheme = _ref2[1];
      var _cssVarsParser2 = cssVarsParser(scheme, parserConfig),
        vars = _cssVarsParser2.vars,
        css = _cssVarsParser2.css,
        varsWithDefaults = _cssVarsParser2.varsWithDefaults;
      themeVars = deepmerge(themeVars, varsWithDefaults);
      colorSchemesMap[key] = {
        css: css,
        vars: vars
      };
    });
    if (light) {
      // default color scheme vars should be merged last to set as default
      var _cssVarsParser3 = cssVarsParser(light, parserConfig),
        _css = _cssVarsParser3.css,
        vars = _cssVarsParser3.vars,
        varsWithDefaults = _cssVarsParser3.varsWithDefaults;
      themeVars = deepmerge(themeVars, varsWithDefaults);
      colorSchemesMap[defaultColorScheme] = {
        css: _css,
        vars: vars
      };
    }
    var generateCssVars = function generateCssVars(colorScheme) {
      var _parserConfig$getSele2;
      if (!colorScheme) {
        var _parserConfig$getSele;
        var _css2 = _extends({}, rootCss);
        return {
          css: _css2,
          vars: rootVars,
          selector: (parserConfig == null || (_parserConfig$getSele = parserConfig.getSelector) == null ? void 0 : _parserConfig$getSele.call(parserConfig, colorScheme, _css2)) || ':root'
        };
      }
      var css = _extends({}, colorSchemesMap[colorScheme].css);
      return {
        css: css,
        vars: colorSchemesMap[colorScheme].vars,
        selector: (parserConfig == null || (_parserConfig$getSele2 = parserConfig.getSelector) == null ? void 0 : _parserConfig$getSele2.call(parserConfig, colorScheme, css)) || ':root'
      };
    };
    return {
      vars: themeVars,
      generateCssVars: generateCssVars
    };
  }

  var defaultTheme$6 = createTheme$1();
  var defaultCreateStyledComponent$2 = systemStyled('div', {
    name: 'MuiContainer',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles["maxWidth".concat(capitalize(String(ownerState.maxWidth)))], ownerState.fixed && styles.fixed, ownerState.disableGutters && styles.disableGutters];
    }
  });
  var useThemePropsDefault$2 = function useThemePropsDefault(inProps) {
    return useThemeProps$1({
      props: inProps,
      name: 'MuiContainer',
      defaultTheme: defaultTheme$6
    });
  };
  var useUtilityClasses$1Q = function useUtilityClasses(ownerState, componentName) {
    var getContainerUtilityClass = function getContainerUtilityClass(slot) {
      return generateUtilityClass(componentName, slot);
    };
    var classes = ownerState.classes,
      fixed = ownerState.fixed,
      disableGutters = ownerState.disableGutters,
      maxWidth = ownerState.maxWidth;
    var slots = {
      root: ['root', maxWidth && "maxWidth".concat(capitalize(String(maxWidth))), fixed && 'fixed', disableGutters && 'disableGutters']
    };
    return composeClasses(slots, getContainerUtilityClass, classes);
  };
  function createContainer() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var _options$createStyled = options.createStyledComponent,
      createStyledComponent = _options$createStyled === void 0 ? defaultCreateStyledComponent$2 : _options$createStyled,
      _options$useThemeProp = options.useThemeProps,
      useThemeProps = _options$useThemeProp === void 0 ? useThemePropsDefault$2 : _options$useThemeProp,
      _options$componentNam = options.componentName,
      componentName = _options$componentNam === void 0 ? 'MuiContainer' : _options$componentNam;
    var ContainerRoot = createStyledComponent(function (_ref) {
      var theme = _ref.theme,
        ownerState = _ref.ownerState;
      return _extends({
        width: '100%',
        marginLeft: 'auto',
        boxSizing: 'border-box',
        marginRight: 'auto',
        display: 'block'
      }, !ownerState.disableGutters && _defineProperty({
        paddingLeft: theme.spacing(2),
        paddingRight: theme.spacing(2)
      }, theme.breakpoints.up('sm'), {
        paddingLeft: theme.spacing(3),
        paddingRight: theme.spacing(3)
      }));
    }, function (_ref3) {
      var theme = _ref3.theme,
        ownerState = _ref3.ownerState;
      return ownerState.fixed && Object.keys(theme.breakpoints.values).reduce(function (acc, breakpointValueKey) {
        var breakpoint = breakpointValueKey;
        var value = theme.breakpoints.values[breakpoint];
        if (value !== 0) {
          // @ts-ignore
          acc[theme.breakpoints.up(breakpoint)] = {
            maxWidth: "".concat(value).concat(theme.breakpoints.unit)
          };
        }
        return acc;
      }, {});
    }, function (_ref4) {
      var theme = _ref4.theme,
        ownerState = _ref4.ownerState;
      return _extends({}, ownerState.maxWidth === 'xs' && _defineProperty({}, theme.breakpoints.up('xs'), {
        // @ts-ignore module augmentation fails if custom breakpoints are used
        maxWidth: Math.max(theme.breakpoints.values.xs, 444)
      }), ownerState.maxWidth &&
      // @ts-ignore module augmentation fails if custom breakpoints are used
      ownerState.maxWidth !== 'xs' && _defineProperty({}, theme.breakpoints.up(ownerState.maxWidth), {
        // @ts-ignore module augmentation fails if custom breakpoints are used
        maxWidth: "".concat(theme.breakpoints.values[ownerState.maxWidth]).concat(theme.breakpoints.unit)
      }));
    });
    var Container = /*#__PURE__*/React__namespace.forwardRef(function Container(inProps, ref) {
      var props = useThemeProps(inProps);
      var className = props.className,
        _props$component = props.component,
        component = _props$component === void 0 ? 'div' : _props$component,
        _props$disableGutters = props.disableGutters,
        disableGutters = _props$disableGutters === void 0 ? false : _props$disableGutters,
        _props$fixed = props.fixed,
        fixed = _props$fixed === void 0 ? false : _props$fixed,
        _props$maxWidth = props.maxWidth,
        maxWidth = _props$maxWidth === void 0 ? 'lg' : _props$maxWidth;
        props.classes;
        var other = _objectWithoutProperties(props, ["className", "component", "disableGutters", "fixed", "maxWidth", "classes"]);
      var ownerState = _extends({}, props, {
        component: component,
        disableGutters: disableGutters,
        fixed: fixed,
        maxWidth: maxWidth
      });

      // @ts-ignore module augmentation fails if custom breakpoints are used
      var classes = useUtilityClasses$1Q(ownerState, componentName);
      return (
        /*#__PURE__*/
        // @ts-ignore theme is injected by the styled util
        jsxRuntimeExports.jsx(ContainerRoot, _extends({
          as: component
          // @ts-ignore module augmentation fails if custom breakpoints are used
          ,
          ownerState: ownerState,
          className: clsx(classes.root, className),
          ref: ref
        }, other))
      );
    });
    Container.propTypes /* remove-proptypes */ = {
      children: PropTypes.node,
      classes: PropTypes.object,
      className: PropTypes.string,
      component: PropTypes.elementType,
      disableGutters: PropTypes.bool,
      fixed: PropTypes.bool,
      maxWidth: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl', false]), PropTypes.string]),
      sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
    } ;
    return Container;
  }

  var filterBreakpointKeys = function filterBreakpointKeys(breakpointsKeys, responsiveKeys) {
    return breakpointsKeys.filter(function (key) {
      return responsiveKeys.includes(key);
    });
  };
  var traverseBreakpoints = function traverseBreakpoints(breakpoints, responsive, iterator) {
    var smallestBreakpoint = breakpoints.keys[0]; // the keys is sorted from smallest to largest by `createBreakpoints`.

    if (Array.isArray(responsive)) {
      responsive.forEach(function (breakpointValue, index) {
        iterator(function (responsiveStyles, style) {
          if (index <= breakpoints.keys.length - 1) {
            if (index === 0) {
              Object.assign(responsiveStyles, style);
            } else {
              responsiveStyles[breakpoints.up(breakpoints.keys[index])] = style;
            }
          }
        }, breakpointValue);
      });
    } else if (responsive && _typeof(responsive) === 'object') {
      // prevent null
      // responsive could be a very big object, pick the smallest responsive values

      var keys = Object.keys(responsive).length > breakpoints.keys.length ? breakpoints.keys : filterBreakpointKeys(breakpoints.keys, Object.keys(responsive));
      keys.forEach(function (key) {
        if (breakpoints.keys.indexOf(key) !== -1) {
          // @ts-ignore already checked that responsive is an object
          var breakpointValue = responsive[key];
          if (breakpointValue !== undefined) {
            iterator(function (responsiveStyles, style) {
              if (smallestBreakpoint === key) {
                Object.assign(responsiveStyles, style);
              } else {
                responsiveStyles[breakpoints.up(key)] = style;
              }
            }, breakpointValue);
          }
        }
      });
    } else if (typeof responsive === 'number' || typeof responsive === 'string') {
      iterator(function (responsiveStyles, style) {
        Object.assign(responsiveStyles, style);
      }, responsive);
    }
  };

  function appendLevel(level) {
    if (!level) {
      return '';
    }
    return "Level".concat(level);
  }
  function isNestedContainer(ownerState) {
    return ownerState.unstable_level > 0 && ownerState.container;
  }
  function createGetSelfSpacing(ownerState) {
    return function getSelfSpacing(axis) {
      return "var(--Grid-".concat(axis, "Spacing").concat(appendLevel(ownerState.unstable_level), ")");
    };
  }
  function createGetParentSpacing(ownerState) {
    return function getParentSpacing(axis) {
      if (ownerState.unstable_level === 0) {
        return "var(--Grid-".concat(axis, "Spacing)");
      }
      return "var(--Grid-".concat(axis, "Spacing").concat(appendLevel(ownerState.unstable_level - 1), ")");
    };
  }
  function getParentColumns(ownerState) {
    if (ownerState.unstable_level === 0) {
      return "var(--Grid-columns)";
    }
    return "var(--Grid-columns".concat(appendLevel(ownerState.unstable_level - 1), ")");
  }
  var generateGridSizeStyles = function generateGridSizeStyles(_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    var getSelfSpacing = createGetSelfSpacing(ownerState);
    var styles = {};
    traverseBreakpoints(theme.breakpoints, ownerState.gridSize, function (appendStyle, value) {
      var style = {};
      if (value === true) {
        style = {
          flexBasis: 0,
          flexGrow: 1,
          maxWidth: '100%'
        };
      }
      if (value === 'auto') {
        style = {
          flexBasis: 'auto',
          flexGrow: 0,
          flexShrink: 0,
          maxWidth: 'none',
          width: 'auto'
        };
      }
      if (typeof value === 'number') {
        style = {
          flexGrow: 0,
          flexBasis: 'auto',
          width: "calc(100% * ".concat(value, " / ").concat(getParentColumns(ownerState)).concat(isNestedContainer(ownerState) ? " + ".concat(getSelfSpacing('column')) : '', ")")
        };
      }
      appendStyle(styles, style);
    });
    return styles;
  };
  var generateGridOffsetStyles = function generateGridOffsetStyles(_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    var styles = {};
    traverseBreakpoints(theme.breakpoints, ownerState.gridOffset, function (appendStyle, value) {
      var style = {};
      if (value === 'auto') {
        style = {
          marginLeft: 'auto'
        };
      }
      if (typeof value === 'number') {
        style = {
          marginLeft: value === 0 ? '0px' : "calc(100% * ".concat(value, " / ").concat(getParentColumns(ownerState), ")")
        };
      }
      appendStyle(styles, style);
    });
    return styles;
  };
  var generateGridColumnsStyles = function generateGridColumnsStyles(_ref3) {
    var theme = _ref3.theme,
      ownerState = _ref3.ownerState;
    if (!ownerState.container) {
      return {};
    }
    var styles = isNestedContainer(ownerState) ? _defineProperty({}, "--Grid-columns".concat(appendLevel(ownerState.unstable_level)), getParentColumns(ownerState)) : {
      '--Grid-columns': 12
    };
    traverseBreakpoints(theme.breakpoints, ownerState.columns, function (appendStyle, value) {
      appendStyle(styles, _defineProperty({}, "--Grid-columns".concat(appendLevel(ownerState.unstable_level)), value));
    });
    return styles;
  };
  var generateGridRowSpacingStyles = function generateGridRowSpacingStyles(_ref5) {
    var theme = _ref5.theme,
      ownerState = _ref5.ownerState;
    if (!ownerState.container) {
      return {};
    }
    var getParentSpacing = createGetParentSpacing(ownerState);
    var styles = isNestedContainer(ownerState) ? _defineProperty({}, "--Grid-rowSpacing".concat(appendLevel(ownerState.unstable_level)), getParentSpacing('row')) : {};
    traverseBreakpoints(theme.breakpoints, ownerState.rowSpacing, function (appendStyle, value) {
      var _theme$spacing;
      appendStyle(styles, _defineProperty({}, "--Grid-rowSpacing".concat(appendLevel(ownerState.unstable_level)), typeof value === 'string' ? value : (_theme$spacing = theme.spacing) == null ? void 0 : _theme$spacing.call(theme, value)));
    });
    return styles;
  };
  var generateGridColumnSpacingStyles = function generateGridColumnSpacingStyles(_ref7) {
    var theme = _ref7.theme,
      ownerState = _ref7.ownerState;
    if (!ownerState.container) {
      return {};
    }
    var getParentSpacing = createGetParentSpacing(ownerState);
    var styles = isNestedContainer(ownerState) ? _defineProperty({}, "--Grid-columnSpacing".concat(appendLevel(ownerState.unstable_level)), getParentSpacing('column')) : {};
    traverseBreakpoints(theme.breakpoints, ownerState.columnSpacing, function (appendStyle, value) {
      var _theme$spacing2;
      appendStyle(styles, _defineProperty({}, "--Grid-columnSpacing".concat(appendLevel(ownerState.unstable_level)), typeof value === 'string' ? value : (_theme$spacing2 = theme.spacing) == null ? void 0 : _theme$spacing2.call(theme, value)));
    });
    return styles;
  };
  var generateGridDirectionStyles = function generateGridDirectionStyles(_ref9) {
    var theme = _ref9.theme,
      ownerState = _ref9.ownerState;
    if (!ownerState.container) {
      return {};
    }
    var styles = {};
    traverseBreakpoints(theme.breakpoints, ownerState.direction, function (appendStyle, value) {
      appendStyle(styles, {
        flexDirection: value
      });
    });
    return styles;
  };
  var generateGridStyles = function generateGridStyles(_ref10) {
    var ownerState = _ref10.ownerState;
    var getSelfSpacing = createGetSelfSpacing(ownerState);
    var getParentSpacing = createGetParentSpacing(ownerState);
    return _extends({
      minWidth: 0,
      boxSizing: 'border-box'
    }, ownerState.container && _extends({
      display: 'flex',
      flexWrap: 'wrap'
    }, ownerState.wrap && ownerState.wrap !== 'wrap' && {
      flexWrap: ownerState.wrap
    }, {
      margin: "calc(".concat(getSelfSpacing('row'), " / -2) calc(").concat(getSelfSpacing('column'), " / -2)")
    }, ownerState.disableEqualOverflow && {
      margin: "calc(".concat(getSelfSpacing('row'), " * -1) 0px 0px calc(").concat(getSelfSpacing('column'), " * -1)")
    }), (!ownerState.container || isNestedContainer(ownerState)) && _extends({
      padding: "calc(".concat(getParentSpacing('row'), " / 2) calc(").concat(getParentSpacing('column'), " / 2)")
    }, (ownerState.disableEqualOverflow || ownerState.parentDisableEqualOverflow) && {
      padding: "".concat(getParentSpacing('row'), " 0px 0px ").concat(getParentSpacing('column'))
    }));
  };
  var generateSizeClassNames = function generateSizeClassNames(gridSize) {
    var classNames = [];
    Object.entries(gridSize).forEach(function (_ref11) {
      var _ref12 = _slicedToArray(_ref11, 2),
        key = _ref12[0],
        value = _ref12[1];
      if (value !== false && value !== undefined) {
        classNames.push("grid-".concat(key, "-").concat(String(value)));
      }
    });
    return classNames;
  };
  var generateSpacingClassNames = function generateSpacingClassNames(spacing) {
    var smallestBreakpoint = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'xs';
    function isValidSpacing(val) {
      if (val === undefined) {
        return false;
      }
      return typeof val === 'string' && !Number.isNaN(Number(val)) || typeof val === 'number' && val > 0;
    }
    if (isValidSpacing(spacing)) {
      return ["spacing-".concat(smallestBreakpoint, "-").concat(String(spacing))];
    }
    if (_typeof(spacing) === 'object' && !Array.isArray(spacing)) {
      var classNames = [];
      Object.entries(spacing).forEach(function (_ref13) {
        var _ref14 = _slicedToArray(_ref13, 2),
          key = _ref14[0],
          value = _ref14[1];
        if (isValidSpacing(value)) {
          classNames.push("spacing-".concat(key, "-").concat(String(value)));
        }
      });
      return classNames;
    }
    return [];
  };
  var generateDirectionClasses = function generateDirectionClasses(direction) {
    if (direction === undefined) {
      return [];
    }
    if (_typeof(direction) === 'object') {
      return Object.entries(direction).map(function (_ref15) {
        var _ref16 = _slicedToArray(_ref15, 2),
          key = _ref16[0],
          value = _ref16[1];
        return "direction-".concat(key, "-").concat(value);
      });
    }
    return ["direction-xs-".concat(String(direction))];
  };

  var defaultTheme$5 = createTheme$1();

  // widening Theme to any so that the consumer can own the theme structure.
  var defaultCreateStyledComponent$1 = systemStyled('div', {
    name: 'MuiGrid',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  });
  function useThemePropsDefault$1(props) {
    return useThemeProps$1({
      props: props,
      name: 'MuiGrid',
      defaultTheme: defaultTheme$5
    });
  }
  function createGrid() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var _options$createStyled = options.createStyledComponent,
      createStyledComponent = _options$createStyled === void 0 ? defaultCreateStyledComponent$1 : _options$createStyled,
      _options$useThemeProp = options.useThemeProps,
      useThemeProps = _options$useThemeProp === void 0 ? useThemePropsDefault$1 : _options$useThemeProp,
      _options$componentNam = options.componentName,
      componentName = _options$componentNam === void 0 ? 'MuiGrid' : _options$componentNam;
    var GridOverflowContext = /*#__PURE__*/React__namespace.createContext(undefined);
    {
      GridOverflowContext.displayName = 'GridOverflowContext';
    }
    var useUtilityClasses = function useUtilityClasses(ownerState, theme) {
      var container = ownerState.container,
        direction = ownerState.direction,
        spacing = ownerState.spacing,
        wrap = ownerState.wrap,
        gridSize = ownerState.gridSize;
      var slots = {
        root: ['root', container && 'container', wrap !== 'wrap' && "wrap-xs-".concat(String(wrap))].concat(_toConsumableArray(generateDirectionClasses(direction)), _toConsumableArray(generateSizeClassNames(gridSize)), _toConsumableArray(container ? generateSpacingClassNames(spacing, theme.breakpoints.keys[0]) : []))
      };
      return composeClasses(slots, function (slot) {
        return generateUtilityClass(componentName, slot);
      }, {});
    };
    var GridRoot = createStyledComponent(generateGridColumnsStyles, generateGridColumnSpacingStyles, generateGridRowSpacingStyles, generateGridSizeStyles, generateGridDirectionStyles, generateGridStyles, generateGridOffsetStyles);
    var Grid = /*#__PURE__*/React__namespace.forwardRef(function Grid(inProps, ref) {
      var _inProps$columns, _inProps$spacing, _ref3, _inProps$rowSpacing, _ref4, _inProps$columnSpacin, _ref5, _disableEqualOverflow;
      var theme = useTheme$2();
      var themeProps = useThemeProps(inProps);
      var props = extendSxProp(themeProps); // `color` type conflicts with html color attribute.
      var overflow = React__namespace.useContext(GridOverflowContext);
      var className = props.className,
        children = props.children,
        _props$columns = props.columns,
        columnsProp = _props$columns === void 0 ? 12 : _props$columns,
        _props$container = props.container,
        container = _props$container === void 0 ? false : _props$container,
        _props$component = props.component,
        component = _props$component === void 0 ? 'div' : _props$component,
        _props$direction = props.direction,
        direction = _props$direction === void 0 ? 'row' : _props$direction,
        _props$wrap = props.wrap,
        wrap = _props$wrap === void 0 ? 'wrap' : _props$wrap,
        _props$spacing = props.spacing,
        spacingProp = _props$spacing === void 0 ? 0 : _props$spacing,
        _props$rowSpacing = props.rowSpacing,
        rowSpacingProp = _props$rowSpacing === void 0 ? spacingProp : _props$rowSpacing,
        _props$columnSpacing = props.columnSpacing,
        columnSpacingProp = _props$columnSpacing === void 0 ? spacingProp : _props$columnSpacing,
        themeDisableEqualOverflow = props.disableEqualOverflow,
        _props$unstable_level = props.unstable_level,
        level = _props$unstable_level === void 0 ? 0 : _props$unstable_level,
        rest = _objectWithoutProperties(props, ["className", "children", "columns", "container", "component", "direction", "wrap", "spacing", "rowSpacing", "columnSpacing", "disableEqualOverflow", "unstable_level"]); // Because `disableEqualOverflow` can be set from the theme's defaultProps, the **nested** grid should look at the instance props instead.
      var disableEqualOverflow = themeDisableEqualOverflow;
      if (level && themeDisableEqualOverflow !== undefined) {
        disableEqualOverflow = inProps.disableEqualOverflow;
      }
      // collect breakpoints related props because they can be customized from the theme.
      var gridSize = {};
      var gridOffset = {};
      var other = {};
      Object.entries(rest).forEach(function (_ref) {
        var _ref2 = _slicedToArray(_ref, 2),
          key = _ref2[0],
          val = _ref2[1];
        if (theme.breakpoints.values[key] !== undefined) {
          gridSize[key] = val;
        } else if (theme.breakpoints.values[key.replace('Offset', '')] !== undefined) {
          gridOffset[key.replace('Offset', '')] = val;
        } else {
          other[key] = val;
        }
      });
      var columns = (_inProps$columns = inProps.columns) != null ? _inProps$columns : level ? undefined : columnsProp;
      var spacing = (_inProps$spacing = inProps.spacing) != null ? _inProps$spacing : level ? undefined : spacingProp;
      var rowSpacing = (_ref3 = (_inProps$rowSpacing = inProps.rowSpacing) != null ? _inProps$rowSpacing : inProps.spacing) != null ? _ref3 : level ? undefined : rowSpacingProp;
      var columnSpacing = (_ref4 = (_inProps$columnSpacin = inProps.columnSpacing) != null ? _inProps$columnSpacin : inProps.spacing) != null ? _ref4 : level ? undefined : columnSpacingProp;
      var ownerState = _extends({}, props, {
        level: level,
        columns: columns,
        container: container,
        direction: direction,
        wrap: wrap,
        spacing: spacing,
        rowSpacing: rowSpacing,
        columnSpacing: columnSpacing,
        gridSize: gridSize,
        gridOffset: gridOffset,
        disableEqualOverflow: (_ref5 = (_disableEqualOverflow = disableEqualOverflow) != null ? _disableEqualOverflow : overflow) != null ? _ref5 : false,
        // use context value if exists.
        parentDisableEqualOverflow: overflow // for nested grid
      });
      var classes = useUtilityClasses(ownerState, theme);
      var result = /*#__PURE__*/jsxRuntimeExports.jsx(GridRoot, _extends({
        ref: ref,
        as: component,
        ownerState: ownerState,
        className: clsx(classes.root, className)
      }, other, {
        children: React__namespace.Children.map(children, function (child) {
          if ( /*#__PURE__*/React__namespace.isValidElement(child) && isMuiElement(child, ['Grid'])) {
            var _unstable_level, _child$props;
            return /*#__PURE__*/React__namespace.cloneElement(child, {
              unstable_level: (_unstable_level = (_child$props = child.props) == null ? void 0 : _child$props.unstable_level) != null ? _unstable_level : level + 1
            });
          }
          return child;
        })
      }));
      if (disableEqualOverflow !== undefined && disableEqualOverflow !== (overflow != null ? overflow : false)) {
        // There are 2 possibilities that should wrap with the GridOverflowContext to communicate with the nested grids:
        // 1. It is the root grid with `disableEqualOverflow`.
        // 2. It is a nested grid with different `disableEqualOverflow` from the context.
        result = /*#__PURE__*/jsxRuntimeExports.jsx(GridOverflowContext.Provider, {
          value: disableEqualOverflow,
          children: result
        });
      }
      return result;
    });
    Grid.propTypes /* remove-proptypes */ = {
      children: PropTypes.node,
      className: PropTypes.string,
      columns: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.number), PropTypes.number, PropTypes.object]),
      columnSpacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),
      component: PropTypes.elementType,
      container: PropTypes.bool,
      direction: PropTypes.oneOfType([PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row']), PropTypes.arrayOf(PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row'])), PropTypes.object]),
      disableEqualOverflow: PropTypes.bool,
      lg: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
      lgOffset: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]),
      md: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
      mdOffset: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]),
      rowSpacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),
      sm: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
      smOffset: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]),
      spacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),
      sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
      wrap: PropTypes.oneOf(['nowrap', 'wrap-reverse', 'wrap']),
      xl: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
      xlOffset: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]),
      xs: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
      xsOffset: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number])
    } ;

    // @ts-ignore internal logic for nested grid
    Grid.muiName = 'Grid';
    return Grid;
  }

  var defaultTheme$4 = createTheme$1();
  // widening Theme to any so that the consumer can own the theme structure.
  var defaultCreateStyledComponent = systemStyled('div', {
    name: 'MuiStack',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  });
  function useThemePropsDefault(props) {
    return useThemeProps$1({
      props: props,
      name: 'MuiStack',
      defaultTheme: defaultTheme$4
    });
  }

  /**
   * Return an array with the separator React element interspersed between
   * each React node of the input children.
   *
   * > joinChildren([1,2,3], 0)
   * [1,0,2,0,3]
   */
  function joinChildren(children, separator) {
    var childrenArray = React__namespace.Children.toArray(children).filter(Boolean);
    return childrenArray.reduce(function (output, child, index) {
      output.push(child);
      if (index < childrenArray.length - 1) {
        output.push( /*#__PURE__*/React__namespace.cloneElement(separator, {
          key: "separator-".concat(index)
        }));
      }
      return output;
    }, []);
  }
  var getSideFromDirection = function getSideFromDirection(direction) {
    return {
      row: 'Left',
      'row-reverse': 'Right',
      column: 'Top',
      'column-reverse': 'Bottom'
    }[direction];
  };
  var style = function style(_ref) {
    var ownerState = _ref.ownerState,
      theme = _ref.theme;
    var styles = _extends({
      display: 'flex',
      flexDirection: 'column'
    }, handleBreakpoints({
      theme: theme
    }, resolveBreakpointValues({
      values: ownerState.direction,
      breakpoints: theme.breakpoints.values
    }), function (propValue) {
      return {
        flexDirection: propValue
      };
    }));
    if (ownerState.spacing) {
      var transformer = createUnarySpacing(theme);
      var base = Object.keys(theme.breakpoints.values).reduce(function (acc, breakpoint) {
        if (_typeof(ownerState.spacing) === 'object' && ownerState.spacing[breakpoint] != null || _typeof(ownerState.direction) === 'object' && ownerState.direction[breakpoint] != null) {
          acc[breakpoint] = true;
        }
        return acc;
      }, {});
      var directionValues = resolveBreakpointValues({
        values: ownerState.direction,
        base: base
      });
      var spacingValues = resolveBreakpointValues({
        values: ownerState.spacing,
        base: base
      });
      if (_typeof(directionValues) === 'object') {
        Object.keys(directionValues).forEach(function (breakpoint, index, breakpoints) {
          var directionValue = directionValues[breakpoint];
          if (!directionValue) {
            var previousDirectionValue = index > 0 ? directionValues[breakpoints[index - 1]] : 'column';
            directionValues[breakpoint] = previousDirectionValue;
          }
        });
      }
      var styleFromPropValue = function styleFromPropValue(propValue, breakpoint) {
        if (ownerState.useFlexGap) {
          return {
            gap: getValue(transformer, propValue)
          };
        }
        return {
          // The useFlexGap={false} implement relies on each child to give up control of the margin.
          // We need to reset the margin to avoid double spacing.
          '& > :not(style):not(style)': {
            margin: 0
          },
          '& > :not(style) ~ :not(style)': _defineProperty({}, "margin".concat(getSideFromDirection(breakpoint ? directionValues[breakpoint] : ownerState.direction)), getValue(transformer, propValue))
        };
      };
      styles = deepmerge(styles, handleBreakpoints({
        theme: theme
      }, spacingValues, styleFromPropValue));
    }
    styles = mergeBreakpointsInOrder(theme.breakpoints, styles);
    return styles;
  };
  function createStack() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var _options$createStyled = options.createStyledComponent,
      createStyledComponent = _options$createStyled === void 0 ? defaultCreateStyledComponent : _options$createStyled,
      _options$useThemeProp = options.useThemeProps,
      useThemeProps = _options$useThemeProp === void 0 ? useThemePropsDefault : _options$useThemeProp,
      _options$componentNam = options.componentName,
      componentName = _options$componentNam === void 0 ? 'MuiStack' : _options$componentNam;
    var useUtilityClasses = function useUtilityClasses() {
      var slots = {
        root: ['root']
      };
      return composeClasses(slots, function (slot) {
        return generateUtilityClass(componentName, slot);
      }, {});
    };
    var StackRoot = createStyledComponent(style);
    var Stack = /*#__PURE__*/React__namespace.forwardRef(function Grid(inProps, ref) {
      var themeProps = useThemeProps(inProps);
      var props = extendSxProp(themeProps); // `color` type conflicts with html color attribute.
      var _props$component = props.component,
        component = _props$component === void 0 ? 'div' : _props$component,
        _props$direction = props.direction,
        direction = _props$direction === void 0 ? 'column' : _props$direction,
        _props$spacing = props.spacing,
        spacing = _props$spacing === void 0 ? 0 : _props$spacing,
        divider = props.divider,
        children = props.children,
        className = props.className,
        _props$useFlexGap = props.useFlexGap,
        useFlexGap = _props$useFlexGap === void 0 ? false : _props$useFlexGap,
        other = _objectWithoutProperties(props, ["component", "direction", "spacing", "divider", "children", "className", "useFlexGap"]);
      var ownerState = {
        direction: direction,
        spacing: spacing,
        useFlexGap: useFlexGap
      };
      var classes = useUtilityClasses();
      return /*#__PURE__*/jsxRuntimeExports.jsx(StackRoot, _extends({
        as: component,
        ownerState: ownerState,
        ref: ref,
        className: clsx(classes.root, className)
      }, other, {
        children: divider ? joinChildren(children, divider) : children
      }));
    });
    Stack.propTypes /* remove-proptypes */ = {
      children: PropTypes.node,
      direction: PropTypes.oneOfType([PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row']), PropTypes.arrayOf(PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row'])), PropTypes.object]),
      divider: PropTypes.node,
      spacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),
      sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
    } ;
    return Stack;
  }

  function adaptV4Theme(inputTheme) {
    {
      console.warn(['MUI: adaptV4Theme() is deprecated.', 'Follow the upgrade guide on https://mui.com/r/migration-v4#theme.'].join('\n'));
    }
    var _inputTheme$defaultPr = inputTheme.defaultProps,
      defaultProps = _inputTheme$defaultPr === void 0 ? {} : _inputTheme$defaultPr,
      _inputTheme$mixins = inputTheme.mixins,
      mixins = _inputTheme$mixins === void 0 ? {} : _inputTheme$mixins,
      _inputTheme$overrides = inputTheme.overrides,
      overrides = _inputTheme$overrides === void 0 ? {} : _inputTheme$overrides,
      _inputTheme$palette = inputTheme.palette,
      palette = _inputTheme$palette === void 0 ? {} : _inputTheme$palette,
      _inputTheme$props = inputTheme.props,
      props = _inputTheme$props === void 0 ? {} : _inputTheme$props,
      _inputTheme$styleOver = inputTheme.styleOverrides,
      styleOverrides = _inputTheme$styleOver === void 0 ? {} : _inputTheme$styleOver,
      other = _objectWithoutProperties(inputTheme, ["defaultProps", "mixins", "overrides", "palette", "props", "styleOverrides"]);
    var theme = _extends({}, other, {
      components: {}
    });

    // default props
    Object.keys(defaultProps).forEach(function (component) {
      var componentValue = theme.components[component] || {};
      componentValue.defaultProps = defaultProps[component];
      theme.components[component] = componentValue;
    });
    Object.keys(props).forEach(function (component) {
      var componentValue = theme.components[component] || {};
      componentValue.defaultProps = props[component];
      theme.components[component] = componentValue;
    });

    // CSS overrides
    Object.keys(styleOverrides).forEach(function (component) {
      var componentValue = theme.components[component] || {};
      componentValue.styleOverrides = styleOverrides[component];
      theme.components[component] = componentValue;
    });
    Object.keys(overrides).forEach(function (component) {
      var componentValue = theme.components[component] || {};
      componentValue.styleOverrides = overrides[component];
      theme.components[component] = componentValue;
    });

    // theme.spacing
    theme.spacing = createSpacing(inputTheme.spacing);

    // theme.mixins.gutters
    var breakpoints = createBreakpoints(inputTheme.breakpoints || {});
    var spacing = theme.spacing;
    theme.mixins = _extends({
      gutters: function gutters() {
        var styles = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
        return _extends({
          paddingLeft: spacing(2),
          paddingRight: spacing(2)
        }, styles, _defineProperty({}, breakpoints.up('sm'), _extends({
          paddingLeft: spacing(3),
          paddingRight: spacing(3)
        }, styles[breakpoints.up('sm')])));
      }
    }, mixins);
    var typeInput = palette.type,
      modeInput = palette.mode,
      paletteRest = _objectWithoutProperties(palette, ["type", "mode"]);
    var finalMode = modeInput || typeInput || 'light';
    theme.palette = _extends({
      // theme.palette.text.hint
      text: {
        hint: finalMode === 'dark' ? 'rgba(255, 255, 255, 0.5)' : 'rgba(0, 0, 0, 0.38)'
      },
      mode: finalMode,
      type: finalMode
    }, paletteRest);
    return theme;
  }

  function createMixins(breakpoints, mixins) {
    return _extends({
      toolbar: _defineProperty(_defineProperty({
        minHeight: 56
      }, breakpoints.up('xs'), {
        '@media (orientation: landscape)': {
          minHeight: 48
        }
      }), breakpoints.up('sm'), {
        minHeight: 64
      })
    }, mixins);
  }

  var light = {
    // The colors used to style the text.
    text: {
      // The most important text.
      primary: 'rgba(0, 0, 0, 0.87)',
      // Secondary text.
      secondary: 'rgba(0, 0, 0, 0.6)',
      // Disabled text have even lower visual prominence.
      disabled: 'rgba(0, 0, 0, 0.38)'
    },
    // The color used to divide different elements.
    divider: 'rgba(0, 0, 0, 0.12)',
    // The background colors used to style the surfaces.
    // Consistency between these values is important.
    background: {
      paper: common$1.white,
      "default": common$1.white
    },
    // The colors used to style the action elements.
    action: {
      // The color of an active action like an icon button.
      active: 'rgba(0, 0, 0, 0.54)',
      // The color of an hovered action.
      hover: 'rgba(0, 0, 0, 0.04)',
      hoverOpacity: 0.04,
      // The color of a selected action.
      selected: 'rgba(0, 0, 0, 0.08)',
      selectedOpacity: 0.08,
      // The color of a disabled action.
      disabled: 'rgba(0, 0, 0, 0.26)',
      // The background color of a disabled action.
      disabledBackground: 'rgba(0, 0, 0, 0.12)',
      disabledOpacity: 0.38,
      focus: 'rgba(0, 0, 0, 0.12)',
      focusOpacity: 0.12,
      activatedOpacity: 0.12
    }
  };
  var dark = {
    text: {
      primary: common$1.white,
      secondary: 'rgba(255, 255, 255, 0.7)',
      disabled: 'rgba(255, 255, 255, 0.5)',
      icon: 'rgba(255, 255, 255, 0.5)'
    },
    divider: 'rgba(255, 255, 255, 0.12)',
    background: {
      paper: '#121212',
      "default": '#121212'
    },
    action: {
      active: common$1.white,
      hover: 'rgba(255, 255, 255, 0.08)',
      hoverOpacity: 0.08,
      selected: 'rgba(255, 255, 255, 0.16)',
      selectedOpacity: 0.16,
      disabled: 'rgba(255, 255, 255, 0.3)',
      disabledBackground: 'rgba(255, 255, 255, 0.12)',
      disabledOpacity: 0.38,
      focus: 'rgba(255, 255, 255, 0.12)',
      focusOpacity: 0.12,
      activatedOpacity: 0.24
    }
  };
  function addLightOrDark(intent, direction, shade, tonalOffset) {
    var tonalOffsetLight = tonalOffset.light || tonalOffset;
    var tonalOffsetDark = tonalOffset.dark || tonalOffset * 1.5;
    if (!intent[direction]) {
      if (intent.hasOwnProperty(shade)) {
        intent[direction] = intent[shade];
      } else if (direction === 'light') {
        intent.light = lighten(intent.main, tonalOffsetLight);
      } else if (direction === 'dark') {
        intent.dark = darken(intent.main, tonalOffsetDark);
      }
    }
  }
  function getDefaultPrimary() {
    var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'light';
    if (mode === 'dark') {
      return {
        main: blue$1[200],
        light: blue$1[50],
        dark: blue$1[400]
      };
    }
    return {
      main: blue$1[700],
      light: blue$1[400],
      dark: blue$1[800]
    };
  }
  function getDefaultSecondary() {
    var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'light';
    if (mode === 'dark') {
      return {
        main: purple$1[200],
        light: purple$1[50],
        dark: purple$1[400]
      };
    }
    return {
      main: purple$1[500],
      light: purple$1[300],
      dark: purple$1[700]
    };
  }
  function getDefaultError() {
    var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'light';
    if (mode === 'dark') {
      return {
        main: red$1[500],
        light: red$1[300],
        dark: red$1[700]
      };
    }
    return {
      main: red$1[700],
      light: red$1[400],
      dark: red$1[800]
    };
  }
  function getDefaultInfo() {
    var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'light';
    if (mode === 'dark') {
      return {
        main: lightBlue$1[400],
        light: lightBlue$1[300],
        dark: lightBlue$1[700]
      };
    }
    return {
      main: lightBlue$1[700],
      light: lightBlue$1[500],
      dark: lightBlue$1[900]
    };
  }
  function getDefaultSuccess() {
    var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'light';
    if (mode === 'dark') {
      return {
        main: green$1[400],
        light: green$1[300],
        dark: green$1[700]
      };
    }
    return {
      main: green$1[800],
      light: green$1[500],
      dark: green$1[900]
    };
  }
  function getDefaultWarning() {
    var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'light';
    if (mode === 'dark') {
      return {
        main: orange$1[400],
        light: orange$1[300],
        dark: orange$1[700]
      };
    }
    return {
      main: '#ed6c02',
      // closest to orange[800] that pass 3:1.
      light: orange$1[500],
      dark: orange$1[900]
    };
  }
  function createPalette(palette) {
    var _palette$mode = palette.mode,
      mode = _palette$mode === void 0 ? 'light' : _palette$mode,
      _palette$contrastThre = palette.contrastThreshold,
      contrastThreshold = _palette$contrastThre === void 0 ? 3 : _palette$contrastThre,
      _palette$tonalOffset = palette.tonalOffset,
      tonalOffset = _palette$tonalOffset === void 0 ? 0.2 : _palette$tonalOffset,
      other = _objectWithoutProperties(palette, ["mode", "contrastThreshold", "tonalOffset"]);
    var primary = palette.primary || getDefaultPrimary(mode);
    var secondary = palette.secondary || getDefaultSecondary(mode);
    var error = palette.error || getDefaultError(mode);
    var info = palette.info || getDefaultInfo(mode);
    var success = palette.success || getDefaultSuccess(mode);
    var warning = palette.warning || getDefaultWarning(mode);

    // Use the same logic as
    // Bootstrap: https://github.com/twbs/bootstrap/blob/1d6e3710dd447de1a200f29e8fa521f8a0908f70/scss/_functions.scss#L59
    // and material-components-web https://github.com/material-components/material-components-web/blob/ac46b8863c4dab9fc22c4c662dc6bd1b65dd652f/packages/mdc-theme/_functions.scss#L54
    function getContrastText(background) {
      var contrastText = getContrastRatio(background, dark.text.primary) >= contrastThreshold ? dark.text.primary : light.text.primary;
      {
        var contrast = getContrastRatio(background, contrastText);
        if (contrast < 3) {
          console.error(["MUI: The contrast ratio of ".concat(contrast, ":1 for ").concat(contrastText, " on ").concat(background), 'falls below the WCAG recommended absolute minimum contrast ratio of 3:1.', 'https://www.w3.org/TR/2008/REC-WCAG20-20081211/#visual-audio-contrast-contrast'].join('\n'));
        }
      }
      return contrastText;
    }
    var augmentColor = function augmentColor(_ref) {
      var color = _ref.color,
        name = _ref.name,
        _ref$mainShade = _ref.mainShade,
        mainShade = _ref$mainShade === void 0 ? 500 : _ref$mainShade,
        _ref$lightShade = _ref.lightShade,
        lightShade = _ref$lightShade === void 0 ? 300 : _ref$lightShade,
        _ref$darkShade = _ref.darkShade,
        darkShade = _ref$darkShade === void 0 ? 700 : _ref$darkShade;
      color = _extends({}, color);
      if (!color.main && color[mainShade]) {
        color.main = color[mainShade];
      }
      if (!color.hasOwnProperty('main')) {
        throw new Error("MUI: The color".concat(name ? " (".concat(name, ")") : '', " provided to augmentColor(color) is invalid.\nThe color object needs to have a `main` property or a `").concat(mainShade, "` property.") );
      }
      if (typeof color.main !== 'string') {
        throw new Error("MUI: The color".concat(name ? " (".concat(name, ")") : '', " provided to augmentColor(color) is invalid.\n`color.main` should be a string, but `").concat(JSON.stringify(color.main), "` was provided instead.\n\nDid you intend to use one of the following approaches?\n\nimport { green } from \"@mui/material/colors\";\n\nconst theme1 = createTheme({ palette: {\n  primary: green,\n} });\n\nconst theme2 = createTheme({ palette: {\n  primary: { main: green[500] },\n} });") );
      }
      addLightOrDark(color, 'light', lightShade, tonalOffset);
      addLightOrDark(color, 'dark', darkShade, tonalOffset);
      if (!color.contrastText) {
        color.contrastText = getContrastText(color.main);
      }
      return color;
    };
    var modes = {
      dark: dark,
      light: light
    };
    {
      if (!modes[mode]) {
        console.error("MUI: The palette mode `".concat(mode, "` is not supported."));
      }
    }
    var paletteOutput = deepmerge(_extends({
      // A collection of common colors.
      common: _extends({}, common$1),
      // prevent mutable object.
      // The palette mode, can be light or dark.
      mode: mode,
      // The colors used to represent primary interface elements for a user.
      primary: augmentColor({
        color: primary,
        name: 'primary'
      }),
      // The colors used to represent secondary interface elements for a user.
      secondary: augmentColor({
        color: secondary,
        name: 'secondary',
        mainShade: 'A400',
        lightShade: 'A200',
        darkShade: 'A700'
      }),
      // The colors used to represent interface elements that the user should be made aware of.
      error: augmentColor({
        color: error,
        name: 'error'
      }),
      // The colors used to represent potentially dangerous actions or important messages.
      warning: augmentColor({
        color: warning,
        name: 'warning'
      }),
      // The colors used to present information to the user that is neutral and not necessarily important.
      info: augmentColor({
        color: info,
        name: 'info'
      }),
      // The colors used to indicate the successful completion of an action that user triggered.
      success: augmentColor({
        color: success,
        name: 'success'
      }),
      // The grey colors.
      grey: grey$1,
      // Used by `getContrastText()` to maximize the contrast between
      // the background and the text.
      contrastThreshold: contrastThreshold,
      // Takes a background color and returns the text color that maximizes the contrast.
      getContrastText: getContrastText,
      // Generate a rich color object.
      augmentColor: augmentColor,
      // Used by the functions below to shift a color's luminance by approximately
      // two indexes within its tonal palette.
      // E.g., shift from Red 500 to Red 300 or Red 700.
      tonalOffset: tonalOffset
    }, modes[mode]), other);
    return paletteOutput;
  }

  function round$2(value) {
    return Math.round(value * 1e5) / 1e5;
  }
  var caseAllCaps = {
    textTransform: 'uppercase'
  };
  var defaultFontFamily = '"Roboto", "Helvetica", "Arial", sans-serif';

  /**
   * @see @link{https://m2.material.io/design/typography/the-type-system.html}
   * @see @link{https://m2.material.io/design/typography/understanding-typography.html}
   */
  function createTypography(palette, typography) {
    var _ref = typeof typography === 'function' ? typography(palette) : typography,
      _ref$fontFamily = _ref.fontFamily,
      fontFamily = _ref$fontFamily === void 0 ? defaultFontFamily : _ref$fontFamily,
      _ref$fontSize = _ref.fontSize,
      fontSize = _ref$fontSize === void 0 ? 14 : _ref$fontSize,
      _ref$fontWeightLight = _ref.fontWeightLight,
      fontWeightLight = _ref$fontWeightLight === void 0 ? 300 : _ref$fontWeightLight,
      _ref$fontWeightRegula = _ref.fontWeightRegular,
      fontWeightRegular = _ref$fontWeightRegula === void 0 ? 400 : _ref$fontWeightRegula,
      _ref$fontWeightMedium = _ref.fontWeightMedium,
      fontWeightMedium = _ref$fontWeightMedium === void 0 ? 500 : _ref$fontWeightMedium,
      _ref$fontWeightBold = _ref.fontWeightBold,
      fontWeightBold = _ref$fontWeightBold === void 0 ? 700 : _ref$fontWeightBold,
      _ref$htmlFontSize = _ref.htmlFontSize,
      htmlFontSize = _ref$htmlFontSize === void 0 ? 16 : _ref$htmlFontSize,
      allVariants = _ref.allVariants,
      pxToRem2 = _ref.pxToRem,
      other = _objectWithoutProperties(_ref, ["fontFamily", "fontSize", "fontWeightLight", "fontWeightRegular", "fontWeightMedium", "fontWeightBold", "htmlFontSize", "allVariants", "pxToRem"]);
    {
      if (typeof fontSize !== 'number') {
        console.error('MUI: `fontSize` is required to be a number.');
      }
      if (typeof htmlFontSize !== 'number') {
        console.error('MUI: `htmlFontSize` is required to be a number.');
      }
    }
    var coef = fontSize / 14;
    var pxToRem = pxToRem2 || function (size) {
      return "".concat(size / htmlFontSize * coef, "rem");
    };
    var buildVariant = function buildVariant(fontWeight, size, lineHeight, letterSpacing, casing) {
      return _extends({
        fontFamily: fontFamily,
        fontWeight: fontWeight,
        fontSize: pxToRem(size),
        // Unitless following https://meyerweb.com/eric/thoughts/2006/02/08/unitless-line-heights/
        lineHeight: lineHeight
      }, fontFamily === defaultFontFamily ? {
        letterSpacing: "".concat(round$2(letterSpacing / size), "em")
      } : {}, casing, allVariants);
    };
    var variants = {
      h1: buildVariant(fontWeightLight, 96, 1.167, -1.5),
      h2: buildVariant(fontWeightLight, 60, 1.2, -0.5),
      h3: buildVariant(fontWeightRegular, 48, 1.167, 0),
      h4: buildVariant(fontWeightRegular, 34, 1.235, 0.25),
      h5: buildVariant(fontWeightRegular, 24, 1.334, 0),
      h6: buildVariant(fontWeightMedium, 20, 1.6, 0.15),
      subtitle1: buildVariant(fontWeightRegular, 16, 1.75, 0.15),
      subtitle2: buildVariant(fontWeightMedium, 14, 1.57, 0.1),
      body1: buildVariant(fontWeightRegular, 16, 1.5, 0.15),
      body2: buildVariant(fontWeightRegular, 14, 1.43, 0.15),
      button: buildVariant(fontWeightMedium, 14, 1.75, 0.4, caseAllCaps),
      caption: buildVariant(fontWeightRegular, 12, 1.66, 0.4),
      overline: buildVariant(fontWeightRegular, 12, 2.66, 1, caseAllCaps),
      // TODO v6: Remove handling of 'inherit' variant from the theme as it is already handled in Material UI's Typography component. Also, remember to remove the associated types.
      inherit: {
        fontFamily: 'inherit',
        fontWeight: 'inherit',
        fontSize: 'inherit',
        lineHeight: 'inherit',
        letterSpacing: 'inherit'
      }
    };
    return deepmerge(_extends({
      htmlFontSize: htmlFontSize,
      pxToRem: pxToRem,
      fontFamily: fontFamily,
      fontSize: fontSize,
      fontWeightLight: fontWeightLight,
      fontWeightRegular: fontWeightRegular,
      fontWeightMedium: fontWeightMedium,
      fontWeightBold: fontWeightBold
    }, variants), other, {
      clone: false // No need to clone deep
    });
  }

  var shadowKeyUmbraOpacity = 0.2;
  var shadowKeyPenumbraOpacity = 0.14;
  var shadowAmbientShadowOpacity = 0.12;
  function createShadow() {
    return ["".concat(arguments.length <= 0 ? undefined : arguments[0], "px ").concat(arguments.length <= 1 ? undefined : arguments[1], "px ").concat(arguments.length <= 2 ? undefined : arguments[2], "px ").concat(arguments.length <= 3 ? undefined : arguments[3], "px rgba(0,0,0,").concat(shadowKeyUmbraOpacity, ")"), "".concat(arguments.length <= 4 ? undefined : arguments[4], "px ").concat(arguments.length <= 5 ? undefined : arguments[5], "px ").concat(arguments.length <= 6 ? undefined : arguments[6], "px ").concat(arguments.length <= 7 ? undefined : arguments[7], "px rgba(0,0,0,").concat(shadowKeyPenumbraOpacity, ")"), "".concat(arguments.length <= 8 ? undefined : arguments[8], "px ").concat(arguments.length <= 9 ? undefined : arguments[9], "px ").concat(arguments.length <= 10 ? undefined : arguments[10], "px ").concat(arguments.length <= 11 ? undefined : arguments[11], "px rgba(0,0,0,").concat(shadowAmbientShadowOpacity, ")")].join(',');
  }

  // Values from https://github.com/material-components/material-components-web/blob/be8747f94574669cb5e7add1a7c54fa41a89cec7/packages/mdc-elevation/_variables.scss
  var shadows = ['none', createShadow(0, 2, 1, -1, 0, 1, 1, 0, 0, 1, 3, 0), createShadow(0, 3, 1, -2, 0, 2, 2, 0, 0, 1, 5, 0), createShadow(0, 3, 3, -2, 0, 3, 4, 0, 0, 1, 8, 0), createShadow(0, 2, 4, -1, 0, 4, 5, 0, 0, 1, 10, 0), createShadow(0, 3, 5, -1, 0, 5, 8, 0, 0, 1, 14, 0), createShadow(0, 3, 5, -1, 0, 6, 10, 0, 0, 1, 18, 0), createShadow(0, 4, 5, -2, 0, 7, 10, 1, 0, 2, 16, 1), createShadow(0, 5, 5, -3, 0, 8, 10, 1, 0, 3, 14, 2), createShadow(0, 5, 6, -3, 0, 9, 12, 1, 0, 3, 16, 2), createShadow(0, 6, 6, -3, 0, 10, 14, 1, 0, 4, 18, 3), createShadow(0, 6, 7, -4, 0, 11, 15, 1, 0, 4, 20, 3), createShadow(0, 7, 8, -4, 0, 12, 17, 2, 0, 5, 22, 4), createShadow(0, 7, 8, -4, 0, 13, 19, 2, 0, 5, 24, 4), createShadow(0, 7, 9, -4, 0, 14, 21, 2, 0, 5, 26, 4), createShadow(0, 8, 9, -5, 0, 15, 22, 2, 0, 6, 28, 5), createShadow(0, 8, 10, -5, 0, 16, 24, 2, 0, 6, 30, 5), createShadow(0, 8, 11, -5, 0, 17, 26, 2, 0, 6, 32, 5), createShadow(0, 9, 11, -5, 0, 18, 28, 2, 0, 7, 34, 6), createShadow(0, 9, 12, -6, 0, 19, 29, 2, 0, 7, 36, 6), createShadow(0, 10, 13, -6, 0, 20, 31, 3, 0, 8, 38, 7), createShadow(0, 10, 13, -6, 0, 21, 33, 3, 0, 8, 40, 7), createShadow(0, 10, 14, -6, 0, 22, 35, 3, 0, 8, 42, 7), createShadow(0, 11, 14, -7, 0, 23, 36, 3, 0, 9, 44, 8), createShadow(0, 11, 15, -7, 0, 24, 38, 3, 0, 9, 46, 8)];
  var shadows$1 = shadows;

  // Follow https://material.google.com/motion/duration-easing.html#duration-easing-natural-easing-curves
  // to learn the context in which each easing should be used.
  var easing = {
    // This is the most common easing curve.
    easeInOut: 'cubic-bezier(0.4, 0, 0.2, 1)',
    // Objects enter the screen at full velocity from off-screen and
    // slowly decelerate to a resting point.
    easeOut: 'cubic-bezier(0.0, 0, 0.2, 1)',
    // Objects leave the screen at full velocity. They do not decelerate when off-screen.
    easeIn: 'cubic-bezier(0.4, 0, 1, 1)',
    // The sharp curve is used by objects that may return to the screen at any time.
    sharp: 'cubic-bezier(0.4, 0, 0.6, 1)'
  };

  // Follow https://m2.material.io/guidelines/motion/duration-easing.html#duration-easing-common-durations
  // to learn when use what timing
  var duration = {
    shortest: 150,
    shorter: 200,
    "short": 250,
    // most basic recommended timing
    standard: 300,
    // this is to be used in complex animations
    complex: 375,
    // recommended when something is entering screen
    enteringScreen: 225,
    // recommended when something is leaving screen
    leavingScreen: 195
  };
  function formatMs(milliseconds) {
    return "".concat(Math.round(milliseconds), "ms");
  }
  function getAutoHeightDuration(height) {
    if (!height) {
      return 0;
    }
    var constant = height / 36;

    // https://www.wolframalpha.com/input/?i=(4+%2B+15+*+(x+%2F+36+)+**+0.25+%2B+(x+%2F+36)+%2F+5)+*+10
    return Math.round((4 + 15 * Math.pow(constant, 0.25) + constant / 5) * 10);
  }
  function createTransitions(inputTransitions) {
    var mergedEasing = _extends({}, easing, inputTransitions.easing);
    var mergedDuration = _extends({}, duration, inputTransitions.duration);
    var create = function create() {
      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['all'];
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var _options$duration = options.duration,
        durationOption = _options$duration === void 0 ? mergedDuration.standard : _options$duration,
        _options$easing = options.easing,
        easingOption = _options$easing === void 0 ? mergedEasing.easeInOut : _options$easing,
        _options$delay = options.delay,
        delay = _options$delay === void 0 ? 0 : _options$delay,
        other = _objectWithoutProperties(options, ["duration", "easing", "delay"]);
      {
        var isString = function isString(value) {
          return typeof value === 'string';
        };
        // IE11 support, replace with Number.isNaN
        // eslint-disable-next-line no-restricted-globals
        var isNumber = function isNumber(value) {
          return !isNaN(parseFloat(value));
        };
        if (!isString(props) && !Array.isArray(props)) {
          console.error('MUI: Argument "props" must be a string or Array.');
        }
        if (!isNumber(durationOption) && !isString(durationOption)) {
          console.error("MUI: Argument \"duration\" must be a number or a string but found ".concat(durationOption, "."));
        }
        if (!isString(easingOption)) {
          console.error('MUI: Argument "easing" must be a string.');
        }
        if (!isNumber(delay) && !isString(delay)) {
          console.error('MUI: Argument "delay" must be a number or a string.');
        }
        if (_typeof(options) !== 'object') {
          console.error(['MUI: Secong argument of transition.create must be an object.', "Arguments should be either `create('prop1', options)` or `create(['prop1', 'prop2'], options)`"].join('\n'));
        }
        if (Object.keys(other).length !== 0) {
          console.error("MUI: Unrecognized argument(s) [".concat(Object.keys(other).join(','), "]."));
        }
      }
      return (Array.isArray(props) ? props : [props]).map(function (animatedProp) {
        return "".concat(animatedProp, " ").concat(typeof durationOption === 'string' ? durationOption : formatMs(durationOption), " ").concat(easingOption, " ").concat(typeof delay === 'string' ? delay : formatMs(delay));
      }).join(',');
    };
    return _extends({
      getAutoHeightDuration: getAutoHeightDuration,
      create: create
    }, inputTransitions, {
      easing: mergedEasing,
      duration: mergedDuration
    });
  }

  // We need to centralize the zIndex definitions as they work
  // like global values in the browser.
  var zIndex = {
    mobileStepper: 1000,
    fab: 1050,
    speedDial: 1050,
    appBar: 1100,
    drawer: 1200,
    modal: 1300,
    snackbar: 1400,
    tooltip: 1500
  };
  var zIndex$1 = zIndex;

  function createTheme() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    options.breakpoints;
      var _options$mixins = options.mixins,
      mixinsInput = _options$mixins === void 0 ? {} : _options$mixins;
      options.spacing;
      var _options$palette = options.palette,
      paletteInput = _options$palette === void 0 ? {} : _options$palette,
      _options$transitions = options.transitions,
      transitionsInput = _options$transitions === void 0 ? {} : _options$transitions,
      _options$typography = options.typography,
      typographyInput = _options$typography === void 0 ? {} : _options$typography;
      options.shape;
      var other = _objectWithoutProperties(options, ["breakpoints", "mixins", "spacing", "palette", "transitions", "typography", "shape"]);
    if (options.vars) {
      throw new Error("MUI: `vars` is a private field used for CSS variables support.\nPlease use another name." );
    }
    var palette = createPalette(paletteInput);
    var systemTheme = createTheme$1(options);
    var muiTheme = deepmerge(systemTheme, {
      mixins: createMixins(systemTheme.breakpoints, mixinsInput),
      palette: palette,
      // Don't use [...shadows] until you've verified its transpiled code is not invoking the iterator protocol.
      shadows: shadows$1.slice(),
      typography: createTypography(palette, typographyInput),
      transitions: createTransitions(transitionsInput),
      zIndex: _extends({}, zIndex$1)
    });
    muiTheme = deepmerge(muiTheme, other);
    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }
    muiTheme = args.reduce(function (acc, argument) {
      return deepmerge(acc, argument);
    }, muiTheme);
    {
      // TODO v6: Refactor to use globalStateClassesMapping from @mui/utils once `readOnly` state class is used in Rating component.
      var stateClasses = ['active', 'checked', 'completed', 'disabled', 'error', 'expanded', 'focused', 'focusVisible', 'required', 'selected'];
      var traverse = function traverse(node, component) {
        var key;

        // eslint-disable-next-line guard-for-in, no-restricted-syntax
        for (key in node) {
          var child = node[key];
          if (stateClasses.indexOf(key) !== -1 && Object.keys(child).length > 0) {
            {
              var stateClass = generateUtilityClass('', key);
              console.error(["MUI: The `".concat(component, "` component increases ") + "the CSS specificity of the `".concat(key, "` internal state."), 'You can not override it like this: ', JSON.stringify(node, null, 2), '', "Instead, you need to use the '&.".concat(stateClass, "' syntax:"), JSON.stringify({
                root: _defineProperty({}, "&.".concat(stateClass), child)
              }, null, 2), '', 'https://mui.com/r/state-classes-guide'].join('\n'));
            }
            // Remove the style to prevent global conflicts.
            node[key] = {};
          }
        }
      };
      Object.keys(muiTheme.components).forEach(function (component) {
        var styleOverrides = muiTheme.components[component].styleOverrides;
        if (styleOverrides && component.indexOf('Mui') === 0) {
          traverse(styleOverrides, component);
        }
      });
    }
    muiTheme.unstable_sxConfig = _extends({}, defaultSxConfig$1, other == null ? void 0 : other.unstable_sxConfig);
    muiTheme.unstable_sx = function sx(props) {
      return styleFunctionSx$1({
        sx: props,
        theme: this
      });
    };
    return muiTheme;
  }
  var warnedOnce$1 = false;
  function createMuiTheme() {
    {
      if (!warnedOnce$1) {
        warnedOnce$1 = true;
        console.error(['MUI: the createMuiTheme function was renamed to createTheme.', '', "You should use `import { createTheme } from '@mui/material/styles'`"].join('\n'));
      }
    }
    return createTheme.apply(void 0, arguments);
  }

  function createMuiStrictModeTheme(options) {
    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }
    return createTheme.apply(void 0, [deepmerge({
      unstable_strictMode: true
    }, options)].concat(args));
  }

  var warnedOnce = false;

  // To remove in v6
  function createStyles(styles) {
    if (!warnedOnce) {
      console.warn(['MUI: createStyles from @mui/material/styles is deprecated.', 'Please use @mui/styles/createStyles'].join('\n'));
      warnedOnce = true;
    }
    return styles;
  }

  function isUnitless(value) {
    return String(parseFloat(value)).length === String(value).length;
  }

  // Ported from Compass
  // https://github.com/Compass/compass/blob/master/core/stylesheets/compass/typography/_units.scss
  // Emulate the sass function "unit"
  function getUnit(input) {
    return String(input).match(/[\d.\-+]*\s*(.*)/)[1] || '';
  }

  // Emulate the sass function "unitless"
  function toUnitless(length) {
    return parseFloat(length);
  }

  // Convert any CSS <length> or <percentage> value to any another.
  // From https://github.com/KyleAMathews/convert-css-length
  function convertLength(baseFontSize) {
    return function (length, toUnit) {
      var fromUnit = getUnit(length);

      // Optimize for cases where `from` and `to` units are accidentally the same.
      if (fromUnit === toUnit) {
        return length;
      }

      // Convert input length to pixels.
      var pxLength = toUnitless(length);
      if (fromUnit !== 'px') {
        if (fromUnit === 'em') {
          pxLength = toUnitless(length) * toUnitless(baseFontSize);
        } else if (fromUnit === 'rem') {
          pxLength = toUnitless(length) * toUnitless(baseFontSize);
        }
      }

      // Convert length in pixels to the output unit
      var outputLength = pxLength;
      if (toUnit !== 'px') {
        if (toUnit === 'em') {
          outputLength = pxLength / toUnitless(baseFontSize);
        } else if (toUnit === 'rem') {
          outputLength = pxLength / toUnitless(baseFontSize);
        } else {
          return length;
        }
      }
      return parseFloat(outputLength.toFixed(5)) + toUnit;
    };
  }
  function alignProperty(_ref) {
    var size = _ref.size,
      grid = _ref.grid;
    var sizeBelow = size - size % grid;
    var sizeAbove = sizeBelow + grid;
    return size - sizeBelow < sizeAbove - size ? sizeBelow : sizeAbove;
  }

  // fontGrid finds a minimal grid (in rem) for the fontSize values so that the
  // lineHeight falls under a x pixels grid, 4px in the case of Material Design,
  // without changing the relative line height
  function fontGrid(_ref2) {
    var lineHeight = _ref2.lineHeight,
      pixels = _ref2.pixels,
      htmlFontSize = _ref2.htmlFontSize;
    return pixels / (lineHeight * htmlFontSize);
  }

  /**
   * generate a responsive version of a given CSS property
   * @example
   * responsiveProperty({
   *   cssProperty: 'fontSize',
   *   min: 15,
   *   max: 20,
   *   unit: 'px',
   *   breakpoints: [300, 600],
   * })
   *
   * // this returns
   *
   * {
   *   fontSize: '15px',
   *   '@media (min-width:300px)': {
   *     fontSize: '17.5px',
   *   },
   *   '@media (min-width:600px)': {
   *     fontSize: '20px',
   *   },
   * }
   * @param {Object} params
   * @param {string} params.cssProperty - The CSS property to be made responsive
   * @param {number} params.min - The smallest value of the CSS property
   * @param {number} params.max - The largest value of the CSS property
   * @param {string} [params.unit] - The unit to be used for the CSS property
   * @param {Array.number} [params.breakpoints]  - An array of breakpoints
   * @param {number} [params.alignStep] - Round scaled value to fall under this grid
   * @returns {Object} responsive styles for {params.cssProperty}
   */
  function responsiveProperty(_ref3) {
    var cssProperty = _ref3.cssProperty,
      min = _ref3.min,
      max = _ref3.max,
      _ref3$unit = _ref3.unit,
      unit = _ref3$unit === void 0 ? 'rem' : _ref3$unit,
      _ref3$breakpoints = _ref3.breakpoints,
      breakpoints = _ref3$breakpoints === void 0 ? [600, 900, 1200] : _ref3$breakpoints,
      _ref3$transform = _ref3.transform,
      transform = _ref3$transform === void 0 ? null : _ref3$transform;
    var output = _defineProperty({}, cssProperty, "".concat(min).concat(unit));
    var factor = (max - min) / breakpoints[breakpoints.length - 1];
    breakpoints.forEach(function (breakpoint) {
      var value = min + factor * breakpoint;
      if (transform !== null) {
        value = transform(value);
      }
      output["@media (min-width:".concat(breakpoint, "px)")] = _defineProperty({}, cssProperty, "".concat(Math.round(value * 10000) / 10000).concat(unit));
    });
    return output;
  }

  function responsiveFontSizes(themeInput) {
    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    var _options$breakpoints = options.breakpoints,
      breakpoints = _options$breakpoints === void 0 ? ['sm', 'md', 'lg'] : _options$breakpoints,
      _options$disableAlign = options.disableAlign,
      disableAlign = _options$disableAlign === void 0 ? false : _options$disableAlign,
      _options$factor = options.factor,
      factor = _options$factor === void 0 ? 2 : _options$factor,
      _options$variants = options.variants,
      variants = _options$variants === void 0 ? ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'subtitle1', 'subtitle2', 'body1', 'body2', 'caption', 'button', 'overline'] : _options$variants;
    var theme = _extends({}, themeInput);
    theme.typography = _extends({}, theme.typography);
    var typography = theme.typography;

    // Convert between CSS lengths e.g. em->px or px->rem
    // Set the baseFontSize for your project. Defaults to 16px (also the browser default).
    var convert = convertLength(typography.htmlFontSize);
    var breakpointValues = breakpoints.map(function (x) {
      return theme.breakpoints.values[x];
    });
    variants.forEach(function (variant) {
      var style = typography[variant];
      if (!style) {
        return;
      }
      var remFontSize = parseFloat(convert(style.fontSize, 'rem'));
      if (remFontSize <= 1) {
        return;
      }
      var maxFontSize = remFontSize;
      var minFontSize = 1 + (maxFontSize - 1) / factor;
      var lineHeight = style.lineHeight;
      if (!isUnitless(lineHeight) && !disableAlign) {
        throw new Error("MUI: Unsupported non-unitless line height with grid alignment.\nUse unitless line heights instead." );
      }
      if (!isUnitless(lineHeight)) {
        // make it unitless
        lineHeight = parseFloat(convert(lineHeight, 'rem')) / parseFloat(remFontSize);
      }
      var transform = null;
      if (!disableAlign) {
        transform = function transform(value) {
          return alignProperty({
            size: value,
            grid: fontGrid({
              pixels: 4,
              lineHeight: lineHeight,
              htmlFontSize: typography.htmlFontSize
            })
          });
        };
      }
      typography[variant] = _extends({}, style, responsiveProperty({
        cssProperty: 'fontSize',
        min: minFontSize,
        max: maxFontSize,
        unit: 'rem',
        breakpoints: breakpointValues,
        transform: transform
      }));
    });
    return theme;
  }

  var defaultTheme$2 = createTheme();
  var defaultTheme$3 = defaultTheme$2;

  function useTheme() {
    var theme = useTheme$2(defaultTheme$3);
    {
      // eslint-disable-next-line react-hooks/rules-of-hooks
      React__namespace.useDebugValue(theme);
    }
    return theme[THEME_ID] || theme;
  }

  function useThemeProps(_ref) {
    var props = _ref.props,
      name = _ref.name;
    return useThemeProps$1({
      props: props,
      name: name,
      defaultTheme: defaultTheme$3,
      themeId: THEME_ID
    });
  }

  // copied from @mui/system/createStyled
  function slotShouldForwardProp(prop) {
    return prop !== 'ownerState' && prop !== 'theme' && prop !== 'sx' && prop !== 'as';
  }

  var rootShouldForwardProp = function rootShouldForwardProp(prop) {
    return slotShouldForwardProp(prop) && prop !== 'classes';
  };
  var rootShouldForwardProp$1 = rootShouldForwardProp;

  var styled = createStyled({
    themeId: THEME_ID,
    defaultTheme: defaultTheme$3,
    rootShouldForwardProp: rootShouldForwardProp$1
  });
  var styled$1 = styled;

  function ThemeProvider(_ref) {
    var themeInput = _ref.theme,
      props = _objectWithoutProperties(_ref, ["theme"]);
    var scopedTheme = themeInput[THEME_ID];
    return /*#__PURE__*/jsxRuntimeExports.jsx(ThemeProvider$1, _extends({}, props, {
      themeId: scopedTheme ? THEME_ID : undefined,
      theme: scopedTheme || themeInput
    }));
  }
  ThemeProvider.propTypes = {
    /**
     * Your component tree.
     */
    children: PropTypes.node,
    /**
     * A theme object. You can provide a function to extend the outer theme.
     */
    theme: PropTypes.oneOfType([PropTypes.object, PropTypes.func]).isRequired
  } ;

  function makeStyles() {
    throw new Error("MUI: makeStyles is no longer exported from @mui/material/styles.\nYou have to import it from @mui/styles.\nSee https://mui.com/r/migration-v4/#mui-material-styles for more details." );
  }

  function withStyles() {
    throw new Error("MUI: withStyles is no longer exported from @mui/material/styles.\nYou have to import it from @mui/styles.\nSee https://mui.com/r/migration-v4/#mui-material-styles for more details." );
  }

  function withTheme() {
    throw new Error("MUI: withTheme is no longer exported from @mui/material/styles.\nYou have to import it from @mui/styles.\nSee https://mui.com/r/migration-v4/#mui-material-styles for more details." );
  }

  function shouldSkipGeneratingVar(keys) {
    var _keys$;
    return !!keys[0].match(/(cssVarPrefix|typography|mixins|breakpoints|direction|transitions)/) || !!keys[0].match(/sxConfig$/) ||
    // ends with sxConfig
    keys[0] === 'palette' && !!((_keys$ = keys[1]) != null && _keys$.match(/(mode|contrastThreshold|tonalOffset)/));
  }

  // Inspired by https://github.com/material-components/material-components-ios/blob/bca36107405594d5b7b16265a5b0ed698f85a5ee/components/Elevation/src/UIColor%2BMaterialElevation.m#L61
  var getOverlayAlpha = function getOverlayAlpha(elevation) {
    var alphaValue;
    if (elevation < 1) {
      alphaValue = 5.11916 * Math.pow(elevation, 2);
    } else {
      alphaValue = 4.5 * Math.log(elevation + 1) + 2;
    }
    return (alphaValue / 100).toFixed(2);
  };
  var getOverlayAlpha$1 = getOverlayAlpha;

  var defaultDarkOverlays = _toConsumableArray(Array(25)).map(function (_, index) {
    if (index === 0) {
      return undefined;
    }
    var overlay = getOverlayAlpha$1(index);
    return "linear-gradient(rgba(255 255 255 / ".concat(overlay, "), rgba(255 255 255 / ").concat(overlay, "))");
  });
  function assignNode(obj, keys) {
    keys.forEach(function (k) {
      if (!obj[k]) {
        obj[k] = {};
      }
    });
  }
  function setColor(obj, key, defaultValue) {
    if (!obj[key] && defaultValue) {
      obj[key] = defaultValue;
    }
  }
  function toRgb(color) {
    if (!color || !color.startsWith('hsl')) {
      return color;
    }
    return hslToRgb(color);
  }
  function setColorChannel(obj, key) {
    if (!("".concat(key, "Channel") in obj)) {
      // custom channel token is not provided, generate one.
      // if channel token can't be generated, show a warning.
      obj["".concat(key, "Channel")] = private_safeColorChannel(toRgb(obj[key]), "MUI: Can't create `palette.".concat(key, "Channel` because `palette.").concat(key, "` is not one of these formats: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla(), color().") + '\n' + "To suppress this warning, you need to explicitly provide the `palette.".concat(key, "Channel` as a string (in rgb format, for example \"12 12 12\") or undefined if you want to remove the channel token."));
    }
  }
  var silent = function silent(fn) {
    try {
      return fn();
    } catch (error) {
      // ignore error
    }
    return undefined;
  };
  var createGetCssVar = function createGetCssVar() {
    var cssVarPrefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'mui';
    return createGetCssVar$1(cssVarPrefix);
  };
  function extendTheme() {
    var _colorSchemesInput$li, _colorSchemesInput$da, _colorSchemesInput$li2, _colorSchemesInput$li3, _colorSchemesInput$da2, _colorSchemesInput$da3;
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var _options$colorSchemes = options.colorSchemes,
      colorSchemesInput = _options$colorSchemes === void 0 ? {} : _options$colorSchemes,
      _options$cssVarPrefix = options.cssVarPrefix,
      cssVarPrefix = _options$cssVarPrefix === void 0 ? 'mui' : _options$cssVarPrefix,
      _options$shouldSkipGe = options.shouldSkipGeneratingVar,
      shouldSkipGeneratingVar$1 = _options$shouldSkipGe === void 0 ? shouldSkipGeneratingVar : _options$shouldSkipGe,
      input = _objectWithoutProperties(options, ["colorSchemes", "cssVarPrefix", "shouldSkipGeneratingVar"]);
    var getCssVar = createGetCssVar(cssVarPrefix);
    var _createThemeWithoutVa = createTheme(_extends({}, input, colorSchemesInput.light && {
        palette: (_colorSchemesInput$li = colorSchemesInput.light) == null ? void 0 : _colorSchemesInput$li.palette
      })),
      lightPalette = _createThemeWithoutVa.palette,
      muiTheme = _objectWithoutProperties(_createThemeWithoutVa, ["palette"]);
    var _createThemeWithoutVa2 = createTheme({
        palette: _extends({
          mode: 'dark'
        }, (_colorSchemesInput$da = colorSchemesInput.dark) == null ? void 0 : _colorSchemesInput$da.palette)
      }),
      darkPalette = _createThemeWithoutVa2.palette;
    var theme = _extends({}, muiTheme, {
      cssVarPrefix: cssVarPrefix,
      getCssVar: getCssVar,
      colorSchemes: _extends({}, colorSchemesInput, {
        light: _extends({}, colorSchemesInput.light, {
          palette: lightPalette,
          opacity: _extends({
            inputPlaceholder: 0.42,
            inputUnderline: 0.42,
            switchTrackDisabled: 0.12,
            switchTrack: 0.38
          }, (_colorSchemesInput$li2 = colorSchemesInput.light) == null ? void 0 : _colorSchemesInput$li2.opacity),
          overlays: ((_colorSchemesInput$li3 = colorSchemesInput.light) == null ? void 0 : _colorSchemesInput$li3.overlays) || []
        }),
        dark: _extends({}, colorSchemesInput.dark, {
          palette: darkPalette,
          opacity: _extends({
            inputPlaceholder: 0.5,
            inputUnderline: 0.7,
            switchTrackDisabled: 0.2,
            switchTrack: 0.3
          }, (_colorSchemesInput$da2 = colorSchemesInput.dark) == null ? void 0 : _colorSchemesInput$da2.opacity),
          overlays: ((_colorSchemesInput$da3 = colorSchemesInput.dark) == null ? void 0 : _colorSchemesInput$da3.overlays) || defaultDarkOverlays
        })
      })
    });
    Object.keys(theme.colorSchemes).forEach(function (key) {
      var palette = theme.colorSchemes[key].palette;
      var setCssVarColor = function setCssVarColor(cssVar) {
        var tokens = cssVar.split('-');
        var color = tokens[1];
        var colorToken = tokens[2];
        return getCssVar(cssVar, palette[color][colorToken]);
      };

      // attach black & white channels to common node
      if (key === 'light') {
        setColor(palette.common, 'background', '#fff');
        setColor(palette.common, 'onBackground', '#000');
      } else {
        setColor(palette.common, 'background', '#000');
        setColor(palette.common, 'onBackground', '#fff');
      }

      // assign component variables
      assignNode(palette, ['Alert', 'AppBar', 'Avatar', 'Button', 'Chip', 'FilledInput', 'LinearProgress', 'Skeleton', 'Slider', 'SnackbarContent', 'SpeedDialAction', 'StepConnector', 'StepContent', 'Switch', 'TableCell', 'Tooltip']);
      if (key === 'light') {
        setColor(palette.Alert, 'errorColor', private_safeDarken(palette.error.light, 0.6));
        setColor(palette.Alert, 'infoColor', private_safeDarken(palette.info.light, 0.6));
        setColor(palette.Alert, 'successColor', private_safeDarken(palette.success.light, 0.6));
        setColor(palette.Alert, 'warningColor', private_safeDarken(palette.warning.light, 0.6));
        setColor(palette.Alert, 'errorFilledBg', setCssVarColor('palette-error-main'));
        setColor(palette.Alert, 'infoFilledBg', setCssVarColor('palette-info-main'));
        setColor(palette.Alert, 'successFilledBg', setCssVarColor('palette-success-main'));
        setColor(palette.Alert, 'warningFilledBg', setCssVarColor('palette-warning-main'));
        setColor(palette.Alert, 'errorFilledColor', silent(function () {
          return lightPalette.getContrastText(palette.error.main);
        }));
        setColor(palette.Alert, 'infoFilledColor', silent(function () {
          return lightPalette.getContrastText(palette.info.main);
        }));
        setColor(palette.Alert, 'successFilledColor', silent(function () {
          return lightPalette.getContrastText(palette.success.main);
        }));
        setColor(palette.Alert, 'warningFilledColor', silent(function () {
          return lightPalette.getContrastText(palette.warning.main);
        }));
        setColor(palette.Alert, 'errorStandardBg', private_safeLighten(palette.error.light, 0.9));
        setColor(palette.Alert, 'infoStandardBg', private_safeLighten(palette.info.light, 0.9));
        setColor(palette.Alert, 'successStandardBg', private_safeLighten(palette.success.light, 0.9));
        setColor(palette.Alert, 'warningStandardBg', private_safeLighten(palette.warning.light, 0.9));
        setColor(palette.Alert, 'errorIconColor', setCssVarColor('palette-error-main'));
        setColor(palette.Alert, 'infoIconColor', setCssVarColor('palette-info-main'));
        setColor(palette.Alert, 'successIconColor', setCssVarColor('palette-success-main'));
        setColor(palette.Alert, 'warningIconColor', setCssVarColor('palette-warning-main'));
        setColor(palette.AppBar, 'defaultBg', setCssVarColor('palette-grey-100'));
        setColor(palette.Avatar, 'defaultBg', setCssVarColor('palette-grey-400'));
        setColor(palette.Button, 'inheritContainedBg', setCssVarColor('palette-grey-300'));
        setColor(palette.Button, 'inheritContainedHoverBg', setCssVarColor('palette-grey-A100'));
        setColor(palette.Chip, 'defaultBorder', setCssVarColor('palette-grey-400'));
        setColor(palette.Chip, 'defaultAvatarColor', setCssVarColor('palette-grey-700'));
        setColor(palette.Chip, 'defaultIconColor', setCssVarColor('palette-grey-700'));
        setColor(palette.FilledInput, 'bg', 'rgba(0, 0, 0, 0.06)');
        setColor(palette.FilledInput, 'hoverBg', 'rgba(0, 0, 0, 0.09)');
        setColor(palette.FilledInput, 'disabledBg', 'rgba(0, 0, 0, 0.12)');
        setColor(palette.LinearProgress, 'primaryBg', private_safeLighten(palette.primary.main, 0.62));
        setColor(palette.LinearProgress, 'secondaryBg', private_safeLighten(palette.secondary.main, 0.62));
        setColor(palette.LinearProgress, 'errorBg', private_safeLighten(palette.error.main, 0.62));
        setColor(palette.LinearProgress, 'infoBg', private_safeLighten(palette.info.main, 0.62));
        setColor(palette.LinearProgress, 'successBg', private_safeLighten(palette.success.main, 0.62));
        setColor(palette.LinearProgress, 'warningBg', private_safeLighten(palette.warning.main, 0.62));
        setColor(palette.Skeleton, 'bg', "rgba(".concat(setCssVarColor('palette-text-primaryChannel'), " / 0.11)"));
        setColor(palette.Slider, 'primaryTrack', private_safeLighten(palette.primary.main, 0.62));
        setColor(palette.Slider, 'secondaryTrack', private_safeLighten(palette.secondary.main, 0.62));
        setColor(palette.Slider, 'errorTrack', private_safeLighten(palette.error.main, 0.62));
        setColor(palette.Slider, 'infoTrack', private_safeLighten(palette.info.main, 0.62));
        setColor(palette.Slider, 'successTrack', private_safeLighten(palette.success.main, 0.62));
        setColor(palette.Slider, 'warningTrack', private_safeLighten(palette.warning.main, 0.62));
        var snackbarContentBackground = private_safeEmphasize(palette.background["default"], 0.8);
        setColor(palette.SnackbarContent, 'bg', snackbarContentBackground);
        setColor(palette.SnackbarContent, 'color', silent(function () {
          return lightPalette.getContrastText(snackbarContentBackground);
        }));
        setColor(palette.SpeedDialAction, 'fabHoverBg', private_safeEmphasize(palette.background.paper, 0.15));
        setColor(palette.StepConnector, 'border', setCssVarColor('palette-grey-400'));
        setColor(palette.StepContent, 'border', setCssVarColor('palette-grey-400'));
        setColor(palette.Switch, 'defaultColor', setCssVarColor('palette-common-white'));
        setColor(palette.Switch, 'defaultDisabledColor', setCssVarColor('palette-grey-100'));
        setColor(palette.Switch, 'primaryDisabledColor', private_safeLighten(palette.primary.main, 0.62));
        setColor(palette.Switch, 'secondaryDisabledColor', private_safeLighten(palette.secondary.main, 0.62));
        setColor(palette.Switch, 'errorDisabledColor', private_safeLighten(palette.error.main, 0.62));
        setColor(palette.Switch, 'infoDisabledColor', private_safeLighten(palette.info.main, 0.62));
        setColor(palette.Switch, 'successDisabledColor', private_safeLighten(palette.success.main, 0.62));
        setColor(palette.Switch, 'warningDisabledColor', private_safeLighten(palette.warning.main, 0.62));
        setColor(palette.TableCell, 'border', private_safeLighten(private_safeAlpha(palette.divider, 1), 0.88));
        setColor(palette.Tooltip, 'bg', private_safeAlpha(palette.grey[700], 0.92));
      } else {
        setColor(palette.Alert, 'errorColor', private_safeLighten(palette.error.light, 0.6));
        setColor(palette.Alert, 'infoColor', private_safeLighten(palette.info.light, 0.6));
        setColor(palette.Alert, 'successColor', private_safeLighten(palette.success.light, 0.6));
        setColor(palette.Alert, 'warningColor', private_safeLighten(palette.warning.light, 0.6));
        setColor(palette.Alert, 'errorFilledBg', setCssVarColor('palette-error-dark'));
        setColor(palette.Alert, 'infoFilledBg', setCssVarColor('palette-info-dark'));
        setColor(palette.Alert, 'successFilledBg', setCssVarColor('palette-success-dark'));
        setColor(palette.Alert, 'warningFilledBg', setCssVarColor('palette-warning-dark'));
        setColor(palette.Alert, 'errorFilledColor', silent(function () {
          return darkPalette.getContrastText(palette.error.dark);
        }));
        setColor(palette.Alert, 'infoFilledColor', silent(function () {
          return darkPalette.getContrastText(palette.info.dark);
        }));
        setColor(palette.Alert, 'successFilledColor', silent(function () {
          return darkPalette.getContrastText(palette.success.dark);
        }));
        setColor(palette.Alert, 'warningFilledColor', silent(function () {
          return darkPalette.getContrastText(palette.warning.dark);
        }));
        setColor(palette.Alert, 'errorStandardBg', private_safeDarken(palette.error.light, 0.9));
        setColor(palette.Alert, 'infoStandardBg', private_safeDarken(palette.info.light, 0.9));
        setColor(palette.Alert, 'successStandardBg', private_safeDarken(palette.success.light, 0.9));
        setColor(palette.Alert, 'warningStandardBg', private_safeDarken(palette.warning.light, 0.9));
        setColor(palette.Alert, 'errorIconColor', setCssVarColor('palette-error-main'));
        setColor(palette.Alert, 'infoIconColor', setCssVarColor('palette-info-main'));
        setColor(palette.Alert, 'successIconColor', setCssVarColor('palette-success-main'));
        setColor(palette.Alert, 'warningIconColor', setCssVarColor('palette-warning-main'));
        setColor(palette.AppBar, 'defaultBg', setCssVarColor('palette-grey-900'));
        setColor(palette.AppBar, 'darkBg', setCssVarColor('palette-background-paper')); // specific for dark mode
        setColor(palette.AppBar, 'darkColor', setCssVarColor('palette-text-primary')); // specific for dark mode
        setColor(palette.Avatar, 'defaultBg', setCssVarColor('palette-grey-600'));
        setColor(palette.Button, 'inheritContainedBg', setCssVarColor('palette-grey-800'));
        setColor(palette.Button, 'inheritContainedHoverBg', setCssVarColor('palette-grey-700'));
        setColor(palette.Chip, 'defaultBorder', setCssVarColor('palette-grey-700'));
        setColor(palette.Chip, 'defaultAvatarColor', setCssVarColor('palette-grey-300'));
        setColor(palette.Chip, 'defaultIconColor', setCssVarColor('palette-grey-300'));
        setColor(palette.FilledInput, 'bg', 'rgba(255, 255, 255, 0.09)');
        setColor(palette.FilledInput, 'hoverBg', 'rgba(255, 255, 255, 0.13)');
        setColor(palette.FilledInput, 'disabledBg', 'rgba(255, 255, 255, 0.12)');
        setColor(palette.LinearProgress, 'primaryBg', private_safeDarken(palette.primary.main, 0.5));
        setColor(palette.LinearProgress, 'secondaryBg', private_safeDarken(palette.secondary.main, 0.5));
        setColor(palette.LinearProgress, 'errorBg', private_safeDarken(palette.error.main, 0.5));
        setColor(palette.LinearProgress, 'infoBg', private_safeDarken(palette.info.main, 0.5));
        setColor(palette.LinearProgress, 'successBg', private_safeDarken(palette.success.main, 0.5));
        setColor(palette.LinearProgress, 'warningBg', private_safeDarken(palette.warning.main, 0.5));
        setColor(palette.Skeleton, 'bg', "rgba(".concat(setCssVarColor('palette-text-primaryChannel'), " / 0.13)"));
        setColor(palette.Slider, 'primaryTrack', private_safeDarken(palette.primary.main, 0.5));
        setColor(palette.Slider, 'secondaryTrack', private_safeDarken(palette.secondary.main, 0.5));
        setColor(palette.Slider, 'errorTrack', private_safeDarken(palette.error.main, 0.5));
        setColor(palette.Slider, 'infoTrack', private_safeDarken(palette.info.main, 0.5));
        setColor(palette.Slider, 'successTrack', private_safeDarken(palette.success.main, 0.5));
        setColor(palette.Slider, 'warningTrack', private_safeDarken(palette.warning.main, 0.5));
        var _snackbarContentBackground = private_safeEmphasize(palette.background["default"], 0.98);
        setColor(palette.SnackbarContent, 'bg', _snackbarContentBackground);
        setColor(palette.SnackbarContent, 'color', silent(function () {
          return darkPalette.getContrastText(_snackbarContentBackground);
        }));
        setColor(palette.SpeedDialAction, 'fabHoverBg', private_safeEmphasize(palette.background.paper, 0.15));
        setColor(palette.StepConnector, 'border', setCssVarColor('palette-grey-600'));
        setColor(palette.StepContent, 'border', setCssVarColor('palette-grey-600'));
        setColor(palette.Switch, 'defaultColor', setCssVarColor('palette-grey-300'));
        setColor(palette.Switch, 'defaultDisabledColor', setCssVarColor('palette-grey-600'));
        setColor(palette.Switch, 'primaryDisabledColor', private_safeDarken(palette.primary.main, 0.55));
        setColor(palette.Switch, 'secondaryDisabledColor', private_safeDarken(palette.secondary.main, 0.55));
        setColor(palette.Switch, 'errorDisabledColor', private_safeDarken(palette.error.main, 0.55));
        setColor(palette.Switch, 'infoDisabledColor', private_safeDarken(palette.info.main, 0.55));
        setColor(palette.Switch, 'successDisabledColor', private_safeDarken(palette.success.main, 0.55));
        setColor(palette.Switch, 'warningDisabledColor', private_safeDarken(palette.warning.main, 0.55));
        setColor(palette.TableCell, 'border', private_safeDarken(private_safeAlpha(palette.divider, 1), 0.68));
        setColor(palette.Tooltip, 'bg', private_safeAlpha(palette.grey[700], 0.92));
      }

      // MUI X - DataGrid needs this token.
      setColorChannel(palette.background, 'default');

      // added for consistency with the `background.default` token
      setColorChannel(palette.background, 'paper');
      setColorChannel(palette.common, 'background');
      setColorChannel(palette.common, 'onBackground');
      setColorChannel(palette, 'divider');
      Object.keys(palette).forEach(function (color) {
        var colors = palette[color];

        // The default palettes (primary, secondary, error, info, success, and warning) errors are handled by the above `createTheme(...)`.

        if (colors && _typeof(colors) === 'object') {
          // Silent the error for custom palettes.
          if (colors.main) {
            setColor(palette[color], 'mainChannel', private_safeColorChannel(toRgb(colors.main)));
          }
          if (colors.light) {
            setColor(palette[color], 'lightChannel', private_safeColorChannel(toRgb(colors.light)));
          }
          if (colors.dark) {
            setColor(palette[color], 'darkChannel', private_safeColorChannel(toRgb(colors.dark)));
          }
          if (colors.contrastText) {
            setColor(palette[color], 'contrastTextChannel', private_safeColorChannel(toRgb(colors.contrastText)));
          }
          if (color === 'text') {
            // Text colors: text.primary, text.secondary
            setColorChannel(palette[color], 'primary');
            setColorChannel(palette[color], 'secondary');
          }
          if (color === 'action') {
            // Action colors: action.active, action.selected
            if (colors.active) {
              setColorChannel(palette[color], 'active');
            }
            if (colors.selected) {
              setColorChannel(palette[color], 'selected');
            }
          }
        }
      });
    });
    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }
    theme = args.reduce(function (acc, argument) {
      return deepmerge(acc, argument);
    }, theme);
    var parserConfig = {
      prefix: cssVarPrefix,
      shouldSkipGeneratingVar: shouldSkipGeneratingVar$1
    };
    var _prepareCssVars = prepareCssVars(theme, parserConfig),
      themeVars = _prepareCssVars.vars,
      generateCssVars = _prepareCssVars.generateCssVars;
    theme.vars = themeVars;
    theme.generateCssVars = generateCssVars;
    theme.shouldSkipGeneratingVar = shouldSkipGeneratingVar$1;
    theme.unstable_sxConfig = _extends({}, defaultSxConfig$1, input == null ? void 0 : input.unstable_sxConfig);
    theme.unstable_sx = function sx(props) {
      return styleFunctionSx$1({
        sx: props,
        theme: this
      });
    };
    return theme;
  }

  /**
   * @internal These variables should not appear in the :root stylesheet when the `defaultMode="dark"`
   */
  var excludeVariablesFromRoot = function excludeVariablesFromRoot(cssVarPrefix) {
    return [].concat(_toConsumableArray(_toConsumableArray(Array(24)).map(function (_, index) {
      return "--".concat(cssVarPrefix ? "".concat(cssVarPrefix, "-") : '', "overlays-").concat(index + 1);
    })), ["--".concat(cssVarPrefix ? "".concat(cssVarPrefix, "-") : '', "palette-AppBar-darkBg"), "--".concat(cssVarPrefix ? "".concat(cssVarPrefix, "-") : '', "palette-AppBar-darkColor")]);
  };
  var excludeVariablesFromRoot$1 = excludeVariablesFromRoot;

  var defaultConfig = {
    attribute: 'data-mui-color-scheme',
    colorSchemeStorageKey: 'mui-color-scheme',
    defaultLightColorScheme: 'light',
    defaultDarkColorScheme: 'dark',
    modeStorageKey: 'mui-mode'
  };

  var defaultTheme$1 = extendTheme();
  var _createCssVarsProvide = createCssVarsProvider({
      themeId: THEME_ID,
      theme: defaultTheme$1,
      attribute: defaultConfig.attribute,
      colorSchemeStorageKey: defaultConfig.colorSchemeStorageKey,
      modeStorageKey: defaultConfig.modeStorageKey,
      defaultColorScheme: {
        light: defaultConfig.defaultLightColorScheme,
        dark: defaultConfig.defaultDarkColorScheme
      },
      resolveTheme: function resolveTheme(theme) {
        var newTheme = _extends({}, theme, {
          typography: createTypography(theme.palette, theme.typography)
        });
        newTheme.unstable_sx = function sx(props) {
          return styleFunctionSx$1({
            sx: props,
            theme: this
          });
        };
        return newTheme;
      },
      excludeVariablesFromRoot: excludeVariablesFromRoot$1
    }),
    CssVarsProvider = _createCssVarsProvide.CssVarsProvider,
    useColorScheme = _createCssVarsProvide.useColorScheme,
    getInitColorSchemeScriptSystem = _createCssVarsProvide.getInitColorSchemeScript;
  /**
   * @deprecated Use `InitColorSchemeScript` instead
   * ```diff
   * - import { getInitColorSchemeScript } from '@mui/material/styles';
   * + import InitColorSchemeScript from '@mui/material/InitColorSchemeScript';
   *
   * - getInitColorSchemeScript();
   * + <InitColorSchemeScript />;
   * ```
   */
  var getInitColorSchemeScript = getInitColorSchemeScriptSystem;

  // TODO: Remove this function in v6.
  // eslint-disable-next-line @typescript-eslint/naming-convention
  function experimental_sx() {
    throw new Error("MUI: The `experimental_sx` has been moved to `theme.unstable_sx`.For more details, see https://github.com/mui/material-ui/pull/35150." );
  }

  ({
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * @ignore
     */
    children: PropTypes.node,
    /**
     * @ignore
     */
    value: PropTypes.object.isRequired
  }) ;
  function useDefaultProps(params) {
    return useDefaultProps$1(params);
  }

  function getSvgIconUtilityClass(slot) {
    return generateUtilityClass('MuiSvgIcon', slot);
  }
  var svgIconClasses = generateUtilityClasses('MuiSvgIcon', ['root', 'colorPrimary', 'colorSecondary', 'colorAction', 'colorError', 'colorDisabled', 'fontSizeInherit', 'fontSizeSmall', 'fontSizeMedium', 'fontSizeLarge']);
  var svgIconClasses$1 = svgIconClasses;

  var useUtilityClasses$1P = function useUtilityClasses(ownerState) {
    var color = ownerState.color,
      fontSize = ownerState.fontSize,
      classes = ownerState.classes;
    var slots = {
      root: ['root', color !== 'inherit' && "color".concat(capitalize(color)), "fontSize".concat(capitalize(fontSize))]
    };
    return composeClasses(slots, getSvgIconUtilityClass, classes);
  };
  var SvgIconRoot = styled$1('svg', {
    name: 'MuiSvgIcon',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.color !== 'inherit' && styles["color".concat(capitalize(ownerState.color))], styles["fontSize".concat(capitalize(ownerState.fontSize))]];
    }
  })(function (_ref) {
    var _theme$transitions, _theme$transitions$cr, _theme$transitions2, _theme$typography, _theme$typography$pxT, _theme$typography2, _theme$typography2$px, _theme$typography3, _theme$typography3$px, _palette$ownerState$c, _palette, _palette2, _palette3;
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return {
      userSelect: 'none',
      width: '1em',
      height: '1em',
      display: 'inline-block',
      // the <svg> will define the property that has `currentColor`
      // for example heroicons uses fill="none" and stroke="currentColor"
      fill: ownerState.hasSvgAsChild ? undefined : 'currentColor',
      flexShrink: 0,
      transition: (_theme$transitions = theme.transitions) == null || (_theme$transitions$cr = _theme$transitions.create) == null ? void 0 : _theme$transitions$cr.call(_theme$transitions, 'fill', {
        duration: (_theme$transitions2 = theme.transitions) == null || (_theme$transitions2 = _theme$transitions2.duration) == null ? void 0 : _theme$transitions2.shorter
      }),
      fontSize: {
        inherit: 'inherit',
        small: ((_theme$typography = theme.typography) == null || (_theme$typography$pxT = _theme$typography.pxToRem) == null ? void 0 : _theme$typography$pxT.call(_theme$typography, 20)) || '1.25rem',
        medium: ((_theme$typography2 = theme.typography) == null || (_theme$typography2$px = _theme$typography2.pxToRem) == null ? void 0 : _theme$typography2$px.call(_theme$typography2, 24)) || '1.5rem',
        large: ((_theme$typography3 = theme.typography) == null || (_theme$typography3$px = _theme$typography3.pxToRem) == null ? void 0 : _theme$typography3$px.call(_theme$typography3, 35)) || '2.1875rem'
      }[ownerState.fontSize],
      // TODO v5 deprecate, v6 remove for sx
      color: (_palette$ownerState$c = (_palette = (theme.vars || theme).palette) == null || (_palette = _palette[ownerState.color]) == null ? void 0 : _palette.main) != null ? _palette$ownerState$c : {
        action: (_palette2 = (theme.vars || theme).palette) == null || (_palette2 = _palette2.action) == null ? void 0 : _palette2.active,
        disabled: (_palette3 = (theme.vars || theme).palette) == null || (_palette3 = _palette3.action) == null ? void 0 : _palette3.disabled,
        inherit: undefined
      }[ownerState.color]
    };
  });
  var SvgIcon = /*#__PURE__*/React__namespace.forwardRef(function SvgIcon(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiSvgIcon'
    });
    var children = props.children,
      className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'inherit' : _props$color,
      _props$component = props.component,
      component = _props$component === void 0 ? 'svg' : _props$component,
      _props$fontSize = props.fontSize,
      fontSize = _props$fontSize === void 0 ? 'medium' : _props$fontSize,
      htmlColor = props.htmlColor,
      _props$inheritViewBox = props.inheritViewBox,
      inheritViewBox = _props$inheritViewBox === void 0 ? false : _props$inheritViewBox,
      titleAccess = props.titleAccess,
      _props$viewBox = props.viewBox,
      viewBox = _props$viewBox === void 0 ? '0 0 24 24' : _props$viewBox,
      other = _objectWithoutProperties(props, ["children", "className", "color", "component", "fontSize", "htmlColor", "inheritViewBox", "titleAccess", "viewBox"]);
    var hasSvgAsChild = /*#__PURE__*/React__namespace.isValidElement(children) && children.type === 'svg';
    var ownerState = _extends({}, props, {
      color: color,
      component: component,
      fontSize: fontSize,
      instanceFontSize: inProps.fontSize,
      inheritViewBox: inheritViewBox,
      viewBox: viewBox,
      hasSvgAsChild: hasSvgAsChild
    });
    var more = {};
    if (!inheritViewBox) {
      more.viewBox = viewBox;
    }
    var classes = useUtilityClasses$1P(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(SvgIconRoot, _extends({
      as: component,
      className: clsx(classes.root, className),
      focusable: "false",
      color: htmlColor,
      "aria-hidden": titleAccess ? undefined : true,
      role: titleAccess ? 'img' : undefined,
      ref: ref
    }, more, other, hasSvgAsChild && children.props, {
      ownerState: ownerState,
      children: [hasSvgAsChild ? children.props.children : children, titleAccess ? /*#__PURE__*/jsxRuntimeExports.jsx("title", {
        children: titleAccess
      }) : null]
    }));
  });
  SvgIcon.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Node passed into the SVG element.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * You can use the `htmlColor` prop to apply a color attribute to the SVG element.
     * @default 'inherit'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['inherit', 'action', 'disabled', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The fontSize applied to the icon. Defaults to 24px, but can be configure to inherit font size.
     * @default 'medium'
     */
    fontSize: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['inherit', 'large', 'medium', 'small']), PropTypes.string]),
    /**
     * Applies a color attribute to the SVG element.
     */
    htmlColor: PropTypes.string,
    /**
     * If `true`, the root node will inherit the custom `component`'s viewBox and the `viewBox`
     * prop will be ignored.
     * Useful when you want to reference a custom `component` and have `SvgIcon` pass that
     * `component`'s viewBox to the root node.
     * @default false
     */
    inheritViewBox: PropTypes.bool,
    /**
     * The shape-rendering attribute. The behavior of the different options is described on the
     * [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/shape-rendering).
     * If you are having issues with blurry icons you should investigate this prop.
     */
    shapeRendering: PropTypes.string,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * Provides a human-readable title for the element that contains it.
     * https://www.w3.org/TR/SVG-access/#Equivalent
     */
    titleAccess: PropTypes.string,
    /**
     * Allows you to redefine what the coordinates without units mean inside an SVG element.
     * For example, if the SVG element is 500 (width) by 200 (height),
     * and you pass viewBox="0 0 50 20",
     * this means that the coordinates inside the SVG will go from the top left corner (0,0)
     * to bottom right (50,20) and each unit will be worth 10px.
     * @default '0 0 24 24'
     */
    viewBox: PropTypes.string
  } ;
  SvgIcon.muiName = 'SvgIcon';
  var SvgIcon$1 = SvgIcon;

  function createSvgIcon(path, displayName) {
    function Component(props, ref) {
      return /*#__PURE__*/jsxRuntimeExports.jsx(SvgIcon$1, _extends({
        "data-testid": "".concat(displayName, "Icon"),
        ref: ref
      }, props, {
        children: path
      }));
    }
    {
      // Need to set `displayName` on the inner component for React.memo.
      // React prior to 16.14 ignores `displayName` on the wrapper.
      Component.displayName = "".concat(displayName, "Icon");
    }
    Component.muiName = SvgIcon$1.muiName;
    return /*#__PURE__*/React__namespace.memo( /*#__PURE__*/React__namespace.forwardRef(Component));
  }

  // TODO: remove this export once ClassNameGenerator is stable
  // eslint-disable-next-line @typescript-eslint/naming-convention
  var unstable_ClassNameGenerator = {
    configure: function configure(generator) {
      {
        console.warn(['MUI: `ClassNameGenerator` import from `@mui/material/utils` is outdated and might cause unexpected issues.', '', "You should use `import { unstable_ClassNameGenerator } from '@mui/material/className'` instead", '', 'The detail of the issue: https://github.com/mui/material-ui/issues/30011#issuecomment-1024993401', '', 'The updated documentation: https://mui.com/guides/classname-generator/'].join('\n'));
      }
      ClassNameGenerator$1.configure(generator);
    }
  };

  function _toArray(arr) {
    return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest();
  }

  function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };
    return _setPrototypeOf(o, p);
  }

  function _inheritsLoose(subClass, superClass) {
    subClass.prototype = Object.create(superClass.prototype);
    subClass.prototype.constructor = subClass;
    _setPrototypeOf(subClass, superClass);
  }

  var config = {
    disabled: false
  };

  var timeoutsShape = PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
    enter: PropTypes.number,
    exit: PropTypes.number,
    appear: PropTypes.number
  }).isRequired]) ;
  PropTypes.oneOfType([PropTypes.string, PropTypes.shape({
    enter: PropTypes.string,
    exit: PropTypes.string,
    active: PropTypes.string
  }), PropTypes.shape({
    enter: PropTypes.string,
    enterDone: PropTypes.string,
    enterActive: PropTypes.string,
    exit: PropTypes.string,
    exitDone: PropTypes.string,
    exitActive: PropTypes.string
  })]) ;

  var TransitionGroupContext = React.createContext(null);

  var forceReflow = function forceReflow(node) {
    return node.scrollTop;
  };

  var UNMOUNTED = 'unmounted';
  var EXITED = 'exited';
  var ENTERING = 'entering';
  var ENTERED = 'entered';
  var EXITING = 'exiting';
  /**
   * The Transition component lets you describe a transition from one component
   * state to another _over time_ with a simple declarative API. Most commonly
   * it's used to animate the mounting and unmounting of a component, but can also
   * be used to describe in-place transition states as well.
   *
   * ---
   *
   * **Note**: `Transition` is a platform-agnostic base component. If you're using
   * transitions in CSS, you'll probably want to use
   * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition)
   * instead. It inherits all the features of `Transition`, but contains
   * additional features necessary to play nice with CSS transitions (hence the
   * name of the component).
   *
   * ---
   *
   * By default the `Transition` component does not alter the behavior of the
   * component it renders, it only tracks "enter" and "exit" states for the
   * components. It's up to you to give meaning and effect to those states. For
   * example we can add styles to a component when it enters or exits:
   *
   * ```jsx
   * import { Transition } from 'react-transition-group';
   *
   * const duration = 300;
   *
   * const defaultStyle = {
   *   transition: `opacity ${duration}ms ease-in-out`,
   *   opacity: 0,
   * }
   *
   * const transitionStyles = {
   *   entering: { opacity: 1 },
   *   entered:  { opacity: 1 },
   *   exiting:  { opacity: 0 },
   *   exited:  { opacity: 0 },
   * };
   *
   * const Fade = ({ in: inProp }) => (
   *   <Transition in={inProp} timeout={duration}>
   *     {state => (
   *       <div style={{
   *         ...defaultStyle,
   *         ...transitionStyles[state]
   *       }}>
   *         I'm a fade Transition!
   *       </div>
   *     )}
   *   </Transition>
   * );
   * ```
   *
   * There are 4 main states a Transition can be in:
   *  - `'entering'`
   *  - `'entered'`
   *  - `'exiting'`
   *  - `'exited'`
   *
   * Transition state is toggled via the `in` prop. When `true` the component
   * begins the "Enter" stage. During this stage, the component will shift from
   * its current transition state, to `'entering'` for the duration of the
   * transition and then to the `'entered'` stage once it's complete. Let's take
   * the following example (we'll use the
   * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook):
   *
   * ```jsx
   * function App() {
   *   const [inProp, setInProp] = useState(false);
   *   return (
   *     <div>
   *       <Transition in={inProp} timeout={500}>
   *         {state => (
   *           // ...
   *         )}
   *       </Transition>
   *       <button onClick={() => setInProp(true)}>
   *         Click to Enter
   *       </button>
   *     </div>
   *   );
   * }
   * ```
   *
   * When the button is clicked the component will shift to the `'entering'` state
   * and stay there for 500ms (the value of `timeout`) before it finally switches
   * to `'entered'`.
   *
   * When `in` is `false` the same thing happens except the state moves from
   * `'exiting'` to `'exited'`.
   */

  var Transition = /*#__PURE__*/function (_React$Component) {
    _inheritsLoose(Transition, _React$Component);

    function Transition(props, context) {
      var _this;

      _this = _React$Component.call(this, props, context) || this;
      var parentGroup = context; // In the context of a TransitionGroup all enters are really appears

      var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;
      var initialStatus;
      _this.appearStatus = null;

      if (props.in) {
        if (appear) {
          initialStatus = EXITED;
          _this.appearStatus = ENTERING;
        } else {
          initialStatus = ENTERED;
        }
      } else {
        if (props.unmountOnExit || props.mountOnEnter) {
          initialStatus = UNMOUNTED;
        } else {
          initialStatus = EXITED;
        }
      }

      _this.state = {
        status: initialStatus
      };
      _this.nextCallback = null;
      return _this;
    }

    Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {
      var nextIn = _ref.in;

      if (nextIn && prevState.status === UNMOUNTED) {
        return {
          status: EXITED
        };
      }

      return null;
    } // getSnapshotBeforeUpdate(prevProps) {
    //   let nextStatus = null
    //   if (prevProps !== this.props) {
    //     const { status } = this.state
    //     if (this.props.in) {
    //       if (status !== ENTERING && status !== ENTERED) {
    //         nextStatus = ENTERING
    //       }
    //     } else {
    //       if (status === ENTERING || status === ENTERED) {
    //         nextStatus = EXITING
    //       }
    //     }
    //   }
    //   return { nextStatus }
    // }
    ;

    var _proto = Transition.prototype;

    _proto.componentDidMount = function componentDidMount() {
      this.updateStatus(true, this.appearStatus);
    };

    _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
      var nextStatus = null;

      if (prevProps !== this.props) {
        var status = this.state.status;

        if (this.props.in) {
          if (status !== ENTERING && status !== ENTERED) {
            nextStatus = ENTERING;
          }
        } else {
          if (status === ENTERING || status === ENTERED) {
            nextStatus = EXITING;
          }
        }
      }

      this.updateStatus(false, nextStatus);
    };

    _proto.componentWillUnmount = function componentWillUnmount() {
      this.cancelNextCallback();
    };

    _proto.getTimeouts = function getTimeouts() {
      var timeout = this.props.timeout;
      var exit, enter, appear;
      exit = enter = appear = timeout;

      if (timeout != null && typeof timeout !== 'number') {
        exit = timeout.exit;
        enter = timeout.enter; // TODO: remove fallback for next major

        appear = timeout.appear !== undefined ? timeout.appear : enter;
      }

      return {
        exit: exit,
        enter: enter,
        appear: appear
      };
    };

    _proto.updateStatus = function updateStatus(mounting, nextStatus) {
      if (mounting === void 0) {
        mounting = false;
      }

      if (nextStatus !== null) {
        // nextStatus will always be ENTERING or EXITING.
        this.cancelNextCallback();

        if (nextStatus === ENTERING) {
          if (this.props.unmountOnExit || this.props.mountOnEnter) {
            var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this); // https://github.com/reactjs/react-transition-group/pull/749
            // With unmountOnExit or mountOnEnter, the enter animation should happen at the transition between `exited` and `entering`.
            // To make the animation happen,  we have to separate each rendering and avoid being processed as batched.

            if (node) forceReflow(node);
          }

          this.performEnter(mounting);
        } else {
          this.performExit();
        }
      } else if (this.props.unmountOnExit && this.state.status === EXITED) {
        this.setState({
          status: UNMOUNTED
        });
      }
    };

    _proto.performEnter = function performEnter(mounting) {
      var _this2 = this;

      var enter = this.props.enter;
      var appearing = this.context ? this.context.isMounting : mounting;

      var _ref2 = this.props.nodeRef ? [appearing] : [ReactDOM.findDOMNode(this), appearing],
          maybeNode = _ref2[0],
          maybeAppearing = _ref2[1];

      var timeouts = this.getTimeouts();
      var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED
      // if we are mounting and running this it means appear _must_ be set

      if (!mounting && !enter || config.disabled) {
        this.safeSetState({
          status: ENTERED
        }, function () {
          _this2.props.onEntered(maybeNode);
        });
        return;
      }

      this.props.onEnter(maybeNode, maybeAppearing);
      this.safeSetState({
        status: ENTERING
      }, function () {
        _this2.props.onEntering(maybeNode, maybeAppearing);

        _this2.onTransitionEnd(enterTimeout, function () {
          _this2.safeSetState({
            status: ENTERED
          }, function () {
            _this2.props.onEntered(maybeNode, maybeAppearing);
          });
        });
      });
    };

    _proto.performExit = function performExit() {
      var _this3 = this;

      var exit = this.props.exit;
      var timeouts = this.getTimeouts();
      var maybeNode = this.props.nodeRef ? undefined : ReactDOM.findDOMNode(this); // no exit animation skip right to EXITED

      if (!exit || config.disabled) {
        this.safeSetState({
          status: EXITED
        }, function () {
          _this3.props.onExited(maybeNode);
        });
        return;
      }

      this.props.onExit(maybeNode);
      this.safeSetState({
        status: EXITING
      }, function () {
        _this3.props.onExiting(maybeNode);

        _this3.onTransitionEnd(timeouts.exit, function () {
          _this3.safeSetState({
            status: EXITED
          }, function () {
            _this3.props.onExited(maybeNode);
          });
        });
      });
    };

    _proto.cancelNextCallback = function cancelNextCallback() {
      if (this.nextCallback !== null) {
        this.nextCallback.cancel();
        this.nextCallback = null;
      }
    };

    _proto.safeSetState = function safeSetState(nextState, callback) {
      // This shouldn't be necessary, but there are weird race conditions with
      // setState callbacks and unmounting in testing, so always make sure that
      // we can cancel any pending setState callbacks after we unmount.
      callback = this.setNextCallback(callback);
      this.setState(nextState, callback);
    };

    _proto.setNextCallback = function setNextCallback(callback) {
      var _this4 = this;

      var active = true;

      this.nextCallback = function (event) {
        if (active) {
          active = false;
          _this4.nextCallback = null;
          callback(event);
        }
      };

      this.nextCallback.cancel = function () {
        active = false;
      };

      return this.nextCallback;
    };

    _proto.onTransitionEnd = function onTransitionEnd(timeout, handler) {
      this.setNextCallback(handler);
      var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);
      var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener;

      if (!node || doesNotHaveTimeoutOrListener) {
        setTimeout(this.nextCallback, 0);
        return;
      }

      if (this.props.addEndListener) {
        var _ref3 = this.props.nodeRef ? [this.nextCallback] : [node, this.nextCallback],
            maybeNode = _ref3[0],
            maybeNextCallback = _ref3[1];

        this.props.addEndListener(maybeNode, maybeNextCallback);
      }

      if (timeout != null) {
        setTimeout(this.nextCallback, timeout);
      }
    };

    _proto.render = function render() {
      var status = this.state.status;

      if (status === UNMOUNTED) {
        return null;
      }

      var _this$props = this.props,
          children = _this$props.children;
          _this$props.in;
          _this$props.mountOnEnter;
          _this$props.unmountOnExit;
          _this$props.appear;
          _this$props.enter;
          _this$props.exit;
          _this$props.timeout;
          _this$props.addEndListener;
          _this$props.onEnter;
          _this$props.onEntering;
          _this$props.onEntered;
          _this$props.onExit;
          _this$props.onExiting;
          _this$props.onExited;
          _this$props.nodeRef;
          var childProps = _objectWithoutPropertiesLoose(_this$props, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);

      return (
        /*#__PURE__*/
        // allows for nested Transitions
        React.createElement(TransitionGroupContext.Provider, {
          value: null
        }, typeof children === 'function' ? children(status, childProps) : React.cloneElement(React.Children.only(children), childProps))
      );
    };

    return Transition;
  }(React.Component);

  Transition.contextType = TransitionGroupContext;
  Transition.propTypes = {
    /**
     * A React reference to DOM element that need to transition:
     * https://stackoverflow.com/a/51127130/4671932
     *
     *   - When `nodeRef` prop is used, `node` is not passed to callback functions
     *      (e.g. `onEnter`) because user already has direct access to the node.
     *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new
     *     `nodeRef` need to be provided to `Transition` with changed `key` prop
     *     (see
     *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).
     */
    nodeRef: PropTypes.shape({
      current: typeof Element === 'undefined' ? PropTypes.any : function (propValue, key, componentName, location, propFullName, secret) {
        var value = propValue[key];
        return PropTypes.instanceOf(value && 'ownerDocument' in value ? value.ownerDocument.defaultView.Element : Element)(propValue, key, componentName, location, propFullName, secret);
      }
    }),

    /**
     * A `function` child can be used instead of a React element. This function is
     * called with the current transition status (`'entering'`, `'entered'`,
     * `'exiting'`, `'exited'`), which can be used to apply context
     * specific props to a component.
     *
     * ```jsx
     * <Transition in={this.state.in} timeout={150}>
     *   {state => (
     *     <MyComponent className={`fade fade-${state}`} />
     *   )}
     * </Transition>
     * ```
     */
    children: PropTypes.oneOfType([PropTypes.func.isRequired, PropTypes.element.isRequired]).isRequired,

    /**
     * Show the component; triggers the enter or exit states
     */
    in: PropTypes.bool,

    /**
     * By default the child component is mounted immediately along with
     * the parent `Transition` component. If you want to "lazy mount" the component on the
     * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
     * mounted, even on "exited", unless you also specify `unmountOnExit`.
     */
    mountOnEnter: PropTypes.bool,

    /**
     * By default the child component stays mounted after it reaches the `'exited'` state.
     * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
     */
    unmountOnExit: PropTypes.bool,

    /**
     * By default the child component does not perform the enter transition when
     * it first mounts, regardless of the value of `in`. If you want this
     * behavior, set both `appear` and `in` to `true`.
     *
     * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop
     * > only adds an additional enter transition. However, in the
     * > `<CSSTransition>` component that first enter transition does result in
     * > additional `.appear-*` classes, that way you can choose to style it
     * > differently.
     */
    appear: PropTypes.bool,

    /**
     * Enable or disable enter transitions.
     */
    enter: PropTypes.bool,

    /**
     * Enable or disable exit transitions.
     */
    exit: PropTypes.bool,

    /**
     * The duration of the transition, in milliseconds.
     * Required unless `addEndListener` is provided.
     *
     * You may specify a single timeout for all transitions:
     *
     * ```jsx
     * timeout={500}
     * ```
     *
     * or individually:
     *
     * ```jsx
     * timeout={{
     *  appear: 500,
     *  enter: 300,
     *  exit: 500,
     * }}
     * ```
     *
     * - `appear` defaults to the value of `enter`
     * - `enter` defaults to `0`
     * - `exit` defaults to `0`
     *
     * @type {number | { enter?: number, exit?: number, appear?: number }}
     */
    timeout: function timeout(props) {
      var pt = timeoutsShape;
      if (!props.addEndListener) pt = pt.isRequired;

      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }

      return pt.apply(void 0, [props].concat(args));
    },

    /**
     * Add a custom transition end trigger. Called with the transitioning
     * DOM node and a `done` callback. Allows for more fine grained transition end
     * logic. Timeouts are still used as a fallback if provided.
     *
     * **Note**: when `nodeRef` prop is passed, `node` is not passed.
     *
     * ```jsx
     * addEndListener={(node, done) => {
     *   // use the css transitionend event to mark the finish of a transition
     *   node.addEventListener('transitionend', done, false);
     * }}
     * ```
     */
    addEndListener: PropTypes.func,

    /**
     * Callback fired before the "entering" status is applied. An extra parameter
     * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
     *
     * **Note**: when `nodeRef` prop is passed, `node` is not passed.
     *
     * @type Function(node: HtmlElement, isAppearing: bool) -> void
     */
    onEnter: PropTypes.func,

    /**
     * Callback fired after the "entering" status is applied. An extra parameter
     * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
     *
     * **Note**: when `nodeRef` prop is passed, `node` is not passed.
     *
     * @type Function(node: HtmlElement, isAppearing: bool)
     */
    onEntering: PropTypes.func,

    /**
     * Callback fired after the "entered" status is applied. An extra parameter
     * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
     *
     * **Note**: when `nodeRef` prop is passed, `node` is not passed.
     *
     * @type Function(node: HtmlElement, isAppearing: bool) -> void
     */
    onEntered: PropTypes.func,

    /**
     * Callback fired before the "exiting" status is applied.
     *
     * **Note**: when `nodeRef` prop is passed, `node` is not passed.
     *
     * @type Function(node: HtmlElement) -> void
     */
    onExit: PropTypes.func,

    /**
     * Callback fired after the "exiting" status is applied.
     *
     * **Note**: when `nodeRef` prop is passed, `node` is not passed.
     *
     * @type Function(node: HtmlElement) -> void
     */
    onExiting: PropTypes.func,

    /**
     * Callback fired after the "exited" status is applied.
     *
     * **Note**: when `nodeRef` prop is passed, `node` is not passed
     *
     * @type Function(node: HtmlElement) -> void
     */
    onExited: PropTypes.func
  } ; // Name the function so it is clearer in the documentation

  function noop() {}

  Transition.defaultProps = {
    in: false,
    mountOnEnter: false,
    unmountOnExit: false,
    appear: false,
    enter: true,
    exit: true,
    onEnter: noop,
    onEntering: noop,
    onEntered: noop,
    onExit: noop,
    onExiting: noop,
    onExited: noop
  };
  Transition.UNMOUNTED = UNMOUNTED;
  Transition.EXITED = EXITED;
  Transition.ENTERING = ENTERING;
  Transition.ENTERED = ENTERED;
  Transition.EXITING = EXITING;
  var Transition$1 = Transition;

  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }
    return self;
  }

  /**
   * Given `this.props.children`, return an object mapping key to child.
   *
   * @param {*} children `this.props.children`
   * @return {object} Mapping of key to child
   */

  function getChildMapping(children, mapFn) {
    var mapper = function mapper(child) {
      return mapFn && React.isValidElement(child) ? mapFn(child) : child;
    };

    var result = Object.create(null);
    if (children) React.Children.map(children, function (c) {
      return c;
    }).forEach(function (child) {
      // run the map function here instead so that the key is the computed one
      result[child.key] = mapper(child);
    });
    return result;
  }
  /**
   * When you're adding or removing children some may be added or removed in the
   * same render pass. We want to show *both* since we want to simultaneously
   * animate elements in and out. This function takes a previous set of keys
   * and a new set of keys and merges them with its best guess of the correct
   * ordering. In the future we may expose some of the utilities in
   * ReactMultiChild to make this easy, but for now React itself does not
   * directly have this concept of the union of prevChildren and nextChildren
   * so we implement it here.
   *
   * @param {object} prev prev children as returned from
   * `ReactTransitionChildMapping.getChildMapping()`.
   * @param {object} next next children as returned from
   * `ReactTransitionChildMapping.getChildMapping()`.
   * @return {object} a key set that contains all keys in `prev` and all keys
   * in `next` in a reasonable order.
   */

  function mergeChildMappings(prev, next) {
    prev = prev || {};
    next = next || {};

    function getValueForKey(key) {
      return key in next ? next[key] : prev[key];
    } // For each key of `next`, the list of keys to insert before that key in
    // the combined list


    var nextKeysPending = Object.create(null);
    var pendingKeys = [];

    for (var prevKey in prev) {
      if (prevKey in next) {
        if (pendingKeys.length) {
          nextKeysPending[prevKey] = pendingKeys;
          pendingKeys = [];
        }
      } else {
        pendingKeys.push(prevKey);
      }
    }

    var i;
    var childMapping = {};

    for (var nextKey in next) {
      if (nextKeysPending[nextKey]) {
        for (i = 0; i < nextKeysPending[nextKey].length; i++) {
          var pendingNextKey = nextKeysPending[nextKey][i];
          childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);
        }
      }

      childMapping[nextKey] = getValueForKey(nextKey);
    } // Finally, add the keys which didn't appear before any key in `next`


    for (i = 0; i < pendingKeys.length; i++) {
      childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);
    }

    return childMapping;
  }

  function getProp(child, prop, props) {
    return props[prop] != null ? props[prop] : child.props[prop];
  }

  function getInitialChildMapping(props, onExited) {
    return getChildMapping(props.children, function (child) {
      return React.cloneElement(child, {
        onExited: onExited.bind(null, child),
        in: true,
        appear: getProp(child, 'appear', props),
        enter: getProp(child, 'enter', props),
        exit: getProp(child, 'exit', props)
      });
    });
  }
  function getNextChildMapping(nextProps, prevChildMapping, onExited) {
    var nextChildMapping = getChildMapping(nextProps.children);
    var children = mergeChildMappings(prevChildMapping, nextChildMapping);
    Object.keys(children).forEach(function (key) {
      var child = children[key];
      if (!React.isValidElement(child)) return;
      var hasPrev = (key in prevChildMapping);
      var hasNext = (key in nextChildMapping);
      var prevChild = prevChildMapping[key];
      var isLeaving = React.isValidElement(prevChild) && !prevChild.props.in; // item is new (entering)

      if (hasNext && (!hasPrev || isLeaving)) {
        // console.log('entering', key)
        children[key] = React.cloneElement(child, {
          onExited: onExited.bind(null, child),
          in: true,
          exit: getProp(child, 'exit', nextProps),
          enter: getProp(child, 'enter', nextProps)
        });
      } else if (!hasNext && hasPrev && !isLeaving) {
        // item is old (exiting)
        // console.log('leaving', key)
        children[key] = React.cloneElement(child, {
          in: false
        });
      } else if (hasNext && hasPrev && React.isValidElement(prevChild)) {
        // item hasn't changed transition states
        // copy over the last transition props;
        // console.log('unchanged', key)
        children[key] = React.cloneElement(child, {
          onExited: onExited.bind(null, child),
          in: prevChild.props.in,
          exit: getProp(child, 'exit', nextProps),
          enter: getProp(child, 'enter', nextProps)
        });
      }
    });
    return children;
  }

  var values = Object.values || function (obj) {
    return Object.keys(obj).map(function (k) {
      return obj[k];
    });
  };

  var defaultProps = {
    component: 'div',
    childFactory: function childFactory(child) {
      return child;
    }
  };
  /**
   * The `<TransitionGroup>` component manages a set of transition components
   * (`<Transition>` and `<CSSTransition>`) in a list. Like with the transition
   * components, `<TransitionGroup>` is a state machine for managing the mounting
   * and unmounting of components over time.
   *
   * Consider the example below. As items are removed or added to the TodoList the
   * `in` prop is toggled automatically by the `<TransitionGroup>`.
   *
   * Note that `<TransitionGroup>`  does not define any animation behavior!
   * Exactly _how_ a list item animates is up to the individual transition
   * component. This means you can mix and match animations across different list
   * items.
   */

  var TransitionGroup = /*#__PURE__*/function (_React$Component) {
    _inheritsLoose(TransitionGroup, _React$Component);

    function TransitionGroup(props, context) {
      var _this;

      _this = _React$Component.call(this, props, context) || this;

      var handleExited = _this.handleExited.bind(_assertThisInitialized(_this)); // Initial children should all be entering, dependent on appear


      _this.state = {
        contextValue: {
          isMounting: true
        },
        handleExited: handleExited,
        firstRender: true
      };
      return _this;
    }

    var _proto = TransitionGroup.prototype;

    _proto.componentDidMount = function componentDidMount() {
      this.mounted = true;
      this.setState({
        contextValue: {
          isMounting: false
        }
      });
    };

    _proto.componentWillUnmount = function componentWillUnmount() {
      this.mounted = false;
    };

    TransitionGroup.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, _ref) {
      var prevChildMapping = _ref.children,
          handleExited = _ref.handleExited,
          firstRender = _ref.firstRender;
      return {
        children: firstRender ? getInitialChildMapping(nextProps, handleExited) : getNextChildMapping(nextProps, prevChildMapping, handleExited),
        firstRender: false
      };
    } // node is `undefined` when user provided `nodeRef` prop
    ;

    _proto.handleExited = function handleExited(child, node) {
      var currentChildMapping = getChildMapping(this.props.children);
      if (child.key in currentChildMapping) return;

      if (child.props.onExited) {
        child.props.onExited(node);
      }

      if (this.mounted) {
        this.setState(function (state) {
          var children = _extends({}, state.children);

          delete children[child.key];
          return {
            children: children
          };
        });
      }
    };

    _proto.render = function render() {
      var _this$props = this.props,
          Component = _this$props.component,
          childFactory = _this$props.childFactory,
          props = _objectWithoutPropertiesLoose(_this$props, ["component", "childFactory"]);

      var contextValue = this.state.contextValue;
      var children = values(this.state.children).map(childFactory);
      delete props.appear;
      delete props.enter;
      delete props.exit;

      if (Component === null) {
        return /*#__PURE__*/React.createElement(TransitionGroupContext.Provider, {
          value: contextValue
        }, children);
      }

      return /*#__PURE__*/React.createElement(TransitionGroupContext.Provider, {
        value: contextValue
      }, /*#__PURE__*/React.createElement(Component, props, children));
    };

    return TransitionGroup;
  }(React.Component);

  TransitionGroup.propTypes = {
    /**
     * `<TransitionGroup>` renders a `<div>` by default. You can change this
     * behavior by providing a `component` prop.
     * If you use React v16+ and would like to avoid a wrapping `<div>` element
     * you can pass in `component={null}`. This is useful if the wrapping div
     * borks your css styles.
     */
    component: PropTypes.any,

    /**
     * A set of `<Transition>` components, that are toggled `in` and out as they
     * leave. the `<TransitionGroup>` will inject specific transition props, so
     * remember to spread them through if you are wrapping the `<Transition>` as
     * with our `<Fade>` example.
     *
     * While this component is meant for multiple `Transition` or `CSSTransition`
     * children, sometimes you may want to have a single transition child with
     * content that you want to be transitioned out and in when you change it
     * (e.g. routes, images etc.) In that case you can change the `key` prop of
     * the transition child as you change its content, this will cause
     * `TransitionGroup` to transition the child out and back in.
     */
    children: PropTypes.node,

    /**
     * A convenience prop that enables or disables appear animations
     * for all children. Note that specifying this will override any defaults set
     * on individual children Transitions.
     */
    appear: PropTypes.bool,

    /**
     * A convenience prop that enables or disables enter animations
     * for all children. Note that specifying this will override any defaults set
     * on individual children Transitions.
     */
    enter: PropTypes.bool,

    /**
     * A convenience prop that enables or disables exit animations
     * for all children. Note that specifying this will override any defaults set
     * on individual children Transitions.
     */
    exit: PropTypes.bool,

    /**
     * You may need to apply reactive updates to a child as it is exiting.
     * This is generally done by using `cloneElement` however in the case of an exiting
     * child the element has already been removed and not accessible to the consumer.
     *
     * If you do need to update a child as it leaves you can provide a `childFactory`
     * to wrap every child, even the ones that are leaving.
     *
     * @type Function(child: ReactElement) -> ReactElement
     */
    childFactory: PropTypes.func
  } ;
  TransitionGroup.defaultProps = defaultProps;
  var TransitionGroup$1 = TransitionGroup;

  var reflow = function reflow(node) {
    return node.scrollTop;
  };
  function getTransitionProps(props, options) {
    var _style$transitionDura, _style$transitionTimi;
    var timeout = props.timeout,
      easing = props.easing,
      _props$style = props.style,
      style = _props$style === void 0 ? {} : _props$style;
    return {
      duration: (_style$transitionDura = style.transitionDuration) != null ? _style$transitionDura : typeof timeout === 'number' ? timeout : timeout[options.mode] || 0,
      easing: (_style$transitionTimi = style.transitionTimingFunction) != null ? _style$transitionTimi : _typeof(easing) === 'object' ? easing[options.mode] : easing,
      delay: style.transitionDelay
    };
  }

  function getCollapseUtilityClass(slot) {
    return generateUtilityClass('MuiCollapse', slot);
  }
  var collapseClasses = generateUtilityClasses('MuiCollapse', ['root', 'horizontal', 'vertical', 'entered', 'hidden', 'wrapper', 'wrapperInner']);
  var collapseClasses$1 = collapseClasses;

  var useUtilityClasses$1O = function useUtilityClasses(ownerState) {
    var orientation = ownerState.orientation,
      classes = ownerState.classes;
    var slots = {
      root: ['root', "".concat(orientation)],
      entered: ['entered'],
      hidden: ['hidden'],
      wrapper: ['wrapper', "".concat(orientation)],
      wrapperInner: ['wrapperInner', "".concat(orientation)]
    };
    return composeClasses(slots, getCollapseUtilityClass, classes);
  };
  var CollapseRoot = styled$1('div', {
    name: 'MuiCollapse',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.orientation], ownerState.state === 'entered' && styles.entered, ownerState.state === 'exited' && !ownerState["in"] && ownerState.collapsedSize === '0px' && styles.hidden];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      height: 0,
      overflow: 'hidden',
      transition: theme.transitions.create('height')
    }, ownerState.orientation === 'horizontal' && {
      height: 'auto',
      width: 0,
      transition: theme.transitions.create('width')
    }, ownerState.state === 'entered' && _extends({
      height: 'auto',
      overflow: 'visible'
    }, ownerState.orientation === 'horizontal' && {
      width: 'auto'
    }), ownerState.state === 'exited' && !ownerState["in"] && ownerState.collapsedSize === '0px' && {
      visibility: 'hidden'
    });
  });
  var CollapseWrapper = styled$1('div', {
    name: 'MuiCollapse',
    slot: 'Wrapper',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.wrapper;
    }
  })(function (_ref2) {
    var ownerState = _ref2.ownerState;
    return _extends({
      // Hack to get children with a negative margin to not falsify the height computation.
      display: 'flex',
      width: '100%'
    }, ownerState.orientation === 'horizontal' && {
      width: 'auto',
      height: '100%'
    });
  });
  var CollapseWrapperInner = styled$1('div', {
    name: 'MuiCollapse',
    slot: 'WrapperInner',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.wrapperInner;
    }
  })(function (_ref3) {
    var ownerState = _ref3.ownerState;
    return _extends({
      width: '100%'
    }, ownerState.orientation === 'horizontal' && {
      width: 'auto',
      height: '100%'
    });
  });

  /**
   * The Collapse transition is used by the
   * [Vertical Stepper](/material-ui/react-stepper/#vertical-stepper) StepContent component.
   * It uses [react-transition-group](https://github.com/reactjs/react-transition-group) internally.
   */
  var Collapse = /*#__PURE__*/React__namespace.forwardRef(function Collapse(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiCollapse'
    });
    var addEndListener = props.addEndListener,
      _children = props.children,
      className = props.className,
      _props$collapsedSize = props.collapsedSize,
      collapsedSizeProp = _props$collapsedSize === void 0 ? '0px' : _props$collapsedSize,
      component = props.component,
      easing = props.easing,
      inProp = props["in"],
      onEnter = props.onEnter,
      onEntered = props.onEntered,
      onEntering = props.onEntering,
      onExit = props.onExit,
      onExited = props.onExited,
      onExiting = props.onExiting,
      _props$orientation = props.orientation,
      orientation = _props$orientation === void 0 ? 'vertical' : _props$orientation,
      style = props.style,
      _props$timeout = props.timeout,
      timeout = _props$timeout === void 0 ? duration.standard : _props$timeout,
      _props$TransitionComp = props.TransitionComponent,
      TransitionComponent = _props$TransitionComp === void 0 ? Transition$1 : _props$TransitionComp,
      other = _objectWithoutProperties(props, ["addEndListener", "children", "className", "collapsedSize", "component", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "orientation", "style", "timeout", "TransitionComponent"]);
    var ownerState = _extends({}, props, {
      orientation: orientation,
      collapsedSize: collapsedSizeProp
    });
    var classes = useUtilityClasses$1O(ownerState);
    var theme = useTheme();
    var timer = useTimeout();
    var wrapperRef = React__namespace.useRef(null);
    var autoTransitionDuration = React__namespace.useRef();
    var collapsedSize = typeof collapsedSizeProp === 'number' ? "".concat(collapsedSizeProp, "px") : collapsedSizeProp;
    var isHorizontal = orientation === 'horizontal';
    var size = isHorizontal ? 'width' : 'height';
    var nodeRef = React__namespace.useRef(null);
    var handleRef = useForkRef(ref, nodeRef);
    var normalizedTransitionCallback = function normalizedTransitionCallback(callback) {
      return function (maybeIsAppearing) {
        if (callback) {
          var node = nodeRef.current;

          // onEnterXxx and onExitXxx callbacks have a different arguments.length value.
          if (maybeIsAppearing === undefined) {
            callback(node);
          } else {
            callback(node, maybeIsAppearing);
          }
        }
      };
    };
    var getWrapperSize = function getWrapperSize() {
      return wrapperRef.current ? wrapperRef.current[isHorizontal ? 'clientWidth' : 'clientHeight'] : 0;
    };
    var handleEnter = normalizedTransitionCallback(function (node, isAppearing) {
      if (wrapperRef.current && isHorizontal) {
        // Set absolute position to get the size of collapsed content
        wrapperRef.current.style.position = 'absolute';
      }
      node.style[size] = collapsedSize;
      if (onEnter) {
        onEnter(node, isAppearing);
      }
    });
    var handleEntering = normalizedTransitionCallback(function (node, isAppearing) {
      var wrapperSize = getWrapperSize();
      if (wrapperRef.current && isHorizontal) {
        // After the size is read reset the position back to default
        wrapperRef.current.style.position = '';
      }
      var _getTransitionProps = getTransitionProps({
          style: style,
          timeout: timeout,
          easing: easing
        }, {
          mode: 'enter'
        }),
        transitionDuration = _getTransitionProps.duration,
        transitionTimingFunction = _getTransitionProps.easing;
      if (timeout === 'auto') {
        var duration2 = theme.transitions.getAutoHeightDuration(wrapperSize);
        node.style.transitionDuration = "".concat(duration2, "ms");
        autoTransitionDuration.current = duration2;
      } else {
        node.style.transitionDuration = typeof transitionDuration === 'string' ? transitionDuration : "".concat(transitionDuration, "ms");
      }
      node.style[size] = "".concat(wrapperSize, "px");
      node.style.transitionTimingFunction = transitionTimingFunction;
      if (onEntering) {
        onEntering(node, isAppearing);
      }
    });
    var handleEntered = normalizedTransitionCallback(function (node, isAppearing) {
      node.style[size] = 'auto';
      if (onEntered) {
        onEntered(node, isAppearing);
      }
    });
    var handleExit = normalizedTransitionCallback(function (node) {
      node.style[size] = "".concat(getWrapperSize(), "px");
      if (onExit) {
        onExit(node);
      }
    });
    var handleExited = normalizedTransitionCallback(onExited);
    var handleExiting = normalizedTransitionCallback(function (node) {
      var wrapperSize = getWrapperSize();
      var _getTransitionProps2 = getTransitionProps({
          style: style,
          timeout: timeout,
          easing: easing
        }, {
          mode: 'exit'
        }),
        transitionDuration = _getTransitionProps2.duration,
        transitionTimingFunction = _getTransitionProps2.easing;
      if (timeout === 'auto') {
        // TODO: rename getAutoHeightDuration to something more generic (width support)
        // Actually it just calculates animation duration based on size
        var duration2 = theme.transitions.getAutoHeightDuration(wrapperSize);
        node.style.transitionDuration = "".concat(duration2, "ms");
        autoTransitionDuration.current = duration2;
      } else {
        node.style.transitionDuration = typeof transitionDuration === 'string' ? transitionDuration : "".concat(transitionDuration, "ms");
      }
      node.style[size] = collapsedSize;
      node.style.transitionTimingFunction = transitionTimingFunction;
      if (onExiting) {
        onExiting(node);
      }
    });
    var handleAddEndListener = function handleAddEndListener(next) {
      if (timeout === 'auto') {
        timer.start(autoTransitionDuration.current || 0, next);
      }
      if (addEndListener) {
        // Old call signature before `react-transition-group` implemented `nodeRef`
        addEndListener(nodeRef.current, next);
      }
    };
    return /*#__PURE__*/jsxRuntimeExports.jsx(TransitionComponent, _extends({
      "in": inProp,
      onEnter: handleEnter,
      onEntered: handleEntered,
      onEntering: handleEntering,
      onExit: handleExit,
      onExited: handleExited,
      onExiting: handleExiting,
      addEndListener: handleAddEndListener,
      nodeRef: nodeRef,
      timeout: timeout === 'auto' ? null : timeout
    }, other, {
      children: function children(state, childProps) {
        return /*#__PURE__*/jsxRuntimeExports.jsx(CollapseRoot, _extends({
          as: component,
          className: clsx(classes.root, className, {
            'entered': classes.entered,
            'exited': !inProp && collapsedSize === '0px' && classes.hidden
          }[state]),
          style: _extends(_defineProperty({}, isHorizontal ? 'minWidth' : 'minHeight', collapsedSize), style),
          ref: handleRef
        }, childProps, {
          // `ownerState` is set after `childProps` to override any existing `ownerState` property in `childProps`
          // that might have been forwarded from the Transition component.
          ownerState: _extends({}, ownerState, {
            state: state
          }),
          children: /*#__PURE__*/jsxRuntimeExports.jsx(CollapseWrapper, {
            ownerState: _extends({}, ownerState, {
              state: state
            }),
            className: classes.wrapper,
            ref: wrapperRef,
            children: /*#__PURE__*/jsxRuntimeExports.jsx(CollapseWrapperInner, {
              ownerState: _extends({}, ownerState, {
                state: state
              }),
              className: classes.wrapperInner,
              children: _children
            })
          })
        }));
      }
    }));
  });
  Collapse.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Add a custom transition end trigger. Called with the transitioning DOM
     * node and a done callback. Allows for more fine grained transition end
     * logic. Note: Timeouts are still used as a fallback if provided.
     */
    addEndListener: PropTypes.func,
    /**
     * The content node to be collapsed.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The width (horizontal) or height (vertical) of the container when collapsed.
     * @default '0px'
     */
    collapsedSize: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: elementTypeAcceptingRef$1,
    /**
     * The transition timing function.
     * You may specify a single easing or a object containing enter and exit values.
     */
    easing: PropTypes.oneOfType([PropTypes.shape({
      enter: PropTypes.string,
      exit: PropTypes.string
    }), PropTypes.string]),
    /**
     * If `true`, the component will transition in.
     */
    "in": PropTypes.bool,
    /**
     * @ignore
     */
    onEnter: PropTypes.func,
    /**
     * @ignore
     */
    onEntered: PropTypes.func,
    /**
     * @ignore
     */
    onEntering: PropTypes.func,
    /**
     * @ignore
     */
    onExit: PropTypes.func,
    /**
     * @ignore
     */
    onExited: PropTypes.func,
    /**
     * @ignore
     */
    onExiting: PropTypes.func,
    /**
     * The transition orientation.
     * @default 'vertical'
     */
    orientation: PropTypes.oneOf(['horizontal', 'vertical']),
    /**
     * @ignore
     */
    style: PropTypes.object,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The duration for the transition, in milliseconds.
     * You may specify a single timeout for all transitions, or individually with an object.
     *
     * Set to 'auto' to automatically calculate transition time based on height.
     * @default duration.standard
     */
    timeout: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.shape({
      appear: PropTypes.number,
      enter: PropTypes.number,
      exit: PropTypes.number
    })])
  } ;
  Collapse.muiSupportAuto = true;
  var Collapse$1 = Collapse;

  function getPaperUtilityClass(slot) {
    return generateUtilityClass('MuiPaper', slot);
  }
  var paperClasses = generateUtilityClasses('MuiPaper', ['root', 'rounded', 'outlined', 'elevation', 'elevation0', 'elevation1', 'elevation2', 'elevation3', 'elevation4', 'elevation5', 'elevation6', 'elevation7', 'elevation8', 'elevation9', 'elevation10', 'elevation11', 'elevation12', 'elevation13', 'elevation14', 'elevation15', 'elevation16', 'elevation17', 'elevation18', 'elevation19', 'elevation20', 'elevation21', 'elevation22', 'elevation23', 'elevation24']);
  var paperClasses$1 = paperClasses;

  var useUtilityClasses$1N = function useUtilityClasses(ownerState) {
    var square = ownerState.square,
      elevation = ownerState.elevation,
      variant = ownerState.variant,
      classes = ownerState.classes;
    var slots = {
      root: ['root', variant, !square && 'rounded', variant === 'elevation' && "elevation".concat(elevation)]
    };
    return composeClasses(slots, getPaperUtilityClass, classes);
  };
  var PaperRoot = styled$1('div', {
    name: 'MuiPaper',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.variant], !ownerState.square && styles.rounded, ownerState.variant === 'elevation' && styles["elevation".concat(ownerState.elevation)]];
    }
  })(function (_ref) {
    var _theme$vars$overlays;
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      backgroundColor: (theme.vars || theme).palette.background.paper,
      color: (theme.vars || theme).palette.text.primary,
      transition: theme.transitions.create('box-shadow')
    }, !ownerState.square && {
      borderRadius: theme.shape.borderRadius
    }, ownerState.variant === 'outlined' && {
      border: "1px solid ".concat((theme.vars || theme).palette.divider)
    }, ownerState.variant === 'elevation' && _extends({
      boxShadow: (theme.vars || theme).shadows[ownerState.elevation]
    }, !theme.vars && theme.palette.mode === 'dark' && {
      backgroundImage: "linear-gradient(".concat(alpha('#fff', getOverlayAlpha$1(ownerState.elevation)), ", ").concat(alpha('#fff', getOverlayAlpha$1(ownerState.elevation)), ")")
    }, theme.vars && {
      backgroundImage: (_theme$vars$overlays = theme.vars.overlays) == null ? void 0 : _theme$vars$overlays[ownerState.elevation]
    }));
  });
  var Paper = /*#__PURE__*/React__namespace.forwardRef(function Paper(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiPaper'
    });
    var className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      _props$elevation = props.elevation,
      elevation = _props$elevation === void 0 ? 1 : _props$elevation,
      _props$square = props.square,
      square = _props$square === void 0 ? false : _props$square,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'elevation' : _props$variant,
      other = _objectWithoutProperties(props, ["className", "component", "elevation", "square", "variant"]);
    var ownerState = _extends({}, props, {
      component: component,
      elevation: elevation,
      square: square,
      variant: variant
    });
    var classes = useUtilityClasses$1N(ownerState);
    {
      // eslint-disable-next-line react-hooks/rules-of-hooks
      var theme = useTheme();
      if (theme.shadows[elevation] === undefined) {
        console.error(["MUI: The elevation provided <Paper elevation={".concat(elevation, "}> is not available in the theme."), "Please make sure that `theme.shadows[".concat(elevation, "]` is defined.")].join('\n'));
      }
    }
    return /*#__PURE__*/jsxRuntimeExports.jsx(PaperRoot, _extends({
      as: component,
      ownerState: ownerState,
      className: clsx(classes.root, className),
      ref: ref
    }, other));
  });
  Paper.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * Shadow depth, corresponds to `dp` in the spec.
     * It accepts values between 0 and 24 inclusive.
     * @default 1
     */
    elevation: chainPropTypes(integerPropType, function (props) {
      var elevation = props.elevation,
        variant = props.variant;
      if (elevation > 0 && variant === 'outlined') {
        return new Error("MUI: Combining `elevation={".concat(elevation, "}` with `variant=\"").concat(variant, "\"` has no effect. Either use `elevation={0}` or use a different `variant`."));
      }
      return null;
    }),
    /**
     * If `true`, rounded corners are disabled.
     * @default false
     */
    square: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The variant to use.
     * @default 'elevation'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['elevation', 'outlined']), PropTypes.string])
  } ;
  var Paper$1 = Paper;

  /**
   * @ignore - internal component.
   * @type {React.Context<{} | {expanded: boolean, disabled: boolean, toggle: () => void}>}
   */
  var AccordionContext = /*#__PURE__*/React__namespace.createContext({});
  {
    AccordionContext.displayName = 'AccordionContext';
  }
  var AccordionContext$1 = AccordionContext;

  /**
   * An internal function to create a Material UI slot.
   *
   * This is an advanced version of Base UI `useSlotProps` because Material UI allows leaf component to be customized via `component` prop
   * while Base UI does not need to support leaf component customization.
   *
   * @param {string} name: name of the slot
   * @param {object} parameters
   * @returns {[Slot, slotProps]} The slot's React component and the slot's props
   *
   * Note: the returned slot's props
   * - will never contain `component` prop.
   * - might contain `as` prop.
   */
  function useSlot(
  /**
   * The slot's name. All Material UI components should have `root` slot.
   *
   * If the name is `root`, the logic behaves differently from other slots,
   * e.g. the `externalForwardedProps` are spread to `root` slot but not other slots.
   */
  name, parameters) {
    var className = parameters.className,
      initialElementType = parameters.elementType,
      ownerState = parameters.ownerState,
      externalForwardedProps = parameters.externalForwardedProps,
      getSlotOwnerState = parameters.getSlotOwnerState,
      internalForwardedProps = parameters.internalForwardedProps,
      useSlotPropsParams = _objectWithoutProperties(parameters, ["className", "elementType", "ownerState", "externalForwardedProps", "getSlotOwnerState", "internalForwardedProps"]);
    var rootComponent = externalForwardedProps.component,
      _externalForwardedPro = externalForwardedProps.slots,
      slots = _externalForwardedPro === void 0 ? _defineProperty({}, name, undefined) : _externalForwardedPro,
      _externalForwardedPro2 = externalForwardedProps.slotProps,
      slotProps = _externalForwardedPro2 === void 0 ? _defineProperty({}, name, undefined) : _externalForwardedPro2,
      other = _objectWithoutProperties(externalForwardedProps, ["component", "slots", "slotProps"]);
    var elementType = slots[name] || initialElementType;

    // `slotProps[name]` can be a callback that receives the component's ownerState.
    // `resolvedComponentsProps` is always a plain object.
    var resolvedComponentsProps = resolveComponentProps(slotProps[name], ownerState);
    var _mergeSlotProps = mergeSlotProps(_extends({
        className: className
      }, useSlotPropsParams, {
        externalForwardedProps: name === 'root' ? other : undefined,
        externalSlotProps: resolvedComponentsProps
      })),
      _mergeSlotProps$props = _mergeSlotProps.props,
      slotComponent = _mergeSlotProps$props.component,
      mergedProps = _objectWithoutProperties(_mergeSlotProps$props, ["component"]),
      internalRef = _mergeSlotProps.internalRef;
    var ref = useForkRef(internalRef, resolvedComponentsProps == null ? void 0 : resolvedComponentsProps.ref, parameters.ref);
    var slotOwnerState = getSlotOwnerState ? getSlotOwnerState(mergedProps) : {};
    var finalOwnerState = _extends({}, ownerState, slotOwnerState);
    var LeafComponent = name === 'root' ? slotComponent || rootComponent : slotComponent;
    var props = appendOwnerState(elementType, _extends({}, name === 'root' && !rootComponent && !slots[name] && internalForwardedProps, name !== 'root' && !slots[name] && internalForwardedProps, mergedProps, LeafComponent && {
      as: LeafComponent
    }, {
      ref: ref
    }), finalOwnerState);
    Object.keys(slotOwnerState).forEach(function (propName) {
      delete props[propName];
    });
    return [elementType, props];
  }

  function getAccordionUtilityClass(slot) {
    return generateUtilityClass('MuiAccordion', slot);
  }
  var accordionClasses = generateUtilityClasses('MuiAccordion', ['root', 'rounded', 'expanded', 'disabled', 'gutters', 'region']);
  var accordionClasses$1 = accordionClasses;

  var useUtilityClasses$1M = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      square = ownerState.square,
      expanded = ownerState.expanded,
      disabled = ownerState.disabled,
      disableGutters = ownerState.disableGutters;
    var slots = {
      root: ['root', !square && 'rounded', expanded && 'expanded', disabled && 'disabled', !disableGutters && 'gutters'],
      region: ['region']
    };
    return composeClasses(slots, getAccordionUtilityClass, classes);
  };
  var AccordionRoot = styled$1(Paper$1, {
    name: 'MuiAccordion',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [_defineProperty({}, "& .".concat(accordionClasses$1.region), styles.region), styles.root, !ownerState.square && styles.rounded, !ownerState.disableGutters && styles.gutters];
    }
  })(function (_ref2) {
    var theme = _ref2.theme;
    var transition = {
      duration: theme.transitions.duration.shortest
    };
    return _defineProperty(_defineProperty({
      position: 'relative',
      transition: theme.transitions.create(['margin'], transition),
      overflowAnchor: 'none',
      // Keep the same scrolling position
      '&::before': {
        position: 'absolute',
        left: 0,
        top: -1,
        right: 0,
        height: 1,
        content: '""',
        opacity: 1,
        backgroundColor: (theme.vars || theme).palette.divider,
        transition: theme.transitions.create(['opacity', 'background-color'], transition)
      },
      '&:first-of-type': {
        '&::before': {
          display: 'none'
        }
      }
    }, "&.".concat(accordionClasses$1.expanded), {
      '&::before': {
        opacity: 0
      },
      '&:first-of-type': {
        marginTop: 0
      },
      '&:last-of-type': {
        marginBottom: 0
      },
      '& + &': {
        '&::before': {
          display: 'none'
        }
      }
    }), "&.".concat(accordionClasses$1.disabled), {
      backgroundColor: (theme.vars || theme).palette.action.disabledBackground
    });
  }, function (_ref4) {
    var theme = _ref4.theme;
    return {
      variants: [{
        props: function props(_props) {
          return !_props.square;
        },
        style: {
          borderRadius: 0,
          '&:first-of-type': {
            borderTopLeftRadius: (theme.vars || theme).shape.borderRadius,
            borderTopRightRadius: (theme.vars || theme).shape.borderRadius
          },
          '&:last-of-type': {
            borderBottomLeftRadius: (theme.vars || theme).shape.borderRadius,
            borderBottomRightRadius: (theme.vars || theme).shape.borderRadius,
            // Fix a rendering issue on Edge
            '@supports (-ms-ime-align: auto)': {
              borderBottomLeftRadius: 0,
              borderBottomRightRadius: 0
            }
          }
        }
      }, {
        props: function props(_props2) {
          return !_props2.disableGutters;
        },
        style: _defineProperty({}, "&.".concat(accordionClasses$1.expanded), {
          margin: '16px 0'
        })
      }]
    };
  });
  var Accordion = /*#__PURE__*/React__namespace.forwardRef(function Accordion(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiAccordion'
    });
    var childrenProp = props.children,
      className = props.className,
      _props$defaultExpande = props.defaultExpanded,
      defaultExpanded = _props$defaultExpande === void 0 ? false : _props$defaultExpande,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$disableGutters = props.disableGutters,
      disableGutters = _props$disableGutters === void 0 ? false : _props$disableGutters,
      expandedProp = props.expanded,
      onChange = props.onChange,
      _props$square = props.square,
      square = _props$square === void 0 ? false : _props$square,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      TransitionComponentProp = props.TransitionComponent,
      TransitionPropsProp = props.TransitionProps,
      other = _objectWithoutProperties(props, ["children", "className", "defaultExpanded", "disabled", "disableGutters", "expanded", "onChange", "square", "slots", "slotProps", "TransitionComponent", "TransitionProps"]);
    var _useControlled = useControlled({
        controlled: expandedProp,
        "default": defaultExpanded,
        name: 'Accordion',
        state: 'expanded'
      }),
      _useControlled2 = _slicedToArray(_useControlled, 2),
      expanded = _useControlled2[0],
      setExpandedState = _useControlled2[1];
    var handleChange = React__namespace.useCallback(function (event) {
      setExpandedState(!expanded);
      if (onChange) {
        onChange(event, !expanded);
      }
    }, [expanded, onChange, setExpandedState]);
    var _React$Children$toArr = React__namespace.Children.toArray(childrenProp),
      _React$Children$toArr2 = _toArray(_React$Children$toArr),
      summary = _React$Children$toArr2[0],
      children = _React$Children$toArr2.slice(1);
    var contextValue = React__namespace.useMemo(function () {
      return {
        expanded: expanded,
        disabled: disabled,
        disableGutters: disableGutters,
        toggle: handleChange
      };
    }, [expanded, disabled, disableGutters, handleChange]);
    var ownerState = _extends({}, props, {
      square: square,
      disabled: disabled,
      disableGutters: disableGutters,
      expanded: expanded
    });
    var classes = useUtilityClasses$1M(ownerState);
    var backwardCompatibleSlots = _extends({
      transition: TransitionComponentProp
    }, slots);
    var backwardCompatibleSlotProps = _extends({
      transition: TransitionPropsProp
    }, slotProps);
    var _useSlot = useSlot('transition', {
        elementType: Collapse$1,
        externalForwardedProps: {
          slots: backwardCompatibleSlots,
          slotProps: backwardCompatibleSlotProps
        },
        ownerState: ownerState
      }),
      _useSlot2 = _slicedToArray(_useSlot, 2),
      TransitionSlot = _useSlot2[0],
      transitionProps = _useSlot2[1];
    return /*#__PURE__*/jsxRuntimeExports.jsxs(AccordionRoot, _extends({
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState,
      square: square
    }, other, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsx(AccordionContext$1.Provider, {
        value: contextValue,
        children: summary
      }), /*#__PURE__*/jsxRuntimeExports.jsx(TransitionSlot, _extends({
        "in": expanded,
        timeout: "auto"
      }, transitionProps, {
        children: /*#__PURE__*/jsxRuntimeExports.jsx("div", {
          "aria-labelledby": summary.props.id,
          id: summary.props['aria-controls'],
          role: "region",
          className: classes.region,
          children: children
        })
      }))]
    }));
  });
  Accordion.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: chainPropTypes(PropTypes.node.isRequired, function (props) {
      var summary = React__namespace.Children.toArray(props.children)[0];
      if (reactIsExports.isFragment(summary)) {
        return new Error("MUI: The Accordion doesn't accept a Fragment as a child. " + 'Consider providing an array instead.');
      }
      if (! /*#__PURE__*/React__namespace.isValidElement(summary)) {
        return new Error('MUI: Expected the first child of Accordion to be a valid element.');
      }
      return null;
    }),
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * If `true`, expands the accordion by default.
     * @default false
     */
    defaultExpanded: PropTypes.bool,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, it removes the margin between two expanded accordion items and the increase of height.
     * @default false
     */
    disableGutters: PropTypes.bool,
    /**
     * If `true`, expands the accordion, otherwise collapse it.
     * Setting this prop enables control over the accordion.
     */
    expanded: PropTypes.bool,
    /**
     * Callback fired when the expand/collapse state is changed.
     *
     * @param {React.SyntheticEvent} event The event source of the callback. **Warning**: This is a generic event not a change event.
     * @param {boolean} expanded The `expanded` state of the accordion.
     */
    onChange: PropTypes.func,
    /**
     * The props used for each slot inside.
     * @default {}
     */
    slotProps: PropTypes.shape({
      transition: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * The components used for each slot inside.
     * @default {}
     */
    slots: PropTypes.shape({
      transition: PropTypes.elementType
    }),
    /**
     * If `true`, rounded corners are disabled.
     * @default false
     */
    square: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The component used for the transition.
     * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
     * @deprecated Use `slots.transition` instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
     */
    TransitionComponent: PropTypes.elementType,
    /**
     * Props applied to the transition element.
     * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
     * @deprecated Use `slotProps.transition` instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
     */
    TransitionProps: PropTypes.object
  } ;
  var Accordion$1 = Accordion;

  function getAccordionActionsUtilityClass(slot) {
    return generateUtilityClass('MuiAccordionActions', slot);
  }
  var accordionActionsClasses = generateUtilityClasses('MuiAccordionActions', ['root', 'spacing']);
  var accordionActionsClasses$1 = accordionActionsClasses;

  var useUtilityClasses$1L = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      disableSpacing = ownerState.disableSpacing;
    var slots = {
      root: ['root', !disableSpacing && 'spacing']
    };
    return composeClasses(slots, getAccordionActionsUtilityClass, classes);
  };
  var AccordionActionsRoot = styled$1('div', {
    name: 'MuiAccordionActions',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, !ownerState.disableSpacing && styles.spacing];
    }
  })({
    display: 'flex',
    alignItems: 'center',
    padding: 8,
    justifyContent: 'flex-end',
    variants: [{
      props: function props(_props) {
        return !_props.disableSpacing;
      },
      style: {
        '& > :not(style) ~ :not(style)': {
          marginLeft: 8
        }
      }
    }]
  });
  var AccordionActions = /*#__PURE__*/React__namespace.forwardRef(function AccordionActions(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiAccordionActions'
    });
    var className = props.className,
      _props$disableSpacing = props.disableSpacing,
      disableSpacing = _props$disableSpacing === void 0 ? false : _props$disableSpacing,
      other = _objectWithoutProperties(props, ["className", "disableSpacing"]);
    var ownerState = _extends({}, props, {
      disableSpacing: disableSpacing
    });
    var classes = useUtilityClasses$1L(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(AccordionActionsRoot, _extends({
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState
    }, other));
  });
  AccordionActions.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * If `true`, the actions do not have additional margin.
     * @default false
     */
    disableSpacing: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var AccordionActions$1 = AccordionActions;

  function getAccordionDetailsUtilityClass(slot) {
    return generateUtilityClass('MuiAccordionDetails', slot);
  }
  var accordionDetailsClasses = generateUtilityClasses('MuiAccordionDetails', ['root']);
  var accordionDetailsClasses$1 = accordionDetailsClasses;

  var useUtilityClasses$1K = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    return composeClasses(slots, getAccordionDetailsUtilityClass, classes);
  };
  var AccordionDetailsRoot = styled$1('div', {
    name: 'MuiAccordionDetails',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })(function (_ref) {
    var theme = _ref.theme;
    return {
      padding: theme.spacing(1, 2, 2)
    };
  });
  var AccordionDetails = /*#__PURE__*/React__namespace.forwardRef(function AccordionDetails(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiAccordionDetails'
    });
    var className = props.className,
      other = _objectWithoutProperties(props, ["className"]);
    var ownerState = props;
    var classes = useUtilityClasses$1K(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(AccordionDetailsRoot, _extends({
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState
    }, other));
  });
  AccordionDetails.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var AccordionDetails$1 = AccordionDetails;

  function _taggedTemplateLiteral(strings, raw) {
    if (!raw) {
      raw = strings.slice(0);
    }
    return Object.freeze(Object.defineProperties(strings, {
      raw: {
        value: Object.freeze(raw)
      }
    }));
  }

  function Ripple(props) {
    var className = props.className,
      classes = props.classes,
      _props$pulsate = props.pulsate,
      pulsate = _props$pulsate === void 0 ? false : _props$pulsate,
      rippleX = props.rippleX,
      rippleY = props.rippleY,
      rippleSize = props.rippleSize,
      inProp = props["in"],
      onExited = props.onExited,
      timeout = props.timeout;
    var _React$useState = React__namespace.useState(false),
      leaving = _React$useState[0],
      setLeaving = _React$useState[1];
    var rippleClassName = clsx(className, classes.ripple, classes.rippleVisible, pulsate && classes.ripplePulsate);
    var rippleStyles = {
      width: rippleSize,
      height: rippleSize,
      top: -(rippleSize / 2) + rippleY,
      left: -(rippleSize / 2) + rippleX
    };
    var childClassName = clsx(classes.child, leaving && classes.childLeaving, pulsate && classes.childPulsate);
    if (!inProp && !leaving) {
      setLeaving(true);
    }
    React__namespace.useEffect(function () {
      if (!inProp && onExited != null) {
        // react-transition-group#onExited
        var timeoutId = setTimeout(onExited, timeout);
        return function () {
          clearTimeout(timeoutId);
        };
      }
      return undefined;
    }, [onExited, inProp, timeout]);
    return /*#__PURE__*/jsxRuntimeExports.jsx("span", {
      className: rippleClassName,
      style: rippleStyles,
      children: /*#__PURE__*/jsxRuntimeExports.jsx("span", {
        className: childClassName
      })
    });
  }
  Ripple.propTypes = {
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object.isRequired,
    className: PropTypes.string,
    /**
     * @ignore - injected from TransitionGroup
     */
    "in": PropTypes.bool,
    /**
     * @ignore - injected from TransitionGroup
     */
    onExited: PropTypes.func,
    /**
     * If `true`, the ripple pulsates, typically indicating the keyboard focus state of an element.
     */
    pulsate: PropTypes.bool,
    /**
     * Diameter of the ripple.
     */
    rippleSize: PropTypes.number,
    /**
     * Horizontal position of the ripple center.
     */
    rippleX: PropTypes.number,
    /**
     * Vertical position of the ripple center.
     */
    rippleY: PropTypes.number,
    /**
     * exit delay
     */
    timeout: PropTypes.number.isRequired
  } ;

  function getTouchRippleUtilityClass(slot) {
    return generateUtilityClass('MuiTouchRipple', slot);
  }
  var touchRippleClasses = generateUtilityClasses('MuiTouchRipple', ['root', 'ripple', 'rippleVisible', 'ripplePulsate', 'child', 'childLeaving', 'childPulsate']);
  var touchRippleClasses$1 = touchRippleClasses;

  var _templateObject$3, _templateObject2$3, _templateObject3$3, _templateObject4$3;
  var DURATION = 550;
  var DELAY_RIPPLE = 80;
  var enterKeyframe = keyframes(_templateObject$3 || (_templateObject$3 = _taggedTemplateLiteral(["\n  0% {\n    transform: scale(0);\n    opacity: 0.1;\n  }\n\n  100% {\n    transform: scale(1);\n    opacity: 0.3;\n  }\n"])));
  var exitKeyframe = keyframes(_templateObject2$3 || (_templateObject2$3 = _taggedTemplateLiteral(["\n  0% {\n    opacity: 1;\n  }\n\n  100% {\n    opacity: 0;\n  }\n"])));
  var pulsateKeyframe = keyframes(_templateObject3$3 || (_templateObject3$3 = _taggedTemplateLiteral(["\n  0% {\n    transform: scale(1);\n  }\n\n  50% {\n    transform: scale(0.92);\n  }\n\n  100% {\n    transform: scale(1);\n  }\n"])));
  var TouchRippleRoot = styled$1('span', {
    name: 'MuiTouchRipple',
    slot: 'Root'
  })({
    overflow: 'hidden',
    pointerEvents: 'none',
    position: 'absolute',
    zIndex: 0,
    top: 0,
    right: 0,
    bottom: 0,
    left: 0,
    borderRadius: 'inherit'
  });

  // This `styled()` function invokes keyframes. `styled-components` only supports keyframes
  // in string templates. Do not convert these styles in JS object as it will break.
  var TouchRippleRipple = styled$1(Ripple, {
    name: 'MuiTouchRipple',
    slot: 'Ripple'
  })(_templateObject4$3 || (_templateObject4$3 = _taggedTemplateLiteral(["\n  opacity: 0;\n  position: absolute;\n\n  &.", " {\n    opacity: 0.3;\n    transform: scale(1);\n    animation-name: ", ";\n    animation-duration: ", "ms;\n    animation-timing-function: ", ";\n  }\n\n  &.", " {\n    animation-duration: ", "ms;\n  }\n\n  & .", " {\n    opacity: 1;\n    display: block;\n    width: 100%;\n    height: 100%;\n    border-radius: 50%;\n    background-color: currentColor;\n  }\n\n  & .", " {\n    opacity: 0;\n    animation-name: ", ";\n    animation-duration: ", "ms;\n    animation-timing-function: ", ";\n  }\n\n  & .", " {\n    position: absolute;\n    /* @noflip */\n    left: 0px;\n    top: 0;\n    animation-name: ", ";\n    animation-duration: 2500ms;\n    animation-timing-function: ", ";\n    animation-iteration-count: infinite;\n    animation-delay: 200ms;\n  }\n"])), touchRippleClasses$1.rippleVisible, enterKeyframe, DURATION, function (_ref) {
    var theme = _ref.theme;
    return theme.transitions.easing.easeInOut;
  }, touchRippleClasses$1.ripplePulsate, function (_ref2) {
    var theme = _ref2.theme;
    return theme.transitions.duration.shorter;
  }, touchRippleClasses$1.child, touchRippleClasses$1.childLeaving, exitKeyframe, DURATION, function (_ref3) {
    var theme = _ref3.theme;
    return theme.transitions.easing.easeInOut;
  }, touchRippleClasses$1.childPulsate, pulsateKeyframe, function (_ref4) {
    var theme = _ref4.theme;
    return theme.transitions.easing.easeInOut;
  });

  /**
   * @ignore - internal component.
   *
   * TODO v5: Make private
   */
  var TouchRipple = /*#__PURE__*/React__namespace.forwardRef(function TouchRipple(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTouchRipple'
    });
    var _props$center = props.center,
      centerProp = _props$center === void 0 ? false : _props$center,
      _props$classes = props.classes,
      classes = _props$classes === void 0 ? {} : _props$classes,
      className = props.className,
      other = _objectWithoutProperties(props, ["center", "classes", "className"]);
    var _React$useState = React__namespace.useState([]),
      ripples = _React$useState[0],
      setRipples = _React$useState[1];
    var nextKey = React__namespace.useRef(0);
    var rippleCallback = React__namespace.useRef(null);
    React__namespace.useEffect(function () {
      if (rippleCallback.current) {
        rippleCallback.current();
        rippleCallback.current = null;
      }
    }, [ripples]);

    // Used to filter out mouse emulated events on mobile.
    var ignoringMouseDown = React__namespace.useRef(false);
    // We use a timer in order to only show the ripples for touch "click" like events.
    // We don't want to display the ripple for touch scroll events.
    var startTimer = useTimeout();

    // This is the hook called once the previous timeout is ready.
    var startTimerCommit = React__namespace.useRef(null);
    var container = React__namespace.useRef(null);
    var startCommit = React__namespace.useCallback(function (params) {
      var pulsate = params.pulsate,
        rippleX = params.rippleX,
        rippleY = params.rippleY,
        rippleSize = params.rippleSize,
        cb = params.cb;
      setRipples(function (oldRipples) {
        return [].concat(_toConsumableArray(oldRipples), [/*#__PURE__*/jsxRuntimeExports.jsx(TouchRippleRipple, {
          classes: {
            ripple: clsx(classes.ripple, touchRippleClasses$1.ripple),
            rippleVisible: clsx(classes.rippleVisible, touchRippleClasses$1.rippleVisible),
            ripplePulsate: clsx(classes.ripplePulsate, touchRippleClasses$1.ripplePulsate),
            child: clsx(classes.child, touchRippleClasses$1.child),
            childLeaving: clsx(classes.childLeaving, touchRippleClasses$1.childLeaving),
            childPulsate: clsx(classes.childPulsate, touchRippleClasses$1.childPulsate)
          },
          timeout: DURATION,
          pulsate: pulsate,
          rippleX: rippleX,
          rippleY: rippleY,
          rippleSize: rippleSize
        }, nextKey.current)]);
      });
      nextKey.current += 1;
      rippleCallback.current = cb;
    }, [classes]);
    var start = React__namespace.useCallback(function () {
      var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var cb = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};
      var _options$pulsate = options.pulsate,
        pulsate = _options$pulsate === void 0 ? false : _options$pulsate,
        _options$center = options.center,
        center = _options$center === void 0 ? centerProp || options.pulsate : _options$center,
        _options$fakeElement = options.fakeElement,
        fakeElement = _options$fakeElement === void 0 ? false : _options$fakeElement;
      if ((event == null ? void 0 : event.type) === 'mousedown' && ignoringMouseDown.current) {
        ignoringMouseDown.current = false;
        return;
      }
      if ((event == null ? void 0 : event.type) === 'touchstart') {
        ignoringMouseDown.current = true;
      }
      var element = fakeElement ? null : container.current;
      var rect = element ? element.getBoundingClientRect() : {
        width: 0,
        height: 0,
        left: 0,
        top: 0
      };

      // Get the size of the ripple
      var rippleX;
      var rippleY;
      var rippleSize;
      if (center || event === undefined || event.clientX === 0 && event.clientY === 0 || !event.clientX && !event.touches) {
        rippleX = Math.round(rect.width / 2);
        rippleY = Math.round(rect.height / 2);
      } else {
        var _ref5 = event.touches && event.touches.length > 0 ? event.touches[0] : event,
          clientX = _ref5.clientX,
          clientY = _ref5.clientY;
        rippleX = Math.round(clientX - rect.left);
        rippleY = Math.round(clientY - rect.top);
      }
      if (center) {
        rippleSize = Math.sqrt((2 * Math.pow(rect.width, 2) + Math.pow(rect.height, 2)) / 3);

        // For some reason the animation is broken on Mobile Chrome if the size is even.
        if (rippleSize % 2 === 0) {
          rippleSize += 1;
        }
      } else {
        var sizeX = Math.max(Math.abs((element ? element.clientWidth : 0) - rippleX), rippleX) * 2 + 2;
        var sizeY = Math.max(Math.abs((element ? element.clientHeight : 0) - rippleY), rippleY) * 2 + 2;
        rippleSize = Math.sqrt(Math.pow(sizeX, 2) + Math.pow(sizeY, 2));
      }

      // Touche devices
      if (event != null && event.touches) {
        // check that this isn't another touchstart due to multitouch
        // otherwise we will only clear a single timer when unmounting while two
        // are running
        if (startTimerCommit.current === null) {
          // Prepare the ripple effect.
          startTimerCommit.current = function () {
            startCommit({
              pulsate: pulsate,
              rippleX: rippleX,
              rippleY: rippleY,
              rippleSize: rippleSize,
              cb: cb
            });
          };
          // Delay the execution of the ripple effect.
          // We have to make a tradeoff with this delay value.
          startTimer.start(DELAY_RIPPLE, function () {
            if (startTimerCommit.current) {
              startTimerCommit.current();
              startTimerCommit.current = null;
            }
          });
        }
      } else {
        startCommit({
          pulsate: pulsate,
          rippleX: rippleX,
          rippleY: rippleY,
          rippleSize: rippleSize,
          cb: cb
        });
      }
    }, [centerProp, startCommit, startTimer]);
    var pulsate = React__namespace.useCallback(function () {
      start({}, {
        pulsate: true
      });
    }, [start]);
    var stop = React__namespace.useCallback(function (event, cb) {
      startTimer.clear();

      // The touch interaction occurs too quickly.
      // We still want to show ripple effect.
      if ((event == null ? void 0 : event.type) === 'touchend' && startTimerCommit.current) {
        startTimerCommit.current();
        startTimerCommit.current = null;
        startTimer.start(0, function () {
          stop(event, cb);
        });
        return;
      }
      startTimerCommit.current = null;
      setRipples(function (oldRipples) {
        if (oldRipples.length > 0) {
          return oldRipples.slice(1);
        }
        return oldRipples;
      });
      rippleCallback.current = cb;
    }, [startTimer]);
    React__namespace.useImperativeHandle(ref, function () {
      return {
        pulsate: pulsate,
        start: start,
        stop: stop
      };
    }, [pulsate, start, stop]);
    return /*#__PURE__*/jsxRuntimeExports.jsx(TouchRippleRoot, _extends({
      className: clsx(touchRippleClasses$1.root, classes.root, className),
      ref: container
    }, other, {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(TransitionGroup$1, {
        component: null,
        exit: true,
        children: ripples
      })
    }));
  });
  TouchRipple.propTypes = {
    /**
     * If `true`, the ripple starts at the center of the component
     * rather than at the point of interaction.
     */
    center: PropTypes.bool,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string
  } ;
  var TouchRipple$1 = TouchRipple;

  function getButtonBaseUtilityClass(slot) {
    return generateUtilityClass('MuiButtonBase', slot);
  }
  var buttonBaseClasses = generateUtilityClasses('MuiButtonBase', ['root', 'disabled', 'focusVisible']);
  var buttonBaseClasses$1 = buttonBaseClasses;

  var useUtilityClasses$1J = function useUtilityClasses(ownerState) {
    var disabled = ownerState.disabled,
      focusVisible = ownerState.focusVisible,
      focusVisibleClassName = ownerState.focusVisibleClassName,
      classes = ownerState.classes;
    var slots = {
      root: ['root', disabled && 'disabled', focusVisible && 'focusVisible']
    };
    var composedClasses = composeClasses(slots, getButtonBaseUtilityClass, classes);
    if (focusVisible && focusVisibleClassName) {
      composedClasses.root += " ".concat(focusVisibleClassName);
    }
    return composedClasses;
  };
  var ButtonBaseRoot = styled$1('button', {
    name: 'MuiButtonBase',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })(_defineProperty(_defineProperty({
    display: 'inline-flex',
    alignItems: 'center',
    justifyContent: 'center',
    position: 'relative',
    boxSizing: 'border-box',
    WebkitTapHighlightColor: 'transparent',
    backgroundColor: 'transparent',
    // Reset default value
    // We disable the focus ring for mouse, touch and keyboard users.
    outline: 0,
    border: 0,
    margin: 0,
    // Remove the margin in Safari
    borderRadius: 0,
    padding: 0,
    // Remove the padding in Firefox
    cursor: 'pointer',
    userSelect: 'none',
    verticalAlign: 'middle',
    MozAppearance: 'none',
    // Reset
    WebkitAppearance: 'none',
    // Reset
    textDecoration: 'none',
    // So we take precedent over the style of a native <a /> element.
    color: 'inherit',
    '&::-moz-focus-inner': {
      borderStyle: 'none' // Remove Firefox dotted outline.
    }
  }, "&.".concat(buttonBaseClasses$1.disabled), {
    pointerEvents: 'none',
    // Disable link interactions
    cursor: 'default'
  }), '@media print', {
    colorAdjust: 'exact'
  }));

  /**
   * `ButtonBase` contains as few styles as possible.
   * It aims to be a simple building block for creating a button.
   * It contains a load of style reset and some focus/ripple logic.
   */
  var ButtonBase = /*#__PURE__*/React__namespace.forwardRef(function ButtonBase(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiButtonBase'
    });
    var action = props.action,
      _props$centerRipple = props.centerRipple,
      centerRipple = _props$centerRipple === void 0 ? false : _props$centerRipple,
      children = props.children,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'button' : _props$component,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$disableRipple = props.disableRipple,
      disableRipple = _props$disableRipple === void 0 ? false : _props$disableRipple,
      _props$disableTouchRi = props.disableTouchRipple,
      disableTouchRipple = _props$disableTouchRi === void 0 ? false : _props$disableTouchRi,
      _props$focusRipple = props.focusRipple,
      focusRipple = _props$focusRipple === void 0 ? false : _props$focusRipple;
      props.focusVisibleClassName;
      var _props$LinkComponent = props.LinkComponent,
      LinkComponent = _props$LinkComponent === void 0 ? 'a' : _props$LinkComponent,
      onBlur = props.onBlur,
      onClick = props.onClick,
      onContextMenu = props.onContextMenu,
      onDragLeave = props.onDragLeave,
      onFocus = props.onFocus,
      onFocusVisible = props.onFocusVisible,
      onKeyDown = props.onKeyDown,
      onKeyUp = props.onKeyUp,
      onMouseDown = props.onMouseDown,
      onMouseLeave = props.onMouseLeave,
      onMouseUp = props.onMouseUp,
      onTouchEnd = props.onTouchEnd,
      onTouchMove = props.onTouchMove,
      onTouchStart = props.onTouchStart,
      _props$tabIndex = props.tabIndex,
      tabIndex = _props$tabIndex === void 0 ? 0 : _props$tabIndex,
      TouchRippleProps = props.TouchRippleProps,
      touchRippleRef = props.touchRippleRef,
      type = props.type,
      other = _objectWithoutProperties(props, ["action", "centerRipple", "children", "className", "component", "disabled", "disableRipple", "disableTouchRipple", "focusRipple", "focusVisibleClassName", "LinkComponent", "onBlur", "onClick", "onContextMenu", "onDragLeave", "onFocus", "onFocusVisible", "onKeyDown", "onKeyUp", "onMouseDown", "onMouseLeave", "onMouseUp", "onTouchEnd", "onTouchMove", "onTouchStart", "tabIndex", "TouchRippleProps", "touchRippleRef", "type"]);
    var buttonRef = React__namespace.useRef(null);
    var rippleRef = React__namespace.useRef(null);
    var handleRippleRef = useForkRef(rippleRef, touchRippleRef);
    var _useIsFocusVisible = useIsFocusVisible(),
      isFocusVisibleRef = _useIsFocusVisible.isFocusVisibleRef,
      handleFocusVisible = _useIsFocusVisible.onFocus,
      handleBlurVisible = _useIsFocusVisible.onBlur,
      focusVisibleRef = _useIsFocusVisible.ref;
    var _React$useState = React__namespace.useState(false),
      focusVisible = _React$useState[0],
      setFocusVisible = _React$useState[1];
    if (disabled && focusVisible) {
      setFocusVisible(false);
    }
    React__namespace.useImperativeHandle(action, function () {
      return {
        focusVisible: function focusVisible() {
          setFocusVisible(true);
          buttonRef.current.focus();
        }
      };
    }, []);
    var _React$useState2 = React__namespace.useState(false),
      mountedState = _React$useState2[0],
      setMountedState = _React$useState2[1];
    React__namespace.useEffect(function () {
      setMountedState(true);
    }, []);
    var enableTouchRipple = mountedState && !disableRipple && !disabled;
    React__namespace.useEffect(function () {
      if (focusVisible && focusRipple && !disableRipple && mountedState) {
        rippleRef.current.pulsate();
      }
    }, [disableRipple, focusRipple, focusVisible, mountedState]);
    function useRippleHandler(rippleAction, eventCallback) {
      var skipRippleAction = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : disableTouchRipple;
      return useEventCallback(function (event) {
        if (eventCallback) {
          eventCallback(event);
        }
        var ignore = skipRippleAction;
        if (!ignore && rippleRef.current) {
          rippleRef.current[rippleAction](event);
        }
        return true;
      });
    }
    var handleMouseDown = useRippleHandler('start', onMouseDown);
    var handleContextMenu = useRippleHandler('stop', onContextMenu);
    var handleDragLeave = useRippleHandler('stop', onDragLeave);
    var handleMouseUp = useRippleHandler('stop', onMouseUp);
    var handleMouseLeave = useRippleHandler('stop', function (event) {
      if (focusVisible) {
        event.preventDefault();
      }
      if (onMouseLeave) {
        onMouseLeave(event);
      }
    });
    var handleTouchStart = useRippleHandler('start', onTouchStart);
    var handleTouchEnd = useRippleHandler('stop', onTouchEnd);
    var handleTouchMove = useRippleHandler('stop', onTouchMove);
    var handleBlur = useRippleHandler('stop', function (event) {
      handleBlurVisible(event);
      if (isFocusVisibleRef.current === false) {
        setFocusVisible(false);
      }
      if (onBlur) {
        onBlur(event);
      }
    }, false);
    var handleFocus = useEventCallback(function (event) {
      // Fix for https://github.com/facebook/react/issues/7769
      if (!buttonRef.current) {
        buttonRef.current = event.currentTarget;
      }
      handleFocusVisible(event);
      if (isFocusVisibleRef.current === true) {
        setFocusVisible(true);
        if (onFocusVisible) {
          onFocusVisible(event);
        }
      }
      if (onFocus) {
        onFocus(event);
      }
    });
    var isNonNativeButton = function isNonNativeButton() {
      var button = buttonRef.current;
      return component && component !== 'button' && !(button.tagName === 'A' && button.href);
    };

    /**
     * IE11 shim for https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/repeat
     */
    var keydownRef = React__namespace.useRef(false);
    var handleKeyDown = useEventCallback(function (event) {
      // Check if key is already down to avoid repeats being counted as multiple activations
      if (focusRipple && !keydownRef.current && focusVisible && rippleRef.current && event.key === ' ') {
        keydownRef.current = true;
        rippleRef.current.stop(event, function () {
          rippleRef.current.start(event);
        });
      }
      if (event.target === event.currentTarget && isNonNativeButton() && event.key === ' ') {
        event.preventDefault();
      }
      if (onKeyDown) {
        onKeyDown(event);
      }

      // Keyboard accessibility for non interactive elements
      if (event.target === event.currentTarget && isNonNativeButton() && event.key === 'Enter' && !disabled) {
        event.preventDefault();
        if (onClick) {
          onClick(event);
        }
      }
    });
    var handleKeyUp = useEventCallback(function (event) {
      // calling preventDefault in keyUp on a <button> will not dispatch a click event if Space is pressed
      // https://codesandbox.io/p/sandbox/button-keyup-preventdefault-dn7f0
      if (focusRipple && event.key === ' ' && rippleRef.current && focusVisible && !event.defaultPrevented) {
        keydownRef.current = false;
        rippleRef.current.stop(event, function () {
          rippleRef.current.pulsate(event);
        });
      }
      if (onKeyUp) {
        onKeyUp(event);
      }

      // Keyboard accessibility for non interactive elements
      if (onClick && event.target === event.currentTarget && isNonNativeButton() && event.key === ' ' && !event.defaultPrevented) {
        onClick(event);
      }
    });
    var ComponentProp = component;
    if (ComponentProp === 'button' && (other.href || other.to)) {
      ComponentProp = LinkComponent;
    }
    var buttonProps = {};
    if (ComponentProp === 'button') {
      buttonProps.type = type === undefined ? 'button' : type;
      buttonProps.disabled = disabled;
    } else {
      if (!other.href && !other.to) {
        buttonProps.role = 'button';
      }
      if (disabled) {
        buttonProps['aria-disabled'] = disabled;
      }
    }
    var handleRef = useForkRef(ref, focusVisibleRef, buttonRef);
    {
      // eslint-disable-next-line react-hooks/rules-of-hooks
      React__namespace.useEffect(function () {
        if (enableTouchRipple && !rippleRef.current) {
          console.error(['MUI: The `component` prop provided to ButtonBase is invalid.', 'Please make sure the children prop is rendered in this custom component.'].join('\n'));
        }
      }, [enableTouchRipple]);
    }
    var ownerState = _extends({}, props, {
      centerRipple: centerRipple,
      component: component,
      disabled: disabled,
      disableRipple: disableRipple,
      disableTouchRipple: disableTouchRipple,
      focusRipple: focusRipple,
      tabIndex: tabIndex,
      focusVisible: focusVisible
    });
    var classes = useUtilityClasses$1J(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(ButtonBaseRoot, _extends({
      as: ComponentProp,
      className: clsx(classes.root, className),
      ownerState: ownerState,
      onBlur: handleBlur,
      onClick: onClick,
      onContextMenu: handleContextMenu,
      onFocus: handleFocus,
      onKeyDown: handleKeyDown,
      onKeyUp: handleKeyUp,
      onMouseDown: handleMouseDown,
      onMouseLeave: handleMouseLeave,
      onMouseUp: handleMouseUp,
      onDragLeave: handleDragLeave,
      onTouchEnd: handleTouchEnd,
      onTouchMove: handleTouchMove,
      onTouchStart: handleTouchStart,
      ref: handleRef,
      tabIndex: disabled ? -1 : tabIndex,
      type: type
    }, buttonProps, other, {
      children: [children, enableTouchRipple ?
      /*#__PURE__*/
      /* TouchRipple is only needed client-side, x2 boost on the server. */
      jsxRuntimeExports.jsx(TouchRipple$1, _extends({
        ref: handleRippleRef,
        center: centerRipple
      }, TouchRippleProps)) : null]
    }));
  });
  ButtonBase.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * A ref for imperative actions.
     * It currently only supports `focusVisible()` action.
     */
    action: refType$1,
    /**
     * If `true`, the ripples are centered.
     * They won't start at the cursor interaction position.
     * @default false
     */
    centerRipple: PropTypes.bool,
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: elementTypeAcceptingRef$1,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the ripple effect is disabled.
     *
     * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
     * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
     * @default false
     */
    disableRipple: PropTypes.bool,
    /**
     * If `true`, the touch ripple effect is disabled.
     * @default false
     */
    disableTouchRipple: PropTypes.bool,
    /**
     * If `true`, the base button will have a keyboard focus ripple.
     * @default false
     */
    focusRipple: PropTypes.bool,
    /**
     * This prop can help identify which element has keyboard focus.
     * The class name will be applied when the element gains the focus through keyboard interaction.
     * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
     * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
     * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
     * if needed.
     */
    focusVisibleClassName: PropTypes.string,
    /**
     * @ignore
     */
    href: PropTypes /* @typescript-to-proptypes-ignore */.any,
    /**
     * The component used to render a link when the `href` prop is provided.
     * @default 'a'
     */
    LinkComponent: PropTypes.elementType,
    /**
     * @ignore
     */
    onBlur: PropTypes.func,
    /**
     * @ignore
     */
    onClick: PropTypes.func,
    /**
     * @ignore
     */
    onContextMenu: PropTypes.func,
    /**
     * @ignore
     */
    onDragLeave: PropTypes.func,
    /**
     * @ignore
     */
    onFocus: PropTypes.func,
    /**
     * Callback fired when the component is focused with a keyboard.
     * We trigger a `onFocus` callback too.
     */
    onFocusVisible: PropTypes.func,
    /**
     * @ignore
     */
    onKeyDown: PropTypes.func,
    /**
     * @ignore
     */
    onKeyUp: PropTypes.func,
    /**
     * @ignore
     */
    onMouseDown: PropTypes.func,
    /**
     * @ignore
     */
    onMouseLeave: PropTypes.func,
    /**
     * @ignore
     */
    onMouseUp: PropTypes.func,
    /**
     * @ignore
     */
    onTouchEnd: PropTypes.func,
    /**
     * @ignore
     */
    onTouchMove: PropTypes.func,
    /**
     * @ignore
     */
    onTouchStart: PropTypes.func,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * @default 0
     */
    tabIndex: PropTypes.number,
    /**
     * Props applied to the `TouchRipple` element.
     */
    TouchRippleProps: PropTypes.object,
    /**
     * A ref that points to the `TouchRipple` element.
     */
    touchRippleRef: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
      current: PropTypes.shape({
        pulsate: PropTypes.func.isRequired,
        start: PropTypes.func.isRequired,
        stop: PropTypes.func.isRequired
      })
    })]),
    /**
     * @ignore
     */
    type: PropTypes.oneOfType([PropTypes.oneOf(['button', 'reset', 'submit']), PropTypes.string])
  } ;
  var ButtonBase$1 = ButtonBase;

  function getAccordionSummaryUtilityClass(slot) {
    return generateUtilityClass('MuiAccordionSummary', slot);
  }
  var accordionSummaryClasses = generateUtilityClasses('MuiAccordionSummary', ['root', 'expanded', 'focusVisible', 'disabled', 'gutters', 'contentGutters', 'content', 'expandIconWrapper']);
  var accordionSummaryClasses$1 = accordionSummaryClasses;

  var useUtilityClasses$1I = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      expanded = ownerState.expanded,
      disabled = ownerState.disabled,
      disableGutters = ownerState.disableGutters;
    var slots = {
      root: ['root', expanded && 'expanded', disabled && 'disabled', !disableGutters && 'gutters'],
      focusVisible: ['focusVisible'],
      content: ['content', expanded && 'expanded', !disableGutters && 'contentGutters'],
      expandIconWrapper: ['expandIconWrapper', expanded && 'expanded']
    };
    return composeClasses(slots, getAccordionSummaryUtilityClass, classes);
  };
  var AccordionSummaryRoot = styled$1(ButtonBase$1, {
    name: 'MuiAccordionSummary',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })(function (_ref) {
    var theme = _ref.theme;
    var transition = {
      duration: theme.transitions.duration.shortest
    };
    return _defineProperty(_defineProperty(_defineProperty(_defineProperty({
      display: 'flex',
      minHeight: 48,
      padding: theme.spacing(0, 2),
      transition: theme.transitions.create(['min-height', 'background-color'], transition)
    }, "&.".concat(accordionSummaryClasses$1.focusVisible), {
      backgroundColor: (theme.vars || theme).palette.action.focus
    }), "&.".concat(accordionSummaryClasses$1.disabled), {
      opacity: (theme.vars || theme).palette.action.disabledOpacity
    }), "&:hover:not(.".concat(accordionSummaryClasses$1.disabled, ")"), {
      cursor: 'pointer'
    }), "variants", [{
      props: function props(_props) {
        return !_props.disableGutters;
      },
      style: _defineProperty({}, "&.".concat(accordionSummaryClasses$1.expanded), {
        minHeight: 64
      })
    }]);
  });
  var AccordionSummaryContent = styled$1('div', {
    name: 'MuiAccordionSummary',
    slot: 'Content',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.content;
    }
  })(function (_ref3) {
    var theme = _ref3.theme;
    return {
      display: 'flex',
      flexGrow: 1,
      margin: '12px 0',
      variants: [{
        props: function props(_props2) {
          return !_props2.disableGutters;
        },
        style: _defineProperty({
          transition: theme.transitions.create(['margin'], {
            duration: theme.transitions.duration.shortest
          })
        }, "&.".concat(accordionSummaryClasses$1.expanded), {
          margin: '20px 0'
        })
      }]
    };
  });
  var AccordionSummaryExpandIconWrapper = styled$1('div', {
    name: 'MuiAccordionSummary',
    slot: 'ExpandIconWrapper',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.expandIconWrapper;
    }
  })(function (_ref4) {
    var theme = _ref4.theme;
    return _defineProperty({
      display: 'flex',
      color: (theme.vars || theme).palette.action.active,
      transform: 'rotate(0deg)',
      transition: theme.transitions.create('transform', {
        duration: theme.transitions.duration.shortest
      })
    }, "&.".concat(accordionSummaryClasses$1.expanded), {
      transform: 'rotate(180deg)'
    });
  });
  var AccordionSummary = /*#__PURE__*/React__namespace.forwardRef(function AccordionSummary(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiAccordionSummary'
    });
    var children = props.children,
      className = props.className,
      expandIcon = props.expandIcon,
      focusVisibleClassName = props.focusVisibleClassName,
      onClick = props.onClick,
      other = _objectWithoutProperties(props, ["children", "className", "expandIcon", "focusVisibleClassName", "onClick"]);
    var _React$useContext = React__namespace.useContext(AccordionContext$1),
      _React$useContext$dis = _React$useContext.disabled,
      disabled = _React$useContext$dis === void 0 ? false : _React$useContext$dis,
      disableGutters = _React$useContext.disableGutters,
      expanded = _React$useContext.expanded,
      toggle = _React$useContext.toggle;
    var handleChange = function handleChange(event) {
      if (toggle) {
        toggle(event);
      }
      if (onClick) {
        onClick(event);
      }
    };
    var ownerState = _extends({}, props, {
      expanded: expanded,
      disabled: disabled,
      disableGutters: disableGutters
    });
    var classes = useUtilityClasses$1I(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(AccordionSummaryRoot, _extends({
      focusRipple: false,
      disableRipple: true,
      disabled: disabled,
      component: "div",
      "aria-expanded": expanded,
      className: clsx(classes.root, className),
      focusVisibleClassName: clsx(classes.focusVisible, focusVisibleClassName),
      onClick: handleChange,
      ref: ref,
      ownerState: ownerState
    }, other, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsx(AccordionSummaryContent, {
        className: classes.content,
        ownerState: ownerState,
        children: children
      }), expandIcon && /*#__PURE__*/jsxRuntimeExports.jsx(AccordionSummaryExpandIconWrapper, {
        className: classes.expandIconWrapper,
        ownerState: ownerState,
        children: expandIcon
      })]
    }));
  });
  AccordionSummary.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The icon to display as the expand indicator.
     */
    expandIcon: PropTypes.node,
    /**
     * This prop can help identify which element has keyboard focus.
     * The class name will be applied when the element gains the focus through keyboard interaction.
     * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
     * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
     * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
     * if needed.
     */
    focusVisibleClassName: PropTypes.string,
    /**
     * @ignore
     */
    onClick: PropTypes.func,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var AccordionSummary$1 = AccordionSummary;

  function getAlertUtilityClass(slot) {
    return generateUtilityClass('MuiAlert', slot);
  }
  var alertClasses = generateUtilityClasses('MuiAlert', ['root', 'action', 'icon', 'message', 'filled', 'colorSuccess', 'colorInfo', 'colorWarning', 'colorError', 'filledSuccess', 'filledInfo', 'filledWarning', 'filledError', 'outlined', 'outlinedSuccess', 'outlinedInfo', 'outlinedWarning', 'outlinedError', 'standard', 'standardSuccess', 'standardInfo', 'standardWarning', 'standardError']);
  var alertClasses$1 = alertClasses;

  function getIconButtonUtilityClass(slot) {
    return generateUtilityClass('MuiIconButton', slot);
  }
  var iconButtonClasses = generateUtilityClasses('MuiIconButton', ['root', 'disabled', 'colorInherit', 'colorPrimary', 'colorSecondary', 'colorError', 'colorInfo', 'colorSuccess', 'colorWarning', 'edgeStart', 'edgeEnd', 'sizeSmall', 'sizeMedium', 'sizeLarge']);
  var iconButtonClasses$1 = iconButtonClasses;

  var useUtilityClasses$1H = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      disabled = ownerState.disabled,
      color = ownerState.color,
      edge = ownerState.edge,
      size = ownerState.size;
    var slots = {
      root: ['root', disabled && 'disabled', color !== 'default' && "color".concat(capitalize(color)), edge && "edge".concat(capitalize(edge)), "size".concat(capitalize(size))]
    };
    return composeClasses(slots, getIconButtonUtilityClass, classes);
  };
  var IconButtonRoot = styled$1(ButtonBase$1, {
    name: 'MuiIconButton',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.color !== 'default' && styles["color".concat(capitalize(ownerState.color))], ownerState.edge && styles["edge".concat(capitalize(ownerState.edge))], styles["size".concat(capitalize(ownerState.size))]];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      textAlign: 'center',
      flex: '0 0 auto',
      fontSize: theme.typography.pxToRem(24),
      padding: 8,
      borderRadius: '50%',
      overflow: 'visible',
      // Explicitly set the default value to solve a bug on IE11.
      color: (theme.vars || theme).palette.action.active,
      transition: theme.transitions.create('background-color', {
        duration: theme.transitions.duration.shortest
      })
    }, !ownerState.disableRipple && {
      '&:hover': {
        backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.action.activeChannel, " / ").concat(theme.vars.palette.action.hoverOpacity, ")") : alpha(theme.palette.action.active, theme.palette.action.hoverOpacity),
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: 'transparent'
        }
      }
    }, ownerState.edge === 'start' && {
      marginLeft: ownerState.size === 'small' ? -3 : -12
    }, ownerState.edge === 'end' && {
      marginRight: ownerState.size === 'small' ? -3 : -12
    });
  }, function (_ref2) {
    var _palette;
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    var palette = (_palette = (theme.vars || theme).palette) == null ? void 0 : _palette[ownerState.color];
    return _extends({}, ownerState.color === 'inherit' && {
      color: 'inherit'
    }, ownerState.color !== 'inherit' && ownerState.color !== 'default' && _extends({
      color: palette == null ? void 0 : palette.main
    }, !ownerState.disableRipple && {
      '&:hover': _extends({}, palette && {
        backgroundColor: theme.vars ? "rgba(".concat(palette.mainChannel, " / ").concat(theme.vars.palette.action.hoverOpacity, ")") : alpha(palette.main, theme.palette.action.hoverOpacity)
      }, {
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: 'transparent'
        }
      })
    }), ownerState.size === 'small' && {
      padding: 5,
      fontSize: theme.typography.pxToRem(18)
    }, ownerState.size === 'large' && {
      padding: 12,
      fontSize: theme.typography.pxToRem(28)
    }, _defineProperty({}, "&.".concat(iconButtonClasses$1.disabled), {
      backgroundColor: 'transparent',
      color: (theme.vars || theme).palette.action.disabled
    }));
  });

  /**
   * Refer to the [Icons](/material-ui/icons/) section of the documentation
   * regarding the available icon options.
   */
  var IconButton = /*#__PURE__*/React__namespace.forwardRef(function IconButton(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiIconButton'
    });
    var _props$edge = props.edge,
      edge = _props$edge === void 0 ? false : _props$edge,
      children = props.children,
      className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'default' : _props$color,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$disableFocusRi = props.disableFocusRipple,
      disableFocusRipple = _props$disableFocusRi === void 0 ? false : _props$disableFocusRi,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      other = _objectWithoutProperties(props, ["edge", "children", "className", "color", "disabled", "disableFocusRipple", "size"]);
    var ownerState = _extends({}, props, {
      edge: edge,
      color: color,
      disabled: disabled,
      disableFocusRipple: disableFocusRipple,
      size: size
    });
    var classes = useUtilityClasses$1H(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(IconButtonRoot, _extends({
      className: clsx(classes.root, className),
      centerRipple: true,
      focusRipple: !disableFocusRipple,
      disabled: disabled,
      ref: ref
    }, other, {
      ownerState: ownerState,
      children: children
    }));
  });
  IconButton.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The icon to display.
     */
    children: chainPropTypes(PropTypes.node, function (props) {
      var found = React__namespace.Children.toArray(props.children).some(function (child) {
        return /*#__PURE__*/React__namespace.isValidElement(child) && child.props.onClick;
      });
      if (found) {
        return new Error(['MUI: You are providing an onClick event listener to a child of a button element.', 'Prefer applying it to the IconButton directly.', 'This guarantees that the whole <button> will be responsive to click events.'].join('\n'));
      }
      return null;
    }),
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'default'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['inherit', 'default', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the  keyboard focus ripple is disabled.
     * @default false
     */
    disableFocusRipple: PropTypes.bool,
    /**
     * If `true`, the ripple effect is disabled.
     *
     * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
     * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
     * @default false
     */
    disableRipple: PropTypes.bool,
    /**
     * If given, uses a negative margin to counteract the padding on one
     * side (this is often helpful for aligning the left or right
     * side of the icon with content above or below, without ruining the border
     * size and shape).
     * @default false
     */
    edge: PropTypes.oneOf(['end', 'start', false]),
    /**
     * The size of the component.
     * `small` is equivalent to the dense button styling.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['small', 'medium', 'large']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var IconButton$1 = IconButton;

  var SuccessOutlinedIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M20,12A8,8 0 0,1 12,20A8,8 0 0,1 4,12A8,8 0 0,1 12,4C12.76,4 13.5,4.11 14.2, 4.31L15.77,2.74C14.61,2.26 13.34,2 12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0, 0 22,12M7.91,10.08L6.5,11.5L11,16L21,6L19.59,4.58L11,13.17L7.91,10.08Z"
  }), 'SuccessOutlined');

  var ReportProblemOutlinedIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M12 5.99L19.53 19H4.47L12 5.99M12 2L1 21h22L12 2zm1 14h-2v2h2v-2zm0-6h-2v4h2v-4z"
  }), 'ReportProblemOutlined');

  var ErrorOutlineIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M11 15h2v2h-2zm0-8h2v6h-2zm.99-5C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"
  }), 'ErrorOutline');

  var InfoOutlinedIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M11,9H13V7H11M12,20C7.59,20 4,16.41 4,12C4,7.59 7.59,4 12,4C16.41,4 20,7.59 20, 12C20,16.41 16.41,20 12,20M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12A10, 10 0 0,0 12,2M11,17H13V11H11V17Z"
  }), 'InfoOutlined');

  var ClearIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M19 6.41L17.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');

  var useUtilityClasses$1G = function useUtilityClasses(ownerState) {
    var variant = ownerState.variant,
      color = ownerState.color,
      severity = ownerState.severity,
      classes = ownerState.classes;
    var slots = {
      root: ['root', "color".concat(capitalize(color || severity)), "".concat(variant).concat(capitalize(color || severity)), "".concat(variant)],
      icon: ['icon'],
      message: ['message'],
      action: ['action']
    };
    return composeClasses(slots, getAlertUtilityClass, classes);
  };
  var AlertRoot = styled$1(Paper$1, {
    name: 'MuiAlert',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.variant], styles["".concat(ownerState.variant).concat(capitalize(ownerState.color || ownerState.severity))]];
    }
  })(function (_ref) {
    var theme = _ref.theme;
    var getColor = theme.palette.mode === 'light' ? darken : lighten;
    var getBackgroundColor = theme.palette.mode === 'light' ? lighten : darken;
    return _extends({}, theme.typography.body2, {
      backgroundColor: 'transparent',
      display: 'flex',
      padding: '6px 16px',
      variants: [].concat(_toConsumableArray(Object.entries(theme.palette).filter(function (_ref2) {
        var _ref3 = _slicedToArray(_ref2, 2),
          value = _ref3[1];
        return value.main && value.light;
      }).map(function (_ref4) {
        var _ref5 = _slicedToArray(_ref4, 1),
          color = _ref5[0];
        return {
          props: {
            colorSeverity: color,
            variant: 'standard'
          },
          style: _defineProperty({
            color: theme.vars ? theme.vars.palette.Alert["".concat(color, "Color")] : getColor(theme.palette[color].light, 0.6),
            backgroundColor: theme.vars ? theme.vars.palette.Alert["".concat(color, "StandardBg")] : getBackgroundColor(theme.palette[color].light, 0.9)
          }, "& .".concat(alertClasses$1.icon), theme.vars ? {
            color: theme.vars.palette.Alert["".concat(color, "IconColor")]
          } : {
            color: theme.palette[color].main
          })
        };
      })), _toConsumableArray(Object.entries(theme.palette).filter(function (_ref6) {
        var _ref7 = _slicedToArray(_ref6, 2),
          value = _ref7[1];
        return value.main && value.light;
      }).map(function (_ref8) {
        var _ref9 = _slicedToArray(_ref8, 1),
          color = _ref9[0];
        return {
          props: {
            colorSeverity: color,
            variant: 'outlined'
          },
          style: _defineProperty({
            color: theme.vars ? theme.vars.palette.Alert["".concat(color, "Color")] : getColor(theme.palette[color].light, 0.6),
            border: "1px solid ".concat((theme.vars || theme).palette[color].light)
          }, "& .".concat(alertClasses$1.icon), theme.vars ? {
            color: theme.vars.palette.Alert["".concat(color, "IconColor")]
          } : {
            color: theme.palette[color].main
          })
        };
      })), _toConsumableArray(Object.entries(theme.palette).filter(function (_ref10) {
        var _ref11 = _slicedToArray(_ref10, 2),
          value = _ref11[1];
        return value.main && value.dark;
      }).map(function (_ref12) {
        var _ref13 = _slicedToArray(_ref12, 1),
          color = _ref13[0];
        return {
          props: {
            colorSeverity: color,
            variant: 'filled'
          },
          style: _extends({
            fontWeight: theme.typography.fontWeightMedium
          }, theme.vars ? {
            color: theme.vars.palette.Alert["".concat(color, "FilledColor")],
            backgroundColor: theme.vars.palette.Alert["".concat(color, "FilledBg")]
          } : {
            backgroundColor: theme.palette.mode === 'dark' ? theme.palette[color].dark : theme.palette[color].main,
            color: theme.palette.getContrastText(theme.palette[color].main)
          })
        };
      })))
    });
  });
  var AlertIcon = styled$1('div', {
    name: 'MuiAlert',
    slot: 'Icon',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.icon;
    }
  })({
    marginRight: 12,
    padding: '7px 0',
    display: 'flex',
    fontSize: 22,
    opacity: 0.9
  });
  var AlertMessage = styled$1('div', {
    name: 'MuiAlert',
    slot: 'Message',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.message;
    }
  })({
    padding: '8px 0',
    minWidth: 0,
    overflow: 'auto'
  });
  var AlertAction = styled$1('div', {
    name: 'MuiAlert',
    slot: 'Action',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.action;
    }
  })({
    display: 'flex',
    alignItems: 'flex-start',
    padding: '4px 0 0 16px',
    marginLeft: 'auto',
    marginRight: -8
  });
  var defaultIconMapping = {
    success: /*#__PURE__*/jsxRuntimeExports.jsx(SuccessOutlinedIcon, {
      fontSize: "inherit"
    }),
    warning: /*#__PURE__*/jsxRuntimeExports.jsx(ReportProblemOutlinedIcon, {
      fontSize: "inherit"
    }),
    error: /*#__PURE__*/jsxRuntimeExports.jsx(ErrorOutlineIcon, {
      fontSize: "inherit"
    }),
    info: /*#__PURE__*/jsxRuntimeExports.jsx(InfoOutlinedIcon, {
      fontSize: "inherit"
    })
  };
  var Alert = /*#__PURE__*/React__namespace.forwardRef(function Alert(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiAlert'
    });
    var action = props.action,
      children = props.children,
      className = props.className,
      _props$closeText = props.closeText,
      closeText = _props$closeText === void 0 ? 'Close' : _props$closeText,
      color = props.color,
      _props$components = props.components,
      components = _props$components === void 0 ? {} : _props$components,
      _props$componentsProp = props.componentsProps,
      componentsProps = _props$componentsProp === void 0 ? {} : _props$componentsProp,
      icon = props.icon,
      _props$iconMapping = props.iconMapping,
      iconMapping = _props$iconMapping === void 0 ? defaultIconMapping : _props$iconMapping,
      onClose = props.onClose,
      _props$role = props.role,
      role = _props$role === void 0 ? 'alert' : _props$role,
      _props$severity = props.severity,
      severity = _props$severity === void 0 ? 'success' : _props$severity,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'standard' : _props$variant,
      other = _objectWithoutProperties(props, ["action", "children", "className", "closeText", "color", "components", "componentsProps", "icon", "iconMapping", "onClose", "role", "severity", "slotProps", "slots", "variant"]);
    var ownerState = _extends({}, props, {
      color: color,
      severity: severity,
      variant: variant,
      colorSeverity: color || severity
    });
    var classes = useUtilityClasses$1G(ownerState);
    var externalForwardedProps = {
      slots: _extends({
        closeButton: components.CloseButton,
        closeIcon: components.CloseIcon
      }, slots),
      slotProps: _extends({}, componentsProps, slotProps)
    };
    var _useSlot = useSlot('closeButton', {
        elementType: IconButton$1,
        externalForwardedProps: externalForwardedProps,
        ownerState: ownerState
      }),
      _useSlot2 = _slicedToArray(_useSlot, 2),
      CloseButtonSlot = _useSlot2[0],
      closeButtonProps = _useSlot2[1];
    var _useSlot3 = useSlot('closeIcon', {
        elementType: ClearIcon,
        externalForwardedProps: externalForwardedProps,
        ownerState: ownerState
      }),
      _useSlot4 = _slicedToArray(_useSlot3, 2),
      CloseIconSlot = _useSlot4[0],
      closeIconProps = _useSlot4[1];
    return /*#__PURE__*/jsxRuntimeExports.jsxs(AlertRoot, _extends({
      role: role,
      elevation: 0,
      ownerState: ownerState,
      className: clsx(classes.root, className),
      ref: ref
    }, other, {
      children: [icon !== false ? /*#__PURE__*/jsxRuntimeExports.jsx(AlertIcon, {
        ownerState: ownerState,
        className: classes.icon,
        children: icon || iconMapping[severity] || defaultIconMapping[severity]
      }) : null, /*#__PURE__*/jsxRuntimeExports.jsx(AlertMessage, {
        ownerState: ownerState,
        className: classes.message,
        children: children
      }), action != null ? /*#__PURE__*/jsxRuntimeExports.jsx(AlertAction, {
        ownerState: ownerState,
        className: classes.action,
        children: action
      }) : null, action == null && onClose ? /*#__PURE__*/jsxRuntimeExports.jsx(AlertAction, {
        ownerState: ownerState,
        className: classes.action,
        children: /*#__PURE__*/jsxRuntimeExports.jsx(CloseButtonSlot, _extends({
          size: "small",
          "aria-label": closeText,
          title: closeText,
          color: "inherit",
          onClick: onClose
        }, closeButtonProps, {
          children: /*#__PURE__*/jsxRuntimeExports.jsx(CloseIconSlot, _extends({
            fontSize: "small"
          }, closeIconProps))
        }))
      }) : null]
    }));
  });
  Alert.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The action to display. It renders after the message, at the end of the alert.
     */
    action: PropTypes.node,
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * Override the default label for the *close popup* icon button.
     *
     * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
     * @default 'Close'
     */
    closeText: PropTypes.string,
    /**
     * The color of the component. Unless provided, the value is taken from the `severity` prop.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * The components used for each slot inside.
     *
     * @deprecated use the `slots` prop instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
     *
     * @default {}
     */
    components: PropTypes.shape({
      CloseButton: PropTypes.elementType,
      CloseIcon: PropTypes.elementType
    }),
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * @deprecated use the `slotProps` prop instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
     *
     * @default {}
     */
    componentsProps: PropTypes.shape({
      closeButton: PropTypes.object,
      closeIcon: PropTypes.object
    }),
    /**
     * Override the icon displayed before the children.
     * Unless provided, the icon is mapped to the value of the `severity` prop.
     * Set to `false` to remove the `icon`.
     */
    icon: PropTypes.node,
    /**
     * The component maps the `severity` prop to a range of different icons,
     * for instance success to `<SuccessOutlined>`.
     * If you wish to change this mapping, you can provide your own.
     * Alternatively, you can use the `icon` prop to override the icon displayed.
     */
    iconMapping: PropTypes.shape({
      error: PropTypes.node,
      info: PropTypes.node,
      success: PropTypes.node,
      warning: PropTypes.node
    }),
    /**
     * Callback fired when the component requests to be closed.
     * When provided and no `action` prop is set, a close icon button is displayed that triggers the callback when clicked.
     * @param {React.SyntheticEvent} event The event source of the callback.
     */
    onClose: PropTypes.func,
    /**
     * The ARIA role attribute of the element.
     * @default 'alert'
     */
    role: PropTypes.string,
    /**
     * The severity of the alert. This defines the color and icon used.
     * @default 'success'
     */
    severity: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * The props used for each slot inside.
     * @default {}
     */
    slotProps: PropTypes.shape({
      closeButton: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      closeIcon: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * The components used for each slot inside.
     * @default {}
     */
    slots: PropTypes.shape({
      closeButton: PropTypes.elementType,
      closeIcon: PropTypes.elementType
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The variant to use.
     * @default 'standard'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['filled', 'outlined', 'standard']), PropTypes.string])
  } ;
  var Alert$1 = Alert;

  function getTypographyUtilityClass(slot) {
    return generateUtilityClass('MuiTypography', slot);
  }
  var typographyClasses = generateUtilityClasses('MuiTypography', ['root', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'subtitle1', 'subtitle2', 'body1', 'body2', 'inherit', 'button', 'caption', 'overline', 'alignLeft', 'alignRight', 'alignCenter', 'alignJustify', 'noWrap', 'gutterBottom', 'paragraph']);
  var typographyClasses$1 = typographyClasses;

  var useUtilityClasses$1F = function useUtilityClasses(ownerState) {
    var align = ownerState.align,
      gutterBottom = ownerState.gutterBottom,
      noWrap = ownerState.noWrap,
      paragraph = ownerState.paragraph,
      variant = ownerState.variant,
      classes = ownerState.classes;
    var slots = {
      root: ['root', variant, ownerState.align !== 'inherit' && "align".concat(capitalize(align)), gutterBottom && 'gutterBottom', noWrap && 'noWrap', paragraph && 'paragraph']
    };
    return composeClasses(slots, getTypographyUtilityClass, classes);
  };
  var TypographyRoot = styled$1('span', {
    name: 'MuiTypography',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.variant && styles[ownerState.variant], ownerState.align !== 'inherit' && styles["align".concat(capitalize(ownerState.align))], ownerState.noWrap && styles.noWrap, ownerState.gutterBottom && styles.gutterBottom, ownerState.paragraph && styles.paragraph];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      margin: 0
    }, ownerState.variant === 'inherit' && {
      // Some elements, like <button> on Chrome have default font that doesn't inherit, reset this.
      font: 'inherit'
    }, ownerState.variant !== 'inherit' && theme.typography[ownerState.variant], ownerState.align !== 'inherit' && {
      textAlign: ownerState.align
    }, ownerState.noWrap && {
      overflow: 'hidden',
      textOverflow: 'ellipsis',
      whiteSpace: 'nowrap'
    }, ownerState.gutterBottom && {
      marginBottom: '0.35em'
    }, ownerState.paragraph && {
      marginBottom: 16
    });
  });
  var defaultVariantMapping = {
    h1: 'h1',
    h2: 'h2',
    h3: 'h3',
    h4: 'h4',
    h5: 'h5',
    h6: 'h6',
    subtitle1: 'h6',
    subtitle2: 'h6',
    body1: 'p',
    body2: 'p',
    inherit: 'p'
  };

  // TODO v6: deprecate these color values in v5.x and remove the transformation in v6
  var colorTransformations$1 = {
    primary: 'primary.main',
    textPrimary: 'text.primary',
    secondary: 'secondary.main',
    textSecondary: 'text.secondary',
    error: 'error.main'
  };
  var transformDeprecatedColors$1 = function transformDeprecatedColors(color) {
    return colorTransformations$1[color] || color;
  };
  var Typography = /*#__PURE__*/React__namespace.forwardRef(function Typography(inProps, ref) {
    var themeProps = useDefaultProps({
      props: inProps,
      name: 'MuiTypography'
    });
    var color = transformDeprecatedColors$1(themeProps.color);
    var props = extendSxProp(_extends({}, themeProps, {
      color: color
    }));
    var _props$align = props.align,
      align = _props$align === void 0 ? 'inherit' : _props$align,
      className = props.className,
      component = props.component,
      _props$gutterBottom = props.gutterBottom,
      gutterBottom = _props$gutterBottom === void 0 ? false : _props$gutterBottom,
      _props$noWrap = props.noWrap,
      noWrap = _props$noWrap === void 0 ? false : _props$noWrap,
      _props$paragraph = props.paragraph,
      paragraph = _props$paragraph === void 0 ? false : _props$paragraph,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'body1' : _props$variant,
      _props$variantMapping = props.variantMapping,
      variantMapping = _props$variantMapping === void 0 ? defaultVariantMapping : _props$variantMapping,
      other = _objectWithoutProperties(props, ["align", "className", "component", "gutterBottom", "noWrap", "paragraph", "variant", "variantMapping"]);
    var ownerState = _extends({}, props, {
      align: align,
      color: color,
      className: className,
      component: component,
      gutterBottom: gutterBottom,
      noWrap: noWrap,
      paragraph: paragraph,
      variant: variant,
      variantMapping: variantMapping
    });
    var Component = component || (paragraph ? 'p' : variantMapping[variant] || defaultVariantMapping[variant]) || 'span';
    var classes = useUtilityClasses$1F(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(TypographyRoot, _extends({
      as: Component,
      ref: ref,
      ownerState: ownerState,
      className: clsx(classes.root, className)
    }, other));
  });
  Typography.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Set the text-align on the component.
     * @default 'inherit'
     */
    align: PropTypes.oneOf(['center', 'inherit', 'justify', 'left', 'right']),
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, the text will have a bottom margin.
     * @default false
     */
    gutterBottom: PropTypes.bool,
    /**
     * If `true`, the text will not wrap, but instead will truncate with a text overflow ellipsis.
     *
     * Note that text overflow can only happen with block or inline-block level elements
     * (the element needs to have a width in order to overflow).
     * @default false
     */
    noWrap: PropTypes.bool,
    /**
     * If `true`, the element will be a paragraph element.
     * @default false
     */
    paragraph: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * Applies the theme typography styles.
     * @default 'body1'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['body1', 'body2', 'button', 'caption', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'inherit', 'overline', 'subtitle1', 'subtitle2']), PropTypes.string]),
    /**
     * The component maps the variant prop to a range of different HTML element types.
     * For instance, subtitle1 to `<h6>`.
     * If you wish to change that mapping, you can provide your own.
     * Alternatively, you can use the `component` prop.
     * @default {
     *   h1: 'h1',
     *   h2: 'h2',
     *   h3: 'h3',
     *   h4: 'h4',
     *   h5: 'h5',
     *   h6: 'h6',
     *   subtitle1: 'h6',
     *   subtitle2: 'h6',
     *   body1: 'p',
     *   body2: 'p',
     *   inherit: 'p',
     * }
     */
    variantMapping: PropTypes /* @typescript-to-proptypes-ignore */.object
  } ;
  var Typography$1 = Typography;

  function getAlertTitleUtilityClass(slot) {
    return generateUtilityClass('MuiAlertTitle', slot);
  }
  var alertTitleClasses = generateUtilityClasses('MuiAlertTitle', ['root']);
  var alertTitleClasses$1 = alertTitleClasses;

  var useUtilityClasses$1E = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    return composeClasses(slots, getAlertTitleUtilityClass, classes);
  };
  var AlertTitleRoot = styled$1(Typography$1, {
    name: 'MuiAlertTitle',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })(function (_ref) {
    var theme = _ref.theme;
    return {
      fontWeight: theme.typography.fontWeightMedium,
      marginTop: -2
    };
  });
  var AlertTitle = /*#__PURE__*/React__namespace.forwardRef(function AlertTitle(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiAlertTitle'
    });
    var className = props.className,
      other = _objectWithoutProperties(props, ["className"]);
    var ownerState = props;
    var classes = useUtilityClasses$1E(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(AlertTitleRoot, _extends({
      gutterBottom: true,
      component: "div",
      ownerState: ownerState,
      ref: ref,
      className: clsx(classes.root, className)
    }, other));
  });
  AlertTitle.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var AlertTitle$1 = AlertTitle;

  function getAppBarUtilityClass(slot) {
    return generateUtilityClass('MuiAppBar', slot);
  }
  var appBarClasses = generateUtilityClasses('MuiAppBar', ['root', 'positionFixed', 'positionAbsolute', 'positionSticky', 'positionStatic', 'positionRelative', 'colorDefault', 'colorPrimary', 'colorSecondary', 'colorInherit', 'colorTransparent', 'colorError', 'colorInfo', 'colorSuccess', 'colorWarning']);
  var appBarClasses$1 = appBarClasses;

  var useUtilityClasses$1D = function useUtilityClasses(ownerState) {
    var color = ownerState.color,
      position = ownerState.position,
      classes = ownerState.classes;
    var slots = {
      root: ['root', "color".concat(capitalize(color)), "position".concat(capitalize(position))]
    };
    return composeClasses(slots, getAppBarUtilityClass, classes);
  };

  // var2 is the fallback.
  // Ex. var1: 'var(--a)', var2: 'var(--b)'; return: 'var(--a, var(--b))'
  var joinVars = function joinVars(var1, var2) {
    return var1 ? "".concat(var1 == null ? void 0 : var1.replace(')', ''), ", ").concat(var2, ")") : var2;
  };
  var AppBarRoot = styled$1(Paper$1, {
    name: 'MuiAppBar',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles["position".concat(capitalize(ownerState.position))], styles["color".concat(capitalize(ownerState.color))]];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    var backgroundColorDefault = theme.palette.mode === 'light' ? theme.palette.grey[100] : theme.palette.grey[900];
    return _extends({
      display: 'flex',
      flexDirection: 'column',
      width: '100%',
      boxSizing: 'border-box',
      // Prevent padding issue with the Modal and fixed positioned AppBar.
      flexShrink: 0
    }, ownerState.position === 'fixed' && {
      position: 'fixed',
      zIndex: (theme.vars || theme).zIndex.appBar,
      top: 0,
      left: 'auto',
      right: 0,
      '@media print': {
        // Prevent the app bar to be visible on each printed page.
        position: 'absolute'
      }
    }, ownerState.position === 'absolute' && {
      position: 'absolute',
      zIndex: (theme.vars || theme).zIndex.appBar,
      top: 0,
      left: 'auto',
      right: 0
    }, ownerState.position === 'sticky' && {
      // ⚠️ sticky is not supported by IE11.
      position: 'sticky',
      zIndex: (theme.vars || theme).zIndex.appBar,
      top: 0,
      left: 'auto',
      right: 0
    }, ownerState.position === 'static' && {
      position: 'static'
    }, ownerState.position === 'relative' && {
      position: 'relative'
    }, !theme.vars && _extends({}, ownerState.color === 'default' && {
      backgroundColor: backgroundColorDefault,
      color: theme.palette.getContrastText(backgroundColorDefault)
    }, ownerState.color && ownerState.color !== 'default' && ownerState.color !== 'inherit' && ownerState.color !== 'transparent' && {
      backgroundColor: theme.palette[ownerState.color].main,
      color: theme.palette[ownerState.color].contrastText
    }, ownerState.color === 'inherit' && {
      color: 'inherit'
    }, theme.palette.mode === 'dark' && !ownerState.enableColorOnDark && {
      backgroundColor: null,
      color: null
    }, ownerState.color === 'transparent' && _extends({
      backgroundColor: 'transparent',
      color: 'inherit'
    }, theme.palette.mode === 'dark' && {
      backgroundImage: 'none'
    })), theme.vars && _extends({}, ownerState.color === 'default' && {
      '--AppBar-background': ownerState.enableColorOnDark ? theme.vars.palette.AppBar.defaultBg : joinVars(theme.vars.palette.AppBar.darkBg, theme.vars.palette.AppBar.defaultBg),
      '--AppBar-color': ownerState.enableColorOnDark ? theme.vars.palette.text.primary : joinVars(theme.vars.palette.AppBar.darkColor, theme.vars.palette.text.primary)
    }, ownerState.color && !ownerState.color.match(/^(default|inherit|transparent)$/) && {
      '--AppBar-background': ownerState.enableColorOnDark ? theme.vars.palette[ownerState.color].main : joinVars(theme.vars.palette.AppBar.darkBg, theme.vars.palette[ownerState.color].main),
      '--AppBar-color': ownerState.enableColorOnDark ? theme.vars.palette[ownerState.color].contrastText : joinVars(theme.vars.palette.AppBar.darkColor, theme.vars.palette[ownerState.color].contrastText)
    }, !['inherit', 'transparent'].includes(ownerState.color) && {
      backgroundColor: 'var(--AppBar-background)'
    }, {
      color: ownerState.color === 'inherit' ? 'inherit' : 'var(--AppBar-color)'
    }, ownerState.color === 'transparent' && {
      backgroundImage: 'none',
      backgroundColor: 'transparent',
      color: 'inherit'
    }));
  });
  var AppBar = /*#__PURE__*/React__namespace.forwardRef(function AppBar(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiAppBar'
    });
    var className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'primary' : _props$color,
      _props$enableColorOnD = props.enableColorOnDark,
      enableColorOnDark = _props$enableColorOnD === void 0 ? false : _props$enableColorOnD,
      _props$position = props.position,
      position = _props$position === void 0 ? 'fixed' : _props$position,
      other = _objectWithoutProperties(props, ["className", "color", "enableColorOnDark", "position"]);
    var ownerState = _extends({}, props, {
      color: color,
      position: position,
      enableColorOnDark: enableColorOnDark
    });
    var classes = useUtilityClasses$1D(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(AppBarRoot, _extends({
      square: true,
      component: "header",
      ownerState: ownerState,
      elevation: 4,
      className: clsx(classes.root, className, position === 'fixed' && 'mui-fixed'),
      ref: ref
    }, other));
  });
  AppBar.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'primary'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['default', 'inherit', 'primary', 'secondary', 'transparent', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * If true, the `color` prop is applied in dark mode.
     * @default false
     */
    enableColorOnDark: PropTypes.bool,
    /**
     * The positioning type. The behavior of the different options is described
     * [in the MDN web docs](https://developer.mozilla.org/en-US/docs/Learn/CSS/CSS_layout/Positioning).
     * Note: `sticky` is not universally supported and will fall back to `static` when unavailable.
     * @default 'fixed'
     */
    position: PropTypes.oneOf(['absolute', 'fixed', 'relative', 'static', 'sticky']),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var AppBar$1 = AppBar;

  // https://stackoverflow.com/questions/990904/remove-accents-diacritics-in-a-string-in-javascript
  // Give up on IE11 support for this feature
  function stripDiacritics(string) {
    return typeof string.normalize !== 'undefined' ? string.normalize('NFD').replace(/[\u0300-\u036f]/g, '') : string;
  }
  function createFilterOptions() {
    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var _config$ignoreAccents = config.ignoreAccents,
      ignoreAccents = _config$ignoreAccents === void 0 ? true : _config$ignoreAccents,
      _config$ignoreCase = config.ignoreCase,
      ignoreCase = _config$ignoreCase === void 0 ? true : _config$ignoreCase,
      limit = config.limit,
      _config$matchFrom = config.matchFrom,
      matchFrom = _config$matchFrom === void 0 ? 'any' : _config$matchFrom,
      stringify = config.stringify,
      _config$trim = config.trim,
      trim = _config$trim === void 0 ? false : _config$trim;
    return function (options, _ref) {
      var inputValue = _ref.inputValue,
        getOptionLabel = _ref.getOptionLabel;
      var input = trim ? inputValue.trim() : inputValue;
      if (ignoreCase) {
        input = input.toLowerCase();
      }
      if (ignoreAccents) {
        input = stripDiacritics(input);
      }
      var filteredOptions = !input ? options : options.filter(function (option) {
        var candidate = (stringify || getOptionLabel)(option);
        if (ignoreCase) {
          candidate = candidate.toLowerCase();
        }
        if (ignoreAccents) {
          candidate = stripDiacritics(candidate);
        }
        return matchFrom === 'start' ? candidate.indexOf(input) === 0 : candidate.indexOf(input) > -1;
      });
      return typeof limit === 'number' ? filteredOptions.slice(0, limit) : filteredOptions;
    };
  }

  // To replace with .findIndex() once we stop IE11 support.
  function findIndex(array, comp) {
    for (var i = 0; i < array.length; i += 1) {
      if (comp(array[i])) {
        return i;
      }
    }
    return -1;
  }
  var defaultFilterOptions = createFilterOptions();

  // Number of options to jump in list box when `Page Up` and `Page Down` keys are used.
  var pageSize = 5;
  var defaultIsActiveElementInListbox = function defaultIsActiveElementInListbox(listboxRef) {
    var _listboxRef$current$p;
    return listboxRef.current !== null && ((_listboxRef$current$p = listboxRef.current.parentElement) == null ? void 0 : _listboxRef$current$p.contains(document.activeElement));
  };
  var MULTIPLE_DEFAULT_VALUE = [];
  function useAutocomplete(props) {
    var _props$unstable_isAct = props.unstable_isActiveElementInListbox,
      unstable_isActiveElementInListbox = _props$unstable_isAct === void 0 ? defaultIsActiveElementInListbox : _props$unstable_isAct,
      _props$unstable_class = props.unstable_classNamePrefix,
      unstable_classNamePrefix = _props$unstable_class === void 0 ? 'Mui' : _props$unstable_class,
      _props$autoComplete = props.autoComplete,
      autoComplete = _props$autoComplete === void 0 ? false : _props$autoComplete,
      _props$autoHighlight = props.autoHighlight,
      autoHighlight = _props$autoHighlight === void 0 ? false : _props$autoHighlight,
      _props$autoSelect = props.autoSelect,
      autoSelect = _props$autoSelect === void 0 ? false : _props$autoSelect,
      _props$blurOnSelect = props.blurOnSelect,
      blurOnSelect = _props$blurOnSelect === void 0 ? false : _props$blurOnSelect,
      _props$clearOnBlur = props.clearOnBlur,
      clearOnBlur = _props$clearOnBlur === void 0 ? !props.freeSolo : _props$clearOnBlur,
      _props$clearOnEscape = props.clearOnEscape,
      clearOnEscape = _props$clearOnEscape === void 0 ? false : _props$clearOnEscape,
      _props$componentName = props.componentName,
      componentName = _props$componentName === void 0 ? 'useAutocomplete' : _props$componentName,
      _props$defaultValue = props.defaultValue,
      defaultValue = _props$defaultValue === void 0 ? props.multiple ? MULTIPLE_DEFAULT_VALUE : null : _props$defaultValue,
      _props$disableClearab = props.disableClearable,
      disableClearable = _props$disableClearab === void 0 ? false : _props$disableClearab,
      _props$disableCloseOn = props.disableCloseOnSelect,
      disableCloseOnSelect = _props$disableCloseOn === void 0 ? false : _props$disableCloseOn,
      disabledProp = props.disabled,
      _props$disabledItemsF = props.disabledItemsFocusable,
      disabledItemsFocusable = _props$disabledItemsF === void 0 ? false : _props$disabledItemsF,
      _props$disableListWra = props.disableListWrap,
      disableListWrap = _props$disableListWra === void 0 ? false : _props$disableListWra,
      _props$filterOptions = props.filterOptions,
      filterOptions = _props$filterOptions === void 0 ? defaultFilterOptions : _props$filterOptions,
      _props$filterSelected = props.filterSelectedOptions,
      filterSelectedOptions = _props$filterSelected === void 0 ? false : _props$filterSelected,
      _props$freeSolo = props.freeSolo,
      freeSolo = _props$freeSolo === void 0 ? false : _props$freeSolo,
      getOptionDisabled = props.getOptionDisabled,
      getOptionKey = props.getOptionKey,
      _props$getOptionLabel = props.getOptionLabel,
      getOptionLabelProp = _props$getOptionLabel === void 0 ? function (option) {
        var _option$label;
        return (_option$label = option.label) != null ? _option$label : option;
      } : _props$getOptionLabel,
      groupBy = props.groupBy,
      _props$handleHomeEndK = props.handleHomeEndKeys,
      handleHomeEndKeys = _props$handleHomeEndK === void 0 ? !props.freeSolo : _props$handleHomeEndK,
      idProp = props.id,
      _props$includeInputIn = props.includeInputInList,
      includeInputInList = _props$includeInputIn === void 0 ? false : _props$includeInputIn,
      inputValueProp = props.inputValue,
      _props$isOptionEqualT = props.isOptionEqualToValue,
      isOptionEqualToValue = _props$isOptionEqualT === void 0 ? function (option, value) {
        return option === value;
      } : _props$isOptionEqualT,
      _props$multiple = props.multiple,
      multiple = _props$multiple === void 0 ? false : _props$multiple,
      onChange = props.onChange,
      onClose = props.onClose,
      onHighlightChange = props.onHighlightChange,
      onInputChange = props.onInputChange,
      onOpen = props.onOpen,
      openProp = props.open,
      _props$openOnFocus = props.openOnFocus,
      openOnFocus = _props$openOnFocus === void 0 ? false : _props$openOnFocus,
      options = props.options,
      _props$readOnly = props.readOnly,
      readOnly = _props$readOnly === void 0 ? false : _props$readOnly,
      _props$selectOnFocus = props.selectOnFocus,
      selectOnFocus = _props$selectOnFocus === void 0 ? !props.freeSolo : _props$selectOnFocus,
      valueProp = props.value;
    var id = useId(idProp);
    var getOptionLabel = getOptionLabelProp;
    getOptionLabel = function getOptionLabel(option) {
      var optionLabel = getOptionLabelProp(option);
      if (typeof optionLabel !== 'string') {
        {
          var erroneousReturn = optionLabel === undefined ? 'undefined' : "".concat(_typeof(optionLabel), " (").concat(optionLabel, ")");
          console.error("MUI: The `getOptionLabel` method of ".concat(componentName, " returned ").concat(erroneousReturn, " instead of a string for ").concat(JSON.stringify(option), "."));
        }
        return String(optionLabel);
      }
      return optionLabel;
    };
    var ignoreFocus = React__namespace.useRef(false);
    var firstFocus = React__namespace.useRef(true);
    var inputRef = React__namespace.useRef(null);
    var listboxRef = React__namespace.useRef(null);
    var _React$useState = React__namespace.useState(null),
      anchorEl = _React$useState[0],
      setAnchorEl = _React$useState[1];
    var _React$useState2 = React__namespace.useState(-1),
      focusedTag = _React$useState2[0],
      setFocusedTag = _React$useState2[1];
    var defaultHighlighted = autoHighlight ? 0 : -1;
    var highlightedIndexRef = React__namespace.useRef(defaultHighlighted);
    var _useControlled = useControlled({
        controlled: valueProp,
        "default": defaultValue,
        name: componentName
      }),
      _useControlled2 = _slicedToArray(_useControlled, 2),
      value = _useControlled2[0],
      setValueState = _useControlled2[1];
    var _useControlled3 = useControlled({
        controlled: inputValueProp,
        "default": '',
        name: componentName,
        state: 'inputValue'
      }),
      _useControlled4 = _slicedToArray(_useControlled3, 2),
      inputValue = _useControlled4[0],
      setInputValueState = _useControlled4[1];
    var _React$useState3 = React__namespace.useState(false),
      focused = _React$useState3[0],
      setFocused = _React$useState3[1];
    var resetInputValue = React__namespace.useCallback(function (event, newValue) {
      // retain current `inputValue` if new option isn't selected and `clearOnBlur` is false
      // When `multiple` is enabled, `newValue` is an array of all selected items including the newly selected item
      var isOptionSelected = multiple ? value.length < newValue.length : newValue !== null;
      if (!isOptionSelected && !clearOnBlur) {
        return;
      }
      var newInputValue;
      if (multiple) {
        newInputValue = '';
      } else if (newValue == null) {
        newInputValue = '';
      } else {
        var optionLabel = getOptionLabel(newValue);
        newInputValue = typeof optionLabel === 'string' ? optionLabel : '';
      }
      if (inputValue === newInputValue) {
        return;
      }
      setInputValueState(newInputValue);
      if (onInputChange) {
        onInputChange(event, newInputValue, 'reset');
      }
    }, [getOptionLabel, inputValue, multiple, onInputChange, setInputValueState, clearOnBlur, value]);
    var _useControlled5 = useControlled({
        controlled: openProp,
        "default": false,
        name: componentName,
        state: 'open'
      }),
      _useControlled6 = _slicedToArray(_useControlled5, 2),
      open = _useControlled6[0],
      setOpenState = _useControlled6[1];
    var _React$useState4 = React__namespace.useState(true),
      inputPristine = _React$useState4[0],
      setInputPristine = _React$useState4[1];
    var inputValueIsSelectedValue = !multiple && value != null && inputValue === getOptionLabel(value);
    var popupOpen = open && !readOnly;
    var filteredOptions = popupOpen ? filterOptions(options.filter(function (option) {
      if (filterSelectedOptions && (multiple ? value : [value]).some(function (value2) {
        return value2 !== null && isOptionEqualToValue(option, value2);
      })) {
        return false;
      }
      return true;
    }),
    // we use the empty string to manipulate `filterOptions` to not filter any options
    // i.e. the filter predicate always returns true
    {
      inputValue: inputValueIsSelectedValue && inputPristine ? '' : inputValue,
      getOptionLabel: getOptionLabel
    }) : [];
    var previousProps = usePreviousProps$1({
      filteredOptions: filteredOptions,
      value: value,
      inputValue: inputValue
    });
    React__namespace.useEffect(function () {
      var valueChange = value !== previousProps.value;
      if (focused && !valueChange) {
        return;
      }

      // Only reset the input's value when freeSolo if the component's value changes.
      if (freeSolo && !valueChange) {
        return;
      }
      resetInputValue(null, value);
    }, [value, resetInputValue, focused, previousProps.value, freeSolo]);
    var listboxAvailable = open && filteredOptions.length > 0 && !readOnly;
    {
      if (value !== null && !freeSolo && options.length > 0) {
        var missingValue = (multiple ? value : [value]).filter(function (value2) {
          return !options.some(function (option) {
            return isOptionEqualToValue(option, value2);
          });
        });
        if (missingValue.length > 0) {
          console.warn(["MUI: The value provided to ".concat(componentName, " is invalid."), "None of the options match with `".concat(missingValue.length > 1 ? JSON.stringify(missingValue) : JSON.stringify(missingValue[0]), "`."), 'You can use the `isOptionEqualToValue` prop to customize the equality test.'].join('\n'));
        }
      }
    }
    var focusTag = useEventCallback(function (tagToFocus) {
      if (tagToFocus === -1) {
        inputRef.current.focus();
      } else {
        anchorEl.querySelector("[data-tag-index=\"".concat(tagToFocus, "\"]")).focus();
      }
    });

    // Ensure the focusedTag is never inconsistent
    React__namespace.useEffect(function () {
      if (multiple && focusedTag > value.length - 1) {
        setFocusedTag(-1);
        focusTag(-1);
      }
    }, [value, multiple, focusedTag, focusTag]);
    function validOptionIndex(index, direction) {
      if (!listboxRef.current || index < 0 || index >= filteredOptions.length) {
        return -1;
      }
      var nextFocus = index;
      while (true) {
        var option = listboxRef.current.querySelector("[data-option-index=\"".concat(nextFocus, "\"]"));

        // Same logic as MenuList.js
        var nextFocusDisabled = disabledItemsFocusable ? false : !option || option.disabled || option.getAttribute('aria-disabled') === 'true';
        if (option && option.hasAttribute('tabindex') && !nextFocusDisabled) {
          // The next option is available
          return nextFocus;
        }

        // The next option is disabled, move to the next element.
        // with looped index
        if (direction === 'next') {
          nextFocus = (nextFocus + 1) % filteredOptions.length;
        } else {
          nextFocus = (nextFocus - 1 + filteredOptions.length) % filteredOptions.length;
        }

        // We end up with initial index, that means we don't have available options.
        // All of them are disabled
        if (nextFocus === index) {
          return -1;
        }
      }
    }
    var setHighlightedIndex = useEventCallback(function (_ref2) {
      var event = _ref2.event,
        index = _ref2.index,
        _ref2$reason = _ref2.reason,
        reason = _ref2$reason === void 0 ? 'auto' : _ref2$reason;
      highlightedIndexRef.current = index;

      // does the index exist?
      if (index === -1) {
        inputRef.current.removeAttribute('aria-activedescendant');
      } else {
        inputRef.current.setAttribute('aria-activedescendant', "".concat(id, "-option-").concat(index));
      }
      if (onHighlightChange) {
        onHighlightChange(event, index === -1 ? null : filteredOptions[index], reason);
      }
      if (!listboxRef.current) {
        return;
      }
      var prev = listboxRef.current.querySelector("[role=\"option\"].".concat(unstable_classNamePrefix, "-focused"));
      if (prev) {
        prev.classList.remove("".concat(unstable_classNamePrefix, "-focused"));
        prev.classList.remove("".concat(unstable_classNamePrefix, "-focusVisible"));
      }
      var listboxNode = listboxRef.current;
      if (listboxRef.current.getAttribute('role') !== 'listbox') {
        listboxNode = listboxRef.current.parentElement.querySelector('[role="listbox"]');
      }

      // "No results"
      if (!listboxNode) {
        return;
      }
      if (index === -1) {
        listboxNode.scrollTop = 0;
        return;
      }
      var option = listboxRef.current.querySelector("[data-option-index=\"".concat(index, "\"]"));
      if (!option) {
        return;
      }
      option.classList.add("".concat(unstable_classNamePrefix, "-focused"));
      if (reason === 'keyboard') {
        option.classList.add("".concat(unstable_classNamePrefix, "-focusVisible"));
      }

      // Scroll active descendant into view.
      // Logic copied from https://www.w3.org/WAI/content-assets/wai-aria-practices/patterns/combobox/examples/js/select-only.js
      // In case of mouse clicks and touch (in mobile devices) we avoid scrolling the element and keep both behaviors same.
      // Consider this API instead once it has a better browser support:
      // .scrollIntoView({ scrollMode: 'if-needed', block: 'nearest' });
      if (listboxNode.scrollHeight > listboxNode.clientHeight && reason !== 'mouse' && reason !== 'touch') {
        var element = option;
        var scrollBottom = listboxNode.clientHeight + listboxNode.scrollTop;
        var elementBottom = element.offsetTop + element.offsetHeight;
        if (elementBottom > scrollBottom) {
          listboxNode.scrollTop = elementBottom - listboxNode.clientHeight;
        } else if (element.offsetTop - element.offsetHeight * (groupBy ? 1.3 : 0) < listboxNode.scrollTop) {
          listboxNode.scrollTop = element.offsetTop - element.offsetHeight * (groupBy ? 1.3 : 0);
        }
      }
    });
    var changeHighlightedIndex = useEventCallback(function (_ref3) {
      var event = _ref3.event,
        diff = _ref3.diff,
        _ref3$direction = _ref3.direction,
        direction = _ref3$direction === void 0 ? 'next' : _ref3$direction,
        _ref3$reason = _ref3.reason,
        reason = _ref3$reason === void 0 ? 'auto' : _ref3$reason;
      if (!popupOpen) {
        return;
      }
      var getNextIndex = function getNextIndex() {
        var maxIndex = filteredOptions.length - 1;
        if (diff === 'reset') {
          return defaultHighlighted;
        }
        if (diff === 'start') {
          return 0;
        }
        if (diff === 'end') {
          return maxIndex;
        }
        var newIndex = highlightedIndexRef.current + diff;
        if (newIndex < 0) {
          if (newIndex === -1 && includeInputInList) {
            return -1;
          }
          if (disableListWrap && highlightedIndexRef.current !== -1 || Math.abs(diff) > 1) {
            return 0;
          }
          return maxIndex;
        }
        if (newIndex > maxIndex) {
          if (newIndex === maxIndex + 1 && includeInputInList) {
            return -1;
          }
          if (disableListWrap || Math.abs(diff) > 1) {
            return maxIndex;
          }
          return 0;
        }
        return newIndex;
      };
      var nextIndex = validOptionIndex(getNextIndex(), direction);
      setHighlightedIndex({
        index: nextIndex,
        reason: reason,
        event: event
      });

      // Sync the content of the input with the highlighted option.
      if (autoComplete && diff !== 'reset') {
        if (nextIndex === -1) {
          inputRef.current.value = inputValue;
        } else {
          var option = getOptionLabel(filteredOptions[nextIndex]);
          inputRef.current.value = option;

          // The portion of the selected suggestion that has not been typed by the user,
          // a completion string, appears inline after the input cursor in the textbox.
          var index = option.toLowerCase().indexOf(inputValue.toLowerCase());
          if (index === 0 && inputValue.length > 0) {
            inputRef.current.setSelectionRange(inputValue.length, option.length);
          }
        }
      }
    });
    var getPreviousHighlightedOptionIndex = function getPreviousHighlightedOptionIndex() {
      var isSameValue = function isSameValue(value1, value2) {
        var label1 = value1 ? getOptionLabel(value1) : '';
        var label2 = value2 ? getOptionLabel(value2) : '';
        return label1 === label2;
      };
      if (highlightedIndexRef.current !== -1 && previousProps.filteredOptions && previousProps.filteredOptions.length !== filteredOptions.length && previousProps.inputValue === inputValue && (multiple ? value.length === previousProps.value.length && previousProps.value.every(function (val, i) {
        return getOptionLabel(value[i]) === getOptionLabel(val);
      }) : isSameValue(previousProps.value, value))) {
        var previousHighlightedOption = previousProps.filteredOptions[highlightedIndexRef.current];
        if (previousHighlightedOption) {
          return findIndex(filteredOptions, function (option) {
            return getOptionLabel(option) === getOptionLabel(previousHighlightedOption);
          });
        }
      }
      return -1;
    };
    var syncHighlightedIndex = React__namespace.useCallback(function () {
      if (!popupOpen) {
        return;
      }

      // Check if the previously highlighted option still exists in the updated filtered options list and if the value and inputValue haven't changed
      // If it exists and the value and the inputValue haven't changed, just update its index, otherwise continue execution
      var previousHighlightedOptionIndex = getPreviousHighlightedOptionIndex();
      if (previousHighlightedOptionIndex !== -1) {
        highlightedIndexRef.current = previousHighlightedOptionIndex;
        return;
      }
      var valueItem = multiple ? value[0] : value;

      // The popup is empty, reset
      if (filteredOptions.length === 0 || valueItem == null) {
        changeHighlightedIndex({
          diff: 'reset'
        });
        return;
      }
      if (!listboxRef.current) {
        return;
      }

      // Synchronize the value with the highlighted index
      if (valueItem != null) {
        var currentOption = filteredOptions[highlightedIndexRef.current];

        // Keep the current highlighted index if possible
        if (multiple && currentOption && findIndex(value, function (val) {
          return isOptionEqualToValue(currentOption, val);
        }) !== -1) {
          return;
        }
        var itemIndex = findIndex(filteredOptions, function (optionItem) {
          return isOptionEqualToValue(optionItem, valueItem);
        });
        if (itemIndex === -1) {
          changeHighlightedIndex({
            diff: 'reset'
          });
        } else {
          setHighlightedIndex({
            index: itemIndex
          });
        }
        return;
      }

      // Prevent the highlighted index to leak outside the boundaries.
      if (highlightedIndexRef.current >= filteredOptions.length - 1) {
        setHighlightedIndex({
          index: filteredOptions.length - 1
        });
        return;
      }

      // Restore the focus to the previous index.
      setHighlightedIndex({
        index: highlightedIndexRef.current
      });
      // Ignore filteredOptions (and options, isOptionEqualToValue, getOptionLabel) not to break the scroll position
      // eslint-disable-next-line react-hooks/exhaustive-deps
    }, [
    // Only sync the highlighted index when the option switch between empty and not
    filteredOptions.length,
    // Don't sync the highlighted index with the value when multiple
    // eslint-disable-next-line react-hooks/exhaustive-deps
    multiple ? false : value, filterSelectedOptions, changeHighlightedIndex, setHighlightedIndex, popupOpen, inputValue, multiple]);
    var handleListboxRef = useEventCallback(function (node) {
      setRef(listboxRef, node);
      if (!node) {
        return;
      }
      syncHighlightedIndex();
    });
    {
      // eslint-disable-next-line react-hooks/rules-of-hooks
      React__namespace.useEffect(function () {
        if (!inputRef.current || inputRef.current.nodeName !== 'INPUT') {
          if (inputRef.current && inputRef.current.nodeName === 'TEXTAREA') {
            console.warn(["A textarea element was provided to ".concat(componentName, " where input was expected."), "This is not a supported scenario but it may work under certain conditions.", "A textarea keyboard navigation may conflict with Autocomplete controls (for example enter and arrow keys).", "Make sure to test keyboard navigation and add custom event handlers if necessary."].join('\n'));
          } else {
            console.error(["MUI: Unable to find the input element. It was resolved to ".concat(inputRef.current, " while an HTMLInputElement was expected."), "Instead, ".concat(componentName, " expects an input element."), '', componentName === 'useAutocomplete' ? 'Make sure you have bound getInputProps correctly and that the normal ref/effect resolutions order is guaranteed.' : 'Make sure you have customized the input component correctly.'].join('\n'));
          }
        }
      }, [componentName]);
    }
    React__namespace.useEffect(function () {
      syncHighlightedIndex();
    }, [syncHighlightedIndex]);
    var handleOpen = function handleOpen(event) {
      if (open) {
        return;
      }
      setOpenState(true);
      setInputPristine(true);
      if (onOpen) {
        onOpen(event);
      }
    };
    var handleClose = function handleClose(event, reason) {
      if (!open) {
        return;
      }
      setOpenState(false);
      if (onClose) {
        onClose(event, reason);
      }
    };
    var handleValue = function handleValue(event, newValue, reason, details) {
      if (multiple) {
        if (value.length === newValue.length && value.every(function (val, i) {
          return val === newValue[i];
        })) {
          return;
        }
      } else if (value === newValue) {
        return;
      }
      if (onChange) {
        onChange(event, newValue, reason, details);
      }
      setValueState(newValue);
    };
    var isTouch = React__namespace.useRef(false);
    var selectNewValue = function selectNewValue(event, option) {
      var reasonProp = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'selectOption';
      var origin = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'options';
      var reason = reasonProp;
      var newValue = option;
      if (multiple) {
        newValue = Array.isArray(value) ? value.slice() : [];
        {
          var matches = newValue.filter(function (val) {
            return isOptionEqualToValue(option, val);
          });
          if (matches.length > 1) {
            console.error(["MUI: The `isOptionEqualToValue` method of ".concat(componentName, " does not handle the arguments correctly."), "The component expects a single value to match a given option but found ".concat(matches.length, " matches.")].join('\n'));
          }
        }
        var itemIndex = findIndex(newValue, function (valueItem) {
          return isOptionEqualToValue(option, valueItem);
        });
        if (itemIndex === -1) {
          newValue.push(option);
        } else if (origin !== 'freeSolo') {
          newValue.splice(itemIndex, 1);
          reason = 'removeOption';
        }
      }
      resetInputValue(event, newValue);
      handleValue(event, newValue, reason, {
        option: option
      });
      if (!disableCloseOnSelect && (!event || !event.ctrlKey && !event.metaKey)) {
        handleClose(event, reason);
      }
      if (blurOnSelect === true || blurOnSelect === 'touch' && isTouch.current || blurOnSelect === 'mouse' && !isTouch.current) {
        inputRef.current.blur();
      }
    };
    function validTagIndex(index, direction) {
      if (index === -1) {
        return -1;
      }
      var nextFocus = index;
      while (true) {
        // Out of range
        if (direction === 'next' && nextFocus === value.length || direction === 'previous' && nextFocus === -1) {
          return -1;
        }
        var option = anchorEl.querySelector("[data-tag-index=\"".concat(nextFocus, "\"]"));

        // Same logic as MenuList.js
        if (!option || !option.hasAttribute('tabindex') || option.disabled || option.getAttribute('aria-disabled') === 'true') {
          nextFocus += direction === 'next' ? 1 : -1;
        } else {
          return nextFocus;
        }
      }
    }
    var handleFocusTag = function handleFocusTag(event, direction) {
      if (!multiple) {
        return;
      }
      if (inputValue === '') {
        handleClose(event, 'toggleInput');
      }
      var nextTag = focusedTag;
      if (focusedTag === -1) {
        if (inputValue === '' && direction === 'previous') {
          nextTag = value.length - 1;
        }
      } else {
        nextTag += direction === 'next' ? 1 : -1;
        if (nextTag < 0) {
          nextTag = 0;
        }
        if (nextTag === value.length) {
          nextTag = -1;
        }
      }
      nextTag = validTagIndex(nextTag, direction);
      setFocusedTag(nextTag);
      focusTag(nextTag);
    };
    var handleClear = function handleClear(event) {
      ignoreFocus.current = true;
      setInputValueState('');
      if (onInputChange) {
        onInputChange(event, '', 'clear');
      }
      handleValue(event, multiple ? [] : null, 'clear');
    };
    var handleKeyDown = function handleKeyDown(other) {
      return function (event) {
        if (other.onKeyDown) {
          other.onKeyDown(event);
        }
        if (event.defaultMuiPrevented) {
          return;
        }
        if (focusedTag !== -1 && ['ArrowLeft', 'ArrowRight'].indexOf(event.key) === -1) {
          setFocusedTag(-1);
          focusTag(-1);
        }

        // Wait until IME is settled.
        if (event.which !== 229) {
          switch (event.key) {
            case 'Home':
              if (popupOpen && handleHomeEndKeys) {
                // Prevent scroll of the page
                event.preventDefault();
                changeHighlightedIndex({
                  diff: 'start',
                  direction: 'next',
                  reason: 'keyboard',
                  event: event
                });
              }
              break;
            case 'End':
              if (popupOpen && handleHomeEndKeys) {
                // Prevent scroll of the page
                event.preventDefault();
                changeHighlightedIndex({
                  diff: 'end',
                  direction: 'previous',
                  reason: 'keyboard',
                  event: event
                });
              }
              break;
            case 'PageUp':
              // Prevent scroll of the page
              event.preventDefault();
              changeHighlightedIndex({
                diff: -pageSize,
                direction: 'previous',
                reason: 'keyboard',
                event: event
              });
              handleOpen(event);
              break;
            case 'PageDown':
              // Prevent scroll of the page
              event.preventDefault();
              changeHighlightedIndex({
                diff: pageSize,
                direction: 'next',
                reason: 'keyboard',
                event: event
              });
              handleOpen(event);
              break;
            case 'ArrowDown':
              // Prevent cursor move
              event.preventDefault();
              changeHighlightedIndex({
                diff: 1,
                direction: 'next',
                reason: 'keyboard',
                event: event
              });
              handleOpen(event);
              break;
            case 'ArrowUp':
              // Prevent cursor move
              event.preventDefault();
              changeHighlightedIndex({
                diff: -1,
                direction: 'previous',
                reason: 'keyboard',
                event: event
              });
              handleOpen(event);
              break;
            case 'ArrowLeft':
              handleFocusTag(event, 'previous');
              break;
            case 'ArrowRight':
              handleFocusTag(event, 'next');
              break;
            case 'Enter':
              if (highlightedIndexRef.current !== -1 && popupOpen) {
                var option = filteredOptions[highlightedIndexRef.current];
                var disabled = getOptionDisabled ? getOptionDisabled(option) : false;

                // Avoid early form validation, let the end-users continue filling the form.
                event.preventDefault();
                if (disabled) {
                  return;
                }
                selectNewValue(event, option, 'selectOption');

                // Move the selection to the end.
                if (autoComplete) {
                  inputRef.current.setSelectionRange(inputRef.current.value.length, inputRef.current.value.length);
                }
              } else if (freeSolo && inputValue !== '' && inputValueIsSelectedValue === false) {
                if (multiple) {
                  // Allow people to add new values before they submit the form.
                  event.preventDefault();
                }
                selectNewValue(event, inputValue, 'createOption', 'freeSolo');
              }
              break;
            case 'Escape':
              if (popupOpen) {
                // Avoid Opera to exit fullscreen mode.
                event.preventDefault();
                // Avoid the Modal to handle the event.
                event.stopPropagation();
                handleClose(event, 'escape');
              } else if (clearOnEscape && (inputValue !== '' || multiple && value.length > 0)) {
                // Avoid Opera to exit fullscreen mode.
                event.preventDefault();
                // Avoid the Modal to handle the event.
                event.stopPropagation();
                handleClear(event);
              }
              break;
            case 'Backspace':
              // Remove the value on the left of the "cursor"
              if (multiple && !readOnly && inputValue === '' && value.length > 0) {
                var index = focusedTag === -1 ? value.length - 1 : focusedTag;
                var newValue = value.slice();
                newValue.splice(index, 1);
                handleValue(event, newValue, 'removeOption', {
                  option: value[index]
                });
              }
              break;
            case 'Delete':
              // Remove the value on the right of the "cursor"
              if (multiple && !readOnly && inputValue === '' && value.length > 0 && focusedTag !== -1) {
                var _index = focusedTag;
                var _newValue = value.slice();
                _newValue.splice(_index, 1);
                handleValue(event, _newValue, 'removeOption', {
                  option: value[_index]
                });
              }
              break;
          }
        }
      };
    };
    var handleFocus = function handleFocus(event) {
      setFocused(true);
      if (openOnFocus && !ignoreFocus.current) {
        handleOpen(event);
      }
    };
    var handleBlur = function handleBlur(event) {
      // Ignore the event when using the scrollbar with IE11
      if (unstable_isActiveElementInListbox(listboxRef)) {
        inputRef.current.focus();
        return;
      }
      setFocused(false);
      firstFocus.current = true;
      ignoreFocus.current = false;
      if (autoSelect && highlightedIndexRef.current !== -1 && popupOpen) {
        selectNewValue(event, filteredOptions[highlightedIndexRef.current], 'blur');
      } else if (autoSelect && freeSolo && inputValue !== '') {
        selectNewValue(event, inputValue, 'blur', 'freeSolo');
      } else if (clearOnBlur) {
        resetInputValue(event, value);
      }
      handleClose(event, 'blur');
    };
    var handleInputChange = function handleInputChange(event) {
      var newValue = event.target.value;
      if (inputValue !== newValue) {
        setInputValueState(newValue);
        setInputPristine(false);
        if (onInputChange) {
          onInputChange(event, newValue, 'input');
        }
      }
      if (newValue === '') {
        if (!disableClearable && !multiple) {
          handleValue(event, null, 'clear');
        }
      } else {
        handleOpen(event);
      }
    };
    var handleOptionMouseMove = function handleOptionMouseMove(event) {
      var index = Number(event.currentTarget.getAttribute('data-option-index'));
      if (highlightedIndexRef.current !== index) {
        setHighlightedIndex({
          event: event,
          index: index,
          reason: 'mouse'
        });
      }
    };
    var handleOptionTouchStart = function handleOptionTouchStart(event) {
      setHighlightedIndex({
        event: event,
        index: Number(event.currentTarget.getAttribute('data-option-index')),
        reason: 'touch'
      });
      isTouch.current = true;
    };
    var handleOptionClick = function handleOptionClick(event) {
      var index = Number(event.currentTarget.getAttribute('data-option-index'));
      selectNewValue(event, filteredOptions[index], 'selectOption');
      isTouch.current = false;
    };
    var handleTagDelete = function handleTagDelete(index) {
      return function (event) {
        var newValue = value.slice();
        newValue.splice(index, 1);
        handleValue(event, newValue, 'removeOption', {
          option: value[index]
        });
      };
    };
    var handlePopupIndicator = function handlePopupIndicator(event) {
      if (open) {
        handleClose(event, 'toggleInput');
      } else {
        handleOpen(event);
      }
    };

    // Prevent input blur when interacting with the combobox
    var handleMouseDown = function handleMouseDown(event) {
      // Prevent focusing the input if click is anywhere outside the Autocomplete
      if (!event.currentTarget.contains(event.target)) {
        return;
      }
      if (event.target.getAttribute('id') !== id) {
        event.preventDefault();
      }
    };

    // Focus the input when interacting with the combobox
    var handleClick = function handleClick(event) {
      // Prevent focusing the input if click is anywhere outside the Autocomplete
      if (!event.currentTarget.contains(event.target)) {
        return;
      }
      inputRef.current.focus();
      if (selectOnFocus && firstFocus.current && inputRef.current.selectionEnd - inputRef.current.selectionStart === 0) {
        inputRef.current.select();
      }
      firstFocus.current = false;
    };
    var handleInputMouseDown = function handleInputMouseDown(event) {
      if (!disabledProp && (inputValue === '' || !open)) {
        handlePopupIndicator(event);
      }
    };
    var dirty = freeSolo && inputValue.length > 0;
    dirty = dirty || (multiple ? value.length > 0 : value !== null);
    var groupedOptions = filteredOptions;
    if (groupBy) {
      // used to keep track of key and indexes in the result array
      var indexBy = new Map();
      var warn = false;
      groupedOptions = filteredOptions.reduce(function (acc, option, index) {
        var group = groupBy(option);
        if (acc.length > 0 && acc[acc.length - 1].group === group) {
          acc[acc.length - 1].options.push(option);
        } else {
          {
            if (indexBy.get(group) && !warn) {
              console.warn("MUI: The options provided combined with the `groupBy` method of ".concat(componentName, " returns duplicated headers."), 'You can solve the issue by sorting the options with the output of `groupBy`.');
              warn = true;
            }
            indexBy.set(group, true);
          }
          acc.push({
            key: index,
            index: index,
            group: group,
            options: [option]
          });
        }
        return acc;
      }, []);
    }
    if (disabledProp && focused) {
      handleBlur();
    }
    return {
      getRootProps: function getRootProps() {
        var other = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
        return _extends({
          'aria-owns': listboxAvailable ? "".concat(id, "-listbox") : null
        }, other, {
          onKeyDown: handleKeyDown(other),
          onMouseDown: handleMouseDown,
          onClick: handleClick
        });
      },
      getInputLabelProps: function getInputLabelProps() {
        return {
          id: "".concat(id, "-label"),
          htmlFor: id
        };
      },
      getInputProps: function getInputProps() {
        return {
          id: id,
          value: inputValue,
          onBlur: handleBlur,
          onFocus: handleFocus,
          onChange: handleInputChange,
          onMouseDown: handleInputMouseDown,
          // if open then this is handled imperatively so don't let react override
          // only have an opinion about this when closed
          'aria-activedescendant': popupOpen ? '' : null,
          'aria-autocomplete': autoComplete ? 'both' : 'list',
          'aria-controls': listboxAvailable ? "".concat(id, "-listbox") : undefined,
          'aria-expanded': listboxAvailable,
          // Disable browser's suggestion that might overlap with the popup.
          // Handle autocomplete but not autofill.
          autoComplete: 'off',
          ref: inputRef,
          autoCapitalize: 'none',
          spellCheck: 'false',
          role: 'combobox',
          disabled: disabledProp
        };
      },
      getClearProps: function getClearProps() {
        return {
          tabIndex: -1,
          type: 'button',
          onClick: handleClear
        };
      },
      getPopupIndicatorProps: function getPopupIndicatorProps() {
        return {
          tabIndex: -1,
          type: 'button',
          onClick: handlePopupIndicator
        };
      },
      getTagProps: function getTagProps(_ref4) {
        var index = _ref4.index;
        return _extends({
          key: index,
          'data-tag-index': index,
          tabIndex: -1
        }, !readOnly && {
          onDelete: handleTagDelete(index)
        });
      },
      getListboxProps: function getListboxProps() {
        return {
          role: 'listbox',
          id: "".concat(id, "-listbox"),
          'aria-labelledby': "".concat(id, "-label"),
          ref: handleListboxRef,
          onMouseDown: function onMouseDown(event) {
            // Prevent blur
            event.preventDefault();
          }
        };
      },
      getOptionProps: function getOptionProps(_ref5) {
        var _getOptionKey;
        var index = _ref5.index,
          option = _ref5.option;
        var selected = (multiple ? value : [value]).some(function (value2) {
          return value2 != null && isOptionEqualToValue(option, value2);
        });
        var disabled = getOptionDisabled ? getOptionDisabled(option) : false;
        return {
          key: (_getOptionKey = getOptionKey == null ? void 0 : getOptionKey(option)) != null ? _getOptionKey : getOptionLabel(option),
          tabIndex: -1,
          role: 'option',
          id: "".concat(id, "-option-").concat(index),
          onMouseMove: handleOptionMouseMove,
          onClick: handleOptionClick,
          onTouchStart: handleOptionTouchStart,
          'data-option-index': index,
          'aria-disabled': disabled,
          'aria-selected': selected
        };
      },
      id: id,
      inputValue: inputValue,
      value: value,
      dirty: dirty,
      expanded: popupOpen && anchorEl,
      popupOpen: popupOpen,
      focused: focused || focusedTag !== -1,
      anchorEl: anchorEl,
      setAnchorEl: setAnchorEl,
      focusedTag: focusedTag,
      groupedOptions: groupedOptions
    };
  }

  var top = 'top';
  var bottom = 'bottom';
  var right = 'right';
  var left = 'left';
  var auto = 'auto';
  var basePlacements = [top, bottom, right, left];
  var start = 'start';
  var end = 'end';
  var clippingParents = 'clippingParents';
  var viewport = 'viewport';
  var popper = 'popper';
  var reference = 'reference';
  var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) {
    return acc.concat([placement + "-" + start, placement + "-" + end]);
  }, []);
  var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) {
    return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
  }, []); // modifiers that need to read the DOM

  var beforeRead = 'beforeRead';
  var read = 'read';
  var afterRead = 'afterRead'; // pure-logic modifiers

  var beforeMain = 'beforeMain';
  var main = 'main';
  var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state)

  var beforeWrite = 'beforeWrite';
  var write = 'write';
  var afterWrite = 'afterWrite';
  var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];

  function getNodeName(element) {
    return element ? (element.nodeName || '').toLowerCase() : null;
  }

  function getWindow(node) {
    if (node == null) {
      return window;
    }

    if (node.toString() !== '[object Window]') {
      var ownerDocument = node.ownerDocument;
      return ownerDocument ? ownerDocument.defaultView || window : window;
    }

    return node;
  }

  function isElement(node) {
    var OwnElement = getWindow(node).Element;
    return node instanceof OwnElement || node instanceof Element;
  }

  function isHTMLElement$1(node) {
    var OwnElement = getWindow(node).HTMLElement;
    return node instanceof OwnElement || node instanceof HTMLElement;
  }

  function isShadowRoot(node) {
    // IE 11 has no ShadowRoot
    if (typeof ShadowRoot === 'undefined') {
      return false;
    }

    var OwnElement = getWindow(node).ShadowRoot;
    return node instanceof OwnElement || node instanceof ShadowRoot;
  }

  // and applies them to the HTMLElements such as popper and arrow

  function applyStyles(_ref) {
    var state = _ref.state;
    Object.keys(state.elements).forEach(function (name) {
      var style = state.styles[name] || {};
      var attributes = state.attributes[name] || {};
      var element = state.elements[name]; // arrow is optional + virtual elements

      if (!isHTMLElement$1(element) || !getNodeName(element)) {
        return;
      } // Flow doesn't support to extend this property, but it's the most
      // effective way to apply styles to an HTMLElement
      // $FlowFixMe[cannot-write]


      Object.assign(element.style, style);
      Object.keys(attributes).forEach(function (name) {
        var value = attributes[name];

        if (value === false) {
          element.removeAttribute(name);
        } else {
          element.setAttribute(name, value === true ? '' : value);
        }
      });
    });
  }

  function effect$2(_ref2) {
    var state = _ref2.state;
    var initialStyles = {
      popper: {
        position: state.options.strategy,
        left: '0',
        top: '0',
        margin: '0'
      },
      arrow: {
        position: 'absolute'
      },
      reference: {}
    };
    Object.assign(state.elements.popper.style, initialStyles.popper);
    state.styles = initialStyles;

    if (state.elements.arrow) {
      Object.assign(state.elements.arrow.style, initialStyles.arrow);
    }

    return function () {
      Object.keys(state.elements).forEach(function (name) {
        var element = state.elements[name];
        var attributes = state.attributes[name] || {};
        var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them

        var style = styleProperties.reduce(function (style, property) {
          style[property] = '';
          return style;
        }, {}); // arrow is optional + virtual elements

        if (!isHTMLElement$1(element) || !getNodeName(element)) {
          return;
        }

        Object.assign(element.style, style);
        Object.keys(attributes).forEach(function (attribute) {
          element.removeAttribute(attribute);
        });
      });
    };
  } // eslint-disable-next-line import/no-unused-modules


  var applyStyles$1 = {
    name: 'applyStyles',
    enabled: true,
    phase: 'write',
    fn: applyStyles,
    effect: effect$2,
    requires: ['computeStyles']
  };

  function getBasePlacement(placement) {
    return placement.split('-')[0];
  }

  var max = Math.max;
  var min = Math.min;
  var round$1 = Math.round;

  function getUAString() {
    var uaData = navigator.userAgentData;

    if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) {
      return uaData.brands.map(function (item) {
        return item.brand + "/" + item.version;
      }).join(' ');
    }

    return navigator.userAgent;
  }

  function isLayoutViewport() {
    return !/^((?!chrome|android).)*safari/i.test(getUAString());
  }

  function getBoundingClientRect(element, includeScale, isFixedStrategy) {
    if (includeScale === void 0) {
      includeScale = false;
    }

    if (isFixedStrategy === void 0) {
      isFixedStrategy = false;
    }

    var clientRect = element.getBoundingClientRect();
    var scaleX = 1;
    var scaleY = 1;

    if (includeScale && isHTMLElement$1(element)) {
      scaleX = element.offsetWidth > 0 ? round$1(clientRect.width) / element.offsetWidth || 1 : 1;
      scaleY = element.offsetHeight > 0 ? round$1(clientRect.height) / element.offsetHeight || 1 : 1;
    }

    var _ref = isElement(element) ? getWindow(element) : window,
        visualViewport = _ref.visualViewport;

    var addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
    var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX;
    var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY;
    var width = clientRect.width / scaleX;
    var height = clientRect.height / scaleY;
    return {
      width: width,
      height: height,
      top: y,
      right: x + width,
      bottom: y + height,
      left: x,
      x: x,
      y: y
    };
  }

  // means it doesn't take into account transforms.

  function getLayoutRect(element) {
    var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed.
    // Fixes https://github.com/popperjs/popper-core/issues/1223

    var width = element.offsetWidth;
    var height = element.offsetHeight;

    if (Math.abs(clientRect.width - width) <= 1) {
      width = clientRect.width;
    }

    if (Math.abs(clientRect.height - height) <= 1) {
      height = clientRect.height;
    }

    return {
      x: element.offsetLeft,
      y: element.offsetTop,
      width: width,
      height: height
    };
  }

  function contains(parent, child) {
    var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method

    if (parent.contains(child)) {
      return true;
    } // then fallback to custom implementation with Shadow DOM support
    else if (rootNode && isShadowRoot(rootNode)) {
        var next = child;

        do {
          if (next && parent.isSameNode(next)) {
            return true;
          } // $FlowFixMe[prop-missing]: need a better way to handle this...


          next = next.parentNode || next.host;
        } while (next);
      } // Give up, the result is false


    return false;
  }

  function getComputedStyle(element) {
    return getWindow(element).getComputedStyle(element);
  }

  function isTableElement(element) {
    return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;
  }

  function getDocumentElement(element) {
    // $FlowFixMe[incompatible-return]: assume body is always available
    return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing]
    element.document) || window.document).documentElement;
  }

  function getParentNode(element) {
    if (getNodeName(element) === 'html') {
      return element;
    }

    return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
      // $FlowFixMe[incompatible-return]
      // $FlowFixMe[prop-missing]
      element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
      element.parentNode || ( // DOM Element detected
      isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
      // $FlowFixMe[incompatible-call]: HTMLElement is a Node
      getDocumentElement(element) // fallback

    );
  }

  function getTrueOffsetParent(element) {
    if (!isHTMLElement$1(element) || // https://github.com/popperjs/popper-core/issues/837
    getComputedStyle(element).position === 'fixed') {
      return null;
    }

    return element.offsetParent;
  } // `.offsetParent` reports `null` for fixed elements, while absolute elements
  // return the containing block


  function getContainingBlock(element) {
    var isFirefox = /firefox/i.test(getUAString());
    var isIE = /Trident/i.test(getUAString());

    if (isIE && isHTMLElement$1(element)) {
      // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
      var elementCss = getComputedStyle(element);

      if (elementCss.position === 'fixed') {
        return null;
      }
    }

    var currentNode = getParentNode(element);

    if (isShadowRoot(currentNode)) {
      currentNode = currentNode.host;
    }

    while (isHTMLElement$1(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {
      var css = getComputedStyle(currentNode); // This is non-exhaustive but covers the most common CSS properties that
      // create a containing block.
      // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block

      if (css.transform !== 'none' || css.perspective !== 'none' || css.contain === 'paint' || ['transform', 'perspective'].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === 'filter' || isFirefox && css.filter && css.filter !== 'none') {
        return currentNode;
      } else {
        currentNode = currentNode.parentNode;
      }
    }

    return null;
  } // Gets the closest ancestor positioned element. Handles some edge cases,
  // such as table ancestors and cross browser bugs.


  function getOffsetParent(element) {
    var window = getWindow(element);
    var offsetParent = getTrueOffsetParent(element);

    while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') {
      offsetParent = getTrueOffsetParent(offsetParent);
    }

    if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static')) {
      return window;
    }

    return offsetParent || getContainingBlock(element) || window;
  }

  function getMainAxisFromPlacement(placement) {
    return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';
  }

  function within(min$1, value, max$1) {
    return max(min$1, min(value, max$1));
  }
  function withinMaxClamp(min, value, max) {
    var v = within(min, value, max);
    return v > max ? max : v;
  }

  function getFreshSideObject() {
    return {
      top: 0,
      right: 0,
      bottom: 0,
      left: 0
    };
  }

  function mergePaddingObject(paddingObject) {
    return Object.assign({}, getFreshSideObject(), paddingObject);
  }

  function expandToHashMap(value, keys) {
    return keys.reduce(function (hashMap, key) {
      hashMap[key] = value;
      return hashMap;
    }, {});
  }

  var toPaddingObject = function toPaddingObject(padding, state) {
    padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, {
      placement: state.placement
    })) : padding;
    return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
  };

  function arrow(_ref) {
    var _state$modifiersData$;

    var state = _ref.state,
        name = _ref.name,
        options = _ref.options;
    var arrowElement = state.elements.arrow;
    var popperOffsets = state.modifiersData.popperOffsets;
    var basePlacement = getBasePlacement(state.placement);
    var axis = getMainAxisFromPlacement(basePlacement);
    var isVertical = [left, right].indexOf(basePlacement) >= 0;
    var len = isVertical ? 'height' : 'width';

    if (!arrowElement || !popperOffsets) {
      return;
    }

    var paddingObject = toPaddingObject(options.padding, state);
    var arrowRect = getLayoutRect(arrowElement);
    var minProp = axis === 'y' ? top : left;
    var maxProp = axis === 'y' ? bottom : right;
    var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
    var startDiff = popperOffsets[axis] - state.rects.reference[axis];
    var arrowOffsetParent = getOffsetParent(arrowElement);
    var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
    var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is
    // outside of the popper bounds

    var min = paddingObject[minProp];
    var max = clientSize - arrowRect[len] - paddingObject[maxProp];
    var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
    var offset = within(min, center, max); // Prevents breaking syntax highlighting...

    var axisProp = axis;
    state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
  }

  function effect$1(_ref2) {
    var state = _ref2.state,
        options = _ref2.options;
    var _options$element = options.element,
        arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element;

    if (arrowElement == null) {
      return;
    } // CSS selector


    if (typeof arrowElement === 'string') {
      arrowElement = state.elements.popper.querySelector(arrowElement);

      if (!arrowElement) {
        return;
      }
    }

    if (!contains(state.elements.popper, arrowElement)) {
      return;
    }

    state.elements.arrow = arrowElement;
  } // eslint-disable-next-line import/no-unused-modules


  var arrow$1 = {
    name: 'arrow',
    enabled: true,
    phase: 'main',
    fn: arrow,
    effect: effect$1,
    requires: ['popperOffsets'],
    requiresIfExists: ['preventOverflow']
  };

  function getVariation(placement) {
    return placement.split('-')[1];
  }

  var unsetSides = {
    top: 'auto',
    right: 'auto',
    bottom: 'auto',
    left: 'auto'
  }; // Round the offsets to the nearest suitable subpixel based on the DPR.
  // Zooming can change the DPR, but it seems to report a value that will
  // cleanly divide the values into the appropriate subpixels.

  function roundOffsetsByDPR(_ref, win) {
    var x = _ref.x,
        y = _ref.y;
    var dpr = win.devicePixelRatio || 1;
    return {
      x: round$1(x * dpr) / dpr || 0,
      y: round$1(y * dpr) / dpr || 0
    };
  }

  function mapToStyles(_ref2) {
    var _Object$assign2;

    var popper = _ref2.popper,
        popperRect = _ref2.popperRect,
        placement = _ref2.placement,
        variation = _ref2.variation,
        offsets = _ref2.offsets,
        position = _ref2.position,
        gpuAcceleration = _ref2.gpuAcceleration,
        adaptive = _ref2.adaptive,
        roundOffsets = _ref2.roundOffsets,
        isFixed = _ref2.isFixed;
    var _offsets$x = offsets.x,
        x = _offsets$x === void 0 ? 0 : _offsets$x,
        _offsets$y = offsets.y,
        y = _offsets$y === void 0 ? 0 : _offsets$y;

    var _ref3 = typeof roundOffsets === 'function' ? roundOffsets({
      x: x,
      y: y
    }) : {
      x: x,
      y: y
    };

    x = _ref3.x;
    y = _ref3.y;
    var hasX = offsets.hasOwnProperty('x');
    var hasY = offsets.hasOwnProperty('y');
    var sideX = left;
    var sideY = top;
    var win = window;

    if (adaptive) {
      var offsetParent = getOffsetParent(popper);
      var heightProp = 'clientHeight';
      var widthProp = 'clientWidth';

      if (offsetParent === getWindow(popper)) {
        offsetParent = getDocumentElement(popper);

        if (getComputedStyle(offsetParent).position !== 'static' && position === 'absolute') {
          heightProp = 'scrollHeight';
          widthProp = 'scrollWidth';
        }
      } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it


      offsetParent = offsetParent;

      if (placement === top || (placement === left || placement === right) && variation === end) {
        sideY = bottom;
        var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : // $FlowFixMe[prop-missing]
        offsetParent[heightProp];
        y -= offsetY - popperRect.height;
        y *= gpuAcceleration ? 1 : -1;
      }

      if (placement === left || (placement === top || placement === bottom) && variation === end) {
        sideX = right;
        var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : // $FlowFixMe[prop-missing]
        offsetParent[widthProp];
        x -= offsetX - popperRect.width;
        x *= gpuAcceleration ? 1 : -1;
      }
    }

    var commonStyles = Object.assign({
      position: position
    }, adaptive && unsetSides);

    var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
      x: x,
      y: y
    }, getWindow(popper)) : {
      x: x,
      y: y
    };

    x = _ref4.x;
    y = _ref4.y;

    if (gpuAcceleration) {
      var _Object$assign;

      return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
    }

    return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2));
  }

  function computeStyles(_ref5) {
    var state = _ref5.state,
        options = _ref5.options;
    var _options$gpuAccelerat = options.gpuAcceleration,
        gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat,
        _options$adaptive = options.adaptive,
        adaptive = _options$adaptive === void 0 ? true : _options$adaptive,
        _options$roundOffsets = options.roundOffsets,
        roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
    var commonStyles = {
      placement: getBasePlacement(state.placement),
      variation: getVariation(state.placement),
      popper: state.elements.popper,
      popperRect: state.rects.popper,
      gpuAcceleration: gpuAcceleration,
      isFixed: state.options.strategy === 'fixed'
    };

    if (state.modifiersData.popperOffsets != null) {
      state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
        offsets: state.modifiersData.popperOffsets,
        position: state.options.strategy,
        adaptive: adaptive,
        roundOffsets: roundOffsets
      })));
    }

    if (state.modifiersData.arrow != null) {
      state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
        offsets: state.modifiersData.arrow,
        position: 'absolute',
        adaptive: false,
        roundOffsets: roundOffsets
      })));
    }

    state.attributes.popper = Object.assign({}, state.attributes.popper, {
      'data-popper-placement': state.placement
    });
  } // eslint-disable-next-line import/no-unused-modules


  var computeStyles$1 = {
    name: 'computeStyles',
    enabled: true,
    phase: 'beforeWrite',
    fn: computeStyles,
    data: {}
  };

  var passive = {
    passive: true
  };

  function effect(_ref) {
    var state = _ref.state,
        instance = _ref.instance,
        options = _ref.options;
    var _options$scroll = options.scroll,
        scroll = _options$scroll === void 0 ? true : _options$scroll,
        _options$resize = options.resize,
        resize = _options$resize === void 0 ? true : _options$resize;
    var window = getWindow(state.elements.popper);
    var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);

    if (scroll) {
      scrollParents.forEach(function (scrollParent) {
        scrollParent.addEventListener('scroll', instance.update, passive);
      });
    }

    if (resize) {
      window.addEventListener('resize', instance.update, passive);
    }

    return function () {
      if (scroll) {
        scrollParents.forEach(function (scrollParent) {
          scrollParent.removeEventListener('scroll', instance.update, passive);
        });
      }

      if (resize) {
        window.removeEventListener('resize', instance.update, passive);
      }
    };
  } // eslint-disable-next-line import/no-unused-modules


  var eventListeners = {
    name: 'eventListeners',
    enabled: true,
    phase: 'write',
    fn: function fn() {},
    effect: effect,
    data: {}
  };

  var hash$1 = {
    left: 'right',
    right: 'left',
    bottom: 'top',
    top: 'bottom'
  };
  function getOppositePlacement(placement) {
    return placement.replace(/left|right|bottom|top/g, function (matched) {
      return hash$1[matched];
    });
  }

  var hash = {
    start: 'end',
    end: 'start'
  };
  function getOppositeVariationPlacement(placement) {
    return placement.replace(/start|end/g, function (matched) {
      return hash[matched];
    });
  }

  function getWindowScroll(node) {
    var win = getWindow(node);
    var scrollLeft = win.pageXOffset;
    var scrollTop = win.pageYOffset;
    return {
      scrollLeft: scrollLeft,
      scrollTop: scrollTop
    };
  }

  function getWindowScrollBarX(element) {
    // If <html> has a CSS width greater than the viewport, then this will be
    // incorrect for RTL.
    // Popper 1 is broken in this case and never had a bug report so let's assume
    // it's not an issue. I don't think anyone ever specifies width on <html>
    // anyway.
    // Browsers where the left scrollbar doesn't cause an issue report `0` for
    // this (e.g. Edge 2019, IE11, Safari)
    return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
  }

  function getViewportRect(element, strategy) {
    var win = getWindow(element);
    var html = getDocumentElement(element);
    var visualViewport = win.visualViewport;
    var width = html.clientWidth;
    var height = html.clientHeight;
    var x = 0;
    var y = 0;

    if (visualViewport) {
      width = visualViewport.width;
      height = visualViewport.height;
      var layoutViewport = isLayoutViewport();

      if (layoutViewport || !layoutViewport && strategy === 'fixed') {
        x = visualViewport.offsetLeft;
        y = visualViewport.offsetTop;
      }
    }

    return {
      width: width,
      height: height,
      x: x + getWindowScrollBarX(element),
      y: y
    };
  }

  // of the `<html>` and `<body>` rect bounds if horizontally scrollable

  function getDocumentRect(element) {
    var _element$ownerDocumen;

    var html = getDocumentElement(element);
    var winScroll = getWindowScroll(element);
    var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
    var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
    var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
    var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
    var y = -winScroll.scrollTop;

    if (getComputedStyle(body || html).direction === 'rtl') {
      x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
    }

    return {
      width: width,
      height: height,
      x: x,
      y: y
    };
  }

  function isScrollParent(element) {
    // Firefox wants us to check `-x` and `-y` variations as well
    var _getComputedStyle = getComputedStyle(element),
        overflow = _getComputedStyle.overflow,
        overflowX = _getComputedStyle.overflowX,
        overflowY = _getComputedStyle.overflowY;

    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
  }

  function getScrollParent(node) {
    if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {
      // $FlowFixMe[incompatible-return]: assume body is always available
      return node.ownerDocument.body;
    }

    if (isHTMLElement$1(node) && isScrollParent(node)) {
      return node;
    }

    return getScrollParent(getParentNode(node));
  }

  /*
  given a DOM element, return the list of all scroll parents, up the list of ancesors
  until we get to the top window object. This list is what we attach scroll listeners
  to, because if any of these parent elements scroll, we'll need to re-calculate the
  reference element's position.
  */

  function listScrollParents(element, list) {
    var _element$ownerDocumen;

    if (list === void 0) {
      list = [];
    }

    var scrollParent = getScrollParent(element);
    var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
    var win = getWindow(scrollParent);
    var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
    var updatedList = list.concat(target);
    return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
    updatedList.concat(listScrollParents(getParentNode(target)));
  }

  function rectToClientRect(rect) {
    return Object.assign({}, rect, {
      left: rect.x,
      top: rect.y,
      right: rect.x + rect.width,
      bottom: rect.y + rect.height
    });
  }

  function getInnerBoundingClientRect(element, strategy) {
    var rect = getBoundingClientRect(element, false, strategy === 'fixed');
    rect.top = rect.top + element.clientTop;
    rect.left = rect.left + element.clientLeft;
    rect.bottom = rect.top + element.clientHeight;
    rect.right = rect.left + element.clientWidth;
    rect.width = element.clientWidth;
    rect.height = element.clientHeight;
    rect.x = rect.left;
    rect.y = rect.top;
    return rect;
  }

  function getClientRectFromMixedType(element, clippingParent, strategy) {
    return clippingParent === viewport ? rectToClientRect(getViewportRect(element, strategy)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent, strategy) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
  } // A "clipping parent" is an overflowable container with the characteristic of
  // clipping (or hiding) overflowing elements with a position different from
  // `initial`


  function getClippingParents(element) {
    var clippingParents = listScrollParents(getParentNode(element));
    var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle(element).position) >= 0;
    var clipperElement = canEscapeClipping && isHTMLElement$1(element) ? getOffsetParent(element) : element;

    if (!isElement(clipperElement)) {
      return [];
    } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414


    return clippingParents.filter(function (clippingParent) {
      return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body';
    });
  } // Gets the maximum area that the element is visible in due to any number of
  // clipping parents


  function getClippingRect(element, boundary, rootBoundary, strategy) {
    var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary);
    var clippingParents = [].concat(mainClippingParents, [rootBoundary]);
    var firstClippingParent = clippingParents[0];
    var clippingRect = clippingParents.reduce(function (accRect, clippingParent) {
      var rect = getClientRectFromMixedType(element, clippingParent, strategy);
      accRect.top = max(rect.top, accRect.top);
      accRect.right = min(rect.right, accRect.right);
      accRect.bottom = min(rect.bottom, accRect.bottom);
      accRect.left = max(rect.left, accRect.left);
      return accRect;
    }, getClientRectFromMixedType(element, firstClippingParent, strategy));
    clippingRect.width = clippingRect.right - clippingRect.left;
    clippingRect.height = clippingRect.bottom - clippingRect.top;
    clippingRect.x = clippingRect.left;
    clippingRect.y = clippingRect.top;
    return clippingRect;
  }

  function computeOffsets(_ref) {
    var reference = _ref.reference,
        element = _ref.element,
        placement = _ref.placement;
    var basePlacement = placement ? getBasePlacement(placement) : null;
    var variation = placement ? getVariation(placement) : null;
    var commonX = reference.x + reference.width / 2 - element.width / 2;
    var commonY = reference.y + reference.height / 2 - element.height / 2;
    var offsets;

    switch (basePlacement) {
      case top:
        offsets = {
          x: commonX,
          y: reference.y - element.height
        };
        break;

      case bottom:
        offsets = {
          x: commonX,
          y: reference.y + reference.height
        };
        break;

      case right:
        offsets = {
          x: reference.x + reference.width,
          y: commonY
        };
        break;

      case left:
        offsets = {
          x: reference.x - element.width,
          y: commonY
        };
        break;

      default:
        offsets = {
          x: reference.x,
          y: reference.y
        };
    }

    var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;

    if (mainAxis != null) {
      var len = mainAxis === 'y' ? 'height' : 'width';

      switch (variation) {
        case start:
          offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
          break;

        case end:
          offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
          break;
      }
    }

    return offsets;
  }

  function detectOverflow(state, options) {
    if (options === void 0) {
      options = {};
    }

    var _options = options,
        _options$placement = _options.placement,
        placement = _options$placement === void 0 ? state.placement : _options$placement,
        _options$strategy = _options.strategy,
        strategy = _options$strategy === void 0 ? state.strategy : _options$strategy,
        _options$boundary = _options.boundary,
        boundary = _options$boundary === void 0 ? clippingParents : _options$boundary,
        _options$rootBoundary = _options.rootBoundary,
        rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary,
        _options$elementConte = _options.elementContext,
        elementContext = _options$elementConte === void 0 ? popper : _options$elementConte,
        _options$altBoundary = _options.altBoundary,
        altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary,
        _options$padding = _options.padding,
        padding = _options$padding === void 0 ? 0 : _options$padding;
    var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
    var altContext = elementContext === popper ? reference : popper;
    var popperRect = state.rects.popper;
    var element = state.elements[altBoundary ? altContext : elementContext];
    var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary, strategy);
    var referenceClientRect = getBoundingClientRect(state.elements.reference);
    var popperOffsets = computeOffsets({
      reference: referenceClientRect,
      element: popperRect,
      strategy: 'absolute',
      placement: placement
    });
    var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets));
    var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect
    // 0 or negative = within the clipping rect

    var overflowOffsets = {
      top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
      bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
      left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
      right: elementClientRect.right - clippingClientRect.right + paddingObject.right
    };
    var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element

    if (elementContext === popper && offsetData) {
      var offset = offsetData[placement];
      Object.keys(overflowOffsets).forEach(function (key) {
        var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
        var axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x';
        overflowOffsets[key] += offset[axis] * multiply;
      });
    }

    return overflowOffsets;
  }

  function computeAutoPlacement(state, options) {
    if (options === void 0) {
      options = {};
    }

    var _options = options,
        placement = _options.placement,
        boundary = _options.boundary,
        rootBoundary = _options.rootBoundary,
        padding = _options.padding,
        flipVariations = _options.flipVariations,
        _options$allowedAutoP = _options.allowedAutoPlacements,
        allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP;
    var variation = getVariation(placement);
    var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) {
      return getVariation(placement) === variation;
    }) : basePlacements;
    var allowedPlacements = placements$1.filter(function (placement) {
      return allowedAutoPlacements.indexOf(placement) >= 0;
    });

    if (allowedPlacements.length === 0) {
      allowedPlacements = placements$1;
    } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions...


    var overflows = allowedPlacements.reduce(function (acc, placement) {
      acc[placement] = detectOverflow(state, {
        placement: placement,
        boundary: boundary,
        rootBoundary: rootBoundary,
        padding: padding
      })[getBasePlacement(placement)];
      return acc;
    }, {});
    return Object.keys(overflows).sort(function (a, b) {
      return overflows[a] - overflows[b];
    });
  }

  function getExpandedFallbackPlacements(placement) {
    if (getBasePlacement(placement) === auto) {
      return [];
    }

    var oppositePlacement = getOppositePlacement(placement);
    return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)];
  }

  function flip(_ref) {
    var state = _ref.state,
        options = _ref.options,
        name = _ref.name;

    if (state.modifiersData[name]._skip) {
      return;
    }

    var _options$mainAxis = options.mainAxis,
        checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,
        _options$altAxis = options.altAxis,
        checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis,
        specifiedFallbackPlacements = options.fallbackPlacements,
        padding = options.padding,
        boundary = options.boundary,
        rootBoundary = options.rootBoundary,
        altBoundary = options.altBoundary,
        _options$flipVariatio = options.flipVariations,
        flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio,
        allowedAutoPlacements = options.allowedAutoPlacements;
    var preferredPlacement = state.options.placement;
    var basePlacement = getBasePlacement(preferredPlacement);
    var isBasePlacement = basePlacement === preferredPlacement;
    var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));
    var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function (acc, placement) {
      return acc.concat(getBasePlacement(placement) === auto ? computeAutoPlacement(state, {
        placement: placement,
        boundary: boundary,
        rootBoundary: rootBoundary,
        padding: padding,
        flipVariations: flipVariations,
        allowedAutoPlacements: allowedAutoPlacements
      }) : placement);
    }, []);
    var referenceRect = state.rects.reference;
    var popperRect = state.rects.popper;
    var checksMap = new Map();
    var makeFallbackChecks = true;
    var firstFittingPlacement = placements[0];

    for (var i = 0; i < placements.length; i++) {
      var placement = placements[i];

      var _basePlacement = getBasePlacement(placement);

      var isStartVariation = getVariation(placement) === start;
      var isVertical = [top, bottom].indexOf(_basePlacement) >= 0;
      var len = isVertical ? 'width' : 'height';
      var overflow = detectOverflow(state, {
        placement: placement,
        boundary: boundary,
        rootBoundary: rootBoundary,
        altBoundary: altBoundary,
        padding: padding
      });
      var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;

      if (referenceRect[len] > popperRect[len]) {
        mainVariationSide = getOppositePlacement(mainVariationSide);
      }

      var altVariationSide = getOppositePlacement(mainVariationSide);
      var checks = [];

      if (checkMainAxis) {
        checks.push(overflow[_basePlacement] <= 0);
      }

      if (checkAltAxis) {
        checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
      }

      if (checks.every(function (check) {
        return check;
      })) {
        firstFittingPlacement = placement;
        makeFallbackChecks = false;
        break;
      }

      checksMap.set(placement, checks);
    }

    if (makeFallbackChecks) {
      // `2` may be desired in some cases – research later
      var numberOfChecks = flipVariations ? 3 : 1;

      var _loop = function _loop(_i) {
        var fittingPlacement = placements.find(function (placement) {
          var checks = checksMap.get(placement);

          if (checks) {
            return checks.slice(0, _i).every(function (check) {
              return check;
            });
          }
        });

        if (fittingPlacement) {
          firstFittingPlacement = fittingPlacement;
          return "break";
        }
      };

      for (var _i = numberOfChecks; _i > 0; _i--) {
        var _ret = _loop(_i);

        if (_ret === "break") break;
      }
    }

    if (state.placement !== firstFittingPlacement) {
      state.modifiersData[name]._skip = true;
      state.placement = firstFittingPlacement;
      state.reset = true;
    }
  } // eslint-disable-next-line import/no-unused-modules


  var flip$1 = {
    name: 'flip',
    enabled: true,
    phase: 'main',
    fn: flip,
    requiresIfExists: ['offset'],
    data: {
      _skip: false
    }
  };

  function getSideOffsets(overflow, rect, preventedOffsets) {
    if (preventedOffsets === void 0) {
      preventedOffsets = {
        x: 0,
        y: 0
      };
    }

    return {
      top: overflow.top - rect.height - preventedOffsets.y,
      right: overflow.right - rect.width + preventedOffsets.x,
      bottom: overflow.bottom - rect.height + preventedOffsets.y,
      left: overflow.left - rect.width - preventedOffsets.x
    };
  }

  function isAnySideFullyClipped(overflow) {
    return [top, right, bottom, left].some(function (side) {
      return overflow[side] >= 0;
    });
  }

  function hide(_ref) {
    var state = _ref.state,
        name = _ref.name;
    var referenceRect = state.rects.reference;
    var popperRect = state.rects.popper;
    var preventedOffsets = state.modifiersData.preventOverflow;
    var referenceOverflow = detectOverflow(state, {
      elementContext: 'reference'
    });
    var popperAltOverflow = detectOverflow(state, {
      altBoundary: true
    });
    var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
    var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
    var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
    var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
    state.modifiersData[name] = {
      referenceClippingOffsets: referenceClippingOffsets,
      popperEscapeOffsets: popperEscapeOffsets,
      isReferenceHidden: isReferenceHidden,
      hasPopperEscaped: hasPopperEscaped
    };
    state.attributes.popper = Object.assign({}, state.attributes.popper, {
      'data-popper-reference-hidden': isReferenceHidden,
      'data-popper-escaped': hasPopperEscaped
    });
  } // eslint-disable-next-line import/no-unused-modules


  var hide$1 = {
    name: 'hide',
    enabled: true,
    phase: 'main',
    requiresIfExists: ['preventOverflow'],
    fn: hide
  };

  function distanceAndSkiddingToXY(placement, rects, offset) {
    var basePlacement = getBasePlacement(placement);
    var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;

    var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, {
      placement: placement
    })) : offset,
        skidding = _ref[0],
        distance = _ref[1];

    skidding = skidding || 0;
    distance = (distance || 0) * invertDistance;
    return [left, right].indexOf(basePlacement) >= 0 ? {
      x: distance,
      y: skidding
    } : {
      x: skidding,
      y: distance
    };
  }

  function offset(_ref2) {
    var state = _ref2.state,
        options = _ref2.options,
        name = _ref2.name;
    var _options$offset = options.offset,
        offset = _options$offset === void 0 ? [0, 0] : _options$offset;
    var data = placements.reduce(function (acc, placement) {
      acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);
      return acc;
    }, {});
    var _data$state$placement = data[state.placement],
        x = _data$state$placement.x,
        y = _data$state$placement.y;

    if (state.modifiersData.popperOffsets != null) {
      state.modifiersData.popperOffsets.x += x;
      state.modifiersData.popperOffsets.y += y;
    }

    state.modifiersData[name] = data;
  } // eslint-disable-next-line import/no-unused-modules


  var offset$1 = {
    name: 'offset',
    enabled: true,
    phase: 'main',
    requires: ['popperOffsets'],
    fn: offset
  };

  function popperOffsets(_ref) {
    var state = _ref.state,
        name = _ref.name;
    // Offsets are the actual position the popper needs to have to be
    // properly positioned near its reference element
    // This is the most basic placement, and will be adjusted by
    // the modifiers in the next step
    state.modifiersData[name] = computeOffsets({
      reference: state.rects.reference,
      element: state.rects.popper,
      strategy: 'absolute',
      placement: state.placement
    });
  } // eslint-disable-next-line import/no-unused-modules


  var popperOffsets$1 = {
    name: 'popperOffsets',
    enabled: true,
    phase: 'read',
    fn: popperOffsets,
    data: {}
  };

  function getAltAxis(axis) {
    return axis === 'x' ? 'y' : 'x';
  }

  function preventOverflow(_ref) {
    var state = _ref.state,
        options = _ref.options,
        name = _ref.name;
    var _options$mainAxis = options.mainAxis,
        checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,
        _options$altAxis = options.altAxis,
        checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis,
        boundary = options.boundary,
        rootBoundary = options.rootBoundary,
        altBoundary = options.altBoundary,
        padding = options.padding,
        _options$tether = options.tether,
        tether = _options$tether === void 0 ? true : _options$tether,
        _options$tetherOffset = options.tetherOffset,
        tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
    var overflow = detectOverflow(state, {
      boundary: boundary,
      rootBoundary: rootBoundary,
      padding: padding,
      altBoundary: altBoundary
    });
    var basePlacement = getBasePlacement(state.placement);
    var variation = getVariation(state.placement);
    var isBasePlacement = !variation;
    var mainAxis = getMainAxisFromPlacement(basePlacement);
    var altAxis = getAltAxis(mainAxis);
    var popperOffsets = state.modifiersData.popperOffsets;
    var referenceRect = state.rects.reference;
    var popperRect = state.rects.popper;
    var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign({}, state.rects, {
      placement: state.placement
    })) : tetherOffset;
    var normalizedTetherOffsetValue = typeof tetherOffsetValue === 'number' ? {
      mainAxis: tetherOffsetValue,
      altAxis: tetherOffsetValue
    } : Object.assign({
      mainAxis: 0,
      altAxis: 0
    }, tetherOffsetValue);
    var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null;
    var data = {
      x: 0,
      y: 0
    };

    if (!popperOffsets) {
      return;
    }

    if (checkMainAxis) {
      var _offsetModifierState$;

      var mainSide = mainAxis === 'y' ? top : left;
      var altSide = mainAxis === 'y' ? bottom : right;
      var len = mainAxis === 'y' ? 'height' : 'width';
      var offset = popperOffsets[mainAxis];
      var min$1 = offset + overflow[mainSide];
      var max$1 = offset - overflow[altSide];
      var additive = tether ? -popperRect[len] / 2 : 0;
      var minLen = variation === start ? referenceRect[len] : popperRect[len];
      var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go
      // outside the reference bounds

      var arrowElement = state.elements.arrow;
      var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
        width: 0,
        height: 0
      };
      var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject();
      var arrowPaddingMin = arrowPaddingObject[mainSide];
      var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want
      // to include its full size in the calculation. If the reference is small
      // and near the edge of a boundary, the popper can overflow even if the
      // reference is not overflowing as well (e.g. virtual elements with no
      // width or height)

      var arrowLen = within(0, referenceRect[len], arrowRect[len]);
      var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis;
      var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis;
      var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);
      var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
      var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
      var tetherMin = offset + minOffset - offsetModifierValue - clientOffset;
      var tetherMax = offset + maxOffset - offsetModifierValue;
      var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset, tether ? max(max$1, tetherMax) : max$1);
      popperOffsets[mainAxis] = preventedOffset;
      data[mainAxis] = preventedOffset - offset;
    }

    if (checkAltAxis) {
      var _offsetModifierState$2;

      var _mainSide = mainAxis === 'x' ? top : left;

      var _altSide = mainAxis === 'x' ? bottom : right;

      var _offset = popperOffsets[altAxis];

      var _len = altAxis === 'y' ? 'height' : 'width';

      var _min = _offset + overflow[_mainSide];

      var _max = _offset - overflow[_altSide];

      var isOriginSide = [top, left].indexOf(basePlacement) !== -1;

      var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0;

      var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis;

      var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max;

      var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max);

      popperOffsets[altAxis] = _preventedOffset;
      data[altAxis] = _preventedOffset - _offset;
    }

    state.modifiersData[name] = data;
  } // eslint-disable-next-line import/no-unused-modules


  var preventOverflow$1 = {
    name: 'preventOverflow',
    enabled: true,
    phase: 'main',
    fn: preventOverflow,
    requiresIfExists: ['offset']
  };

  function getHTMLElementScroll(element) {
    return {
      scrollLeft: element.scrollLeft,
      scrollTop: element.scrollTop
    };
  }

  function getNodeScroll(node) {
    if (node === getWindow(node) || !isHTMLElement$1(node)) {
      return getWindowScroll(node);
    } else {
      return getHTMLElementScroll(node);
    }
  }

  function isElementScaled(element) {
    var rect = element.getBoundingClientRect();
    var scaleX = round$1(rect.width) / element.offsetWidth || 1;
    var scaleY = round$1(rect.height) / element.offsetHeight || 1;
    return scaleX !== 1 || scaleY !== 1;
  } // Returns the composite rect of an element relative to its offsetParent.
  // Composite means it takes into account transforms as well as layout.


  function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
    if (isFixed === void 0) {
      isFixed = false;
    }

    var isOffsetParentAnElement = isHTMLElement$1(offsetParent);
    var offsetParentIsScaled = isHTMLElement$1(offsetParent) && isElementScaled(offsetParent);
    var documentElement = getDocumentElement(offsetParent);
    var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled, isFixed);
    var scroll = {
      scrollLeft: 0,
      scrollTop: 0
    };
    var offsets = {
      x: 0,
      y: 0
    };

    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
      if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078
      isScrollParent(documentElement)) {
        scroll = getNodeScroll(offsetParent);
      }

      if (isHTMLElement$1(offsetParent)) {
        offsets = getBoundingClientRect(offsetParent, true);
        offsets.x += offsetParent.clientLeft;
        offsets.y += offsetParent.clientTop;
      } else if (documentElement) {
        offsets.x = getWindowScrollBarX(documentElement);
      }
    }

    return {
      x: rect.left + scroll.scrollLeft - offsets.x,
      y: rect.top + scroll.scrollTop - offsets.y,
      width: rect.width,
      height: rect.height
    };
  }

  function order(modifiers) {
    var map = new Map();
    var visited = new Set();
    var result = [];
    modifiers.forEach(function (modifier) {
      map.set(modifier.name, modifier);
    }); // On visiting object, check for its dependencies and visit them recursively

    function sort(modifier) {
      visited.add(modifier.name);
      var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
      requires.forEach(function (dep) {
        if (!visited.has(dep)) {
          var depModifier = map.get(dep);

          if (depModifier) {
            sort(depModifier);
          }
        }
      });
      result.push(modifier);
    }

    modifiers.forEach(function (modifier) {
      if (!visited.has(modifier.name)) {
        // check for visited object
        sort(modifier);
      }
    });
    return result;
  }

  function orderModifiers(modifiers) {
    // order based on dependencies
    var orderedModifiers = order(modifiers); // order based on phase

    return modifierPhases.reduce(function (acc, phase) {
      return acc.concat(orderedModifiers.filter(function (modifier) {
        return modifier.phase === phase;
      }));
    }, []);
  }

  function debounce(fn) {
    var pending;
    return function () {
      if (!pending) {
        pending = new Promise(function (resolve) {
          Promise.resolve().then(function () {
            pending = undefined;
            resolve(fn());
          });
        });
      }

      return pending;
    };
  }

  function mergeByName(modifiers) {
    var merged = modifiers.reduce(function (merged, current) {
      var existing = merged[current.name];
      merged[current.name] = existing ? Object.assign({}, existing, current, {
        options: Object.assign({}, existing.options, current.options),
        data: Object.assign({}, existing.data, current.data)
      }) : current;
      return merged;
    }, {}); // IE11 does not support Object.values

    return Object.keys(merged).map(function (key) {
      return merged[key];
    });
  }

  var DEFAULT_OPTIONS = {
    placement: 'bottom',
    modifiers: [],
    strategy: 'absolute'
  };

  function areValidElements() {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return !args.some(function (element) {
      return !(element && typeof element.getBoundingClientRect === 'function');
    });
  }

  function popperGenerator(generatorOptions) {
    if (generatorOptions === void 0) {
      generatorOptions = {};
    }

    var _generatorOptions = generatorOptions,
        _generatorOptions$def = _generatorOptions.defaultModifiers,
        defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def,
        _generatorOptions$def2 = _generatorOptions.defaultOptions,
        defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
    return function createPopper(reference, popper, options) {
      if (options === void 0) {
        options = defaultOptions;
      }

      var state = {
        placement: 'bottom',
        orderedModifiers: [],
        options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
        modifiersData: {},
        elements: {
          reference: reference,
          popper: popper
        },
        attributes: {},
        styles: {}
      };
      var effectCleanupFns = [];
      var isDestroyed = false;
      var instance = {
        state: state,
        setOptions: function setOptions(setOptionsAction) {
          var options = typeof setOptionsAction === 'function' ? setOptionsAction(state.options) : setOptionsAction;
          cleanupModifierEffects();
          state.options = Object.assign({}, defaultOptions, state.options, options);
          state.scrollParents = {
            reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [],
            popper: listScrollParents(popper)
          }; // Orders the modifiers based on their dependencies and `phase`
          // properties

          var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers

          state.orderedModifiers = orderedModifiers.filter(function (m) {
            return m.enabled;
          });
          runModifierEffects();
          return instance.update();
        },
        // Sync update – it will always be executed, even if not necessary. This
        // is useful for low frequency updates where sync behavior simplifies the
        // logic.
        // For high frequency updates (e.g. `resize` and `scroll` events), always
        // prefer the async Popper#update method
        forceUpdate: function forceUpdate() {
          if (isDestroyed) {
            return;
          }

          var _state$elements = state.elements,
              reference = _state$elements.reference,
              popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements
          // anymore

          if (!areValidElements(reference, popper)) {
            return;
          } // Store the reference and popper rects to be read by modifiers


          state.rects = {
            reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'),
            popper: getLayoutRect(popper)
          }; // Modifiers have the ability to reset the current update cycle. The
          // most common use case for this is the `flip` modifier changing the
          // placement, which then needs to re-run all the modifiers, because the
          // logic was previously ran for the previous placement and is therefore
          // stale/incorrect

          state.reset = false;
          state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier
          // is filled with the initial data specified by the modifier. This means
          // it doesn't persist and is fresh on each update.
          // To ensure persistent data, use `${name}#persistent`

          state.orderedModifiers.forEach(function (modifier) {
            return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
          });

          for (var index = 0; index < state.orderedModifiers.length; index++) {
            if (state.reset === true) {
              state.reset = false;
              index = -1;
              continue;
            }

            var _state$orderedModifie = state.orderedModifiers[index],
                fn = _state$orderedModifie.fn,
                _state$orderedModifie2 = _state$orderedModifie.options,
                _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2,
                name = _state$orderedModifie.name;

            if (typeof fn === 'function') {
              state = fn({
                state: state,
                options: _options,
                name: name,
                instance: instance
              }) || state;
            }
          }
        },
        // Async and optimistically optimized update – it will not be executed if
        // not necessary (debounced to run at most once-per-tick)
        update: debounce(function () {
          return new Promise(function (resolve) {
            instance.forceUpdate();
            resolve(state);
          });
        }),
        destroy: function destroy() {
          cleanupModifierEffects();
          isDestroyed = true;
        }
      };

      if (!areValidElements(reference, popper)) {
        return instance;
      }

      instance.setOptions(options).then(function (state) {
        if (!isDestroyed && options.onFirstUpdate) {
          options.onFirstUpdate(state);
        }
      }); // Modifiers have the ability to execute arbitrary code before the first
      // update cycle runs. They will be executed in the same order as the update
      // cycle. This is useful when a modifier adds some persistent data that
      // other modifiers need to use, but the modifier is run after the dependent
      // one.

      function runModifierEffects() {
        state.orderedModifiers.forEach(function (_ref) {
          var name = _ref.name,
              _ref$options = _ref.options,
              options = _ref$options === void 0 ? {} : _ref$options,
              effect = _ref.effect;

          if (typeof effect === 'function') {
            var cleanupFn = effect({
              state: state,
              name: name,
              instance: instance,
              options: options
            });

            var noopFn = function noopFn() {};

            effectCleanupFns.push(cleanupFn || noopFn);
          }
        });
      }

      function cleanupModifierEffects() {
        effectCleanupFns.forEach(function (fn) {
          return fn();
        });
        effectCleanupFns = [];
      }

      return instance;
    };
  }

  var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1];
  var createPopper = /*#__PURE__*/popperGenerator({
    defaultModifiers: defaultModifiers
  }); // eslint-disable-next-line import/no-unused-modules

  function getContainer$1(container) {
    return typeof container === 'function' ? container() : container;
  }

  /**
   * Portals provide a first-class way to render children into a DOM node
   * that exists outside the DOM hierarchy of the parent component.
   *
   * Demos:
   *
   * - [Portal](https://mui.com/material-ui/react-portal/)
   *
   * API:
   *
   * - [Portal API](https://mui.com/material-ui/api/portal/)
   */
  var Portal = /*#__PURE__*/React__namespace.forwardRef(function Portal(props, forwardedRef) {
    var children = props.children,
      container = props.container,
      _props$disablePortal = props.disablePortal,
      disablePortal = _props$disablePortal === void 0 ? false : _props$disablePortal;
    var _React$useState = React__namespace.useState(null),
      mountNode = _React$useState[0],
      setMountNode = _React$useState[1];
    var handleRef = useForkRef( /*#__PURE__*/React__namespace.isValidElement(children) ? getReactElementRef(children) : null, forwardedRef);
    useEnhancedEffect$1(function () {
      if (!disablePortal) {
        setMountNode(getContainer$1(container) || document.body);
      }
    }, [container, disablePortal]);
    useEnhancedEffect$1(function () {
      if (mountNode && !disablePortal) {
        setRef(forwardedRef, mountNode);
        return function () {
          setRef(forwardedRef, null);
        };
      }
      return undefined;
    }, [forwardedRef, mountNode, disablePortal]);
    if (disablePortal) {
      if ( /*#__PURE__*/React__namespace.isValidElement(children)) {
        var newProps = {
          ref: handleRef
        };
        return /*#__PURE__*/React__namespace.cloneElement(children, newProps);
      }
      return /*#__PURE__*/jsxRuntimeExports.jsx(React__namespace.Fragment, {
        children: children
      });
    }
    return /*#__PURE__*/jsxRuntimeExports.jsx(React__namespace.Fragment, {
      children: mountNode ? /*#__PURE__*/ReactDOM__namespace.createPortal(children, mountNode) : mountNode
    });
  });
  Portal.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The children to render into the `container`.
     */
    children: PropTypes.node,
    /**
     * An HTML element or function that returns one.
     * The `container` will have the portal children appended to it.
     *
     * You can also provide a callback, which is called in a React layout effect.
     * This lets you set the container from a ref, and also makes server-side rendering possible.
     *
     * By default, it uses the body of the top-level document object,
     * so it's simply `document.body` most of the time.
     */
    container: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.func]),
    /**
     * The `children` will be under the DOM hierarchy of the parent component.
     * @default false
     */
    disablePortal: PropTypes.bool
  } ;
  {
    // eslint-disable-next-line
    Portal['propTypes' + ''] = exactProp(Portal.propTypes);
  }
  var Portal$1 = Portal;

  function getPopperUtilityClass(slot) {
    return generateUtilityClass('MuiPopper', slot);
  }
  generateUtilityClasses('MuiPopper', ['root']);

  function flipPlacement(placement, direction) {
    if (direction === 'ltr') {
      return placement;
    }
    switch (placement) {
      case 'bottom-end':
        return 'bottom-start';
      case 'bottom-start':
        return 'bottom-end';
      case 'top-end':
        return 'top-start';
      case 'top-start':
        return 'top-end';
      default:
        return placement;
    }
  }
  function resolveAnchorEl$1(anchorEl) {
    return typeof anchorEl === 'function' ? anchorEl() : anchorEl;
  }
  function isHTMLElement(element) {
    return element.nodeType !== undefined;
  }
  function isVirtualElement(element) {
    return !isHTMLElement(element);
  }
  var useUtilityClasses$1C = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    return composeClasses(slots, getPopperUtilityClass, classes);
  };
  var defaultPopperOptions = {};
  var PopperTooltip = /*#__PURE__*/React__namespace.forwardRef(function PopperTooltip(props, forwardedRef) {
    var _slots$root;
    var anchorEl = props.anchorEl,
      children = props.children,
      direction = props.direction,
      disablePortal = props.disablePortal,
      modifiers = props.modifiers,
      open = props.open,
      initialPlacement = props.placement,
      popperOptions = props.popperOptions,
      popperRefProp = props.popperRef,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      TransitionProps = props.TransitionProps;
      props.ownerState;
      var other = _objectWithoutProperties(props, ["anchorEl", "children", "direction", "disablePortal", "modifiers", "open", "placement", "popperOptions", "popperRef", "slotProps", "slots", "TransitionProps", "ownerState"]);
    var tooltipRef = React__namespace.useRef(null);
    var ownRef = useForkRef(tooltipRef, forwardedRef);
    var popperRef = React__namespace.useRef(null);
    var handlePopperRef = useForkRef(popperRef, popperRefProp);
    var handlePopperRefRef = React__namespace.useRef(handlePopperRef);
    useEnhancedEffect$1(function () {
      handlePopperRefRef.current = handlePopperRef;
    }, [handlePopperRef]);
    React__namespace.useImperativeHandle(popperRefProp, function () {
      return popperRef.current;
    }, []);
    var rtlPlacement = flipPlacement(initialPlacement, direction);
    /**
     * placement initialized from prop but can change during lifetime if modifiers.flip.
     * modifiers.flip is essentially a flip for controlled/uncontrolled behavior
     */
    var _React$useState = React__namespace.useState(rtlPlacement),
      placement = _React$useState[0],
      setPlacement = _React$useState[1];
    var _React$useState2 = React__namespace.useState(resolveAnchorEl$1(anchorEl)),
      resolvedAnchorElement = _React$useState2[0],
      setResolvedAnchorElement = _React$useState2[1];
    React__namespace.useEffect(function () {
      if (popperRef.current) {
        popperRef.current.forceUpdate();
      }
    });
    React__namespace.useEffect(function () {
      if (anchorEl) {
        setResolvedAnchorElement(resolveAnchorEl$1(anchorEl));
      }
    }, [anchorEl]);
    useEnhancedEffect$1(function () {
      if (!resolvedAnchorElement || !open) {
        return undefined;
      }
      var handlePopperUpdate = function handlePopperUpdate(data) {
        setPlacement(data.placement);
      };
      {
        if (resolvedAnchorElement && isHTMLElement(resolvedAnchorElement) && resolvedAnchorElement.nodeType === 1) {
          var box = resolvedAnchorElement.getBoundingClientRect();
          if (box.top === 0 && box.left === 0 && box.right === 0 && box.bottom === 0) {
            console.warn(['MUI: The `anchorEl` prop provided to the component is invalid.', 'The anchor element should be part of the document layout.', "Make sure the element is present in the document or that it's not display none."].join('\n'));
          }
        }
      }
      var popperModifiers = [{
        name: 'preventOverflow',
        options: {
          altBoundary: disablePortal
        }
      }, {
        name: 'flip',
        options: {
          altBoundary: disablePortal
        }
      }, {
        name: 'onUpdate',
        enabled: true,
        phase: 'afterWrite',
        fn: function fn(_ref) {
          var state = _ref.state;
          handlePopperUpdate(state);
        }
      }];
      if (modifiers != null) {
        popperModifiers = popperModifiers.concat(modifiers);
      }
      if (popperOptions && popperOptions.modifiers != null) {
        popperModifiers = popperModifiers.concat(popperOptions.modifiers);
      }
      var popper = createPopper(resolvedAnchorElement, tooltipRef.current, _extends({
        placement: rtlPlacement
      }, popperOptions, {
        modifiers: popperModifiers
      }));
      handlePopperRefRef.current(popper);
      return function () {
        popper.destroy();
        handlePopperRefRef.current(null);
      };
    }, [resolvedAnchorElement, disablePortal, modifiers, open, popperOptions, rtlPlacement]);
    var childProps = {
      placement: placement
    };
    if (TransitionProps !== null) {
      childProps.TransitionProps = TransitionProps;
    }
    var classes = useUtilityClasses$1C(props);
    var Root = (_slots$root = slots.root) != null ? _slots$root : 'div';
    var rootProps = useSlotProps({
      elementType: Root,
      externalSlotProps: slotProps.root,
      externalForwardedProps: other,
      additionalProps: {
        role: 'tooltip',
        ref: ownRef
      },
      ownerState: props,
      className: classes.root
    });
    return /*#__PURE__*/jsxRuntimeExports.jsx(Root, _extends({}, rootProps, {
      children: typeof children === 'function' ? children(childProps) : children
    }));
  });

  /**
   * @ignore - internal component.
   */
  var Popper$2 = /*#__PURE__*/React__namespace.forwardRef(function Popper(props, forwardedRef) {
    var anchorEl = props.anchorEl,
      children = props.children,
      containerProp = props.container,
      _props$direction = props.direction,
      direction = _props$direction === void 0 ? 'ltr' : _props$direction,
      _props$disablePortal = props.disablePortal,
      disablePortal = _props$disablePortal === void 0 ? false : _props$disablePortal,
      _props$keepMounted = props.keepMounted,
      keepMounted = _props$keepMounted === void 0 ? false : _props$keepMounted,
      modifiers = props.modifiers,
      open = props.open,
      _props$placement = props.placement,
      placement = _props$placement === void 0 ? 'bottom' : _props$placement,
      _props$popperOptions = props.popperOptions,
      popperOptions = _props$popperOptions === void 0 ? defaultPopperOptions : _props$popperOptions,
      popperRef = props.popperRef,
      style = props.style,
      _props$transition = props.transition,
      transition = _props$transition === void 0 ? false : _props$transition,
      _props$slotProps2 = props.slotProps,
      slotProps = _props$slotProps2 === void 0 ? {} : _props$slotProps2,
      _props$slots2 = props.slots,
      slots = _props$slots2 === void 0 ? {} : _props$slots2,
      other = _objectWithoutProperties(props, ["anchorEl", "children", "container", "direction", "disablePortal", "keepMounted", "modifiers", "open", "placement", "popperOptions", "popperRef", "style", "transition", "slotProps", "slots"]);
    var _React$useState3 = React__namespace.useState(true),
      exited = _React$useState3[0],
      setExited = _React$useState3[1];
    var handleEnter = function handleEnter() {
      setExited(false);
    };
    var handleExited = function handleExited() {
      setExited(true);
    };
    if (!keepMounted && !open && (!transition || exited)) {
      return null;
    }

    // If the container prop is provided, use that
    // If the anchorEl prop is provided, use its parent body element as the container
    // If neither are provided let the Modal take care of choosing the container
    var container;
    if (containerProp) {
      container = containerProp;
    } else if (anchorEl) {
      var resolvedAnchorEl = resolveAnchorEl$1(anchorEl);
      container = resolvedAnchorEl && isHTMLElement(resolvedAnchorEl) ? ownerDocument(resolvedAnchorEl).body : ownerDocument(null).body;
    }
    var display = !open && keepMounted && (!transition || exited) ? 'none' : undefined;
    var transitionProps = transition ? {
      "in": open,
      onEnter: handleEnter,
      onExited: handleExited
    } : undefined;
    return /*#__PURE__*/jsxRuntimeExports.jsx(Portal$1, {
      disablePortal: disablePortal,
      container: container,
      children: /*#__PURE__*/jsxRuntimeExports.jsx(PopperTooltip, _extends({
        anchorEl: anchorEl,
        direction: direction,
        disablePortal: disablePortal,
        modifiers: modifiers,
        ref: forwardedRef,
        open: transition ? !exited : open,
        placement: placement,
        popperOptions: popperOptions,
        popperRef: popperRef,
        slotProps: slotProps,
        slots: slots
      }, other, {
        style: _extends({
          // Prevents scroll issue, waiting for Popper.js to add this style once initiated.
          position: 'fixed',
          // Fix Popper.js display issue
          top: 0,
          left: 0,
          display: display
        }, style),
        TransitionProps: transitionProps,
        children: children
      }))
    });
  });
  Popper$2.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * An HTML element, [virtualElement](https://popper.js.org/docs/v2/virtual-elements/),
     * or a function that returns either.
     * It's used to set the position of the popper.
     * The return value will passed as the reference object of the Popper instance.
     */
    anchorEl: chainPropTypes(PropTypes.oneOfType([HTMLElementType, PropTypes.object, PropTypes.func]), function (props) {
      if (props.open) {
        var resolvedAnchorEl = resolveAnchorEl$1(props.anchorEl);
        if (resolvedAnchorEl && isHTMLElement(resolvedAnchorEl) && resolvedAnchorEl.nodeType === 1) {
          var box = resolvedAnchorEl.getBoundingClientRect();
          if (box.top === 0 && box.left === 0 && box.right === 0 && box.bottom === 0) {
            return new Error(['MUI: The `anchorEl` prop provided to the component is invalid.', 'The anchor element should be part of the document layout.', "Make sure the element is present in the document or that it's not display none."].join('\n'));
          }
        } else if (!resolvedAnchorEl || typeof resolvedAnchorEl.getBoundingClientRect !== 'function' || isVirtualElement(resolvedAnchorEl) && resolvedAnchorEl.contextElement != null && resolvedAnchorEl.contextElement.nodeType !== 1) {
          return new Error(['MUI: The `anchorEl` prop provided to the component is invalid.', 'It should be an HTML element instance or a virtualElement ', '(https://popper.js.org/docs/v2/virtual-elements/).'].join('\n'));
        }
      }
      return null;
    }),
    /**
     * Popper render function or node.
     */
    children: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.node, PropTypes.func]),
    /**
     * An HTML element or function that returns one.
     * The `container` will have the portal children appended to it.
     *
     * You can also provide a callback, which is called in a React layout effect.
     * This lets you set the container from a ref, and also makes server-side rendering possible.
     *
     * By default, it uses the body of the top-level document object,
     * so it's simply `document.body` most of the time.
     */
    container: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.func]),
    /**
     * Direction of the text.
     * @default 'ltr'
     */
    direction: PropTypes.oneOf(['ltr', 'rtl']),
    /**
     * The `children` will be under the DOM hierarchy of the parent component.
     * @default false
     */
    disablePortal: PropTypes.bool,
    /**
     * Always keep the children in the DOM.
     * This prop can be useful in SEO situation or
     * when you want to maximize the responsiveness of the Popper.
     * @default false
     */
    keepMounted: PropTypes.bool,
    /**
     * Popper.js is based on a "plugin-like" architecture,
     * most of its features are fully encapsulated "modifiers".
     *
     * A modifier is a function that is called each time Popper.js needs to
     * compute the position of the popper.
     * For this reason, modifiers should be very performant to avoid bottlenecks.
     * To learn how to create a modifier, [read the modifiers documentation](https://popper.js.org/docs/v2/modifiers/).
     */
    modifiers: PropTypes.arrayOf(PropTypes.shape({
      data: PropTypes.object,
      effect: PropTypes.func,
      enabled: PropTypes.bool,
      fn: PropTypes.func,
      name: PropTypes.any,
      options: PropTypes.object,
      phase: PropTypes.oneOf(['afterMain', 'afterRead', 'afterWrite', 'beforeMain', 'beforeRead', 'beforeWrite', 'main', 'read', 'write']),
      requires: PropTypes.arrayOf(PropTypes.string),
      requiresIfExists: PropTypes.arrayOf(PropTypes.string)
    })),
    /**
     * If `true`, the component is shown.
     */
    open: PropTypes.bool.isRequired,
    /**
     * Popper placement.
     * @default 'bottom'
     */
    placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
    /**
     * Options provided to the [`Popper.js`](https://popper.js.org/docs/v2/constructors/#options) instance.
     * @default {}
     */
    popperOptions: PropTypes.shape({
      modifiers: PropTypes.array,
      onFirstUpdate: PropTypes.func,
      placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
      strategy: PropTypes.oneOf(['absolute', 'fixed'])
    }),
    /**
     * A ref that points to the used popper instance.
     */
    popperRef: refType$1,
    /**
     * The props used for each slot inside the Popper.
     * @default {}
     */
    slotProps: PropTypes.shape({
      root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * The components used for each slot inside the Popper.
     * Either a string to use a HTML element or a component.
     * @default {}
     */
    slots: PropTypes.shape({
      root: PropTypes.elementType
    }),
    /**
     * Help supporting a react-transition-group/Transition component.
     * @default false
     */
    transition: PropTypes.bool
  } ;
  var BasePopper = Popper$2;

  var PopperRoot = styled$1(BasePopper, {
    name: 'MuiPopper',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })({});

  /**
   *
   * Demos:
   *
   * - [Autocomplete](https://mui.com/material-ui/react-autocomplete/)
   * - [Menu](https://mui.com/material-ui/react-menu/)
   * - [Popper](https://mui.com/material-ui/react-popper/)
   *
   * API:
   *
   * - [Popper API](https://mui.com/material-ui/api/popper/)
   */
  var Popper = /*#__PURE__*/React__namespace.forwardRef(function Popper(inProps, ref) {
    var _slots$root;
    var theme = useTheme$3();
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiPopper'
    });
    var anchorEl = props.anchorEl,
      component = props.component,
      components = props.components,
      componentsProps = props.componentsProps,
      container = props.container,
      disablePortal = props.disablePortal,
      keepMounted = props.keepMounted,
      modifiers = props.modifiers,
      open = props.open,
      placement = props.placement,
      popperOptions = props.popperOptions,
      popperRef = props.popperRef,
      transition = props.transition,
      slots = props.slots,
      slotProps = props.slotProps,
      other = _objectWithoutProperties(props, ["anchorEl", "component", "components", "componentsProps", "container", "disablePortal", "keepMounted", "modifiers", "open", "placement", "popperOptions", "popperRef", "transition", "slots", "slotProps"]);
    var RootComponent = (_slots$root = slots == null ? void 0 : slots.root) != null ? _slots$root : components == null ? void 0 : components.Root;
    var otherProps = _extends({
      anchorEl: anchorEl,
      container: container,
      disablePortal: disablePortal,
      keepMounted: keepMounted,
      modifiers: modifiers,
      open: open,
      placement: placement,
      popperOptions: popperOptions,
      popperRef: popperRef,
      transition: transition
    }, other);
    return /*#__PURE__*/jsxRuntimeExports.jsx(PopperRoot, _extends({
      as: component,
      direction: theme == null ? void 0 : theme.direction,
      slots: {
        root: RootComponent
      },
      slotProps: slotProps != null ? slotProps : componentsProps
    }, otherProps, {
      ref: ref
    }));
  });
  Popper.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * An HTML element, [virtualElement](https://popper.js.org/docs/v2/virtual-elements/),
     * or a function that returns either.
     * It's used to set the position of the popper.
     * The return value will passed as the reference object of the Popper instance.
     */
    anchorEl: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.object, PropTypes.func]),
    /**
     * Popper render function or node.
     */
    children: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.node, PropTypes.func]),
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The components used for each slot inside the Popper.
     * Either a string to use a HTML element or a component.
     * @default {}
     */
    components: PropTypes.shape({
      Root: PropTypes.elementType
    }),
    /**
     * The props used for each slot inside the Popper.
     * @default {}
     */
    componentsProps: PropTypes.shape({
      root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * An HTML element or function that returns one.
     * The `container` will have the portal children appended to it.
     *
     * You can also provide a callback, which is called in a React layout effect.
     * This lets you set the container from a ref, and also makes server-side rendering possible.
     *
     * By default, it uses the body of the top-level document object,
     * so it's simply `document.body` most of the time.
     */
    container: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.func]),
    /**
     * The `children` will be under the DOM hierarchy of the parent component.
     * @default false
     */
    disablePortal: PropTypes.bool,
    /**
     * Always keep the children in the DOM.
     * This prop can be useful in SEO situation or
     * when you want to maximize the responsiveness of the Popper.
     * @default false
     */
    keepMounted: PropTypes.bool,
    /**
     * Popper.js is based on a "plugin-like" architecture,
     * most of its features are fully encapsulated "modifiers".
     *
     * A modifier is a function that is called each time Popper.js needs to
     * compute the position of the popper.
     * For this reason, modifiers should be very performant to avoid bottlenecks.
     * To learn how to create a modifier, [read the modifiers documentation](https://popper.js.org/docs/v2/modifiers/).
     */
    modifiers: PropTypes.arrayOf(PropTypes.shape({
      data: PropTypes.object,
      effect: PropTypes.func,
      enabled: PropTypes.bool,
      fn: PropTypes.func,
      name: PropTypes.any,
      options: PropTypes.object,
      phase: PropTypes.oneOf(['afterMain', 'afterRead', 'afterWrite', 'beforeMain', 'beforeRead', 'beforeWrite', 'main', 'read', 'write']),
      requires: PropTypes.arrayOf(PropTypes.string),
      requiresIfExists: PropTypes.arrayOf(PropTypes.string)
    })),
    /**
     * If `true`, the component is shown.
     */
    open: PropTypes.bool.isRequired,
    /**
     * Popper placement.
     * @default 'bottom'
     */
    placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
    /**
     * Options provided to the [`Popper.js`](https://popper.js.org/docs/v2/constructors/#options) instance.
     * @default {}
     */
    popperOptions: PropTypes.shape({
      modifiers: PropTypes.array,
      onFirstUpdate: PropTypes.func,
      placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
      strategy: PropTypes.oneOf(['absolute', 'fixed'])
    }),
    /**
     * A ref that points to the used popper instance.
     */
    popperRef: refType$1,
    /**
     * The props used for each slot inside the Popper.
     * @default {}
     */
    slotProps: PropTypes.shape({
      root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * The components used for each slot inside the Popper.
     * Either a string to use a HTML element or a component.
     * @default {}
     */
    slots: PropTypes.shape({
      root: PropTypes.elementType
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * Help supporting a react-transition-group/Transition component.
     * @default false
     */
    transition: PropTypes.bool
  } ;
  var Popper$1 = Popper;

  function getListSubheaderUtilityClass(slot) {
    return generateUtilityClass('MuiListSubheader', slot);
  }
  var listSubheaderClasses = generateUtilityClasses('MuiListSubheader', ['root', 'colorPrimary', 'colorInherit', 'gutters', 'inset', 'sticky']);
  var listSubheaderClasses$1 = listSubheaderClasses;

  var useUtilityClasses$1B = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      color = ownerState.color,
      disableGutters = ownerState.disableGutters,
      inset = ownerState.inset,
      disableSticky = ownerState.disableSticky;
    var slots = {
      root: ['root', color !== 'default' && "color".concat(capitalize(color)), !disableGutters && 'gutters', inset && 'inset', !disableSticky && 'sticky']
    };
    return composeClasses(slots, getListSubheaderUtilityClass, classes);
  };
  var ListSubheaderRoot = styled$1('li', {
    name: 'MuiListSubheader',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.color !== 'default' && styles["color".concat(capitalize(ownerState.color))], !ownerState.disableGutters && styles.gutters, ownerState.inset && styles.inset, !ownerState.disableSticky && styles.sticky];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      boxSizing: 'border-box',
      lineHeight: '48px',
      listStyle: 'none',
      color: (theme.vars || theme).palette.text.secondary,
      fontFamily: theme.typography.fontFamily,
      fontWeight: theme.typography.fontWeightMedium,
      fontSize: theme.typography.pxToRem(14)
    }, ownerState.color === 'primary' && {
      color: (theme.vars || theme).palette.primary.main
    }, ownerState.color === 'inherit' && {
      color: 'inherit'
    }, !ownerState.disableGutters && {
      paddingLeft: 16,
      paddingRight: 16
    }, ownerState.inset && {
      paddingLeft: 72
    }, !ownerState.disableSticky && {
      position: 'sticky',
      top: 0,
      zIndex: 1,
      backgroundColor: (theme.vars || theme).palette.background.paper
    });
  });
  var ListSubheader = /*#__PURE__*/React__namespace.forwardRef(function ListSubheader(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiListSubheader'
    });
    var className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'default' : _props$color,
      _props$component = props.component,
      component = _props$component === void 0 ? 'li' : _props$component,
      _props$disableGutters = props.disableGutters,
      disableGutters = _props$disableGutters === void 0 ? false : _props$disableGutters,
      _props$disableSticky = props.disableSticky,
      disableSticky = _props$disableSticky === void 0 ? false : _props$disableSticky,
      _props$inset = props.inset,
      inset = _props$inset === void 0 ? false : _props$inset,
      other = _objectWithoutProperties(props, ["className", "color", "component", "disableGutters", "disableSticky", "inset"]);
    var ownerState = _extends({}, props, {
      color: color,
      component: component,
      disableGutters: disableGutters,
      disableSticky: disableSticky,
      inset: inset
    });
    var classes = useUtilityClasses$1B(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(ListSubheaderRoot, _extends({
      as: component,
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState
    }, other));
  });
  ListSubheader.muiSkipListHighlight = true;
  ListSubheader.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component. It supports those theme colors that make sense for this component.
     * @default 'default'
     */
    color: PropTypes.oneOf(['default', 'inherit', 'primary']),
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, the List Subheader will not have gutters.
     * @default false
     */
    disableGutters: PropTypes.bool,
    /**
     * If `true`, the List Subheader will not stick to the top during scroll.
     * @default false
     */
    disableSticky: PropTypes.bool,
    /**
     * If `true`, the List Subheader is indented.
     * @default false
     */
    inset: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var ListSubheader$1 = ListSubheader;

  var CancelIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm5 13.59L15.59 17 12 13.41 8.41 17 7 15.59 10.59 12 7 8.41 8.41 7 12 10.59 15.59 7 17 8.41 13.41 12 17 15.59z"
  }), 'Cancel');

  function getChipUtilityClass(slot) {
    return generateUtilityClass('MuiChip', slot);
  }
  var chipClasses = generateUtilityClasses('MuiChip', ['root', 'sizeSmall', 'sizeMedium', 'colorError', 'colorInfo', 'colorPrimary', 'colorSecondary', 'colorSuccess', 'colorWarning', 'disabled', 'clickable', 'clickableColorPrimary', 'clickableColorSecondary', 'deletable', 'deletableColorPrimary', 'deletableColorSecondary', 'outlined', 'filled', 'outlinedPrimary', 'outlinedSecondary', 'filledPrimary', 'filledSecondary', 'avatar', 'avatarSmall', 'avatarMedium', 'avatarColorPrimary', 'avatarColorSecondary', 'icon', 'iconSmall', 'iconMedium', 'iconColorPrimary', 'iconColorSecondary', 'label', 'labelSmall', 'labelMedium', 'deleteIcon', 'deleteIconSmall', 'deleteIconMedium', 'deleteIconColorPrimary', 'deleteIconColorSecondary', 'deleteIconOutlinedColorPrimary', 'deleteIconOutlinedColorSecondary', 'deleteIconFilledColorPrimary', 'deleteIconFilledColorSecondary', 'focusVisible']);
  var chipClasses$1 = chipClasses;

  var useUtilityClasses$1A = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      disabled = ownerState.disabled,
      size = ownerState.size,
      color = ownerState.color,
      iconColor = ownerState.iconColor,
      onDelete = ownerState.onDelete,
      clickable = ownerState.clickable,
      variant = ownerState.variant;
    var slots = {
      root: ['root', variant, disabled && 'disabled', "size".concat(capitalize(size)), "color".concat(capitalize(color)), clickable && 'clickable', clickable && "clickableColor".concat(capitalize(color)), onDelete && 'deletable', onDelete && "deletableColor".concat(capitalize(color)), "".concat(variant).concat(capitalize(color))],
      label: ['label', "label".concat(capitalize(size))],
      avatar: ['avatar', "avatar".concat(capitalize(size)), "avatarColor".concat(capitalize(color))],
      icon: ['icon', "icon".concat(capitalize(size)), "iconColor".concat(capitalize(iconColor))],
      deleteIcon: ['deleteIcon', "deleteIcon".concat(capitalize(size)), "deleteIconColor".concat(capitalize(color)), "deleteIcon".concat(capitalize(variant), "Color").concat(capitalize(color))]
    };
    return composeClasses(slots, getChipUtilityClass, classes);
  };
  var ChipRoot = styled$1('div', {
    name: 'MuiChip',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      var color = ownerState.color,
        iconColor = ownerState.iconColor,
        clickable = ownerState.clickable,
        onDelete = ownerState.onDelete,
        size = ownerState.size,
        variant = ownerState.variant;
      return [_defineProperty({}, "& .".concat(chipClasses$1.avatar), styles.avatar), _defineProperty({}, "& .".concat(chipClasses$1.avatar), styles["avatar".concat(capitalize(size))]), _defineProperty({}, "& .".concat(chipClasses$1.avatar), styles["avatarColor".concat(capitalize(color))]), _defineProperty({}, "& .".concat(chipClasses$1.icon), styles.icon), _defineProperty({}, "& .".concat(chipClasses$1.icon), styles["icon".concat(capitalize(size))]), _defineProperty({}, "& .".concat(chipClasses$1.icon), styles["iconColor".concat(capitalize(iconColor))]), _defineProperty({}, "& .".concat(chipClasses$1.deleteIcon), styles.deleteIcon), _defineProperty({}, "& .".concat(chipClasses$1.deleteIcon), styles["deleteIcon".concat(capitalize(size))]), _defineProperty({}, "& .".concat(chipClasses$1.deleteIcon), styles["deleteIconColor".concat(capitalize(color))]), _defineProperty({}, "& .".concat(chipClasses$1.deleteIcon), styles["deleteIcon".concat(capitalize(variant), "Color").concat(capitalize(color))]), styles.root, styles["size".concat(capitalize(size))], styles["color".concat(capitalize(color))], clickable && styles.clickable, clickable && color !== 'default' && styles["clickableColor".concat(capitalize(color), ")")], onDelete && styles.deletable, onDelete && color !== 'default' && styles["deletableColor".concat(capitalize(color))], styles[variant], styles["".concat(variant).concat(capitalize(color))]];
    }
  })(function (_ref11) {
    var theme = _ref11.theme,
      ownerState = _ref11.ownerState;
    var textColor = theme.palette.mode === 'light' ? theme.palette.grey[700] : theme.palette.grey[300];
    return _extends(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
      maxWidth: '100%',
      fontFamily: theme.typography.fontFamily,
      fontSize: theme.typography.pxToRem(13),
      display: 'inline-flex',
      alignItems: 'center',
      justifyContent: 'center',
      height: 32,
      color: (theme.vars || theme).palette.text.primary,
      backgroundColor: (theme.vars || theme).palette.action.selected,
      borderRadius: 32 / 2,
      whiteSpace: 'nowrap',
      transition: theme.transitions.create(['background-color', 'box-shadow']),
      // reset cursor explicitly in case ButtonBase is used
      cursor: 'unset',
      // We disable the focus ring for mouse, touch and keyboard users.
      outline: 0,
      textDecoration: 'none',
      border: 0,
      // Remove `button` border
      padding: 0,
      // Remove `button` padding
      verticalAlign: 'middle',
      boxSizing: 'border-box'
    }, "&.".concat(chipClasses$1.disabled), {
      opacity: (theme.vars || theme).palette.action.disabledOpacity,
      pointerEvents: 'none'
    }), "& .".concat(chipClasses$1.avatar), {
      marginLeft: 5,
      marginRight: -6,
      width: 24,
      height: 24,
      color: theme.vars ? theme.vars.palette.Chip.defaultAvatarColor : textColor,
      fontSize: theme.typography.pxToRem(12)
    }), "& .".concat(chipClasses$1.avatarColorPrimary), {
      color: (theme.vars || theme).palette.primary.contrastText,
      backgroundColor: (theme.vars || theme).palette.primary.dark
    }), "& .".concat(chipClasses$1.avatarColorSecondary), {
      color: (theme.vars || theme).palette.secondary.contrastText,
      backgroundColor: (theme.vars || theme).palette.secondary.dark
    }), "& .".concat(chipClasses$1.avatarSmall), {
      marginLeft: 4,
      marginRight: -4,
      width: 18,
      height: 18,
      fontSize: theme.typography.pxToRem(10)
    }), "& .".concat(chipClasses$1.icon), _extends({
      marginLeft: 5,
      marginRight: -6
    }, ownerState.size === 'small' && {
      fontSize: 18,
      marginLeft: 4,
      marginRight: -4
    }, ownerState.iconColor === ownerState.color && _extends({
      color: theme.vars ? theme.vars.palette.Chip.defaultIconColor : textColor
    }, ownerState.color !== 'default' && {
      color: 'inherit'
    }))), "& .".concat(chipClasses$1.deleteIcon), _extends({
      WebkitTapHighlightColor: 'transparent',
      color: theme.vars ? "rgba(".concat(theme.vars.palette.text.primaryChannel, " / 0.26)") : alpha(theme.palette.text.primary, 0.26),
      fontSize: 22,
      cursor: 'pointer',
      margin: '0 5px 0 -6px',
      '&:hover': {
        color: theme.vars ? "rgba(".concat(theme.vars.palette.text.primaryChannel, " / 0.4)") : alpha(theme.palette.text.primary, 0.4)
      }
    }, ownerState.size === 'small' && {
      fontSize: 16,
      marginRight: 4,
      marginLeft: -4
    }, ownerState.color !== 'default' && {
      color: theme.vars ? "rgba(".concat(theme.vars.palette[ownerState.color].contrastTextChannel, " / 0.7)") : alpha(theme.palette[ownerState.color].contrastText, 0.7),
      '&:hover, &:active': {
        color: (theme.vars || theme).palette[ownerState.color].contrastText
      }
    })), ownerState.size === 'small' && {
      height: 24
    }, ownerState.color !== 'default' && {
      backgroundColor: (theme.vars || theme).palette[ownerState.color].main,
      color: (theme.vars || theme).palette[ownerState.color].contrastText
    }, ownerState.onDelete && _defineProperty({}, "&.".concat(chipClasses$1.focusVisible), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.action.selectedChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.focusOpacity, "))") : alpha(theme.palette.action.selected, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)
    }), ownerState.onDelete && ownerState.color !== 'default' && _defineProperty({}, "&.".concat(chipClasses$1.focusVisible), {
      backgroundColor: (theme.vars || theme).palette[ownerState.color].dark
    }));
  }, function (_ref14) {
    var theme = _ref14.theme,
      ownerState = _ref14.ownerState;
    return _extends({}, ownerState.clickable && _defineProperty(_defineProperty({
      userSelect: 'none',
      WebkitTapHighlightColor: 'transparent',
      cursor: 'pointer',
      '&:hover': {
        backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.action.selectedChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.hoverOpacity, "))") : alpha(theme.palette.action.selected, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity)
      }
    }, "&.".concat(chipClasses$1.focusVisible), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.action.selectedChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.focusOpacity, "))") : alpha(theme.palette.action.selected, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)
    }), '&:active', {
      boxShadow: (theme.vars || theme).shadows[1]
    }), ownerState.clickable && ownerState.color !== 'default' && _defineProperty({}, "&:hover, &.".concat(chipClasses$1.focusVisible), {
      backgroundColor: (theme.vars || theme).palette[ownerState.color].dark
    }));
  }, function (_ref17) {
    var theme = _ref17.theme,
      ownerState = _ref17.ownerState;
    return _extends({}, ownerState.variant === 'outlined' && _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
      backgroundColor: 'transparent',
      border: theme.vars ? "1px solid ".concat(theme.vars.palette.Chip.defaultBorder) : "1px solid ".concat(theme.palette.mode === 'light' ? theme.palette.grey[400] : theme.palette.grey[700])
    }, "&.".concat(chipClasses$1.clickable, ":hover"), {
      backgroundColor: (theme.vars || theme).palette.action.hover
    }), "&.".concat(chipClasses$1.focusVisible), {
      backgroundColor: (theme.vars || theme).palette.action.focus
    }), "& .".concat(chipClasses$1.avatar), {
      marginLeft: 4
    }), "& .".concat(chipClasses$1.avatarSmall), {
      marginLeft: 2
    }), "& .".concat(chipClasses$1.icon), {
      marginLeft: 4
    }), "& .".concat(chipClasses$1.iconSmall), {
      marginLeft: 2
    }), "& .".concat(chipClasses$1.deleteIcon), {
      marginRight: 5
    }), "& .".concat(chipClasses$1.deleteIconSmall), {
      marginRight: 3
    }), ownerState.variant === 'outlined' && ownerState.color !== 'default' && _defineProperty(_defineProperty(_defineProperty({
      color: (theme.vars || theme).palette[ownerState.color].main,
      border: "1px solid ".concat(theme.vars ? "rgba(".concat(theme.vars.palette[ownerState.color].mainChannel, " / 0.7)") : alpha(theme.palette[ownerState.color].main, 0.7))
    }, "&.".concat(chipClasses$1.clickable, ":hover"), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette[ownerState.color].mainChannel, " / ").concat(theme.vars.palette.action.hoverOpacity, ")") : alpha(theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity)
    }), "&.".concat(chipClasses$1.focusVisible), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette[ownerState.color].mainChannel, " / ").concat(theme.vars.palette.action.focusOpacity, ")") : alpha(theme.palette[ownerState.color].main, theme.palette.action.focusOpacity)
    }), "& .".concat(chipClasses$1.deleteIcon), {
      color: theme.vars ? "rgba(".concat(theme.vars.palette[ownerState.color].mainChannel, " / 0.7)") : alpha(theme.palette[ownerState.color].main, 0.7),
      '&:hover, &:active': {
        color: (theme.vars || theme).palette[ownerState.color].main
      }
    }));
  });
  var ChipLabel = styled$1('span', {
    name: 'MuiChip',
    slot: 'Label',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      var size = ownerState.size;
      return [styles.label, styles["label".concat(capitalize(size))]];
    }
  })(function (_ref20) {
    var ownerState = _ref20.ownerState;
    return _extends({
      overflow: 'hidden',
      textOverflow: 'ellipsis',
      paddingLeft: 12,
      paddingRight: 12,
      whiteSpace: 'nowrap'
    }, ownerState.variant === 'outlined' && {
      paddingLeft: 11,
      paddingRight: 11
    }, ownerState.size === 'small' && {
      paddingLeft: 8,
      paddingRight: 8
    }, ownerState.size === 'small' && ownerState.variant === 'outlined' && {
      paddingLeft: 7,
      paddingRight: 7
    });
  });
  function isDeleteKeyboardEvent(keyboardEvent) {
    return keyboardEvent.key === 'Backspace' || keyboardEvent.key === 'Delete';
  }

  /**
   * Chips represent complex entities in small blocks, such as a contact.
   */
  var Chip = /*#__PURE__*/React__namespace.forwardRef(function Chip(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiChip'
    });
    var avatarProp = props.avatar,
      className = props.className,
      clickableProp = props.clickable,
      _props$color = props.color,
      color = _props$color === void 0 ? 'default' : _props$color,
      ComponentProp = props.component,
      deleteIconProp = props.deleteIcon,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      iconProp = props.icon,
      label = props.label,
      onClick = props.onClick,
      onDelete = props.onDelete,
      onKeyDown = props.onKeyDown,
      onKeyUp = props.onKeyUp,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'filled' : _props$variant,
      tabIndex = props.tabIndex,
      _props$skipFocusWhenD = props.skipFocusWhenDisabled,
      skipFocusWhenDisabled = _props$skipFocusWhenD === void 0 ? false : _props$skipFocusWhenD,
      other = _objectWithoutProperties(props, ["avatar", "className", "clickable", "color", "component", "deleteIcon", "disabled", "icon", "label", "onClick", "onDelete", "onKeyDown", "onKeyUp", "size", "variant", "tabIndex", "skipFocusWhenDisabled"]);
    var chipRef = React__namespace.useRef(null);
    var handleRef = useForkRef(chipRef, ref);
    var handleDeleteIconClick = function handleDeleteIconClick(event) {
      // Stop the event from bubbling up to the `Chip`
      event.stopPropagation();
      if (onDelete) {
        onDelete(event);
      }
    };
    var handleKeyDown = function handleKeyDown(event) {
      // Ignore events from children of `Chip`.
      if (event.currentTarget === event.target && isDeleteKeyboardEvent(event)) {
        // Will be handled in keyUp, otherwise some browsers
        // might init navigation
        event.preventDefault();
      }
      if (onKeyDown) {
        onKeyDown(event);
      }
    };
    var handleKeyUp = function handleKeyUp(event) {
      // Ignore events from children of `Chip`.
      if (event.currentTarget === event.target) {
        if (onDelete && isDeleteKeyboardEvent(event)) {
          onDelete(event);
        } else if (event.key === 'Escape' && chipRef.current) {
          chipRef.current.blur();
        }
      }
      if (onKeyUp) {
        onKeyUp(event);
      }
    };
    var clickable = clickableProp !== false && onClick ? true : clickableProp;
    var component = clickable || onDelete ? ButtonBase$1 : ComponentProp || 'div';
    var ownerState = _extends({}, props, {
      component: component,
      disabled: disabled,
      size: size,
      color: color,
      iconColor: /*#__PURE__*/React__namespace.isValidElement(iconProp) ? iconProp.props.color || color : color,
      onDelete: !!onDelete,
      clickable: clickable,
      variant: variant
    });
    var classes = useUtilityClasses$1A(ownerState);
    var moreProps = component === ButtonBase$1 ? _extends({
      component: ComponentProp || 'div',
      focusVisibleClassName: classes.focusVisible
    }, onDelete && {
      disableRipple: true
    }) : {};
    var deleteIcon = null;
    if (onDelete) {
      deleteIcon = deleteIconProp && /*#__PURE__*/React__namespace.isValidElement(deleteIconProp) ? ( /*#__PURE__*/React__namespace.cloneElement(deleteIconProp, {
        className: clsx(deleteIconProp.props.className, classes.deleteIcon),
        onClick: handleDeleteIconClick
      })) : /*#__PURE__*/jsxRuntimeExports.jsx(CancelIcon, {
        className: clsx(classes.deleteIcon),
        onClick: handleDeleteIconClick
      });
    }
    var avatar = null;
    if (avatarProp && /*#__PURE__*/React__namespace.isValidElement(avatarProp)) {
      avatar = /*#__PURE__*/React__namespace.cloneElement(avatarProp, {
        className: clsx(classes.avatar, avatarProp.props.className)
      });
    }
    var icon = null;
    if (iconProp && /*#__PURE__*/React__namespace.isValidElement(iconProp)) {
      icon = /*#__PURE__*/React__namespace.cloneElement(iconProp, {
        className: clsx(classes.icon, iconProp.props.className)
      });
    }
    {
      if (avatar && icon) {
        console.error('MUI: The Chip component can not handle the avatar ' + 'and the icon prop at the same time. Pick one.');
      }
    }
    return /*#__PURE__*/jsxRuntimeExports.jsxs(ChipRoot, _extends({
      as: component,
      className: clsx(classes.root, className),
      disabled: clickable && disabled ? true : undefined,
      onClick: onClick,
      onKeyDown: handleKeyDown,
      onKeyUp: handleKeyUp,
      ref: handleRef,
      tabIndex: skipFocusWhenDisabled && disabled ? -1 : tabIndex,
      ownerState: ownerState
    }, moreProps, other, {
      children: [avatar || icon, /*#__PURE__*/jsxRuntimeExports.jsx(ChipLabel, {
        className: clsx(classes.label),
        ownerState: ownerState,
        children: label
      }), deleteIcon]
    }));
  });
  Chip.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The Avatar element to display.
     */
    avatar: PropTypes.element,
    /**
     * This prop isn't supported.
     * Use the `component` prop if you need to change the children structure.
     */
    children: unsupportedProp,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * If `true`, the chip will appear clickable, and will raise when pressed,
     * even if the onClick prop is not defined.
     * If `false`, the chip will not appear clickable, even if onClick prop is defined.
     * This can be used, for example,
     * along with the component prop to indicate an anchor Chip is clickable.
     * Note: this controls the UI and does not affect the onClick event.
     */
    clickable: PropTypes.bool,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'default'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['default', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * Override the default delete icon element. Shown only if `onDelete` is set.
     */
    deleteIcon: PropTypes.element,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * Icon element.
     */
    icon: PropTypes.element,
    /**
     * The content of the component.
     */
    label: PropTypes.node,
    /**
     * @ignore
     */
    onClick: PropTypes.func,
    /**
     * Callback fired when the delete icon is clicked.
     * If set, the delete icon will be shown.
     */
    onDelete: PropTypes.func,
    /**
     * @ignore
     */
    onKeyDown: PropTypes.func,
    /**
     * @ignore
     */
    onKeyUp: PropTypes.func,
    /**
     * The size of the component.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['medium', 'small']), PropTypes.string]),
    /**
     * If `true`, allows the disabled chip to escape focus.
     * If `false`, allows the disabled chip to receive focus.
     * @default false
     */
    skipFocusWhenDisabled: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * @ignore
     */
    tabIndex: PropTypes.number,
    /**
     * The variant to use.
     * @default 'filled'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['filled', 'outlined']), PropTypes.string])
  } ;
  var Chip$1 = Chip;

  function getStyleValue(value) {
    return parseInt(value, 10) || 0;
  }
  var styles$4 = {
    shadow: {
      // Visibility needed to hide the extra text area on iPads
      visibility: 'hidden',
      // Remove from the content flow
      position: 'absolute',
      // Ignore the scrollbar width
      overflow: 'hidden',
      height: 0,
      top: 0,
      left: 0,
      // Create a new layer, increase the isolation of the computed values
      transform: 'translateZ(0)'
    }
  };
  function isEmpty$1(obj) {
    return obj === undefined || obj === null || Object.keys(obj).length === 0 || obj.outerHeightStyle === 0 && !obj.overflowing;
  }

  /**
   *
   * Demos:
   *
   * - [Textarea Autosize](https://mui.com/material-ui/react-textarea-autosize/)
   *
   * API:
   *
   * - [TextareaAutosize API](https://mui.com/material-ui/api/textarea-autosize/)
   */
  var TextareaAutosize = /*#__PURE__*/React__namespace.forwardRef(function TextareaAutosize(props, forwardedRef) {
    var onChange = props.onChange,
      maxRows = props.maxRows,
      _props$minRows = props.minRows,
      minRows = _props$minRows === void 0 ? 1 : _props$minRows,
      style = props.style,
      value = props.value,
      other = _objectWithoutProperties(props, ["onChange", "maxRows", "minRows", "style", "value"]);
    var _React$useRef = React__namespace.useRef(value != null),
      isControlled = _React$useRef.current;
    var inputRef = React__namespace.useRef(null);
    var handleRef = useForkRef(forwardedRef, inputRef);
    var heightRef = React__namespace.useRef(null);
    var shadowRef = React__namespace.useRef(null);
    var calculateTextareaStyles = React__namespace.useCallback(function () {
      var input = inputRef.current;
      var containerWindow = ownerWindow(input);
      var computedStyle = containerWindow.getComputedStyle(input);

      // If input's width is shrunk and it's not visible, don't sync height.
      if (computedStyle.width === '0px') {
        return {
          outerHeightStyle: 0,
          overflowing: false
        };
      }
      var inputShallow = shadowRef.current;
      inputShallow.style.width = computedStyle.width;
      inputShallow.value = input.value || props.placeholder || 'x';
      if (inputShallow.value.slice(-1) === '\n') {
        // Certain fonts which overflow the line height will cause the textarea
        // to report a different scrollHeight depending on whether the last line
        // is empty. Make it non-empty to avoid this issue.
        inputShallow.value += ' ';
      }
      var boxSizing = computedStyle.boxSizing;
      var padding = getStyleValue(computedStyle.paddingBottom) + getStyleValue(computedStyle.paddingTop);
      var border = getStyleValue(computedStyle.borderBottomWidth) + getStyleValue(computedStyle.borderTopWidth);

      // The height of the inner content
      var innerHeight = inputShallow.scrollHeight;

      // Measure height of a textarea with a single row
      inputShallow.value = 'x';
      var singleRowHeight = inputShallow.scrollHeight;

      // The height of the outer content
      var outerHeight = innerHeight;
      if (minRows) {
        outerHeight = Math.max(Number(minRows) * singleRowHeight, outerHeight);
      }
      if (maxRows) {
        outerHeight = Math.min(Number(maxRows) * singleRowHeight, outerHeight);
      }
      outerHeight = Math.max(outerHeight, singleRowHeight);

      // Take the box sizing into account for applying this value as a style.
      var outerHeightStyle = outerHeight + (boxSizing === 'border-box' ? padding + border : 0);
      var overflowing = Math.abs(outerHeight - innerHeight) <= 1;
      return {
        outerHeightStyle: outerHeightStyle,
        overflowing: overflowing
      };
    }, [maxRows, minRows, props.placeholder]);
    var syncHeight = React__namespace.useCallback(function () {
      var textareaStyles = calculateTextareaStyles();
      if (isEmpty$1(textareaStyles)) {
        return;
      }
      var outerHeightStyle = textareaStyles.outerHeightStyle;
      var input = inputRef.current;
      if (heightRef.current !== outerHeightStyle) {
        heightRef.current = outerHeightStyle;
        input.style.height = "".concat(outerHeightStyle, "px");
      }
      input.style.overflow = textareaStyles.overflowing ? 'hidden' : '';
    }, [calculateTextareaStyles]);
    useEnhancedEffect$1(function () {
      var handleResize = function handleResize() {
        syncHeight();
      };
      // Workaround a "ResizeObserver loop completed with undelivered notifications" error
      // in test.
      // Note that we might need to use this logic in production per https://github.com/WICG/resize-observer/issues/38
      // Also see https://github.com/mui/mui-x/issues/8733
      var rAF;
      var debounceHandleResize = debounce$1(handleResize);
      var input = inputRef.current;
      var containerWindow = ownerWindow(input);
      containerWindow.addEventListener('resize', debounceHandleResize);
      var resizeObserver;
      if (typeof ResizeObserver !== 'undefined') {
        resizeObserver = new ResizeObserver(handleResize);
        resizeObserver.observe(input);
      }
      return function () {
        debounceHandleResize.clear();
        cancelAnimationFrame(rAF);
        containerWindow.removeEventListener('resize', debounceHandleResize);
        if (resizeObserver) {
          resizeObserver.disconnect();
        }
      };
    }, [calculateTextareaStyles, syncHeight]);
    useEnhancedEffect$1(function () {
      syncHeight();
    });
    var handleChange = function handleChange(event) {
      if (!isControlled) {
        syncHeight();
      }
      if (onChange) {
        onChange(event);
      }
    };
    return /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsx("textarea", _extends({
        value: value,
        onChange: handleChange,
        ref: handleRef
        // Apply the rows prop to get a "correct" first SSR paint
        ,
        rows: minRows,
        style: style
      }, other)), /*#__PURE__*/jsxRuntimeExports.jsx("textarea", {
        "aria-hidden": true,
        className: props.className,
        readOnly: true,
        ref: shadowRef,
        tabIndex: -1,
        style: _extends({}, styles$4.shadow, style, {
          paddingTop: 0,
          paddingBottom: 0
        })
      })]
    });
  });
  TextareaAutosize.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * Maximum number of rows to display.
     */
    maxRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * Minimum number of rows to display.
     * @default 1
     */
    minRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * @ignore
     */
    onChange: PropTypes.func,
    /**
     * @ignore
     */
    placeholder: PropTypes.string,
    /**
     * @ignore
     */
    style: PropTypes.object,
    /**
     * @ignore
     */
    value: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.string), PropTypes.number, PropTypes.string])
  } ;
  var TextareaAutosize$1 = TextareaAutosize;

  function formControlState(_ref) {
    var props = _ref.props,
      states = _ref.states,
      muiFormControl = _ref.muiFormControl;
    return states.reduce(function (acc, state) {
      acc[state] = props[state];
      if (muiFormControl) {
        if (typeof props[state] === 'undefined') {
          acc[state] = muiFormControl[state];
        }
      }
      return acc;
    }, {});
  }

  /**
   * @ignore - internal component.
   */
  var FormControlContext = /*#__PURE__*/React__namespace.createContext(undefined);
  {
    FormControlContext.displayName = 'FormControlContext';
  }
  var FormControlContext$1 = FormControlContext;

  function useFormControl() {
    return React__namespace.useContext(FormControlContext$1);
  }

  function GlobalStyles(props) {
    return /*#__PURE__*/jsxRuntimeExports.jsx(GlobalStyles$1, _extends({}, props, {
      defaultTheme: defaultTheme$3,
      themeId: THEME_ID
    }));
  }
  GlobalStyles.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The styles you want to apply globally.
     */
    styles: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.array, PropTypes.func, PropTypes.number, PropTypes.object, PropTypes.string, PropTypes.bool])
  } ;

  // Supports determination of isControlled().
  // Controlled input accepts its current value as a prop.
  //
  // @see https://facebook.github.io/react/docs/forms.html#controlled-components
  // @param value
  // @returns {boolean} true if string (including '') or number (including zero)
  function hasValue(value) {
    return value != null && !(Array.isArray(value) && value.length === 0);
  }

  // Determine if field is empty or filled.
  // Response determines if label is presented above field or as placeholder.
  //
  // @param obj
  // @param SSR
  // @returns {boolean} False when not present or empty string.
  //                    True when any number or string with length.
  function isFilled(obj) {
    var SSR = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    return obj && (hasValue(obj.value) && obj.value !== '' || SSR && hasValue(obj.defaultValue) && obj.defaultValue !== '');
  }

  // Determine if an Input is adorned on start.
  // It's corresponding to the left with LTR.
  //
  // @param obj
  // @returns {boolean} False when no adornments.
  //                    True when adorned at the start.
  function isAdornedStart(obj) {
    return obj.startAdornment;
  }

  function getInputBaseUtilityClass(slot) {
    return generateUtilityClass('MuiInputBase', slot);
  }
  var inputBaseClasses = generateUtilityClasses('MuiInputBase', ['root', 'formControl', 'focused', 'disabled', 'adornedStart', 'adornedEnd', 'error', 'sizeSmall', 'multiline', 'colorSecondary', 'fullWidth', 'hiddenLabel', 'readOnly', 'input', 'inputSizeSmall', 'inputMultiline', 'inputTypeSearch', 'inputAdornedStart', 'inputAdornedEnd', 'inputHiddenLabel']);
  var inputBaseClasses$1 = inputBaseClasses;

  var rootOverridesResolver = function rootOverridesResolver(props, styles) {
    var ownerState = props.ownerState;
    return [styles.root, ownerState.formControl && styles.formControl, ownerState.startAdornment && styles.adornedStart, ownerState.endAdornment && styles.adornedEnd, ownerState.error && styles.error, ownerState.size === 'small' && styles.sizeSmall, ownerState.multiline && styles.multiline, ownerState.color && styles["color".concat(capitalize(ownerState.color))], ownerState.fullWidth && styles.fullWidth, ownerState.hiddenLabel && styles.hiddenLabel];
  };
  var inputOverridesResolver = function inputOverridesResolver(props, styles) {
    var ownerState = props.ownerState;
    return [styles.input, ownerState.size === 'small' && styles.inputSizeSmall, ownerState.multiline && styles.inputMultiline, ownerState.type === 'search' && styles.inputTypeSearch, ownerState.startAdornment && styles.inputAdornedStart, ownerState.endAdornment && styles.inputAdornedEnd, ownerState.hiddenLabel && styles.inputHiddenLabel];
  };
  var useUtilityClasses$1z = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      color = ownerState.color,
      disabled = ownerState.disabled,
      error = ownerState.error,
      endAdornment = ownerState.endAdornment,
      focused = ownerState.focused,
      formControl = ownerState.formControl,
      fullWidth = ownerState.fullWidth,
      hiddenLabel = ownerState.hiddenLabel,
      multiline = ownerState.multiline,
      readOnly = ownerState.readOnly,
      size = ownerState.size,
      startAdornment = ownerState.startAdornment,
      type = ownerState.type;
    var slots = {
      root: ['root', "color".concat(capitalize(color)), disabled && 'disabled', error && 'error', fullWidth && 'fullWidth', focused && 'focused', formControl && 'formControl', size && size !== 'medium' && "size".concat(capitalize(size)), multiline && 'multiline', startAdornment && 'adornedStart', endAdornment && 'adornedEnd', hiddenLabel && 'hiddenLabel', readOnly && 'readOnly'],
      input: ['input', disabled && 'disabled', type === 'search' && 'inputTypeSearch', multiline && 'inputMultiline', size === 'small' && 'inputSizeSmall', hiddenLabel && 'inputHiddenLabel', startAdornment && 'inputAdornedStart', endAdornment && 'inputAdornedEnd', readOnly && 'readOnly']
    };
    return composeClasses(slots, getInputBaseUtilityClass, classes);
  };
  var InputBaseRoot = styled$1('div', {
    name: 'MuiInputBase',
    slot: 'Root',
    overridesResolver: rootOverridesResolver
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({}, theme.typography.body1, _defineProperty({
      color: (theme.vars || theme).palette.text.primary,
      lineHeight: '1.4375em',
      // 23px
      boxSizing: 'border-box',
      // Prevent padding issue with fullWidth.
      position: 'relative',
      cursor: 'text',
      display: 'inline-flex',
      alignItems: 'center'
    }, "&.".concat(inputBaseClasses$1.disabled), {
      color: (theme.vars || theme).palette.text.disabled,
      cursor: 'default'
    }), ownerState.multiline && _extends({
      padding: '4px 0 5px'
    }, ownerState.size === 'small' && {
      paddingTop: 1
    }), ownerState.fullWidth && {
      width: '100%'
    });
  });
  var InputBaseComponent = styled$1('input', {
    name: 'MuiInputBase',
    slot: 'Input',
    overridesResolver: inputOverridesResolver
  })(function (_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    var light = theme.palette.mode === 'light';
    var placeholder = _extends({
      color: 'currentColor'
    }, theme.vars ? {
      opacity: theme.vars.opacity.inputPlaceholder
    } : {
      opacity: light ? 0.42 : 0.5
    }, {
      transition: theme.transitions.create('opacity', {
        duration: theme.transitions.duration.shorter
      })
    });
    var placeholderHidden = {
      opacity: '0 !important'
    };
    var placeholderVisible = theme.vars ? {
      opacity: theme.vars.opacity.inputPlaceholder
    } : {
      opacity: light ? 0.42 : 0.5
    };
    return _extends(_defineProperty(_defineProperty(_defineProperty({
      font: 'inherit',
      letterSpacing: 'inherit',
      color: 'currentColor',
      padding: '4px 0 5px',
      border: 0,
      boxSizing: 'content-box',
      background: 'none',
      height: '1.4375em',
      // Reset 23pxthe native input line-height
      margin: 0,
      // Reset for Safari
      WebkitTapHighlightColor: 'transparent',
      display: 'block',
      // Make the flex item shrink with Firefox
      minWidth: 0,
      width: '100%',
      // Fix IE11 width issue
      animationName: 'mui-auto-fill-cancel',
      animationDuration: '10ms',
      '&::-webkit-input-placeholder': placeholder,
      '&::-moz-placeholder': placeholder,
      // Firefox 19+
      '&:-ms-input-placeholder': placeholder,
      // IE11
      '&::-ms-input-placeholder': placeholder,
      // Edge
      '&:focus': {
        outline: 0
      },
      // Reset Firefox invalid required input style
      '&:invalid': {
        boxShadow: 'none'
      },
      '&::-webkit-search-decoration': {
        // Remove the padding when type=search.
        WebkitAppearance: 'none'
      }
    }, "label[data-shrink=false] + .".concat(inputBaseClasses$1.formControl, " &"), {
      '&::-webkit-input-placeholder': placeholderHidden,
      '&::-moz-placeholder': placeholderHidden,
      // Firefox 19+
      '&:-ms-input-placeholder': placeholderHidden,
      // IE11
      '&::-ms-input-placeholder': placeholderHidden,
      // Edge
      '&:focus::-webkit-input-placeholder': placeholderVisible,
      '&:focus::-moz-placeholder': placeholderVisible,
      // Firefox 19+
      '&:focus:-ms-input-placeholder': placeholderVisible,
      // IE11
      '&:focus::-ms-input-placeholder': placeholderVisible // Edge
    }), "&.".concat(inputBaseClasses$1.disabled), {
      opacity: 1,
      // Reset iOS opacity
      WebkitTextFillColor: (theme.vars || theme).palette.text.disabled // Fix opacity Safari bug
    }), '&:-webkit-autofill', {
      animationDuration: '5000s',
      animationName: 'mui-auto-fill'
    }), ownerState.size === 'small' && {
      paddingTop: 1
    }, ownerState.multiline && {
      height: 'auto',
      resize: 'none',
      padding: 0,
      paddingTop: 0
    }, ownerState.type === 'search' && {
      // Improve type search style.
      MozAppearance: 'textfield'
    });
  });
  var inputGlobalStyles = /*#__PURE__*/jsxRuntimeExports.jsx(GlobalStyles, {
    styles: {
      '@keyframes mui-auto-fill': {
        from: {
          display: 'block'
        }
      },
      '@keyframes mui-auto-fill-cancel': {
        from: {
          display: 'block'
        }
      }
    }
  });

  /**
   * `InputBase` contains as few styles as possible.
   * It aims to be a simple building block for creating an input.
   * It contains a load of style reset and some state logic.
   */
  var InputBase = /*#__PURE__*/React__namespace.forwardRef(function InputBase(inProps, ref) {
    var _slotProps$input;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiInputBase'
    });
    var ariaDescribedby = props['aria-describedby'],
      autoComplete = props.autoComplete,
      autoFocus = props.autoFocus,
      className = props.className;
      props.color;
      var _props$components = props.components,
      components = _props$components === void 0 ? {} : _props$components,
      _props$componentsProp = props.componentsProps,
      componentsProps = _props$componentsProp === void 0 ? {} : _props$componentsProp,
      defaultValue = props.defaultValue,
      disabled = props.disabled,
      disableInjectingGlobalStyles = props.disableInjectingGlobalStyles,
      endAdornment = props.endAdornment;
      props.error;
      var _props$fullWidth = props.fullWidth,
      fullWidth = _props$fullWidth === void 0 ? false : _props$fullWidth,
      id = props.id,
      _props$inputComponent = props.inputComponent,
      inputComponent = _props$inputComponent === void 0 ? 'input' : _props$inputComponent,
      _props$inputProps = props.inputProps,
      inputPropsProp = _props$inputProps === void 0 ? {} : _props$inputProps,
      inputRefProp = props.inputRef;
      props.margin;
      var maxRows = props.maxRows,
      minRows = props.minRows,
      _props$multiline = props.multiline,
      multiline = _props$multiline === void 0 ? false : _props$multiline,
      name = props.name,
      onBlur = props.onBlur,
      onChange = props.onChange,
      onClick = props.onClick,
      onFocus = props.onFocus,
      onKeyDown = props.onKeyDown,
      onKeyUp = props.onKeyUp,
      placeholder = props.placeholder,
      readOnly = props.readOnly,
      renderSuffix = props.renderSuffix,
      rows = props.rows;
      props.size;
      var _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      startAdornment = props.startAdornment,
      _props$type = props.type,
      type = _props$type === void 0 ? 'text' : _props$type,
      valueProp = props.value,
      other = _objectWithoutProperties(props, ["aria-describedby", "autoComplete", "autoFocus", "className", "color", "components", "componentsProps", "defaultValue", "disabled", "disableInjectingGlobalStyles", "endAdornment", "error", "fullWidth", "id", "inputComponent", "inputProps", "inputRef", "margin", "maxRows", "minRows", "multiline", "name", "onBlur", "onChange", "onClick", "onFocus", "onKeyDown", "onKeyUp", "placeholder", "readOnly", "renderSuffix", "rows", "size", "slotProps", "slots", "startAdornment", "type", "value"]);
    var value = inputPropsProp.value != null ? inputPropsProp.value : valueProp;
    var _React$useRef = React__namespace.useRef(value != null),
      isControlled = _React$useRef.current;
    var inputRef = React__namespace.useRef();
    var handleInputRefWarning = React__namespace.useCallback(function (instance) {
      {
        if (instance && instance.nodeName !== 'INPUT' && !instance.focus) {
          console.error(['MUI: You have provided a `inputComponent` to the input component', 'that does not correctly handle the `ref` prop.', 'Make sure the `ref` prop is called with a HTMLInputElement.'].join('\n'));
        }
      }
    }, []);
    var handleInputRef = useForkRef(inputRef, inputRefProp, inputPropsProp.ref, handleInputRefWarning);
    var _React$useState = React__namespace.useState(false),
      focused = _React$useState[0],
      setFocused = _React$useState[1];
    var muiFormControl = useFormControl();
    {
      // eslint-disable-next-line react-hooks/rules-of-hooks
      React__namespace.useEffect(function () {
        if (muiFormControl) {
          return muiFormControl.registerEffect();
        }
        return undefined;
      }, [muiFormControl]);
    }
    var fcs = formControlState({
      props: props,
      muiFormControl: muiFormControl,
      states: ['color', 'disabled', 'error', 'hiddenLabel', 'size', 'required', 'filled']
    });
    fcs.focused = muiFormControl ? muiFormControl.focused : focused;

    // The blur won't fire when the disabled state is set on a focused input.
    // We need to book keep the focused state manually.
    React__namespace.useEffect(function () {
      if (!muiFormControl && disabled && focused) {
        setFocused(false);
        if (onBlur) {
          onBlur();
        }
      }
    }, [muiFormControl, disabled, focused, onBlur]);
    var onFilled = muiFormControl && muiFormControl.onFilled;
    var onEmpty = muiFormControl && muiFormControl.onEmpty;
    var checkDirty = React__namespace.useCallback(function (obj) {
      if (isFilled(obj)) {
        if (onFilled) {
          onFilled();
        }
      } else if (onEmpty) {
        onEmpty();
      }
    }, [onFilled, onEmpty]);
    useEnhancedEffect$1(function () {
      if (isControlled) {
        checkDirty({
          value: value
        });
      }
    }, [value, checkDirty, isControlled]);
    var handleFocus = function handleFocus(event) {
      // Fix a bug with IE11 where the focus/blur events are triggered
      // while the component is disabled.
      if (fcs.disabled) {
        event.stopPropagation();
        return;
      }
      if (onFocus) {
        onFocus(event);
      }
      if (inputPropsProp.onFocus) {
        inputPropsProp.onFocus(event);
      }
      if (muiFormControl && muiFormControl.onFocus) {
        muiFormControl.onFocus(event);
      } else {
        setFocused(true);
      }
    };
    var handleBlur = function handleBlur(event) {
      if (onBlur) {
        onBlur(event);
      }
      if (inputPropsProp.onBlur) {
        inputPropsProp.onBlur(event);
      }
      if (muiFormControl && muiFormControl.onBlur) {
        muiFormControl.onBlur(event);
      } else {
        setFocused(false);
      }
    };
    var handleChange = function handleChange(event) {
      if (!isControlled) {
        var element = event.target || inputRef.current;
        if (element == null) {
          throw new Error("MUI: Expected valid input target. Did you use a custom `inputComponent` and forget to forward refs? See https://mui.com/r/input-component-ref-interface for more info." );
        }
        checkDirty({
          value: element.value
        });
      }
      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }
      if (inputPropsProp.onChange) {
        inputPropsProp.onChange.apply(inputPropsProp, [event].concat(args));
      }

      // Perform in the willUpdate
      if (onChange) {
        onChange.apply(void 0, [event].concat(args));
      }
    };

    // Check the input state on mount, in case it was filled by the user
    // or auto filled by the browser before the hydration (for SSR).
    React__namespace.useEffect(function () {
      checkDirty(inputRef.current);
      // eslint-disable-next-line react-hooks/exhaustive-deps
    }, []);
    var handleClick = function handleClick(event) {
      if (inputRef.current && event.currentTarget === event.target) {
        inputRef.current.focus();
      }
      if (onClick) {
        onClick(event);
      }
    };
    var InputComponent = inputComponent;
    var inputProps = inputPropsProp;
    if (multiline && InputComponent === 'input') {
      if (rows) {
        {
          if (minRows || maxRows) {
            console.warn('MUI: You can not use the `minRows` or `maxRows` props when the input `rows` prop is set.');
          }
        }
        inputProps = _extends({
          type: undefined,
          minRows: rows,
          maxRows: rows
        }, inputProps);
      } else {
        inputProps = _extends({
          type: undefined,
          maxRows: maxRows,
          minRows: minRows
        }, inputProps);
      }
      InputComponent = TextareaAutosize$1;
    }
    var handleAutoFill = function handleAutoFill(event) {
      // Provide a fake value as Chrome might not let you access it for security reasons.
      checkDirty(event.animationName === 'mui-auto-fill-cancel' ? inputRef.current : {
        value: 'x'
      });
    };
    React__namespace.useEffect(function () {
      if (muiFormControl) {
        muiFormControl.setAdornedStart(Boolean(startAdornment));
      }
    }, [muiFormControl, startAdornment]);
    var ownerState = _extends({}, props, {
      color: fcs.color || 'primary',
      disabled: fcs.disabled,
      endAdornment: endAdornment,
      error: fcs.error,
      focused: fcs.focused,
      formControl: muiFormControl,
      fullWidth: fullWidth,
      hiddenLabel: fcs.hiddenLabel,
      multiline: multiline,
      size: fcs.size,
      startAdornment: startAdornment,
      type: type
    });
    var classes = useUtilityClasses$1z(ownerState);
    var Root = slots.root || components.Root || InputBaseRoot;
    var rootProps = slotProps.root || componentsProps.root || {};
    var Input = slots.input || components.Input || InputBaseComponent;
    inputProps = _extends({}, inputProps, (_slotProps$input = slotProps.input) != null ? _slotProps$input : componentsProps.input);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
      children: [!disableInjectingGlobalStyles && inputGlobalStyles, /*#__PURE__*/jsxRuntimeExports.jsxs(Root, _extends({}, rootProps, !isHostComponent(Root) && {
        ownerState: _extends({}, ownerState, rootProps.ownerState)
      }, {
        ref: ref,
        onClick: handleClick
      }, other, {
        className: clsx(classes.root, rootProps.className, className, readOnly && 'MuiInputBase-readOnly'),
        children: [startAdornment, /*#__PURE__*/jsxRuntimeExports.jsx(FormControlContext$1.Provider, {
          value: null,
          children: /*#__PURE__*/jsxRuntimeExports.jsx(Input, _extends({
            ownerState: ownerState,
            "aria-invalid": fcs.error,
            "aria-describedby": ariaDescribedby,
            autoComplete: autoComplete,
            autoFocus: autoFocus,
            defaultValue: defaultValue,
            disabled: fcs.disabled,
            id: id,
            onAnimationStart: handleAutoFill,
            name: name,
            placeholder: placeholder,
            readOnly: readOnly,
            required: fcs.required,
            rows: rows,
            value: value,
            onKeyDown: onKeyDown,
            onKeyUp: onKeyUp,
            type: type
          }, inputProps, !isHostComponent(Input) && {
            as: InputComponent,
            ownerState: _extends({}, ownerState, inputProps.ownerState)
          }, {
            ref: handleInputRef,
            className: clsx(classes.input, inputProps.className, readOnly && 'MuiInputBase-readOnly'),
            onBlur: handleBlur,
            onChange: handleChange,
            onFocus: handleFocus
          }))
        }), endAdornment, renderSuffix ? renderSuffix(_extends({}, fcs, {
          startAdornment: startAdornment
        })) : null]
      }))]
    });
  });
  InputBase.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * @ignore
     */
    'aria-describedby': PropTypes.string,
    /**
     * This prop helps users to fill forms faster, especially on mobile devices.
     * The name can be confusing, as it's more like an autofill.
     * You can learn more about it [following the specification](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill).
     */
    autoComplete: PropTypes.string,
    /**
     * If `true`, the `input` element is focused during the first mount.
     */
    autoFocus: PropTypes.bool,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * The prop defaults to the value (`'primary'`) inherited from the parent FormControl component.
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `slots` prop.
     * It's recommended to use the `slots` prop instead.
     *
     * @default {}
     */
    components: PropTypes.shape({
      Input: PropTypes.elementType,
      Root: PropTypes.elementType
    }),
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `slotProps` prop.
     * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.
     *
     * @default {}
     */
    componentsProps: PropTypes.shape({
      input: PropTypes.object,
      root: PropTypes.object
    }),
    /**
     * The default value. Use when the component is not controlled.
     */
    defaultValue: PropTypes.any,
    /**
     * If `true`, the component is disabled.
     * The prop defaults to the value (`false`) inherited from the parent FormControl component.
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, GlobalStyles for the auto-fill keyframes will not be injected/removed on mount/unmount. Make sure to inject them at the top of your application.
     * This option is intended to help with boosting the initial rendering performance if you are loading a big amount of Input components at once.
     * @default false
     */
    disableInjectingGlobalStyles: PropTypes.bool,
    /**
     * End `InputAdornment` for this component.
     */
    endAdornment: PropTypes.node,
    /**
     * If `true`, the `input` will indicate an error.
     * The prop defaults to the value (`false`) inherited from the parent FormControl component.
     */
    error: PropTypes.bool,
    /**
     * If `true`, the `input` will take up the full width of its container.
     * @default false
     */
    fullWidth: PropTypes.bool,
    /**
     * The id of the `input` element.
     */
    id: PropTypes.string,
    /**
     * The component used for the `input` element.
     * Either a string to use a HTML element or a component.
     * @default 'input'
     */
    inputComponent: elementTypeAcceptingRef$1,
    /**
     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
     * @default {}
     */
    inputProps: PropTypes.object,
    /**
     * Pass a ref to the `input` element.
     */
    inputRef: refType$1,
    /**
     * If `dense`, will adjust vertical spacing. This is normally obtained via context from
     * FormControl.
     * The prop defaults to the value (`'none'`) inherited from the parent FormControl component.
     */
    margin: PropTypes.oneOf(['dense', 'none']),
    /**
     * Maximum number of rows to display when multiline option is set to true.
     */
    maxRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * Minimum number of rows to display when multiline option is set to true.
     */
    minRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * If `true`, a [TextareaAutosize](/material-ui/react-textarea-autosize/) element is rendered.
     * @default false
     */
    multiline: PropTypes.bool,
    /**
     * Name attribute of the `input` element.
     */
    name: PropTypes.string,
    /**
     * Callback fired when the `input` is blurred.
     *
     * Notice that the first argument (event) might be undefined.
     */
    onBlur: PropTypes.func,
    /**
     * Callback fired when the value is changed.
     *
     * @param {React.ChangeEvent<HTMLTextAreaElement | HTMLInputElement>} event The event source of the callback.
     * You can pull out the new value by accessing `event.target.value` (string).
     */
    onChange: PropTypes.func,
    /**
     * @ignore
     */
    onClick: PropTypes.func,
    /**
     * @ignore
     */
    onFocus: PropTypes.func,
    /**
     * Callback fired when the `input` doesn't satisfy its constraints.
     */
    onInvalid: PropTypes.func,
    /**
     * @ignore
     */
    onKeyDown: PropTypes.func,
    /**
     * @ignore
     */
    onKeyUp: PropTypes.func,
    /**
     * The short hint displayed in the `input` before the user enters a value.
     */
    placeholder: PropTypes.string,
    /**
     * It prevents the user from changing the value of the field
     * (not from interacting with the field).
     */
    readOnly: PropTypes.bool,
    /**
     * @ignore
     */
    renderSuffix: PropTypes.func,
    /**
     * If `true`, the `input` element is required.
     * The prop defaults to the value (`false`) inherited from the parent FormControl component.
     */
    required: PropTypes.bool,
    /**
     * Number of rows to display when multiline option is set to true.
     */
    rows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * The size of the component.
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['medium', 'small']), PropTypes.string]),
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `componentsProps` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slotProps: PropTypes.shape({
      input: PropTypes.object,
      root: PropTypes.object
    }),
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `components` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slots: PropTypes.shape({
      input: PropTypes.elementType,
      root: PropTypes.elementType
    }),
    /**
     * Start `InputAdornment` for this component.
     */
    startAdornment: PropTypes.node,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * Type of the `input` element. It should be [a valid HTML5 input type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Form_%3Cinput%3E_types).
     * @default 'text'
     */
    type: PropTypes.string,
    /**
     * The value of the `input` element, required for a controlled component.
     */
    value: PropTypes.any
  } ;
  var InputBase$1 = InputBase;

  function getInputUtilityClass(slot) {
    return generateUtilityClass('MuiInput', slot);
  }
  var inputClasses = _extends({}, inputBaseClasses$1, generateUtilityClasses('MuiInput', ['root', 'underline', 'input']));
  var inputClasses$1 = inputClasses;

  function getOutlinedInputUtilityClass(slot) {
    return generateUtilityClass('MuiOutlinedInput', slot);
  }
  var outlinedInputClasses = _extends({}, inputBaseClasses$1, generateUtilityClasses('MuiOutlinedInput', ['root', 'notchedOutline', 'input']));
  var outlinedInputClasses$1 = outlinedInputClasses;

  function getFilledInputUtilityClass(slot) {
    return generateUtilityClass('MuiFilledInput', slot);
  }
  var filledInputClasses = _extends({}, inputBaseClasses$1, generateUtilityClasses('MuiFilledInput', ['root', 'underline', 'input']));
  var filledInputClasses$1 = filledInputClasses;

  var ArrowDropDownIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M7 10l5 5 5-5z"
  }), 'ArrowDropDown');

  function getAutocompleteUtilityClass(slot) {
    return generateUtilityClass('MuiAutocomplete', slot);
  }
  var autocompleteClasses = generateUtilityClasses('MuiAutocomplete', ['root', 'expanded', 'fullWidth', 'focused', 'focusVisible', 'tag', 'tagSizeSmall', 'tagSizeMedium', 'hasPopupIcon', 'hasClearIcon', 'inputRoot', 'input', 'inputFocused', 'endAdornment', 'clearIndicator', 'popupIndicator', 'popupIndicatorOpen', 'popper', 'popperDisablePortal', 'paper', 'listbox', 'loading', 'noOptions', 'option', 'groupLabel', 'groupUl']);
  var autocompleteClasses$1 = autocompleteClasses;

  var _styled, _ClearIcon, _ArrowDropDownIcon;
  var useUtilityClasses$1y = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      disablePortal = ownerState.disablePortal,
      expanded = ownerState.expanded,
      focused = ownerState.focused,
      fullWidth = ownerState.fullWidth,
      hasClearIcon = ownerState.hasClearIcon,
      hasPopupIcon = ownerState.hasPopupIcon,
      inputFocused = ownerState.inputFocused,
      popupOpen = ownerState.popupOpen,
      size = ownerState.size;
    var slots = {
      root: ['root', expanded && 'expanded', focused && 'focused', fullWidth && 'fullWidth', hasClearIcon && 'hasClearIcon', hasPopupIcon && 'hasPopupIcon'],
      inputRoot: ['inputRoot'],
      input: ['input', inputFocused && 'inputFocused'],
      tag: ['tag', "tagSize".concat(capitalize(size))],
      endAdornment: ['endAdornment'],
      clearIndicator: ['clearIndicator'],
      popupIndicator: ['popupIndicator', popupOpen && 'popupIndicatorOpen'],
      popper: ['popper', disablePortal && 'popperDisablePortal'],
      paper: ['paper'],
      listbox: ['listbox'],
      loading: ['loading'],
      noOptions: ['noOptions'],
      option: ['option'],
      groupLabel: ['groupLabel'],
      groupUl: ['groupUl']
    };
    return composeClasses(slots, getAutocompleteUtilityClass, classes);
  };
  var AutocompleteRoot = styled$1('div', {
    name: 'MuiAutocomplete',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      var fullWidth = ownerState.fullWidth,
        hasClearIcon = ownerState.hasClearIcon,
        hasPopupIcon = ownerState.hasPopupIcon,
        inputFocused = ownerState.inputFocused,
        size = ownerState.size;
      return [_defineProperty({}, "& .".concat(autocompleteClasses$1.tag), styles.tag), _defineProperty({}, "& .".concat(autocompleteClasses$1.tag), styles["tagSize".concat(capitalize(size))]), _defineProperty({}, "& .".concat(autocompleteClasses$1.inputRoot), styles.inputRoot), _defineProperty({}, "& .".concat(autocompleteClasses$1.input), styles.input), _defineProperty({}, "& .".concat(autocompleteClasses$1.input), inputFocused && styles.inputFocused), styles.root, fullWidth && styles.fullWidth, hasPopupIcon && styles.hasPopupIcon, hasClearIcon && styles.hasClearIcon];
    }
  })((_styled = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_styled, "&.".concat(autocompleteClasses$1.focused, " .").concat(autocompleteClasses$1.clearIndicator), {
    visibility: 'visible'
  }), '@media (pointer: fine)', _defineProperty({}, "&:hover .".concat(autocompleteClasses$1.clearIndicator), {
    visibility: 'visible'
  })), "& .".concat(autocompleteClasses$1.tag), {
    margin: 3,
    maxWidth: 'calc(100% - 6px)'
  }), "& .".concat(autocompleteClasses$1.inputRoot), _defineProperty(_defineProperty(_defineProperty({}, ".".concat(autocompleteClasses$1.hasPopupIcon, "&, .").concat(autocompleteClasses$1.hasClearIcon, "&"), {
    paddingRight: 26 + 4
  }), ".".concat(autocompleteClasses$1.hasPopupIcon, ".").concat(autocompleteClasses$1.hasClearIcon, "&"), {
    paddingRight: 52 + 4
  }), "& .".concat(autocompleteClasses$1.input), {
    width: 0,
    minWidth: 30
  })), "& .".concat(inputClasses$1.root), {
    paddingBottom: 1,
    '& .MuiInput-input': {
      padding: '4px 4px 4px 0px'
    }
  }), "& .".concat(inputClasses$1.root, ".").concat(inputBaseClasses$1.sizeSmall), _defineProperty({}, "& .".concat(inputClasses$1.input), {
    padding: '2px 4px 3px 0'
  })), "& .".concat(outlinedInputClasses$1.root), _defineProperty(_defineProperty(_defineProperty(_defineProperty({
    padding: 9
  }, ".".concat(autocompleteClasses$1.hasPopupIcon, "&, .").concat(autocompleteClasses$1.hasClearIcon, "&"), {
    paddingRight: 26 + 4 + 9
  }), ".".concat(autocompleteClasses$1.hasPopupIcon, ".").concat(autocompleteClasses$1.hasClearIcon, "&"), {
    paddingRight: 52 + 4 + 9
  }), "& .".concat(autocompleteClasses$1.input), {
    padding: '7.5px 4px 7.5px 5px'
  }), "& .".concat(autocompleteClasses$1.endAdornment), {
    right: 9
  })), "& .".concat(outlinedInputClasses$1.root, ".").concat(inputBaseClasses$1.sizeSmall), _defineProperty({
    // Don't specify paddingRight, as it overrides the default value set when there is only
    // one of the popup or clear icon as the specificity is equal so the latter one wins
    paddingTop: 6,
    paddingBottom: 6,
    paddingLeft: 6
  }, "& .".concat(autocompleteClasses$1.input), {
    padding: '2.5px 4px 2.5px 8px'
  })), "& .".concat(filledInputClasses$1.root), _defineProperty(_defineProperty(_defineProperty(_defineProperty({
    paddingTop: 19,
    paddingLeft: 8
  }, ".".concat(autocompleteClasses$1.hasPopupIcon, "&, .").concat(autocompleteClasses$1.hasClearIcon, "&"), {
    paddingRight: 26 + 4 + 9
  }), ".".concat(autocompleteClasses$1.hasPopupIcon, ".").concat(autocompleteClasses$1.hasClearIcon, "&"), {
    paddingRight: 52 + 4 + 9
  }), "& .".concat(filledInputClasses$1.input), {
    padding: '7px 4px'
  }), "& .".concat(autocompleteClasses$1.endAdornment), {
    right: 9
  })), "& .".concat(filledInputClasses$1.root, ".").concat(inputBaseClasses$1.sizeSmall), _defineProperty({
    paddingBottom: 1
  }, "& .".concat(filledInputClasses$1.input), {
    padding: '2.5px 4px'
  })), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_styled, "& .".concat(inputBaseClasses$1.hiddenLabel), {
    paddingTop: 8
  }), "& .".concat(filledInputClasses$1.root, ".").concat(inputBaseClasses$1.hiddenLabel), _defineProperty({
    paddingTop: 0,
    paddingBottom: 0
  }, "& .".concat(autocompleteClasses$1.input), {
    paddingTop: 16,
    paddingBottom: 17
  })), "& .".concat(filledInputClasses$1.root, ".").concat(inputBaseClasses$1.hiddenLabel, ".").concat(inputBaseClasses$1.sizeSmall), _defineProperty({}, "& .".concat(autocompleteClasses$1.input), {
    paddingTop: 8,
    paddingBottom: 9
  })), "& .".concat(autocompleteClasses$1.input), {
    flexGrow: 1,
    textOverflow: 'ellipsis',
    opacity: 0
  }), "variants", [{
    props: {
      fullWidth: true
    },
    style: {
      width: '100%'
    }
  }, {
    props: {
      size: 'small'
    },
    style: _defineProperty({}, "& .".concat(autocompleteClasses$1.tag), {
      margin: 2,
      maxWidth: 'calc(100% - 4px)'
    })
  }, {
    props: {
      inputFocused: true
    },
    style: _defineProperty({}, "& .".concat(autocompleteClasses$1.input), {
      opacity: 1
    })
  }, {
    props: {
      multiple: true
    },
    style: _defineProperty({}, "& .".concat(autocompleteClasses$1.inputRoot), {
      flexWrap: 'wrap'
    })
  }])));
  var AutocompleteEndAdornment = styled$1('div', {
    name: 'MuiAutocomplete',
    slot: 'EndAdornment',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.endAdornment;
    }
  })({
    // We use a position absolute to support wrapping tags.
    position: 'absolute',
    right: 0,
    top: '50%',
    transform: 'translate(0, -50%)'
  });
  var AutocompleteClearIndicator = styled$1(IconButton$1, {
    name: 'MuiAutocomplete',
    slot: 'ClearIndicator',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.clearIndicator;
    }
  })({
    marginRight: -2,
    padding: 4,
    visibility: 'hidden'
  });
  var AutocompletePopupIndicator = styled$1(IconButton$1, {
    name: 'MuiAutocomplete',
    slot: 'PopupIndicator',
    overridesResolver: function overridesResolver(_ref6, styles) {
      var ownerState = _ref6.ownerState;
      return _extends({}, styles.popupIndicator, ownerState.popupOpen && styles.popupIndicatorOpen);
    }
  })({
    padding: 2,
    marginRight: -2,
    variants: [{
      props: {
        popupOpen: true
      },
      style: {
        transform: 'rotate(180deg)'
      }
    }]
  });
  var AutocompletePopper = styled$1(Popper$1, {
    name: 'MuiAutocomplete',
    slot: 'Popper',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [_defineProperty({}, "& .".concat(autocompleteClasses$1.option), styles.option), styles.popper, ownerState.disablePortal && styles.popperDisablePortal];
    }
  })(function (_ref8) {
    var theme = _ref8.theme;
    return {
      zIndex: (theme.vars || theme).zIndex.modal,
      variants: [{
        props: {
          disablePortal: true
        },
        style: {
          position: 'absolute'
        }
      }]
    };
  });
  var AutocompletePaper = styled$1(Paper$1, {
    name: 'MuiAutocomplete',
    slot: 'Paper',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.paper;
    }
  })(function (_ref9) {
    var theme = _ref9.theme;
    return _extends({}, theme.typography.body1, {
      overflow: 'auto'
    });
  });
  var AutocompleteLoading = styled$1('div', {
    name: 'MuiAutocomplete',
    slot: 'Loading',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.loading;
    }
  })(function (_ref10) {
    var theme = _ref10.theme;
    return {
      color: (theme.vars || theme).palette.text.secondary,
      padding: '14px 16px'
    };
  });
  var AutocompleteNoOptions = styled$1('div', {
    name: 'MuiAutocomplete',
    slot: 'NoOptions',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.noOptions;
    }
  })(function (_ref11) {
    var theme = _ref11.theme;
    return {
      color: (theme.vars || theme).palette.text.secondary,
      padding: '14px 16px'
    };
  });
  var AutocompleteListbox = styled$1('div', {
    name: 'MuiAutocomplete',
    slot: 'Listbox',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.listbox;
    }
  })(function (_ref12) {
    var theme = _ref12.theme;
    return _defineProperty({
      listStyle: 'none',
      margin: 0,
      padding: '8px 0',
      maxHeight: '40vh',
      overflow: 'auto',
      position: 'relative'
    }, "& .".concat(autocompleteClasses$1.option), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
      minHeight: 48,
      display: 'flex',
      overflow: 'hidden',
      justifyContent: 'flex-start',
      alignItems: 'center',
      cursor: 'pointer',
      paddingTop: 6,
      boxSizing: 'border-box',
      outline: '0',
      WebkitTapHighlightColor: 'transparent',
      paddingBottom: 6,
      paddingLeft: 16,
      paddingRight: 16
    }, theme.breakpoints.up('sm'), {
      minHeight: 'auto'
    }), "&.".concat(autocompleteClasses$1.focused), {
      backgroundColor: (theme.vars || theme).palette.action.hover,
      // Reset on touch devices, it doesn't add specificity
      '@media (hover: none)': {
        backgroundColor: 'transparent'
      }
    }), '&[aria-disabled="true"]', {
      opacity: (theme.vars || theme).palette.action.disabledOpacity,
      pointerEvents: 'none'
    }), "&.".concat(autocompleteClasses$1.focusVisible), {
      backgroundColor: (theme.vars || theme).palette.action.focus
    }), '&[aria-selected="true"]', _defineProperty(_defineProperty({
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / ").concat(theme.vars.palette.action.selectedOpacity, ")") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity)
    }, "&.".concat(autocompleteClasses$1.focused), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.hoverOpacity, "))") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity),
      // Reset on touch devices, it doesn't add specificity
      '@media (hover: none)': {
        backgroundColor: (theme.vars || theme).palette.action.selected
      }
    }), "&.".concat(autocompleteClasses$1.focusVisible), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.focusOpacity, "))") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)
    })));
  });
  var AutocompleteGroupLabel = styled$1(ListSubheader$1, {
    name: 'MuiAutocomplete',
    slot: 'GroupLabel',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.groupLabel;
    }
  })(function (_ref14) {
    var theme = _ref14.theme;
    return {
      backgroundColor: (theme.vars || theme).palette.background.paper,
      top: -8
    };
  });
  var AutocompleteGroupUl = styled$1('ul', {
    name: 'MuiAutocomplete',
    slot: 'GroupUl',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.groupUl;
    }
  })(_defineProperty({
    padding: 0
  }, "& .".concat(autocompleteClasses$1.option), {
    paddingLeft: 24
  }));
  var Autocomplete = /*#__PURE__*/React__namespace.forwardRef(function Autocomplete(inProps, ref) {
    var _slotProps$clearIndic, _slotProps$paper, _slotProps$popper, _slotProps$popupIndic;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiAutocomplete'
    });

    /* eslint-disable @typescript-eslint/no-unused-vars */
    props.autoComplete;
      props.autoHighlight;
      props.autoSelect;
      props.blurOnSelect;
      var ChipProps = props.ChipProps,
      className = props.className,
      _props$clearIcon = props.clearIcon,
      clearIcon = _props$clearIcon === void 0 ? _ClearIcon || (_ClearIcon = /*#__PURE__*/jsxRuntimeExports.jsx(ClearIcon, {
        fontSize: "small"
      })) : _props$clearIcon,
      _props$clearOnBlur = props.clearOnBlur;
      _props$clearOnBlur === void 0 ? !props.freeSolo : _props$clearOnBlur;
      props.clearOnEscape;
      var _props$clearText = props.clearText,
      clearText = _props$clearText === void 0 ? 'Clear' : _props$clearText,
      _props$closeText = props.closeText,
      closeText = _props$closeText === void 0 ? 'Close' : _props$closeText,
      _props$componentsProp = props.componentsProps,
      componentsProps = _props$componentsProp === void 0 ? {} : _props$componentsProp,
      _props$defaultValue = props.defaultValue;
      _props$defaultValue === void 0 ? props.multiple ? [] : null : _props$defaultValue;
      var _props$disableClearab = props.disableClearable,
      disableClearable = _props$disableClearab === void 0 ? false : _props$disableClearab;
      props.disableCloseOnSelect;
      var _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled;
      props.disabledItemsFocusable;
      props.disableListWrap;
      var _props$disablePortal = props.disablePortal,
      disablePortal = _props$disablePortal === void 0 ? false : _props$disablePortal;
      props.filterOptions;
      props.filterSelectedOptions;
      var _props$forcePopupIcon = props.forcePopupIcon,
      forcePopupIcon = _props$forcePopupIcon === void 0 ? 'auto' : _props$forcePopupIcon,
      _props$freeSolo = props.freeSolo,
      freeSolo = _props$freeSolo === void 0 ? false : _props$freeSolo,
      _props$fullWidth = props.fullWidth,
      fullWidth = _props$fullWidth === void 0 ? false : _props$fullWidth,
      _props$getLimitTagsTe = props.getLimitTagsText,
      getLimitTagsText = _props$getLimitTagsTe === void 0 ? function (more) {
        return "+".concat(more);
      } : _props$getLimitTagsTe;
      props.getOptionDisabled;
      props.getOptionKey;
      var getOptionLabelProp = props.getOptionLabel;
      props.isOptionEqualToValue;
      var groupBy = props.groupBy,
      _props$handleHomeEndK = props.handleHomeEndKeys;
      _props$handleHomeEndK === void 0 ? !props.freeSolo : _props$handleHomeEndK;
      props.id;
      props.includeInputInList;
      props.inputValue;
      var _props$limitTags = props.limitTags,
      limitTags = _props$limitTags === void 0 ? -1 : _props$limitTags,
      _props$ListboxCompone = props.ListboxComponent,
      ListboxComponent = _props$ListboxCompone === void 0 ? 'ul' : _props$ListboxCompone,
      ListboxProps = props.ListboxProps,
      _props$loading = props.loading,
      loading = _props$loading === void 0 ? false : _props$loading,
      _props$loadingText = props.loadingText,
      loadingText = _props$loadingText === void 0 ? 'Loading…' : _props$loadingText,
      _props$multiple = props.multiple,
      multiple = _props$multiple === void 0 ? false : _props$multiple,
      _props$noOptionsText = props.noOptionsText,
      noOptionsText = _props$noOptionsText === void 0 ? 'No options' : _props$noOptionsText;
      props.onChange;
      props.onClose;
      props.onHighlightChange;
      props.onInputChange;
      props.onOpen;
      props.open;
      props.openOnFocus;
      var _props$openText = props.openText,
      openText = _props$openText === void 0 ? 'Open' : _props$openText;
      props.options;
      var _props$PaperComponent = props.PaperComponent,
      PaperComponent = _props$PaperComponent === void 0 ? Paper$1 : _props$PaperComponent,
      _props$PopperComponen = props.PopperComponent,
      PopperComponent = _props$PopperComponen === void 0 ? Popper$1 : _props$PopperComponen,
      _props$popupIcon = props.popupIcon,
      popupIcon = _props$popupIcon === void 0 ? _ArrowDropDownIcon || (_ArrowDropDownIcon = /*#__PURE__*/jsxRuntimeExports.jsx(ArrowDropDownIcon, {})) : _props$popupIcon,
      _props$readOnly = props.readOnly,
      readOnly = _props$readOnly === void 0 ? false : _props$readOnly,
      renderGroupProp = props.renderGroup,
      renderInput = props.renderInput,
      renderOptionProp = props.renderOption,
      renderTags = props.renderTags,
      _props$selectOnFocus = props.selectOnFocus;
      _props$selectOnFocus === void 0 ? !props.freeSolo : _props$selectOnFocus;
      var _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps;
      props.value;
      var other = _objectWithoutProperties(props, ["autoComplete", "autoHighlight", "autoSelect", "blurOnSelect", "ChipProps", "className", "clearIcon", "clearOnBlur", "clearOnEscape", "clearText", "closeText", "componentsProps", "defaultValue", "disableClearable", "disableCloseOnSelect", "disabled", "disabledItemsFocusable", "disableListWrap", "disablePortal", "filterOptions", "filterSelectedOptions", "forcePopupIcon", "freeSolo", "fullWidth", "getLimitTagsText", "getOptionDisabled", "getOptionKey", "getOptionLabel", "isOptionEqualToValue", "groupBy", "handleHomeEndKeys", "id", "includeInputInList", "inputValue", "limitTags", "ListboxComponent", "ListboxProps", "loading", "loadingText", "multiple", "noOptionsText", "onChange", "onClose", "onHighlightChange", "onInputChange", "onOpen", "open", "openOnFocus", "openText", "options", "PaperComponent", "PopperComponent", "popupIcon", "readOnly", "renderGroup", "renderInput", "renderOption", "renderTags", "selectOnFocus", "size", "slotProps", "value"]);
    /* eslint-enable @typescript-eslint/no-unused-vars */
    var _useAutocomplete = useAutocomplete(_extends({}, props, {
        componentName: 'Autocomplete'
      })),
      getRootProps = _useAutocomplete.getRootProps,
      getInputProps = _useAutocomplete.getInputProps,
      getInputLabelProps = _useAutocomplete.getInputLabelProps,
      getPopupIndicatorProps = _useAutocomplete.getPopupIndicatorProps,
      getClearProps = _useAutocomplete.getClearProps,
      getTagProps = _useAutocomplete.getTagProps,
      getListboxProps = _useAutocomplete.getListboxProps,
      getOptionProps = _useAutocomplete.getOptionProps,
      value = _useAutocomplete.value,
      dirty = _useAutocomplete.dirty,
      expanded = _useAutocomplete.expanded,
      id = _useAutocomplete.id,
      popupOpen = _useAutocomplete.popupOpen,
      focused = _useAutocomplete.focused,
      focusedTag = _useAutocomplete.focusedTag,
      anchorEl = _useAutocomplete.anchorEl,
      setAnchorEl = _useAutocomplete.setAnchorEl,
      inputValue = _useAutocomplete.inputValue,
      groupedOptions = _useAutocomplete.groupedOptions;
    var hasClearIcon = !disableClearable && !disabled && dirty && !readOnly;
    var hasPopupIcon = (!freeSolo || forcePopupIcon === true) && forcePopupIcon !== false;
    var _getInputProps = getInputProps(),
      handleInputMouseDown = _getInputProps.onMouseDown;
    var _ref15 = ListboxProps != null ? ListboxProps : {},
      externalListboxRef = _ref15.ref;
    var _getListboxProps = getListboxProps(),
      listboxRef = _getListboxProps.ref,
      otherListboxProps = _objectWithoutProperties(_getListboxProps, ["ref"]);
    var combinedListboxRef = useForkRef(listboxRef, externalListboxRef);
    var defaultGetOptionLabel = function defaultGetOptionLabel(option) {
      var _option$label;
      return (_option$label = option.label) != null ? _option$label : option;
    };
    var getOptionLabel = getOptionLabelProp || defaultGetOptionLabel;

    // If you modify this, make sure to keep the `AutocompleteOwnerState` type in sync.
    var ownerState = _extends({}, props, {
      disablePortal: disablePortal,
      expanded: expanded,
      focused: focused,
      fullWidth: fullWidth,
      getOptionLabel: getOptionLabel,
      hasClearIcon: hasClearIcon,
      hasPopupIcon: hasPopupIcon,
      inputFocused: focusedTag === -1,
      popupOpen: popupOpen,
      size: size
    });
    var classes = useUtilityClasses$1y(ownerState);
    var startAdornment;
    if (multiple && value.length > 0) {
      var getCustomizedTagProps = function getCustomizedTagProps(params) {
        return _extends({
          className: classes.tag,
          disabled: disabled
        }, getTagProps(params));
      };
      if (renderTags) {
        startAdornment = renderTags(value, getCustomizedTagProps, ownerState);
      } else {
        startAdornment = value.map(function (option, index) {
          var _getCustomizedTagProp = getCustomizedTagProps({
              index: index
            }),
            key = _getCustomizedTagProp.key,
            customTagProps = _objectWithoutProperties(_getCustomizedTagProp, ["key"]);
          return /*#__PURE__*/jsxRuntimeExports.jsx(Chip$1, _extends({
            label: getOptionLabel(option),
            size: size
          }, customTagProps, ChipProps), key);
        });
      }
    }
    if (limitTags > -1 && Array.isArray(startAdornment)) {
      var more = startAdornment.length - limitTags;
      if (!focused && more > 0) {
        startAdornment = startAdornment.splice(0, limitTags);
        startAdornment.push( /*#__PURE__*/jsxRuntimeExports.jsx("span", {
          className: classes.tag,
          children: getLimitTagsText(more)
        }, startAdornment.length));
      }
    }
    var defaultRenderGroup = function defaultRenderGroup(params) {
      return /*#__PURE__*/jsxRuntimeExports.jsxs("li", {
        children: [/*#__PURE__*/jsxRuntimeExports.jsx(AutocompleteGroupLabel, {
          className: classes.groupLabel,
          ownerState: ownerState,
          component: "div",
          children: params.group
        }), /*#__PURE__*/jsxRuntimeExports.jsx(AutocompleteGroupUl, {
          className: classes.groupUl,
          ownerState: ownerState,
          children: params.children
        })]
      }, params.key);
    };
    var renderGroup = renderGroupProp || defaultRenderGroup;
    var defaultRenderOption = function defaultRenderOption(props2, option) {
      // Need to clearly apply key because of https://github.com/vercel/next.js/issues/55642
      var key = props2.key,
        otherProps = _objectWithoutProperties(props2, ["key"]);
      return /*#__PURE__*/jsxRuntimeExports.jsx("li", _extends({}, otherProps, {
        children: getOptionLabel(option)
      }), key);
    };
    var renderOption = renderOptionProp || defaultRenderOption;
    var renderListOption = function renderListOption(option, index) {
      var optionProps = getOptionProps({
        option: option,
        index: index
      });
      return renderOption(_extends({}, optionProps, {
        className: classes.option
      }), option, {
        selected: optionProps['aria-selected'],
        index: index,
        inputValue: inputValue
      }, ownerState);
    };
    var clearIndicatorSlotProps = (_slotProps$clearIndic = slotProps.clearIndicator) != null ? _slotProps$clearIndic : componentsProps.clearIndicator;
    var paperSlotProps = (_slotProps$paper = slotProps.paper) != null ? _slotProps$paper : componentsProps.paper;
    var popperSlotProps = (_slotProps$popper = slotProps.popper) != null ? _slotProps$popper : componentsProps.popper;
    var popupIndicatorSlotProps = (_slotProps$popupIndic = slotProps.popupIndicator) != null ? _slotProps$popupIndic : componentsProps.popupIndicator;
    return /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsx(AutocompleteRoot, _extends({
        ref: ref,
        className: clsx(classes.root, className),
        ownerState: ownerState
      }, getRootProps(other), {
        children: renderInput({
          id: id,
          disabled: disabled,
          fullWidth: true,
          size: size === 'small' ? 'small' : undefined,
          InputLabelProps: getInputLabelProps(),
          InputProps: _extends({
            ref: setAnchorEl,
            className: classes.inputRoot,
            startAdornment: startAdornment,
            onClick: function onClick(event) {
              if (event.target === event.currentTarget) {
                handleInputMouseDown(event);
              }
            }
          }, (hasClearIcon || hasPopupIcon) && {
            endAdornment: /*#__PURE__*/jsxRuntimeExports.jsxs(AutocompleteEndAdornment, {
              className: classes.endAdornment,
              ownerState: ownerState,
              children: [hasClearIcon ? /*#__PURE__*/jsxRuntimeExports.jsx(AutocompleteClearIndicator, _extends({}, getClearProps(), {
                "aria-label": clearText,
                title: clearText,
                ownerState: ownerState
              }, clearIndicatorSlotProps, {
                className: clsx(classes.clearIndicator, clearIndicatorSlotProps == null ? void 0 : clearIndicatorSlotProps.className),
                children: clearIcon
              })) : null, hasPopupIcon ? /*#__PURE__*/jsxRuntimeExports.jsx(AutocompletePopupIndicator, _extends({}, getPopupIndicatorProps(), {
                disabled: disabled,
                "aria-label": popupOpen ? closeText : openText,
                title: popupOpen ? closeText : openText,
                ownerState: ownerState
              }, popupIndicatorSlotProps, {
                className: clsx(classes.popupIndicator, popupIndicatorSlotProps == null ? void 0 : popupIndicatorSlotProps.className),
                children: popupIcon
              })) : null]
            })
          }),
          inputProps: _extends({
            className: classes.input,
            disabled: disabled,
            readOnly: readOnly
          }, getInputProps())
        })
      })), anchorEl ? /*#__PURE__*/jsxRuntimeExports.jsx(AutocompletePopper, _extends({
        as: PopperComponent,
        disablePortal: disablePortal,
        style: {
          width: anchorEl ? anchorEl.clientWidth : null
        },
        ownerState: ownerState,
        role: "presentation",
        anchorEl: anchorEl,
        open: popupOpen
      }, popperSlotProps, {
        className: clsx(classes.popper, popperSlotProps == null ? void 0 : popperSlotProps.className),
        children: /*#__PURE__*/jsxRuntimeExports.jsxs(AutocompletePaper, _extends({
          ownerState: ownerState,
          as: PaperComponent
        }, paperSlotProps, {
          className: clsx(classes.paper, paperSlotProps == null ? void 0 : paperSlotProps.className),
          children: [loading && groupedOptions.length === 0 ? /*#__PURE__*/jsxRuntimeExports.jsx(AutocompleteLoading, {
            className: classes.loading,
            ownerState: ownerState,
            children: loadingText
          }) : null, groupedOptions.length === 0 && !freeSolo && !loading ? /*#__PURE__*/jsxRuntimeExports.jsx(AutocompleteNoOptions, {
            className: classes.noOptions,
            ownerState: ownerState,
            role: "presentation",
            onMouseDown: function onMouseDown(event) {
              // Prevent input blur when interacting with the "no options" content
              event.preventDefault();
            },
            children: noOptionsText
          }) : null, groupedOptions.length > 0 ? /*#__PURE__*/jsxRuntimeExports.jsx(AutocompleteListbox, _extends({
            as: ListboxComponent,
            className: classes.listbox,
            ownerState: ownerState
          }, otherListboxProps, ListboxProps, {
            ref: combinedListboxRef,
            children: groupedOptions.map(function (option, index) {
              if (groupBy) {
                return renderGroup({
                  key: option.key,
                  group: option.group,
                  children: option.options.map(function (option2, index2) {
                    return renderListOption(option2, option.index + index2);
                  })
                });
              }
              return renderListOption(option, index);
            })
          })) : null]
        }))
      })) : null]
    });
  });
  Autocomplete.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * If `true`, the portion of the selected suggestion that the user hasn't typed,
     * known as the completion string, appears inline after the input cursor in the textbox.
     * The inline completion string is visually highlighted and has a selected state.
     * @default false
     */
    autoComplete: PropTypes.bool,
    /**
     * If `true`, the first option is automatically highlighted.
     * @default false
     */
    autoHighlight: PropTypes.bool,
    /**
     * If `true`, the selected option becomes the value of the input
     * when the Autocomplete loses focus unless the user chooses
     * a different option or changes the character string in the input.
     *
     * When using the `freeSolo` mode, the typed value will be the input value
     * if the Autocomplete loses focus without highlighting an option.
     * @default false
     */
    autoSelect: PropTypes.bool,
    /**
     * Control if the input should be blurred when an option is selected:
     *
     * - `false` the input is not blurred.
     * - `true` the input is always blurred.
     * - `touch` the input is blurred after a touch event.
     * - `mouse` the input is blurred after a mouse event.
     * @default false
     */
    blurOnSelect: PropTypes.oneOfType([PropTypes.oneOf(['mouse', 'touch']), PropTypes.bool]),
    /**
     * Props applied to the [`Chip`](/material-ui/api/chip/) element.
     */
    ChipProps: PropTypes.object,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The icon to display in place of the default clear icon.
     * @default <ClearIcon fontSize="small" />
     */
    clearIcon: PropTypes.node,
    /**
     * If `true`, the input's text is cleared on blur if no value is selected.
     *
     * Set it to `true` if you want to help the user enter a new value.
     * Set it to `false` if you want to help the user resume their search.
     * @default !props.freeSolo
     */
    clearOnBlur: PropTypes.bool,
    /**
     * If `true`, clear all values when the user presses escape and the popup is closed.
     * @default false
     */
    clearOnEscape: PropTypes.bool,
    /**
     * Override the default text for the *clear* icon button.
     *
     * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
     * @default 'Clear'
     */
    clearText: PropTypes.string,
    /**
     * Override the default text for the *close popup* icon button.
     *
     * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
     * @default 'Close'
     */
    closeText: PropTypes.string,
    /**
     * The props used for each slot inside.
     * @default {}
     */
    componentsProps: PropTypes.shape({
      clearIndicator: PropTypes.object,
      paper: PropTypes.object,
      popper: PropTypes.object,
      popupIndicator: PropTypes.object
    }),
    /**
     * The default value. Use when the component is not controlled.
     * @default props.multiple ? [] : null
     */
    defaultValue: chainPropTypes(PropTypes.any, function (props) {
      if (props.multiple && props.defaultValue !== undefined && !Array.isArray(props.defaultValue)) {
        return new Error(['MUI: The Autocomplete expects the `defaultValue` prop to be an array when `multiple={true}` or undefined.', "However, ".concat(props.defaultValue, " was provided.")].join('\n'));
      }
      return null;
    }),
    /**
     * If `true`, the input can't be cleared.
     * @default false
     */
    disableClearable: PropTypes.bool,
    /**
     * If `true`, the popup won't close when a value is selected.
     * @default false
     */
    disableCloseOnSelect: PropTypes.bool,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, will allow focus on disabled items.
     * @default false
     */
    disabledItemsFocusable: PropTypes.bool,
    /**
     * If `true`, the list box in the popup will not wrap focus.
     * @default false
     */
    disableListWrap: PropTypes.bool,
    /**
     * If `true`, the `Popper` content will be under the DOM hierarchy of the parent component.
     * @default false
     */
    disablePortal: PropTypes.bool,
    /**
     * A function that determines the filtered options to be rendered on search.
     *
     * @default createFilterOptions()
     * @param {Value[]} options The options to render.
     * @param {object} state The state of the component.
     * @returns {Value[]}
     */
    filterOptions: PropTypes.func,
    /**
     * If `true`, hide the selected options from the list box.
     * @default false
     */
    filterSelectedOptions: PropTypes.bool,
    /**
     * Force the visibility display of the popup icon.
     * @default 'auto'
     */
    forcePopupIcon: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.bool]),
    /**
     * If `true`, the Autocomplete is free solo, meaning that the user input is not bound to provided options.
     * @default false
     */
    freeSolo: PropTypes.bool,
    /**
     * If `true`, the input will take up the full width of its container.
     * @default false
     */
    fullWidth: PropTypes.bool,
    /**
     * The label to display when the tags are truncated (`limitTags`).
     *
     * @param {number} more The number of truncated tags.
     * @returns {ReactNode}
     * @default (more) => `+${more}`
     */
    getLimitTagsText: PropTypes.func,
    /**
     * Used to determine the disabled state for a given option.
     *
     * @param {Value} option The option to test.
     * @returns {boolean}
     */
    getOptionDisabled: PropTypes.func,
    /**
     * Used to determine the key for a given option.
     * This can be useful when the labels of options are not unique (since labels are used as keys by default).
     *
     * @param {Value} option The option to get the key for.
     * @returns {string | number}
     */
    getOptionKey: PropTypes.func,
    /**
     * Used to determine the string value for a given option.
     * It's used to fill the input (and the list box options if `renderOption` is not provided).
     *
     * If used in free solo mode, it must accept both the type of the options and a string.
     *
     * @param {Value} option
     * @returns {string}
     * @default (option) => option.label ?? option
     */
    getOptionLabel: PropTypes.func,
    /**
     * If provided, the options will be grouped under the returned string.
     * The groupBy value is also used as the text for group headings when `renderGroup` is not provided.
     *
     * @param {Value} options The options to group.
     * @returns {string}
     */
    groupBy: PropTypes.func,
    /**
     * If `true`, the component handles the "Home" and "End" keys when the popup is open.
     * It should move focus to the first option and last option, respectively.
     * @default !props.freeSolo
     */
    handleHomeEndKeys: PropTypes.bool,
    /**
     * This prop is used to help implement the accessibility logic.
     * If you don't provide an id it will fall back to a randomly generated one.
     */
    id: PropTypes.string,
    /**
     * If `true`, the highlight can move to the input.
     * @default false
     */
    includeInputInList: PropTypes.bool,
    /**
     * The input value.
     */
    inputValue: PropTypes.string,
    /**
     * Used to determine if the option represents the given value.
     * Uses strict equality by default.
     * ⚠️ Both arguments need to be handled, an option can only match with one value.
     *
     * @param {Value} option The option to test.
     * @param {Value} value The value to test against.
     * @returns {boolean}
     */
    isOptionEqualToValue: PropTypes.func,
    /**
     * The maximum number of tags that will be visible when not focused.
     * Set `-1` to disable the limit.
     * @default -1
     */
    limitTags: integerPropType,
    /**
     * The component used to render the listbox.
     * @default 'ul'
     */
    ListboxComponent: PropTypes.elementType,
    /**
     * Props applied to the Listbox element.
     */
    ListboxProps: PropTypes.object,
    /**
     * If `true`, the component is in a loading state.
     * This shows the `loadingText` in place of suggestions (only if there are no suggestions to show, for example `options` are empty).
     * @default false
     */
    loading: PropTypes.bool,
    /**
     * Text to display when in a loading state.
     *
     * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
     * @default 'Loading…'
     */
    loadingText: PropTypes.node,
    /**
     * If `true`, `value` must be an array and the menu will support multiple selections.
     * @default false
     */
    multiple: PropTypes.bool,
    /**
     * Text to display when there are no options.
     *
     * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
     * @default 'No options'
     */
    noOptionsText: PropTypes.node,
    /**
     * Callback fired when the value changes.
     *
     * @param {React.SyntheticEvent} event The event source of the callback.
     * @param {Value|Value[]} value The new value of the component.
     * @param {string} reason One of "createOption", "selectOption", "removeOption", "blur" or "clear".
     * @param {string} [details]
     */
    onChange: PropTypes.func,
    /**
     * Callback fired when the popup requests to be closed.
     * Use in controlled mode (see open).
     *
     * @param {React.SyntheticEvent} event The event source of the callback.
     * @param {string} reason Can be: `"toggleInput"`, `"escape"`, `"selectOption"`, `"removeOption"`, `"blur"`.
     */
    onClose: PropTypes.func,
    /**
     * Callback fired when the highlight option changes.
     *
     * @param {React.SyntheticEvent} event The event source of the callback.
     * @param {Value} option The highlighted option.
     * @param {string} reason Can be: `"keyboard"`, `"auto"`, `"mouse"`, `"touch"`.
     */
    onHighlightChange: PropTypes.func,
    /**
     * Callback fired when the input value changes.
     *
     * @param {React.SyntheticEvent} event The event source of the callback.
     * @param {string} value The new value of the text input.
     * @param {string} reason Can be: `"input"` (user input), `"reset"` (programmatic change), `"clear"`.
     */
    onInputChange: PropTypes.func,
    /**
     * @ignore
     */
    onKeyDown: PropTypes.func,
    /**
     * Callback fired when the popup requests to be opened.
     * Use in controlled mode (see open).
     *
     * @param {React.SyntheticEvent} event The event source of the callback.
     */
    onOpen: PropTypes.func,
    /**
     * If `true`, the component is shown.
     */
    open: PropTypes.bool,
    /**
     * If `true`, the popup will open on input focus.
     * @default false
     */
    openOnFocus: PropTypes.bool,
    /**
     * Override the default text for the *open popup* icon button.
     *
     * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
     * @default 'Open'
     */
    openText: PropTypes.string,
    /**
     * Array of options.
     */
    options: PropTypes.array.isRequired,
    /**
     * The component used to render the body of the popup.
     * @default Paper
     */
    PaperComponent: PropTypes.elementType,
    /**
     * The component used to position the popup.
     * @default Popper
     */
    PopperComponent: PropTypes.elementType,
    /**
     * The icon to display in place of the default popup icon.
     * @default <ArrowDropDownIcon />
     */
    popupIcon: PropTypes.node,
    /**
     * If `true`, the component becomes readonly. It is also supported for multiple tags where the tag cannot be deleted.
     * @default false
     */
    readOnly: PropTypes.bool,
    /**
     * Render the group.
     *
     * @param {AutocompleteRenderGroupParams} params The group to render.
     * @returns {ReactNode}
     */
    renderGroup: PropTypes.func,
    /**
     * Render the input.
     *
     * @param {object} params
     * @returns {ReactNode}
     */
    renderInput: PropTypes.func.isRequired,
    /**
     * Render the option, use `getOptionLabel` by default.
     *
     * @param {object} props The props to apply on the li element.
     * @param {Value} option The option to render.
     * @param {object} state The state of each option.
     * @param {object} ownerState The state of the Autocomplete component.
     * @returns {ReactNode}
     */
    renderOption: PropTypes.func,
    /**
     * Render the selected value.
     *
     * @param {Value[]} value The `value` provided to the component.
     * @param {function} getTagProps A tag props getter.
     * @param {object} ownerState The state of the Autocomplete component.
     * @returns {ReactNode}
     */
    renderTags: PropTypes.func,
    /**
     * If `true`, the input's text is selected on focus.
     * It helps the user clear the selected value.
     * @default !props.freeSolo
     */
    selectOnFocus: PropTypes.bool,
    /**
     * The size of the component.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['small', 'medium']), PropTypes.string]),
    /**
     * The props used for each slot inside.
     * @default {}
     */
    slotProps: PropTypes.shape({
      clearIndicator: PropTypes.object,
      paper: PropTypes.object,
      popper: PropTypes.object,
      popupIndicator: PropTypes.object
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The value of the autocomplete.
     *
     * The value must have reference equality with the option in order to be selected.
     * You can customize the equality behavior with the `isOptionEqualToValue` prop.
     */
    value: chainPropTypes(PropTypes.any, function (props) {
      if (props.multiple && props.value !== undefined && !Array.isArray(props.value)) {
        return new Error(['MUI: The Autocomplete expects the `value` prop to be an array when `multiple={true}` or undefined.', "However, ".concat(props.value, " was provided.")].join('\n'));
      }
      return null;
    })
  } ;
  var Autocomplete$1 = Autocomplete;

  var Person = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M12 12c2.21 0 4-1.79 4-4s-1.79-4-4-4-4 1.79-4 4 1.79 4 4 4zm0 2c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4z"
  }), 'Person');

  function getAvatarUtilityClass(slot) {
    return generateUtilityClass('MuiAvatar', slot);
  }
  var avatarClasses = generateUtilityClasses('MuiAvatar', ['root', 'colorDefault', 'circular', 'rounded', 'square', 'img', 'fallback']);
  var avatarClasses$1 = avatarClasses;

  var useUtilityClasses$1x = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      variant = ownerState.variant,
      colorDefault = ownerState.colorDefault;
    var slots = {
      root: ['root', variant, colorDefault && 'colorDefault'],
      img: ['img'],
      fallback: ['fallback']
    };
    return composeClasses(slots, getAvatarUtilityClass, classes);
  };
  var AvatarRoot = styled$1('div', {
    name: 'MuiAvatar',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.variant], ownerState.colorDefault && styles.colorDefault];
    }
  })(function (_ref) {
    var theme = _ref.theme;
    return {
      position: 'relative',
      display: 'flex',
      alignItems: 'center',
      justifyContent: 'center',
      flexShrink: 0,
      width: 40,
      height: 40,
      fontFamily: theme.typography.fontFamily,
      fontSize: theme.typography.pxToRem(20),
      lineHeight: 1,
      borderRadius: '50%',
      overflow: 'hidden',
      userSelect: 'none',
      variants: [{
        props: {
          variant: 'rounded'
        },
        style: {
          borderRadius: (theme.vars || theme).shape.borderRadius
        }
      }, {
        props: {
          variant: 'square'
        },
        style: {
          borderRadius: 0
        }
      }, {
        props: {
          colorDefault: true
        },
        style: _extends({
          color: (theme.vars || theme).palette.background["default"]
        }, theme.vars ? {
          backgroundColor: theme.vars.palette.Avatar.defaultBg
        } : _extends({
          backgroundColor: theme.palette.grey[400]
        }, theme.applyStyles('dark', {
          backgroundColor: theme.palette.grey[600]
        })))
      }]
    };
  });
  var AvatarImg = styled$1('img', {
    name: 'MuiAvatar',
    slot: 'Img',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.img;
    }
  })({
    width: '100%',
    height: '100%',
    textAlign: 'center',
    // Handle non-square image. The property isn't supported by IE11.
    objectFit: 'cover',
    // Hide alt text.
    color: 'transparent',
    // Hide the image broken icon, only works on Chrome.
    textIndent: 10000
  });
  var AvatarFallback = styled$1(Person, {
    name: 'MuiAvatar',
    slot: 'Fallback',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.fallback;
    }
  })({
    width: '75%',
    height: '75%'
  });
  function useLoaded(_ref2) {
    var crossOrigin = _ref2.crossOrigin,
      referrerPolicy = _ref2.referrerPolicy,
      src = _ref2.src,
      srcSet = _ref2.srcSet;
    var _React$useState = React__namespace.useState(false),
      loaded = _React$useState[0],
      setLoaded = _React$useState[1];
    React__namespace.useEffect(function () {
      if (!src && !srcSet) {
        return undefined;
      }
      setLoaded(false);
      var active = true;
      var image = new Image();
      image.onload = function () {
        if (!active) {
          return;
        }
        setLoaded('loaded');
      };
      image.onerror = function () {
        if (!active) {
          return;
        }
        setLoaded('error');
      };
      image.crossOrigin = crossOrigin;
      image.referrerPolicy = referrerPolicy;
      image.src = src;
      if (srcSet) {
        image.srcset = srcSet;
      }
      return function () {
        active = false;
      };
    }, [crossOrigin, referrerPolicy, src, srcSet]);
    return loaded;
  }
  var Avatar = /*#__PURE__*/React__namespace.forwardRef(function Avatar(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiAvatar'
    });
    var alt = props.alt,
      childrenProp = props.children,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      imgProps = props.imgProps,
      sizes = props.sizes,
      src = props.src,
      srcSet = props.srcSet,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'circular' : _props$variant,
      other = _objectWithoutProperties(props, ["alt", "children", "className", "component", "slots", "slotProps", "imgProps", "sizes", "src", "srcSet", "variant"]);
    var children = null;

    // Use a hook instead of onError on the img element to support server-side rendering.
    var loaded = useLoaded(_extends({}, imgProps, {
      src: src,
      srcSet: srcSet
    }));
    var hasImg = src || srcSet;
    var hasImgNotFailing = hasImg && loaded !== 'error';
    var ownerState = _extends({}, props, {
      colorDefault: !hasImgNotFailing,
      component: component,
      variant: variant
    });
    var classes = useUtilityClasses$1x(ownerState);
    var _useSlot = useSlot('img', {
        className: classes.img,
        elementType: AvatarImg,
        externalForwardedProps: {
          slots: slots,
          slotProps: {
            img: _extends({}, imgProps, slotProps.img)
          }
        },
        additionalProps: {
          alt: alt,
          src: src,
          srcSet: srcSet,
          sizes: sizes
        },
        ownerState: ownerState
      }),
      _useSlot2 = _slicedToArray(_useSlot, 2),
      ImgSlot = _useSlot2[0],
      imgSlotProps = _useSlot2[1];
    if (hasImgNotFailing) {
      children = /*#__PURE__*/jsxRuntimeExports.jsx(ImgSlot, _extends({}, imgSlotProps));
      // We only render valid children, non valid children are rendered with a fallback
      // We consider that invalid children are all falsy values, except 0, which is valid.
    } else if (!!childrenProp || childrenProp === 0) {
      children = childrenProp;
    } else if (hasImg && alt) {
      children = alt[0];
    } else {
      children = /*#__PURE__*/jsxRuntimeExports.jsx(AvatarFallback, {
        ownerState: ownerState,
        className: classes.fallback
      });
    }
    return /*#__PURE__*/jsxRuntimeExports.jsx(AvatarRoot, _extends({
      as: component,
      ownerState: ownerState,
      className: clsx(classes.root, className),
      ref: ref
    }, other, {
      children: children
    }));
  });
  Avatar.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Used in combination with `src` or `srcSet` to
     * provide an alt attribute for the rendered `img` element.
     */
    alt: PropTypes.string,
    /**
     * Used to render icon or text elements inside the Avatar if `src` is not set.
     * This can be an element, or just a string.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attributes) applied to the `img` element if the component is used to display an image.
     * It can be used to listen for the loading error event.
     * @deprecated Use `slotProps.img` instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
     */
    imgProps: PropTypes.object,
    /**
     * The `sizes` attribute for the `img` element.
     */
    sizes: PropTypes.string,
    /**
     * The props used for each slot inside.
     * @default {}
     */
    slotProps: PropTypes.shape({
      img: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * The components used for each slot inside.
     * @default {}
     */
    slots: PropTypes.shape({
      img: PropTypes.elementType
    }),
    /**
     * The `src` attribute for the `img` element.
     */
    src: PropTypes.string,
    /**
     * The `srcSet` attribute for the `img` element.
     * Use this attribute for responsive image display.
     */
    srcSet: PropTypes.string,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The shape of the avatar.
     * @default 'circular'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['circular', 'rounded', 'square']), PropTypes.string])
  } ;
  var Avatar$1 = Avatar;

  function getAvatarGroupUtilityClass(slot) {
    return generateUtilityClass('MuiAvatarGroup', slot);
  }
  var avatarGroupClasses = generateUtilityClasses('MuiAvatarGroup', ['root', 'avatar']);
  var avatarGroupClasses$1 = avatarGroupClasses;

  var SPACINGS$2 = {
    small: -16,
    medium: null
  };
  var useUtilityClasses$1w = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root'],
      avatar: ['avatar']
    };
    return composeClasses(slots, getAvatarGroupUtilityClass, classes);
  };
  var AvatarGroupRoot = styled$1('div', {
    name: 'MuiAvatarGroup',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return _extends(_defineProperty({}, "& .".concat(avatarGroupClasses$1.avatar), styles.avatar), styles.root);
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    var marginValue = ownerState.spacing && SPACINGS$2[ownerState.spacing] !== undefined ? SPACINGS$2[ownerState.spacing] : -ownerState.spacing;
    return _defineProperty(_defineProperty(_defineProperty({}, "& .".concat(avatarClasses$1.root), {
      border: "2px solid ".concat((theme.vars || theme).palette.background["default"]),
      boxSizing: 'content-box',
      marginLeft: marginValue != null ? marginValue : -8,
      '&:last-child': {
        marginLeft: 0
      }
    }), "display", 'flex'), "flexDirection", 'row-reverse');
  });
  var AvatarGroup = /*#__PURE__*/React__namespace.forwardRef(function AvatarGroup(inProps, ref) {
    var _slotProps$additional;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiAvatarGroup'
    });
    var childrenProp = props.children,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      _props$componentsProp = props.componentsProps,
      componentsProps = _props$componentsProp === void 0 ? {} : _props$componentsProp,
      _props$max = props.max,
      max = _props$max === void 0 ? 5 : _props$max,
      renderSurplus = props.renderSurplus,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      _props$spacing = props.spacing,
      spacing = _props$spacing === void 0 ? 'medium' : _props$spacing,
      total = props.total,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'circular' : _props$variant,
      other = _objectWithoutProperties(props, ["children", "className", "component", "componentsProps", "max", "renderSurplus", "slotProps", "spacing", "total", "variant"]);
    var clampedMax = max < 2 ? 2 : max;
    var ownerState = _extends({}, props, {
      max: max,
      spacing: spacing,
      component: component,
      variant: variant
    });
    var classes = useUtilityClasses$1w(ownerState);
    var children = React__namespace.Children.toArray(childrenProp).filter(function (child) {
      {
        if (reactIsExports.isFragment(child)) {
          console.error(["MUI: The AvatarGroup component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n'));
        }
      }
      return /*#__PURE__*/React__namespace.isValidElement(child);
    });
    var totalAvatars = total || children.length;
    if (totalAvatars === clampedMax) {
      clampedMax += 1;
    }
    clampedMax = Math.min(totalAvatars + 1, clampedMax);
    var maxAvatars = Math.min(children.length, clampedMax - 1);
    var extraAvatars = Math.max(totalAvatars - clampedMax, totalAvatars - maxAvatars, 0);
    var extraAvatarsElement = renderSurplus ? renderSurplus(extraAvatars) : "+".concat(extraAvatars);
    var additionalAvatarSlotProps = (_slotProps$additional = slotProps.additionalAvatar) != null ? _slotProps$additional : componentsProps.additionalAvatar;
    return /*#__PURE__*/jsxRuntimeExports.jsxs(AvatarGroupRoot, _extends({
      as: component,
      ownerState: ownerState,
      className: clsx(classes.root, className),
      ref: ref
    }, other, {
      children: [extraAvatars ? /*#__PURE__*/jsxRuntimeExports.jsx(Avatar$1, _extends({
        variant: variant
      }, additionalAvatarSlotProps, {
        className: clsx(classes.avatar, additionalAvatarSlotProps == null ? void 0 : additionalAvatarSlotProps.className),
        children: extraAvatarsElement
      })) : null, children.slice(0, maxAvatars).reverse().map(function (child) {
        return /*#__PURE__*/React__namespace.cloneElement(child, {
          className: clsx(child.props.className, classes.avatar),
          variant: child.props.variant || variant
        });
      })]
    }));
  });
  AvatarGroup.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The avatars to stack.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `slotProps` prop.
     * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.
     *
     * @default {}
     */
    componentsProps: PropTypes.shape({
      additionalAvatar: PropTypes.object
    }),
    /**
     * Max avatars to show before +x.
     * @default 5
     */
    max: chainPropTypes(PropTypes.number, function (props) {
      if (props.max < 2) {
        return new Error(['MUI: The prop `max` should be equal to 2 or above.', 'A value below is clamped to 2.'].join('\n'));
      }
      return null;
    }),
    /**
     * custom renderer of extraAvatars
     * @param {number} surplus number of extra avatars
     * @returns {React.ReactNode} custom element to display
     */
    renderSurplus: PropTypes.func,
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `componentsProps` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slotProps: PropTypes.shape({
      additionalAvatar: PropTypes.object
    }),
    /**
     * Spacing between avatars.
     * @default 'medium'
     */
    spacing: PropTypes.oneOfType([PropTypes.oneOf(['medium', 'small']), PropTypes.number]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The total number of avatars. Used for calculating the number of extra avatars.
     * @default children.length
     */
    total: PropTypes.number,
    /**
     * The variant to use.
     * @default 'circular'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['circular', 'rounded', 'square']), PropTypes.string])
  } ;
  var AvatarGroup$1 = AvatarGroup;

  var styles$3 = {
    entering: {
      opacity: 1
    },
    entered: {
      opacity: 1
    }
  };

  /**
   * The Fade transition is used by the [Modal](/material-ui/react-modal/) component.
   * It uses [react-transition-group](https://github.com/reactjs/react-transition-group) internally.
   */
  var Fade = /*#__PURE__*/React__namespace.forwardRef(function Fade(props, ref) {
    var theme = useTheme();
    var defaultTimeout = {
      enter: theme.transitions.duration.enteringScreen,
      exit: theme.transitions.duration.leavingScreen
    };
    var addEndListener = props.addEndListener,
      _props$appear = props.appear,
      appear = _props$appear === void 0 ? true : _props$appear,
      _children = props.children,
      easing = props.easing,
      inProp = props["in"],
      onEnter = props.onEnter,
      onEntered = props.onEntered,
      onEntering = props.onEntering,
      onExit = props.onExit,
      onExited = props.onExited,
      onExiting = props.onExiting,
      style = props.style,
      _props$timeout = props.timeout,
      timeout = _props$timeout === void 0 ? defaultTimeout : _props$timeout,
      _props$TransitionComp = props.TransitionComponent,
      TransitionComponent = _props$TransitionComp === void 0 ? Transition$1 : _props$TransitionComp,
      other = _objectWithoutProperties(props, ["addEndListener", "appear", "children", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "style", "timeout", "TransitionComponent"]);
    var nodeRef = React__namespace.useRef(null);
    var handleRef = useForkRef(nodeRef, getReactElementRef(_children), ref);
    var normalizedTransitionCallback = function normalizedTransitionCallback(callback) {
      return function (maybeIsAppearing) {
        if (callback) {
          var node = nodeRef.current;

          // onEnterXxx and onExitXxx callbacks have a different arguments.length value.
          if (maybeIsAppearing === undefined) {
            callback(node);
          } else {
            callback(node, maybeIsAppearing);
          }
        }
      };
    };
    var handleEntering = normalizedTransitionCallback(onEntering);
    var handleEnter = normalizedTransitionCallback(function (node, isAppearing) {
      reflow(node); // So the animation always start from the start.

      var transitionProps = getTransitionProps({
        style: style,
        timeout: timeout,
        easing: easing
      }, {
        mode: 'enter'
      });
      node.style.webkitTransition = theme.transitions.create('opacity', transitionProps);
      node.style.transition = theme.transitions.create('opacity', transitionProps);
      if (onEnter) {
        onEnter(node, isAppearing);
      }
    });
    var handleEntered = normalizedTransitionCallback(onEntered);
    var handleExiting = normalizedTransitionCallback(onExiting);
    var handleExit = normalizedTransitionCallback(function (node) {
      var transitionProps = getTransitionProps({
        style: style,
        timeout: timeout,
        easing: easing
      }, {
        mode: 'exit'
      });
      node.style.webkitTransition = theme.transitions.create('opacity', transitionProps);
      node.style.transition = theme.transitions.create('opacity', transitionProps);
      if (onExit) {
        onExit(node);
      }
    });
    var handleExited = normalizedTransitionCallback(onExited);
    var handleAddEndListener = function handleAddEndListener(next) {
      if (addEndListener) {
        // Old call signature before `react-transition-group` implemented `nodeRef`
        addEndListener(nodeRef.current, next);
      }
    };
    return /*#__PURE__*/jsxRuntimeExports.jsx(TransitionComponent, _extends({
      appear: appear,
      "in": inProp,
      nodeRef: nodeRef ,
      onEnter: handleEnter,
      onEntered: handleEntered,
      onEntering: handleEntering,
      onExit: handleExit,
      onExited: handleExited,
      onExiting: handleExiting,
      addEndListener: handleAddEndListener,
      timeout: timeout
    }, other, {
      children: function children(state, childProps) {
        return /*#__PURE__*/React__namespace.cloneElement(_children, _extends({
          style: _extends({
            opacity: 0,
            visibility: state === 'exited' && !inProp ? 'hidden' : undefined
          }, styles$3[state], style, _children.props.style),
          ref: handleRef
        }, childProps));
      }
    }));
  });
  Fade.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Add a custom transition end trigger. Called with the transitioning DOM
     * node and a done callback. Allows for more fine grained transition end
     * logic. Note: Timeouts are still used as a fallback if provided.
     */
    addEndListener: PropTypes.func,
    /**
     * Perform the enter transition when it first mounts if `in` is also `true`.
     * Set this to `false` to disable this behavior.
     * @default true
     */
    appear: PropTypes.bool,
    /**
     * A single child content element.
     */
    children: elementAcceptingRef$1.isRequired,
    /**
     * The transition timing function.
     * You may specify a single easing or a object containing enter and exit values.
     */
    easing: PropTypes.oneOfType([PropTypes.shape({
      enter: PropTypes.string,
      exit: PropTypes.string
    }), PropTypes.string]),
    /**
     * If `true`, the component will transition in.
     */
    "in": PropTypes.bool,
    /**
     * @ignore
     */
    onEnter: PropTypes.func,
    /**
     * @ignore
     */
    onEntered: PropTypes.func,
    /**
     * @ignore
     */
    onEntering: PropTypes.func,
    /**
     * @ignore
     */
    onExit: PropTypes.func,
    /**
     * @ignore
     */
    onExited: PropTypes.func,
    /**
     * @ignore
     */
    onExiting: PropTypes.func,
    /**
     * @ignore
     */
    style: PropTypes.object,
    /**
     * The duration for the transition, in milliseconds.
     * You may specify a single timeout for all transitions, or individually with an object.
     * @default {
     *   enter: theme.transitions.duration.enteringScreen,
     *   exit: theme.transitions.duration.leavingScreen,
     * }
     */
    timeout: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
      appear: PropTypes.number,
      enter: PropTypes.number,
      exit: PropTypes.number
    })])
  } ;
  var Fade$1 = Fade;

  function getBackdropUtilityClass(slot) {
    return generateUtilityClass('MuiBackdrop', slot);
  }
  var backdropClasses = generateUtilityClasses('MuiBackdrop', ['root', 'invisible']);
  var backdropClasses$1 = backdropClasses;

  var useUtilityClasses$1v = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      invisible = ownerState.invisible;
    var slots = {
      root: ['root', invisible && 'invisible']
    };
    return composeClasses(slots, getBackdropUtilityClass, classes);
  };
  var BackdropRoot = styled$1('div', {
    name: 'MuiBackdrop',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.invisible && styles.invisible];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends({
      position: 'fixed',
      display: 'flex',
      alignItems: 'center',
      justifyContent: 'center',
      right: 0,
      bottom: 0,
      top: 0,
      left: 0,
      backgroundColor: 'rgba(0, 0, 0, 0.5)',
      WebkitTapHighlightColor: 'transparent'
    }, ownerState.invisible && {
      backgroundColor: 'transparent'
    });
  });
  var Backdrop = /*#__PURE__*/React__namespace.forwardRef(function Backdrop(inProps, ref) {
    var _slotProps$root, _ref2, _slots$root;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiBackdrop'
    });
    var children = props.children,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      _props$components = props.components,
      components = _props$components === void 0 ? {} : _props$components,
      _props$componentsProp = props.componentsProps,
      componentsProps = _props$componentsProp === void 0 ? {} : _props$componentsProp,
      _props$invisible = props.invisible,
      invisible = _props$invisible === void 0 ? false : _props$invisible,
      open = props.open,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      _props$TransitionComp = props.TransitionComponent,
      TransitionComponent = _props$TransitionComp === void 0 ? Fade$1 : _props$TransitionComp,
      transitionDuration = props.transitionDuration,
      other = _objectWithoutProperties(props, ["children", "className", "component", "components", "componentsProps", "invisible", "open", "slotProps", "slots", "TransitionComponent", "transitionDuration"]);
    var ownerState = _extends({}, props, {
      component: component,
      invisible: invisible
    });
    var classes = useUtilityClasses$1v(ownerState);
    var rootSlotProps = (_slotProps$root = slotProps.root) != null ? _slotProps$root : componentsProps.root;
    return /*#__PURE__*/jsxRuntimeExports.jsx(TransitionComponent, _extends({
      "in": open,
      timeout: transitionDuration
    }, other, {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(BackdropRoot, _extends({
        "aria-hidden": true
      }, rootSlotProps, {
        as: (_ref2 = (_slots$root = slots.root) != null ? _slots$root : components.Root) != null ? _ref2 : component,
        className: clsx(classes.root, className, rootSlotProps == null ? void 0 : rootSlotProps.className),
        ownerState: _extends({}, ownerState, rootSlotProps == null ? void 0 : rootSlotProps.ownerState),
        classes: classes,
        ref: ref,
        children: children
      }))
    }));
  });
  Backdrop.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `slots` prop.
     * It's recommended to use the `slots` prop instead.
     *
     * @default {}
     */
    components: PropTypes.shape({
      Root: PropTypes.elementType
    }),
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `slotProps` prop.
     * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.
     *
     * @default {}
     */
    componentsProps: PropTypes.shape({
      root: PropTypes.object
    }),
    /**
     * If `true`, the backdrop is invisible.
     * It can be used when rendering a popover or a custom select component.
     * @default false
     */
    invisible: PropTypes.bool,
    /**
     * If `true`, the component is shown.
     */
    open: PropTypes.bool.isRequired,
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `componentsProps` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slotProps: PropTypes.shape({
      root: PropTypes.object
    }),
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `components` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slots: PropTypes.shape({
      root: PropTypes.elementType
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The component used for the transition.
     * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
     * @default Fade
     */
    TransitionComponent: PropTypes.elementType,
    /**
     * The duration for the transition, in milliseconds.
     * You may specify a single timeout for all transitions, or individually with an object.
     */
    transitionDuration: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
      appear: PropTypes.number,
      enter: PropTypes.number,
      exit: PropTypes.number
    })])
  } ;
  var Backdrop$1 = Backdrop;

  /**
   *
   * Demos:
   *
   * - [Badge](https://next.mui.com/base-ui/react-badge/#hook)
   *
   * API:
   *
   * - [useBadge API](https://next.mui.com/base-ui/react-badge/hooks-api/#use-badge)
   */
  function useBadge(parameters) {
    var badgeContentProp = parameters.badgeContent,
      _parameters$invisible = parameters.invisible,
      invisibleProp = _parameters$invisible === void 0 ? false : _parameters$invisible,
      _parameters$max = parameters.max,
      maxProp = _parameters$max === void 0 ? 99 : _parameters$max,
      _parameters$showZero = parameters.showZero,
      showZero = _parameters$showZero === void 0 ? false : _parameters$showZero;
    var prevProps = usePreviousProps$1({
      badgeContent: badgeContentProp,
      max: maxProp
    });
    var invisible = invisibleProp;
    if (invisibleProp === false && badgeContentProp === 0 && !showZero) {
      invisible = true;
    }
    var _ref = invisible ? prevProps : parameters,
      badgeContent = _ref.badgeContent,
      _ref$max = _ref.max,
      max = _ref$max === void 0 ? maxProp : _ref$max;
    var displayValue = badgeContent && Number(badgeContent) > max ? "".concat(max, "+") : badgeContent;
    return {
      badgeContent: badgeContent,
      invisible: invisible,
      max: max,
      displayValue: displayValue
    };
  }

  function getBadgeUtilityClass(slot) {
    return generateUtilityClass('MuiBadge', slot);
  }
  var badgeClasses = generateUtilityClasses('MuiBadge', ['root', 'badge', 'dot', 'standard', 'anchorOriginTopRight', 'anchorOriginBottomRight', 'anchorOriginTopLeft', 'anchorOriginBottomLeft', 'invisible', 'colorError', 'colorInfo', 'colorPrimary', 'colorSecondary', 'colorSuccess', 'colorWarning', 'overlapRectangular', 'overlapCircular',
  // TODO: v6 remove the overlap value from these class keys
  'anchorOriginTopLeftCircular', 'anchorOriginTopLeftRectangular', 'anchorOriginTopRightCircular', 'anchorOriginTopRightRectangular', 'anchorOriginBottomLeftCircular', 'anchorOriginBottomLeftRectangular', 'anchorOriginBottomRightCircular', 'anchorOriginBottomRightRectangular']);
  var badgeClasses$1 = badgeClasses;

  var RADIUS_STANDARD = 10;
  var RADIUS_DOT = 4;
  var useUtilityClasses$1u = function useUtilityClasses(ownerState) {
    var color = ownerState.color,
      anchorOrigin = ownerState.anchorOrigin,
      invisible = ownerState.invisible,
      overlap = ownerState.overlap,
      variant = ownerState.variant,
      _ownerState$classes = ownerState.classes,
      classes = _ownerState$classes === void 0 ? {} : _ownerState$classes;
    var slots = {
      root: ['root'],
      badge: ['badge', variant, invisible && 'invisible', "anchorOrigin".concat(capitalize(anchorOrigin.vertical)).concat(capitalize(anchorOrigin.horizontal)), "anchorOrigin".concat(capitalize(anchorOrigin.vertical)).concat(capitalize(anchorOrigin.horizontal)).concat(capitalize(overlap)), "overlap".concat(capitalize(overlap)), color !== 'default' && "color".concat(capitalize(color))]
    };
    return composeClasses(slots, getBadgeUtilityClass, classes);
  };
  var BadgeRoot = styled$1('span', {
    name: 'MuiBadge',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })({
    position: 'relative',
    display: 'inline-flex',
    // For correct alignment with the text.
    verticalAlign: 'middle',
    flexShrink: 0
  });
  var BadgeBadge = styled$1('span', {
    name: 'MuiBadge',
    slot: 'Badge',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.badge, styles[ownerState.variant], styles["anchorOrigin".concat(capitalize(ownerState.anchorOrigin.vertical)).concat(capitalize(ownerState.anchorOrigin.horizontal)).concat(capitalize(ownerState.overlap))], ownerState.color !== 'default' && styles["color".concat(capitalize(ownerState.color))], ownerState.invisible && styles.invisible];
    }
  })(function (_ref) {
    var _theme$vars;
    var theme = _ref.theme;
    return {
      display: 'flex',
      flexDirection: 'row',
      flexWrap: 'wrap',
      justifyContent: 'center',
      alignContent: 'center',
      alignItems: 'center',
      position: 'absolute',
      boxSizing: 'border-box',
      fontFamily: theme.typography.fontFamily,
      fontWeight: theme.typography.fontWeightMedium,
      fontSize: theme.typography.pxToRem(12),
      minWidth: RADIUS_STANDARD * 2,
      lineHeight: 1,
      padding: '0 6px',
      height: RADIUS_STANDARD * 2,
      borderRadius: RADIUS_STANDARD,
      zIndex: 1,
      // Render the badge on top of potential ripples.
      transition: theme.transitions.create('transform', {
        easing: theme.transitions.easing.easeInOut,
        duration: theme.transitions.duration.enteringScreen
      }),
      variants: [].concat(_toConsumableArray(Object.keys(((_theme$vars = theme.vars) != null ? _theme$vars : theme).palette).filter(function (key) {
        var _theme$vars2, _theme$vars3;
        return ((_theme$vars2 = theme.vars) != null ? _theme$vars2 : theme).palette[key].main && ((_theme$vars3 = theme.vars) != null ? _theme$vars3 : theme).palette[key].contrastText;
      }).map(function (color) {
        return {
          props: {
            color: color
          },
          style: {
            backgroundColor: (theme.vars || theme).palette[color].main,
            color: (theme.vars || theme).palette[color].contrastText
          }
        };
      })), [{
        props: {
          variant: 'dot'
        },
        style: {
          borderRadius: RADIUS_DOT,
          height: RADIUS_DOT * 2,
          minWidth: RADIUS_DOT * 2,
          padding: 0
        }
      }, {
        props: function props(_ref2) {
          var ownerState = _ref2.ownerState;
          return ownerState.anchorOrigin.vertical === 'top' && ownerState.anchorOrigin.horizontal === 'right' && ownerState.overlap === 'rectangular';
        },
        style: _defineProperty({
          top: 0,
          right: 0,
          transform: 'scale(1) translate(50%, -50%)',
          transformOrigin: '100% 0%'
        }, "&.".concat(badgeClasses$1.invisible), {
          transform: 'scale(0) translate(50%, -50%)'
        })
      }, {
        props: function props(_ref3) {
          var ownerState = _ref3.ownerState;
          return ownerState.anchorOrigin.vertical === 'bottom' && ownerState.anchorOrigin.horizontal === 'right' && ownerState.overlap === 'rectangular';
        },
        style: _defineProperty({
          bottom: 0,
          right: 0,
          transform: 'scale(1) translate(50%, 50%)',
          transformOrigin: '100% 100%'
        }, "&.".concat(badgeClasses$1.invisible), {
          transform: 'scale(0) translate(50%, 50%)'
        })
      }, {
        props: function props(_ref4) {
          var ownerState = _ref4.ownerState;
          return ownerState.anchorOrigin.vertical === 'top' && ownerState.anchorOrigin.horizontal === 'left' && ownerState.overlap === 'rectangular';
        },
        style: _defineProperty({
          top: 0,
          left: 0,
          transform: 'scale(1) translate(-50%, -50%)',
          transformOrigin: '0% 0%'
        }, "&.".concat(badgeClasses$1.invisible), {
          transform: 'scale(0) translate(-50%, -50%)'
        })
      }, {
        props: function props(_ref5) {
          var ownerState = _ref5.ownerState;
          return ownerState.anchorOrigin.vertical === 'bottom' && ownerState.anchorOrigin.horizontal === 'left' && ownerState.overlap === 'rectangular';
        },
        style: _defineProperty({
          bottom: 0,
          left: 0,
          transform: 'scale(1) translate(-50%, 50%)',
          transformOrigin: '0% 100%'
        }, "&.".concat(badgeClasses$1.invisible), {
          transform: 'scale(0) translate(-50%, 50%)'
        })
      }, {
        props: function props(_ref6) {
          var ownerState = _ref6.ownerState;
          return ownerState.anchorOrigin.vertical === 'top' && ownerState.anchorOrigin.horizontal === 'right' && ownerState.overlap === 'circular';
        },
        style: _defineProperty({
          top: '14%',
          right: '14%',
          transform: 'scale(1) translate(50%, -50%)',
          transformOrigin: '100% 0%'
        }, "&.".concat(badgeClasses$1.invisible), {
          transform: 'scale(0) translate(50%, -50%)'
        })
      }, {
        props: function props(_ref7) {
          var ownerState = _ref7.ownerState;
          return ownerState.anchorOrigin.vertical === 'bottom' && ownerState.anchorOrigin.horizontal === 'right' && ownerState.overlap === 'circular';
        },
        style: _defineProperty({
          bottom: '14%',
          right: '14%',
          transform: 'scale(1) translate(50%, 50%)',
          transformOrigin: '100% 100%'
        }, "&.".concat(badgeClasses$1.invisible), {
          transform: 'scale(0) translate(50%, 50%)'
        })
      }, {
        props: function props(_ref8) {
          var ownerState = _ref8.ownerState;
          return ownerState.anchorOrigin.vertical === 'top' && ownerState.anchorOrigin.horizontal === 'left' && ownerState.overlap === 'circular';
        },
        style: _defineProperty({
          top: '14%',
          left: '14%',
          transform: 'scale(1) translate(-50%, -50%)',
          transformOrigin: '0% 0%'
        }, "&.".concat(badgeClasses$1.invisible), {
          transform: 'scale(0) translate(-50%, -50%)'
        })
      }, {
        props: function props(_ref9) {
          var ownerState = _ref9.ownerState;
          return ownerState.anchorOrigin.vertical === 'bottom' && ownerState.anchorOrigin.horizontal === 'left' && ownerState.overlap === 'circular';
        },
        style: _defineProperty({
          bottom: '14%',
          left: '14%',
          transform: 'scale(1) translate(-50%, 50%)',
          transformOrigin: '0% 100%'
        }, "&.".concat(badgeClasses$1.invisible), {
          transform: 'scale(0) translate(-50%, 50%)'
        })
      }, {
        props: {
          invisible: true
        },
        style: {
          transition: theme.transitions.create('transform', {
            easing: theme.transitions.easing.easeInOut,
            duration: theme.transitions.duration.leavingScreen
          })
        }
      }])
    };
  });
  var Badge = /*#__PURE__*/React__namespace.forwardRef(function Badge(inProps, ref) {
    var _ref11, _slots$root, _ref12, _slots$badge, _slotProps$root, _slotProps$badge;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiBadge'
    });
    var _props$anchorOrigin = props.anchorOrigin,
      anchorOriginProp = _props$anchorOrigin === void 0 ? {
        vertical: 'top',
        horizontal: 'right'
      } : _props$anchorOrigin,
      className = props.className;
      props.classes;
      var component = props.component,
      _props$components = props.components,
      components = _props$components === void 0 ? {} : _props$components,
      _props$componentsProp = props.componentsProps,
      componentsProps = _props$componentsProp === void 0 ? {} : _props$componentsProp,
      children = props.children,
      _props$overlap = props.overlap,
      overlapProp = _props$overlap === void 0 ? 'rectangular' : _props$overlap,
      _props$color = props.color,
      colorProp = _props$color === void 0 ? 'default' : _props$color,
      _props$invisible = props.invisible,
      invisibleProp = _props$invisible === void 0 ? false : _props$invisible,
      _props$max = props.max,
      maxProp = _props$max === void 0 ? 99 : _props$max,
      badgeContentProp = props.badgeContent,
      slots = props.slots,
      slotProps = props.slotProps,
      _props$showZero = props.showZero,
      showZero = _props$showZero === void 0 ? false : _props$showZero,
      _props$variant = props.variant,
      variantProp = _props$variant === void 0 ? 'standard' : _props$variant,
      other = _objectWithoutProperties(props, ["anchorOrigin", "className", "classes", "component", "components", "componentsProps", "children", "overlap", "color", "invisible", "max", "badgeContent", "slots", "slotProps", "showZero", "variant"]);
    var _useBadge = useBadge({
        max: maxProp,
        invisible: invisibleProp,
        badgeContent: badgeContentProp,
        showZero: showZero
      }),
      badgeContent = _useBadge.badgeContent,
      invisibleFromHook = _useBadge.invisible,
      max = _useBadge.max,
      displayValueFromHook = _useBadge.displayValue;
    var prevProps = usePreviousProps$1({
      anchorOrigin: anchorOriginProp,
      color: colorProp,
      overlap: overlapProp,
      variant: variantProp,
      badgeContent: badgeContentProp
    });
    var invisible = invisibleFromHook || badgeContent == null && variantProp !== 'dot';
    var _ref10 = invisible ? prevProps : props,
      _ref10$color = _ref10.color,
      color = _ref10$color === void 0 ? colorProp : _ref10$color,
      _ref10$overlap = _ref10.overlap,
      overlap = _ref10$overlap === void 0 ? overlapProp : _ref10$overlap,
      _ref10$anchorOrigin = _ref10.anchorOrigin,
      anchorOrigin = _ref10$anchorOrigin === void 0 ? anchorOriginProp : _ref10$anchorOrigin,
      _ref10$variant = _ref10.variant,
      variant = _ref10$variant === void 0 ? variantProp : _ref10$variant;
    var displayValue = variant !== 'dot' ? displayValueFromHook : undefined;
    var ownerState = _extends({}, props, {
      badgeContent: badgeContent,
      invisible: invisible,
      max: max,
      displayValue: displayValue,
      showZero: showZero,
      anchorOrigin: anchorOrigin,
      color: color,
      overlap: overlap,
      variant: variant
    });
    var classes = useUtilityClasses$1u(ownerState);

    // support both `slots` and `components` for backward compatibility
    var RootSlot = (_ref11 = (_slots$root = slots == null ? void 0 : slots.root) != null ? _slots$root : components.Root) != null ? _ref11 : BadgeRoot;
    var BadgeSlot = (_ref12 = (_slots$badge = slots == null ? void 0 : slots.badge) != null ? _slots$badge : components.Badge) != null ? _ref12 : BadgeBadge;
    var rootSlotProps = (_slotProps$root = slotProps == null ? void 0 : slotProps.root) != null ? _slotProps$root : componentsProps.root;
    var badgeSlotProps = (_slotProps$badge = slotProps == null ? void 0 : slotProps.badge) != null ? _slotProps$badge : componentsProps.badge;
    var rootProps = useSlotProps({
      elementType: RootSlot,
      externalSlotProps: rootSlotProps,
      externalForwardedProps: other,
      additionalProps: {
        ref: ref,
        as: component
      },
      ownerState: ownerState,
      className: clsx(rootSlotProps == null ? void 0 : rootSlotProps.className, classes.root, className)
    });
    var badgeProps = useSlotProps({
      elementType: BadgeSlot,
      externalSlotProps: badgeSlotProps,
      ownerState: ownerState,
      className: clsx(classes.badge, badgeSlotProps == null ? void 0 : badgeSlotProps.className)
    });
    return /*#__PURE__*/jsxRuntimeExports.jsxs(RootSlot, _extends({}, rootProps, {
      children: [children, /*#__PURE__*/jsxRuntimeExports.jsx(BadgeSlot, _extends({}, badgeProps, {
        children: displayValue
      }))]
    }));
  });
  Badge.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The anchor of the badge.
     * @default {
     *   vertical: 'top',
     *   horizontal: 'right',
     * }
     */
    anchorOrigin: PropTypes.shape({
      horizontal: PropTypes.oneOf(['left', 'right']).isRequired,
      vertical: PropTypes.oneOf(['bottom', 'top']).isRequired
    }),
    /**
     * The content rendered within the badge.
     */
    badgeContent: PropTypes.node,
    /**
     * The badge will be added relative to this node.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'default'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['default', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `slots` prop.
     * It's recommended to use the `slots` prop instead.
     *
     * @default {}
     */
    components: PropTypes.shape({
      Badge: PropTypes.elementType,
      Root: PropTypes.elementType
    }),
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `slotProps` prop.
     * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.
     *
     * @default {}
     */
    componentsProps: PropTypes.shape({
      badge: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * If `true`, the badge is invisible.
     * @default false
     */
    invisible: PropTypes.bool,
    /**
     * Max count to show.
     * @default 99
     */
    max: PropTypes.number,
    /**
     * Wrapped shape the badge should overlap.
     * @default 'rectangular'
     */
    overlap: PropTypes.oneOf(['circular', 'rectangular']),
    /**
     * Controls whether the badge is hidden when `badgeContent` is zero.
     * @default false
     */
    showZero: PropTypes.bool,
    /**
     * The props used for each slot inside the Badge.
     * @default {}
     */
    slotProps: PropTypes.shape({
      badge: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * The components used for each slot inside the Badge.
     * Either a string to use a HTML element or a component.
     * @default {}
     */
    slots: PropTypes.shape({
      badge: PropTypes.elementType,
      root: PropTypes.elementType
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The variant to use.
     * @default 'standard'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['dot', 'standard']), PropTypes.string])
  } ;
  var Badge$1 = Badge;

  function getBottomNavigationUtilityClass(slot) {
    return generateUtilityClass('MuiBottomNavigation', slot);
  }
  var bottomNavigationClasses = generateUtilityClasses('MuiBottomNavigation', ['root']);
  var bottomNavigationClasses$1 = bottomNavigationClasses;

  var useUtilityClasses$1t = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    return composeClasses(slots, getBottomNavigationUtilityClass, classes);
  };
  var BottomNavigationRoot = styled$1('div', {
    name: 'MuiBottomNavigation',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })(function (_ref) {
    var theme = _ref.theme;
    return {
      display: 'flex',
      justifyContent: 'center',
      height: 56,
      backgroundColor: (theme.vars || theme).palette.background.paper
    };
  });
  var BottomNavigation = /*#__PURE__*/React__namespace.forwardRef(function BottomNavigation(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiBottomNavigation'
    });
    var children = props.children,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      onChange = props.onChange,
      _props$showLabels = props.showLabels,
      showLabels = _props$showLabels === void 0 ? false : _props$showLabels,
      value = props.value,
      other = _objectWithoutProperties(props, ["children", "className", "component", "onChange", "showLabels", "value"]);
    var ownerState = _extends({}, props, {
      component: component,
      showLabels: showLabels
    });
    var classes = useUtilityClasses$1t(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(BottomNavigationRoot, _extends({
      as: component,
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState
    }, other, {
      children: React__namespace.Children.map(children, function (child, childIndex) {
        if (! /*#__PURE__*/React__namespace.isValidElement(child)) {
          return null;
        }
        {
          if (reactIsExports.isFragment(child)) {
            console.error(["MUI: The BottomNavigation component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n'));
          }
        }
        var childValue = child.props.value === undefined ? childIndex : child.props.value;
        return /*#__PURE__*/React__namespace.cloneElement(child, {
          selected: childValue === value,
          showLabel: child.props.showLabel !== undefined ? child.props.showLabel : showLabels,
          value: childValue,
          onChange: onChange
        });
      })
    }));
  });
  BottomNavigation.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * Callback fired when the value changes.
     *
     * @param {React.SyntheticEvent} event The event source of the callback. **Warning**: This is a generic event not a change event.
     * @param {any} value We default to the index of the child.
     */
    onChange: PropTypes.func,
    /**
     * If `true`, all `BottomNavigationAction`s will show their labels.
     * By default, only the selected `BottomNavigationAction` will show its label.
     * @default false
     */
    showLabels: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The value of the currently selected `BottomNavigationAction`.
     */
    value: PropTypes.any
  } ;
  var BottomNavigation$1 = BottomNavigation;

  function getBottomNavigationActionUtilityClass(slot) {
    return generateUtilityClass('MuiBottomNavigationAction', slot);
  }
  var bottomNavigationActionClasses = generateUtilityClasses('MuiBottomNavigationAction', ['root', 'iconOnly', 'selected', 'label']);
  var bottomNavigationActionClasses$1 = bottomNavigationActionClasses;

  var useUtilityClasses$1s = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      showLabel = ownerState.showLabel,
      selected = ownerState.selected;
    var slots = {
      root: ['root', !showLabel && !selected && 'iconOnly', selected && 'selected'],
      label: ['label', !showLabel && !selected && 'iconOnly', selected && 'selected']
    };
    return composeClasses(slots, getBottomNavigationActionUtilityClass, classes);
  };
  var BottomNavigationActionRoot = styled$1(ButtonBase$1, {
    name: 'MuiBottomNavigationAction',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, !ownerState.showLabel && !ownerState.selected && styles.iconOnly];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      transition: theme.transitions.create(['color', 'padding-top'], {
        duration: theme.transitions.duration["short"]
      }),
      padding: '0px 12px',
      minWidth: 80,
      maxWidth: 168,
      color: (theme.vars || theme).palette.text.secondary,
      flexDirection: 'column',
      flex: '1'
    }, !ownerState.showLabel && !ownerState.selected && {
      paddingTop: 14
    }, !ownerState.showLabel && !ownerState.selected && !ownerState.label && {
      paddingTop: 0
    }, _defineProperty({}, "&.".concat(bottomNavigationActionClasses$1.selected), {
      color: (theme.vars || theme).palette.primary.main
    }));
  });
  var BottomNavigationActionLabel = styled$1('span', {
    name: 'MuiBottomNavigationAction',
    slot: 'Label',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.label;
    }
  })(function (_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    return _extends({
      fontFamily: theme.typography.fontFamily,
      fontSize: theme.typography.pxToRem(12),
      opacity: 1,
      transition: 'font-size 0.2s, opacity 0.2s',
      transitionDelay: '0.1s'
    }, !ownerState.showLabel && !ownerState.selected && {
      opacity: 0,
      transitionDelay: '0s'
    }, _defineProperty({}, "&.".concat(bottomNavigationActionClasses$1.selected), {
      fontSize: theme.typography.pxToRem(14)
    }));
  });
  var BottomNavigationAction = /*#__PURE__*/React__namespace.forwardRef(function BottomNavigationAction(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiBottomNavigationAction'
    });
    var className = props.className,
      icon = props.icon,
      label = props.label,
      onChange = props.onChange,
      onClick = props.onClick;
      props.selected;
      props.showLabel;
      var value = props.value,
      other = _objectWithoutProperties(props, ["className", "icon", "label", "onChange", "onClick", "selected", "showLabel", "value"]);
    var ownerState = props;
    var classes = useUtilityClasses$1s(ownerState);
    var handleChange = function handleChange(event) {
      if (onChange) {
        onChange(event, value);
      }
      if (onClick) {
        onClick(event);
      }
    };
    return /*#__PURE__*/jsxRuntimeExports.jsxs(BottomNavigationActionRoot, _extends({
      ref: ref,
      className: clsx(classes.root, className),
      focusRipple: true,
      onClick: handleChange,
      ownerState: ownerState
    }, other, {
      children: [icon, /*#__PURE__*/jsxRuntimeExports.jsx(BottomNavigationActionLabel, {
        className: classes.label,
        ownerState: ownerState,
        children: label
      })]
    }));
  });
  BottomNavigationAction.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * This prop isn't supported.
     * Use the `component` prop if you need to change the children structure.
     */
    children: unsupportedProp,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The icon to display.
     */
    icon: PropTypes.node,
    /**
     * The label element.
     */
    label: PropTypes.node,
    /**
     * @ignore
     */
    onChange: PropTypes.func,
    /**
     * @ignore
     */
    onClick: PropTypes.func,
    /**
     * If `true`, the `BottomNavigationAction` will show its label.
     * By default, only the selected `BottomNavigationAction`
     * inside `BottomNavigation` will show its label.
     *
     * The prop defaults to the value (`false`) inherited from the parent BottomNavigation component.
     */
    showLabel: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * You can provide your own value. Otherwise, we fallback to the child position index.
     */
    value: PropTypes.any
  } ;
  var BottomNavigationAction$1 = BottomNavigationAction;

  var boxClasses = generateUtilityClasses('MuiBox', ['root']);
  var boxClasses$1 = boxClasses;

  var defaultTheme = createTheme();
  var Box = createBox({
    themeId: THEME_ID,
    defaultTheme: defaultTheme,
    defaultClassName: boxClasses$1.root,
    generateClassName: ClassNameGenerator$1.generate
  });
  Box.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * @ignore
     */
    children: PropTypes.node,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var Box$1 = Box;

  var MoreHorizIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M6 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-6 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"
  }), 'MoreHoriz');

  var BreadcrumbCollapsedButton = styled$1(ButtonBase$1)(function (_ref) {
    var theme = _ref.theme;
    return _extends({
      display: 'flex',
      marginLeft: "calc(".concat(theme.spacing(1), " * 0.5)"),
      marginRight: "calc(".concat(theme.spacing(1), " * 0.5)")
    }, theme.palette.mode === 'light' ? {
      backgroundColor: theme.palette.grey[100],
      color: theme.palette.grey[700]
    } : {
      backgroundColor: theme.palette.grey[700],
      color: theme.palette.grey[100]
    }, {
      borderRadius: 2,
      '&:hover, &:focus': _extends({}, theme.palette.mode === 'light' ? {
        backgroundColor: theme.palette.grey[200]
      } : {
        backgroundColor: theme.palette.grey[600]
      }),
      '&:active': _extends({
        boxShadow: theme.shadows[0]
      }, theme.palette.mode === 'light' ? {
        backgroundColor: emphasize(theme.palette.grey[200], 0.12)
      } : {
        backgroundColor: emphasize(theme.palette.grey[600], 0.12)
      })
    });
  });
  var BreadcrumbCollapsedIcon = styled$1(MoreHorizIcon)({
    width: 24,
    height: 16
  });

  /**
   * @ignore - internal component.
   */
  function BreadcrumbCollapsed(props) {
    var _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      otherProps = _objectWithoutProperties(props, ["slots", "slotProps"]);
    var ownerState = props;
    return /*#__PURE__*/jsxRuntimeExports.jsx("li", {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(BreadcrumbCollapsedButton, _extends({
        focusRipple: true
      }, otherProps, {
        ownerState: ownerState,
        children: /*#__PURE__*/jsxRuntimeExports.jsx(BreadcrumbCollapsedIcon, _extends({
          as: slots.CollapsedIcon,
          ownerState: ownerState
        }, slotProps.collapsedIcon))
      }))
    });
  }
  BreadcrumbCollapsed.propTypes = {
    /**
     * The props used for the CollapsedIcon slot.
     * @default {}
     */
    slotProps: PropTypes.shape({
      collapsedIcon: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * The components used for each slot inside the BreadcumbCollapsed.
     * Either a string to use a HTML element or a component.
     * @default {}
     */
    slots: PropTypes.shape({
      CollapsedIcon: PropTypes.elementType
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.object
  } ;

  function getBreadcrumbsUtilityClass(slot) {
    return generateUtilityClass('MuiBreadcrumbs', slot);
  }
  var breadcrumbsClasses = generateUtilityClasses('MuiBreadcrumbs', ['root', 'ol', 'li', 'separator']);
  var breadcrumbsClasses$1 = breadcrumbsClasses;

  var useUtilityClasses$1r = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root'],
      li: ['li'],
      ol: ['ol'],
      separator: ['separator']
    };
    return composeClasses(slots, getBreadcrumbsUtilityClass, classes);
  };
  var BreadcrumbsRoot = styled$1(Typography$1, {
    name: 'MuiBreadcrumbs',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return [_defineProperty({}, "& .".concat(breadcrumbsClasses$1.li), styles.li), styles.root];
    }
  })({});
  var BreadcrumbsOl = styled$1('ol', {
    name: 'MuiBreadcrumbs',
    slot: 'Ol',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.ol;
    }
  })({
    display: 'flex',
    flexWrap: 'wrap',
    alignItems: 'center',
    padding: 0,
    margin: 0,
    listStyle: 'none'
  });
  var BreadcrumbsSeparator = styled$1('li', {
    name: 'MuiBreadcrumbs',
    slot: 'Separator',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.separator;
    }
  })({
    display: 'flex',
    userSelect: 'none',
    marginLeft: 8,
    marginRight: 8
  });
  function insertSeparators(items, className, separator, ownerState) {
    return items.reduce(function (acc, current, index) {
      if (index < items.length - 1) {
        acc = acc.concat(current, /*#__PURE__*/jsxRuntimeExports.jsx(BreadcrumbsSeparator, {
          "aria-hidden": true,
          className: className,
          ownerState: ownerState,
          children: separator
        }, "separator-".concat(index)));
      } else {
        acc.push(current);
      }
      return acc;
    }, []);
  }
  var Breadcrumbs = /*#__PURE__*/React__namespace.forwardRef(function Breadcrumbs(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiBreadcrumbs'
    });
    var children = props.children,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'nav' : _props$component,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      _props$expandText = props.expandText,
      expandText = _props$expandText === void 0 ? 'Show path' : _props$expandText,
      _props$itemsAfterColl = props.itemsAfterCollapse,
      itemsAfterCollapse = _props$itemsAfterColl === void 0 ? 1 : _props$itemsAfterColl,
      _props$itemsBeforeCol = props.itemsBeforeCollapse,
      itemsBeforeCollapse = _props$itemsBeforeCol === void 0 ? 1 : _props$itemsBeforeCol,
      _props$maxItems = props.maxItems,
      maxItems = _props$maxItems === void 0 ? 8 : _props$maxItems,
      _props$separator = props.separator,
      separator = _props$separator === void 0 ? '/' : _props$separator,
      other = _objectWithoutProperties(props, ["children", "className", "component", "slots", "slotProps", "expandText", "itemsAfterCollapse", "itemsBeforeCollapse", "maxItems", "separator"]);
    var _React$useState = React__namespace.useState(false),
      expanded = _React$useState[0],
      setExpanded = _React$useState[1];
    var ownerState = _extends({}, props, {
      component: component,
      expanded: expanded,
      expandText: expandText,
      itemsAfterCollapse: itemsAfterCollapse,
      itemsBeforeCollapse: itemsBeforeCollapse,
      maxItems: maxItems,
      separator: separator
    });
    var classes = useUtilityClasses$1r(ownerState);
    var collapsedIconSlotProps = useSlotProps({
      elementType: slots.CollapsedIcon,
      externalSlotProps: slotProps.collapsedIcon,
      ownerState: ownerState
    });
    var listRef = React__namespace.useRef(null);
    var renderItemsBeforeAndAfter = function renderItemsBeforeAndAfter(allItems) {
      var handleClickExpand = function handleClickExpand() {
        setExpanded(true);

        // The clicked element received the focus but gets removed from the DOM.
        // Let's keep the focus in the component after expanding.
        // Moving it to the <ol> or <nav> does not cause any announcement in NVDA.
        // By moving it to some link/button at least we have some announcement.
        var focusable = listRef.current.querySelector('a[href],button,[tabindex]');
        if (focusable) {
          focusable.focus();
        }
      };

      // This defends against someone passing weird input, to ensure that if all
      // items would be shown anyway, we just show all items without the EllipsisItem
      if (itemsBeforeCollapse + itemsAfterCollapse >= allItems.length) {
        {
          console.error(['MUI: You have provided an invalid combination of props to the Breadcrumbs.', "itemsAfterCollapse={".concat(itemsAfterCollapse, "} + itemsBeforeCollapse={").concat(itemsBeforeCollapse, "} >= maxItems={").concat(maxItems, "}")].join('\n'));
        }
        return allItems;
      }
      return [].concat(_toConsumableArray(allItems.slice(0, itemsBeforeCollapse)), [/*#__PURE__*/jsxRuntimeExports.jsx(BreadcrumbCollapsed, {
        "aria-label": expandText,
        slots: {
          CollapsedIcon: slots.CollapsedIcon
        },
        slotProps: {
          collapsedIcon: collapsedIconSlotProps
        },
        onClick: handleClickExpand
      }, "ellipsis")], _toConsumableArray(allItems.slice(allItems.length - itemsAfterCollapse, allItems.length)));
    };
    var allItems = React__namespace.Children.toArray(children).filter(function (child) {
      {
        if (reactIsExports.isFragment(child)) {
          console.error(["MUI: The Breadcrumbs component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n'));
        }
      }
      return /*#__PURE__*/React__namespace.isValidElement(child);
    }).map(function (child, index) {
      return /*#__PURE__*/jsxRuntimeExports.jsx("li", {
        className: classes.li,
        children: child
      }, "child-".concat(index));
    });
    return /*#__PURE__*/jsxRuntimeExports.jsx(BreadcrumbsRoot, _extends({
      ref: ref,
      component: component,
      color: "text.secondary",
      className: clsx(classes.root, className),
      ownerState: ownerState
    }, other, {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(BreadcrumbsOl, {
        className: classes.ol,
        ref: listRef,
        ownerState: ownerState,
        children: insertSeparators(expanded || maxItems && allItems.length <= maxItems ? allItems : renderItemsBeforeAndAfter(allItems), classes.separator, separator, ownerState)
      })
    }));
  });
  Breadcrumbs.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * Override the default label for the expand button.
     *
     * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
     * @default 'Show path'
     */
    expandText: PropTypes.string,
    /**
     * If max items is exceeded, the number of items to show after the ellipsis.
     * @default 1
     */
    itemsAfterCollapse: integerPropType,
    /**
     * If max items is exceeded, the number of items to show before the ellipsis.
     * @default 1
     */
    itemsBeforeCollapse: integerPropType,
    /**
     * Specifies the maximum number of breadcrumbs to display. When there are more
     * than the maximum number, only the first `itemsBeforeCollapse` and last `itemsAfterCollapse`
     * will be shown, with an ellipsis in between.
     * @default 8
     */
    maxItems: integerPropType,
    /**
     * Custom separator node.
     * @default '/'
     */
    separator: PropTypes.node,
    /**
     * The props used for each slot inside the Breadcumb.
     * @default {}
     */
    slotProps: PropTypes.shape({
      collapsedIcon: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * The components used for each slot inside the Breadcumb.
     * Either a string to use a HTML element or a component.
     * @default {}
     */
    slots: PropTypes.shape({
      CollapsedIcon: PropTypes.elementType
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var Breadcrumbs$1 = Breadcrumbs;

  function getButtonUtilityClass(slot) {
    return generateUtilityClass('MuiButton', slot);
  }
  var buttonClasses = generateUtilityClasses('MuiButton', ['root', 'text', 'textInherit', 'textPrimary', 'textSecondary', 'textSuccess', 'textError', 'textInfo', 'textWarning', 'outlined', 'outlinedInherit', 'outlinedPrimary', 'outlinedSecondary', 'outlinedSuccess', 'outlinedError', 'outlinedInfo', 'outlinedWarning', 'contained', 'containedInherit', 'containedPrimary', 'containedSecondary', 'containedSuccess', 'containedError', 'containedInfo', 'containedWarning', 'disableElevation', 'focusVisible', 'disabled', 'colorInherit', 'colorPrimary', 'colorSecondary', 'colorSuccess', 'colorError', 'colorInfo', 'colorWarning', 'textSizeSmall', 'textSizeMedium', 'textSizeLarge', 'outlinedSizeSmall', 'outlinedSizeMedium', 'outlinedSizeLarge', 'containedSizeSmall', 'containedSizeMedium', 'containedSizeLarge', 'sizeMedium', 'sizeSmall', 'sizeLarge', 'fullWidth', 'startIcon', 'endIcon', 'icon', 'iconSizeSmall', 'iconSizeMedium', 'iconSizeLarge']);
  var buttonClasses$1 = buttonClasses;

  /**
   * @ignore - internal component.
   */
  var ButtonGroupContext = /*#__PURE__*/React__namespace.createContext({});
  {
    ButtonGroupContext.displayName = 'ButtonGroupContext';
  }
  var ButtonGroupContext$1 = ButtonGroupContext;

  /**
   * @ignore - internal component.
   */
  var ButtonGroupButtonContext = /*#__PURE__*/React__namespace.createContext(undefined);
  {
    ButtonGroupButtonContext.displayName = 'ButtonGroupButtonContext';
  }
  var ButtonGroupButtonContext$1 = ButtonGroupButtonContext;

  var useUtilityClasses$1q = function useUtilityClasses(ownerState) {
    var color = ownerState.color,
      disableElevation = ownerState.disableElevation,
      fullWidth = ownerState.fullWidth,
      size = ownerState.size,
      variant = ownerState.variant,
      classes = ownerState.classes;
    var slots = {
      root: ['root', variant, "".concat(variant).concat(capitalize(color)), "size".concat(capitalize(size)), "".concat(variant, "Size").concat(capitalize(size)), "color".concat(capitalize(color)), disableElevation && 'disableElevation', fullWidth && 'fullWidth'],
      label: ['label'],
      startIcon: ['icon', 'startIcon', "iconSize".concat(capitalize(size))],
      endIcon: ['icon', 'endIcon', "iconSize".concat(capitalize(size))]
    };
    var composedClasses = composeClasses(slots, getButtonUtilityClass, classes);
    return _extends({}, classes, composedClasses);
  };
  var commonIconStyles = function commonIconStyles(ownerState) {
    return _extends({}, ownerState.size === 'small' && {
      '& > *:nth-of-type(1)': {
        fontSize: 18
      }
    }, ownerState.size === 'medium' && {
      '& > *:nth-of-type(1)': {
        fontSize: 20
      }
    }, ownerState.size === 'large' && {
      '& > *:nth-of-type(1)': {
        fontSize: 22
      }
    });
  };
  var ButtonRoot = styled$1(ButtonBase$1, {
    shouldForwardProp: function shouldForwardProp(prop) {
      return rootShouldForwardProp$1(prop) || prop === 'classes';
    },
    name: 'MuiButton',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.variant], styles["".concat(ownerState.variant).concat(capitalize(ownerState.color))], styles["size".concat(capitalize(ownerState.size))], styles["".concat(ownerState.variant, "Size").concat(capitalize(ownerState.size))], ownerState.color === 'inherit' && styles.colorInherit, ownerState.disableElevation && styles.disableElevation, ownerState.fullWidth && styles.fullWidth];
    }
  })(function (_ref) {
    var _theme$palette$getCon, _theme$palette;
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    var inheritContainedBackgroundColor = theme.palette.mode === 'light' ? theme.palette.grey[300] : theme.palette.grey[800];
    var inheritContainedHoverBackgroundColor = theme.palette.mode === 'light' ? theme.palette.grey.A100 : theme.palette.grey[700];
    return _extends({}, theme.typography.button, _defineProperty(_defineProperty({
      minWidth: 64,
      padding: '6px 16px',
      borderRadius: (theme.vars || theme).shape.borderRadius,
      transition: theme.transitions.create(['background-color', 'box-shadow', 'border-color', 'color'], {
        duration: theme.transitions.duration["short"]
      }),
      '&:hover': _extends({
        textDecoration: 'none',
        backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.text.primaryChannel, " / ").concat(theme.vars.palette.action.hoverOpacity, ")") : alpha(theme.palette.text.primary, theme.palette.action.hoverOpacity),
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: 'transparent'
        }
      }, ownerState.variant === 'text' && ownerState.color !== 'inherit' && {
        backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette[ownerState.color].mainChannel, " / ").concat(theme.vars.palette.action.hoverOpacity, ")") : alpha(theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: 'transparent'
        }
      }, ownerState.variant === 'outlined' && ownerState.color !== 'inherit' && {
        border: "1px solid ".concat((theme.vars || theme).palette[ownerState.color].main),
        backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette[ownerState.color].mainChannel, " / ").concat(theme.vars.palette.action.hoverOpacity, ")") : alpha(theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: 'transparent'
        }
      }, ownerState.variant === 'contained' && {
        backgroundColor: theme.vars ? theme.vars.palette.Button.inheritContainedHoverBg : inheritContainedHoverBackgroundColor,
        boxShadow: (theme.vars || theme).shadows[4],
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          boxShadow: (theme.vars || theme).shadows[2],
          backgroundColor: (theme.vars || theme).palette.grey[300]
        }
      }, ownerState.variant === 'contained' && ownerState.color !== 'inherit' && {
        backgroundColor: (theme.vars || theme).palette[ownerState.color].dark,
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: (theme.vars || theme).palette[ownerState.color].main
        }
      }),
      '&:active': _extends({}, ownerState.variant === 'contained' && {
        boxShadow: (theme.vars || theme).shadows[8]
      })
    }, "&.".concat(buttonClasses$1.focusVisible), _extends({}, ownerState.variant === 'contained' && {
      boxShadow: (theme.vars || theme).shadows[6]
    })), "&.".concat(buttonClasses$1.disabled), _extends({
      color: (theme.vars || theme).palette.action.disabled
    }, ownerState.variant === 'outlined' && {
      border: "1px solid ".concat((theme.vars || theme).palette.action.disabledBackground)
    }, ownerState.variant === 'contained' && {
      color: (theme.vars || theme).palette.action.disabled,
      boxShadow: (theme.vars || theme).shadows[0],
      backgroundColor: (theme.vars || theme).palette.action.disabledBackground
    })), ownerState.variant === 'text' && {
      padding: '6px 8px'
    }, ownerState.variant === 'text' && ownerState.color !== 'inherit' && {
      color: (theme.vars || theme).palette[ownerState.color].main
    }, ownerState.variant === 'outlined' && {
      padding: '5px 15px',
      border: '1px solid currentColor'
    }, ownerState.variant === 'outlined' && ownerState.color !== 'inherit' && {
      color: (theme.vars || theme).palette[ownerState.color].main,
      border: theme.vars ? "1px solid rgba(".concat(theme.vars.palette[ownerState.color].mainChannel, " / 0.5)") : "1px solid ".concat(alpha(theme.palette[ownerState.color].main, 0.5))
    }, ownerState.variant === 'contained' && {
      color: theme.vars ?
      // this is safe because grey does not change between default light/dark mode
      theme.vars.palette.text.primary : (_theme$palette$getCon = (_theme$palette = theme.palette).getContrastText) == null ? void 0 : _theme$palette$getCon.call(_theme$palette, theme.palette.grey[300]),
      backgroundColor: theme.vars ? theme.vars.palette.Button.inheritContainedBg : inheritContainedBackgroundColor,
      boxShadow: (theme.vars || theme).shadows[2]
    }, ownerState.variant === 'contained' && ownerState.color !== 'inherit' && {
      color: (theme.vars || theme).palette[ownerState.color].contrastText,
      backgroundColor: (theme.vars || theme).palette[ownerState.color].main
    }, ownerState.color === 'inherit' && {
      color: 'inherit',
      borderColor: 'currentColor'
    }, ownerState.size === 'small' && ownerState.variant === 'text' && {
      padding: '4px 5px',
      fontSize: theme.typography.pxToRem(13)
    }, ownerState.size === 'large' && ownerState.variant === 'text' && {
      padding: '8px 11px',
      fontSize: theme.typography.pxToRem(15)
    }, ownerState.size === 'small' && ownerState.variant === 'outlined' && {
      padding: '3px 9px',
      fontSize: theme.typography.pxToRem(13)
    }, ownerState.size === 'large' && ownerState.variant === 'outlined' && {
      padding: '7px 21px',
      fontSize: theme.typography.pxToRem(15)
    }, ownerState.size === 'small' && ownerState.variant === 'contained' && {
      padding: '4px 10px',
      fontSize: theme.typography.pxToRem(13)
    }, ownerState.size === 'large' && ownerState.variant === 'contained' && {
      padding: '8px 22px',
      fontSize: theme.typography.pxToRem(15)
    }, ownerState.fullWidth && {
      width: '100%'
    });
  }, function (_ref2) {
    var ownerState = _ref2.ownerState;
    return ownerState.disableElevation && _defineProperty(_defineProperty(_defineProperty({
      boxShadow: 'none',
      '&:hover': {
        boxShadow: 'none'
      }
    }, "&.".concat(buttonClasses$1.focusVisible), {
      boxShadow: 'none'
    }), '&:active', {
      boxShadow: 'none'
    }), "&.".concat(buttonClasses$1.disabled), {
      boxShadow: 'none'
    });
  });
  var ButtonStartIcon = styled$1('span', {
    name: 'MuiButton',
    slot: 'StartIcon',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.startIcon, styles["iconSize".concat(capitalize(ownerState.size))]];
    }
  })(function (_ref4) {
    var ownerState = _ref4.ownerState;
    return _extends({
      display: 'inherit',
      marginRight: 8,
      marginLeft: -4
    }, ownerState.size === 'small' && {
      marginLeft: -2
    }, commonIconStyles(ownerState));
  });
  var ButtonEndIcon = styled$1('span', {
    name: 'MuiButton',
    slot: 'EndIcon',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.endIcon, styles["iconSize".concat(capitalize(ownerState.size))]];
    }
  })(function (_ref5) {
    var ownerState = _ref5.ownerState;
    return _extends({
      display: 'inherit',
      marginRight: -4,
      marginLeft: 8
    }, ownerState.size === 'small' && {
      marginRight: -2
    }, commonIconStyles(ownerState));
  });
  var Button = /*#__PURE__*/React__namespace.forwardRef(function Button(inProps, ref) {
    // props priority: `inProps` > `contextProps` > `themeDefaultProps`
    var contextProps = React__namespace.useContext(ButtonGroupContext$1);
    var buttonGroupButtonContextPositionClassName = React__namespace.useContext(ButtonGroupButtonContext$1);
    var resolvedProps = resolveProps(contextProps, inProps);
    var props = useDefaultProps({
      props: resolvedProps,
      name: 'MuiButton'
    });
    var children = props.children,
      _props$color = props.color,
      color = _props$color === void 0 ? 'primary' : _props$color,
      _props$component = props.component,
      component = _props$component === void 0 ? 'button' : _props$component,
      className = props.className,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$disableElevati = props.disableElevation,
      disableElevation = _props$disableElevati === void 0 ? false : _props$disableElevati,
      _props$disableFocusRi = props.disableFocusRipple,
      disableFocusRipple = _props$disableFocusRi === void 0 ? false : _props$disableFocusRi,
      endIconProp = props.endIcon,
      focusVisibleClassName = props.focusVisibleClassName,
      _props$fullWidth = props.fullWidth,
      fullWidth = _props$fullWidth === void 0 ? false : _props$fullWidth,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      startIconProp = props.startIcon,
      type = props.type,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'text' : _props$variant,
      other = _objectWithoutProperties(props, ["children", "color", "component", "className", "disabled", "disableElevation", "disableFocusRipple", "endIcon", "focusVisibleClassName", "fullWidth", "size", "startIcon", "type", "variant"]);
    var ownerState = _extends({}, props, {
      color: color,
      component: component,
      disabled: disabled,
      disableElevation: disableElevation,
      disableFocusRipple: disableFocusRipple,
      fullWidth: fullWidth,
      size: size,
      type: type,
      variant: variant
    });
    var classes = useUtilityClasses$1q(ownerState);
    var startIcon = startIconProp && /*#__PURE__*/jsxRuntimeExports.jsx(ButtonStartIcon, {
      className: classes.startIcon,
      ownerState: ownerState,
      children: startIconProp
    });
    var endIcon = endIconProp && /*#__PURE__*/jsxRuntimeExports.jsx(ButtonEndIcon, {
      className: classes.endIcon,
      ownerState: ownerState,
      children: endIconProp
    });
    var positionClassName = buttonGroupButtonContextPositionClassName || '';
    return /*#__PURE__*/jsxRuntimeExports.jsxs(ButtonRoot, _extends({
      ownerState: ownerState,
      className: clsx(contextProps.className, classes.root, className, positionClassName),
      component: component,
      disabled: disabled,
      focusRipple: !disableFocusRipple,
      focusVisibleClassName: clsx(classes.focusVisible, focusVisibleClassName),
      ref: ref,
      type: type
    }, other, {
      classes: classes,
      children: [startIcon, children, endIcon]
    }));
  });
  Button.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'primary'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['inherit', 'primary', 'secondary', 'success', 'error', 'info', 'warning']), PropTypes.string]),
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, no elevation is used.
     * @default false
     */
    disableElevation: PropTypes.bool,
    /**
     * If `true`, the  keyboard focus ripple is disabled.
     * @default false
     */
    disableFocusRipple: PropTypes.bool,
    /**
     * If `true`, the ripple effect is disabled.
     *
     * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
     * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
     * @default false
     */
    disableRipple: PropTypes.bool,
    /**
     * Element placed after the children.
     */
    endIcon: PropTypes.node,
    /**
     * @ignore
     */
    focusVisibleClassName: PropTypes.string,
    /**
     * If `true`, the button will take up the full width of its container.
     * @default false
     */
    fullWidth: PropTypes.bool,
    /**
     * The URL to link to when the button is clicked.
     * If defined, an `a` element will be used as the root node.
     */
    href: PropTypes.string,
    /**
     * The size of the component.
     * `small` is equivalent to the dense button styling.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['small', 'medium', 'large']), PropTypes.string]),
    /**
     * Element placed before the children.
     */
    startIcon: PropTypes.node,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * @ignore
     */
    type: PropTypes.oneOfType([PropTypes.oneOf(['button', 'reset', 'submit']), PropTypes.string]),
    /**
     * The variant to use.
     * @default 'text'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['contained', 'outlined', 'text']), PropTypes.string])
  } ;
  var Button$1 = Button;

  function getButtonGroupUtilityClass(slot) {
    return generateUtilityClass('MuiButtonGroup', slot);
  }
  var buttonGroupClasses = generateUtilityClasses('MuiButtonGroup', ['root', 'contained', 'outlined', 'text', 'disableElevation', 'disabled', 'firstButton', 'fullWidth', 'vertical', 'grouped', 'groupedHorizontal', 'groupedVertical', 'groupedText', 'groupedTextHorizontal', 'groupedTextVertical', 'groupedTextPrimary', 'groupedTextSecondary', 'groupedOutlined', 'groupedOutlinedHorizontal', 'groupedOutlinedVertical', 'groupedOutlinedPrimary', 'groupedOutlinedSecondary', 'groupedContained', 'groupedContainedHorizontal', 'groupedContainedVertical', 'groupedContainedPrimary', 'groupedContainedSecondary', 'lastButton', 'middleButton']);
  var buttonGroupClasses$1 = buttonGroupClasses;

  var overridesResolver$6 = function overridesResolver(props, styles) {
    var ownerState = props.ownerState;
    return [_defineProperty({}, "& .".concat(buttonGroupClasses$1.grouped), styles.grouped), _defineProperty({}, "& .".concat(buttonGroupClasses$1.grouped), styles["grouped".concat(capitalize(ownerState.orientation))]), _defineProperty({}, "& .".concat(buttonGroupClasses$1.grouped), styles["grouped".concat(capitalize(ownerState.variant))]), _defineProperty({}, "& .".concat(buttonGroupClasses$1.grouped), styles["grouped".concat(capitalize(ownerState.variant)).concat(capitalize(ownerState.orientation))]), _defineProperty({}, "& .".concat(buttonGroupClasses$1.grouped), styles["grouped".concat(capitalize(ownerState.variant)).concat(capitalize(ownerState.color))]), _defineProperty({}, "& .".concat(buttonGroupClasses$1.firstButton), styles.firstButton), _defineProperty({}, "& .".concat(buttonGroupClasses$1.lastButton), styles.lastButton), _defineProperty({}, "& .".concat(buttonGroupClasses$1.middleButton), styles.middleButton), styles.root, styles[ownerState.variant], ownerState.disableElevation === true && styles.disableElevation, ownerState.fullWidth && styles.fullWidth, ownerState.orientation === 'vertical' && styles.vertical];
  };
  var useUtilityClasses$1p = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      color = ownerState.color,
      disabled = ownerState.disabled,
      disableElevation = ownerState.disableElevation,
      fullWidth = ownerState.fullWidth,
      orientation = ownerState.orientation,
      variant = ownerState.variant;
    var slots = {
      root: ['root', variant, orientation === 'vertical' && 'vertical', fullWidth && 'fullWidth', disableElevation && 'disableElevation'],
      grouped: ['grouped', "grouped".concat(capitalize(orientation)), "grouped".concat(capitalize(variant)), "grouped".concat(capitalize(variant)).concat(capitalize(orientation)), "grouped".concat(capitalize(variant)).concat(capitalize(color)), disabled && 'disabled'],
      firstButton: ['firstButton'],
      lastButton: ['lastButton'],
      middleButton: ['middleButton']
    };
    return composeClasses(slots, getButtonGroupUtilityClass, classes);
  };
  var ButtonGroupRoot = styled$1('div', {
    name: 'MuiButtonGroup',
    slot: 'Root',
    overridesResolver: overridesResolver$6
  })(function (_ref9) {
    var theme = _ref9.theme,
      ownerState = _ref9.ownerState;
    return _extends({
      display: 'inline-flex',
      borderRadius: (theme.vars || theme).shape.borderRadius
    }, ownerState.variant === 'contained' && {
      boxShadow: (theme.vars || theme).shadows[2]
    }, ownerState.disableElevation && {
      boxShadow: 'none'
    }, ownerState.fullWidth && {
      width: '100%'
    }, ownerState.orientation === 'vertical' && {
      flexDirection: 'column'
    }, _defineProperty(_defineProperty(_defineProperty({}, "& .".concat(buttonGroupClasses$1.grouped), _extends({
      minWidth: 40,
      '&:hover': _extends({}, ownerState.variant === 'contained' && {
        boxShadow: 'none'
      })
    }, ownerState.variant === 'contained' && {
      boxShadow: 'none'
    })), "& .".concat(buttonGroupClasses$1.firstButton, ",& .").concat(buttonGroupClasses$1.middleButton), _extends({}, ownerState.orientation === 'horizontal' && {
      borderTopRightRadius: 0,
      borderBottomRightRadius: 0
    }, ownerState.orientation === 'vertical' && {
      borderBottomRightRadius: 0,
      borderBottomLeftRadius: 0
    }, ownerState.variant === 'text' && ownerState.orientation === 'horizontal' && _defineProperty({
      borderRight: theme.vars ? "1px solid rgba(".concat(theme.vars.palette.common.onBackgroundChannel, " / 0.23)") : "1px solid ".concat(theme.palette.mode === 'light' ? 'rgba(0, 0, 0, 0.23)' : 'rgba(255, 255, 255, 0.23)')
    }, "&.".concat(buttonGroupClasses$1.disabled), {
      borderRight: "1px solid ".concat((theme.vars || theme).palette.action.disabled)
    }), ownerState.variant === 'text' && ownerState.orientation === 'vertical' && _defineProperty({
      borderBottom: theme.vars ? "1px solid rgba(".concat(theme.vars.palette.common.onBackgroundChannel, " / 0.23)") : "1px solid ".concat(theme.palette.mode === 'light' ? 'rgba(0, 0, 0, 0.23)' : 'rgba(255, 255, 255, 0.23)')
    }, "&.".concat(buttonGroupClasses$1.disabled), {
      borderBottom: "1px solid ".concat((theme.vars || theme).palette.action.disabled)
    }), ownerState.variant === 'text' && ownerState.color !== 'inherit' && {
      borderColor: theme.vars ? "rgba(".concat(theme.vars.palette[ownerState.color].mainChannel, " / 0.5)") : alpha(theme.palette[ownerState.color].main, 0.5)
    }, ownerState.variant === 'outlined' && ownerState.orientation === 'horizontal' && {
      borderRightColor: 'transparent'
    }, ownerState.variant === 'outlined' && ownerState.orientation === 'vertical' && {
      borderBottomColor: 'transparent'
    }, ownerState.variant === 'contained' && ownerState.orientation === 'horizontal' && _defineProperty({
      borderRight: "1px solid ".concat((theme.vars || theme).palette.grey[400])
    }, "&.".concat(buttonGroupClasses$1.disabled), {
      borderRight: "1px solid ".concat((theme.vars || theme).palette.action.disabled)
    }), ownerState.variant === 'contained' && ownerState.orientation === 'vertical' && _defineProperty({
      borderBottom: "1px solid ".concat((theme.vars || theme).palette.grey[400])
    }, "&.".concat(buttonGroupClasses$1.disabled), {
      borderBottom: "1px solid ".concat((theme.vars || theme).palette.action.disabled)
    }), ownerState.variant === 'contained' && ownerState.color !== 'inherit' && {
      borderColor: (theme.vars || theme).palette[ownerState.color].dark
    }, {
      '&:hover': _extends({}, ownerState.variant === 'outlined' && ownerState.orientation === 'horizontal' && {
        borderRightColor: 'currentColor'
      }, ownerState.variant === 'outlined' && ownerState.orientation === 'vertical' && {
        borderBottomColor: 'currentColor'
      })
    })), "& .".concat(buttonGroupClasses$1.lastButton, ",& .").concat(buttonGroupClasses$1.middleButton), _extends({}, ownerState.orientation === 'horizontal' && {
      borderTopLeftRadius: 0,
      borderBottomLeftRadius: 0
    }, ownerState.orientation === 'vertical' && {
      borderTopRightRadius: 0,
      borderTopLeftRadius: 0
    }, ownerState.variant === 'outlined' && ownerState.orientation === 'horizontal' && {
      marginLeft: -1
    }, ownerState.variant === 'outlined' && ownerState.orientation === 'vertical' && {
      marginTop: -1
    })));
  });
  var ButtonGroup = /*#__PURE__*/React__namespace.forwardRef(function ButtonGroup(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiButtonGroup'
    });
    var children = props.children,
      className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'primary' : _props$color,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$disableElevati = props.disableElevation,
      disableElevation = _props$disableElevati === void 0 ? false : _props$disableElevati,
      _props$disableFocusRi = props.disableFocusRipple,
      disableFocusRipple = _props$disableFocusRi === void 0 ? false : _props$disableFocusRi,
      _props$disableRipple = props.disableRipple,
      disableRipple = _props$disableRipple === void 0 ? false : _props$disableRipple,
      _props$fullWidth = props.fullWidth,
      fullWidth = _props$fullWidth === void 0 ? false : _props$fullWidth,
      _props$orientation = props.orientation,
      orientation = _props$orientation === void 0 ? 'horizontal' : _props$orientation,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'outlined' : _props$variant,
      other = _objectWithoutProperties(props, ["children", "className", "color", "component", "disabled", "disableElevation", "disableFocusRipple", "disableRipple", "fullWidth", "orientation", "size", "variant"]);
    var ownerState = _extends({}, props, {
      color: color,
      component: component,
      disabled: disabled,
      disableElevation: disableElevation,
      disableFocusRipple: disableFocusRipple,
      disableRipple: disableRipple,
      fullWidth: fullWidth,
      orientation: orientation,
      size: size,
      variant: variant
    });
    var classes = useUtilityClasses$1p(ownerState);
    var context = React__namespace.useMemo(function () {
      return {
        className: classes.grouped,
        color: color,
        disabled: disabled,
        disableElevation: disableElevation,
        disableFocusRipple: disableFocusRipple,
        disableRipple: disableRipple,
        fullWidth: fullWidth,
        size: size,
        variant: variant
      };
    }, [color, disabled, disableElevation, disableFocusRipple, disableRipple, fullWidth, size, variant, classes.grouped]);
    var validChildren = getValidReactChildren(children);
    var childrenCount = validChildren.length;
    var getButtonPositionClassName = function getButtonPositionClassName(index) {
      var isFirstButton = index === 0;
      var isLastButton = index === childrenCount - 1;
      if (isFirstButton && isLastButton) {
        return '';
      }
      if (isFirstButton) {
        return classes.firstButton;
      }
      if (isLastButton) {
        return classes.lastButton;
      }
      return classes.middleButton;
    };
    return /*#__PURE__*/jsxRuntimeExports.jsx(ButtonGroupRoot, _extends({
      as: component,
      role: "group",
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState
    }, other, {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(ButtonGroupContext$1.Provider, {
        value: context,
        children: validChildren.map(function (child, index) {
          return /*#__PURE__*/jsxRuntimeExports.jsx(ButtonGroupButtonContext$1.Provider, {
            value: getButtonPositionClassName(index),
            children: child
          }, index);
        })
      })
    }));
  });
  ButtonGroup.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'primary'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['inherit', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, no elevation is used.
     * @default false
     */
    disableElevation: PropTypes.bool,
    /**
     * If `true`, the button keyboard focus ripple is disabled.
     * @default false
     */
    disableFocusRipple: PropTypes.bool,
    /**
     * If `true`, the button ripple effect is disabled.
     * @default false
     */
    disableRipple: PropTypes.bool,
    /**
     * If `true`, the buttons will take up the full width of its container.
     * @default false
     */
    fullWidth: PropTypes.bool,
    /**
     * The component orientation (layout flow direction).
     * @default 'horizontal'
     */
    orientation: PropTypes.oneOf(['horizontal', 'vertical']),
    /**
     * The size of the component.
     * `small` is equivalent to the dense button styling.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['small', 'medium', 'large']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The variant to use.
     * @default 'outlined'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['contained', 'outlined', 'text']), PropTypes.string])
  } ;
  var ButtonGroup$1 = ButtonGroup;

  function getCardUtilityClass(slot) {
    return generateUtilityClass('MuiCard', slot);
  }
  var cardClasses = generateUtilityClasses('MuiCard', ['root']);
  var cardClasses$1 = cardClasses;

  var useUtilityClasses$1o = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    return composeClasses(slots, getCardUtilityClass, classes);
  };
  var CardRoot = styled$1(Paper$1, {
    name: 'MuiCard',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })(function () {
    return {
      overflow: 'hidden'
    };
  });
  var Card = /*#__PURE__*/React__namespace.forwardRef(function Card(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiCard'
    });
    var className = props.className,
      _props$raised = props.raised,
      raised = _props$raised === void 0 ? false : _props$raised,
      other = _objectWithoutProperties(props, ["className", "raised"]);
    var ownerState = _extends({}, props, {
      raised: raised
    });
    var classes = useUtilityClasses$1o(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(CardRoot, _extends({
      className: clsx(classes.root, className),
      elevation: raised ? 8 : undefined,
      ref: ref,
      ownerState: ownerState
    }, other));
  });
  Card.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * If `true`, the card will use raised styling.
     * @default false
     */
    raised: chainPropTypes(PropTypes.bool, function (props) {
      if (props.raised && props.variant === 'outlined') {
        return new Error('MUI: Combining `raised={true}` with `variant="outlined"` has no effect.');
      }
      return null;
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var Card$1 = Card;

  function getCardActionAreaUtilityClass(slot) {
    return generateUtilityClass('MuiCardActionArea', slot);
  }
  var cardActionAreaClasses = generateUtilityClasses('MuiCardActionArea', ['root', 'focusVisible', 'focusHighlight']);
  var cardActionAreaClasses$1 = cardActionAreaClasses;

  var useUtilityClasses$1n = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root'],
      focusHighlight: ['focusHighlight']
    };
    return composeClasses(slots, getCardActionAreaUtilityClass, classes);
  };
  var CardActionAreaRoot = styled$1(ButtonBase$1, {
    name: 'MuiCardActionArea',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })(function (_ref) {
    var theme = _ref.theme;
    return _defineProperty(_defineProperty({
      display: 'block',
      textAlign: 'inherit',
      borderRadius: 'inherit',
      // for Safari to work https://github.com/mui/material-ui/issues/36285.
      width: '100%'
    }, "&:hover .".concat(cardActionAreaClasses$1.focusHighlight), {
      opacity: (theme.vars || theme).palette.action.hoverOpacity,
      '@media (hover: none)': {
        opacity: 0
      }
    }), "&.".concat(cardActionAreaClasses$1.focusVisible, " .").concat(cardActionAreaClasses$1.focusHighlight), {
      opacity: (theme.vars || theme).palette.action.focusOpacity
    });
  });
  var CardActionAreaFocusHighlight = styled$1('span', {
    name: 'MuiCardActionArea',
    slot: 'FocusHighlight',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.focusHighlight;
    }
  })(function (_ref3) {
    var theme = _ref3.theme;
    return {
      overflow: 'hidden',
      pointerEvents: 'none',
      position: 'absolute',
      top: 0,
      right: 0,
      bottom: 0,
      left: 0,
      borderRadius: 'inherit',
      opacity: 0,
      backgroundColor: 'currentcolor',
      transition: theme.transitions.create('opacity', {
        duration: theme.transitions.duration["short"]
      })
    };
  });
  var CardActionArea = /*#__PURE__*/React__namespace.forwardRef(function CardActionArea(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiCardActionArea'
    });
    var children = props.children,
      className = props.className,
      focusVisibleClassName = props.focusVisibleClassName,
      other = _objectWithoutProperties(props, ["children", "className", "focusVisibleClassName"]);
    var ownerState = props;
    var classes = useUtilityClasses$1n(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(CardActionAreaRoot, _extends({
      className: clsx(classes.root, className),
      focusVisibleClassName: clsx(focusVisibleClassName, classes.focusVisible),
      ref: ref,
      ownerState: ownerState
    }, other, {
      children: [children, /*#__PURE__*/jsxRuntimeExports.jsx(CardActionAreaFocusHighlight, {
        className: classes.focusHighlight,
        ownerState: ownerState
      })]
    }));
  });
  CardActionArea.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * @ignore
     */
    focusVisibleClassName: PropTypes.string,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var CardActionArea$1 = CardActionArea;

  function getCardActionsUtilityClass(slot) {
    return generateUtilityClass('MuiCardActions', slot);
  }
  var cardActionsClasses = generateUtilityClasses('MuiCardActions', ['root', 'spacing']);
  var cardActionsClasses$1 = cardActionsClasses;

  var useUtilityClasses$1m = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      disableSpacing = ownerState.disableSpacing;
    var slots = {
      root: ['root', !disableSpacing && 'spacing']
    };
    return composeClasses(slots, getCardActionsUtilityClass, classes);
  };
  var CardActionsRoot = styled$1('div', {
    name: 'MuiCardActions',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, !ownerState.disableSpacing && styles.spacing];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends({
      display: 'flex',
      alignItems: 'center',
      padding: 8
    }, !ownerState.disableSpacing && {
      '& > :not(style) ~ :not(style)': {
        marginLeft: 8
      }
    });
  });
  var CardActions = /*#__PURE__*/React__namespace.forwardRef(function CardActions(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiCardActions'
    });
    var _props$disableSpacing = props.disableSpacing,
      disableSpacing = _props$disableSpacing === void 0 ? false : _props$disableSpacing,
      className = props.className,
      other = _objectWithoutProperties(props, ["disableSpacing", "className"]);
    var ownerState = _extends({}, props, {
      disableSpacing: disableSpacing
    });
    var classes = useUtilityClasses$1m(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(CardActionsRoot, _extends({
      className: clsx(classes.root, className),
      ownerState: ownerState,
      ref: ref
    }, other));
  });
  CardActions.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * If `true`, the actions do not have additional margin.
     * @default false
     */
    disableSpacing: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var CardActions$1 = CardActions;

  function getCardContentUtilityClass(slot) {
    return generateUtilityClass('MuiCardContent', slot);
  }
  var cardContentClasses = generateUtilityClasses('MuiCardContent', ['root']);
  var cardContentClasses$1 = cardContentClasses;

  var useUtilityClasses$1l = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    return composeClasses(slots, getCardContentUtilityClass, classes);
  };
  var CardContentRoot = styled$1('div', {
    name: 'MuiCardContent',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })(function () {
    return {
      padding: 16,
      '&:last-child': {
        paddingBottom: 24
      }
    };
  });
  var CardContent = /*#__PURE__*/React__namespace.forwardRef(function CardContent(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiCardContent'
    });
    var className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      other = _objectWithoutProperties(props, ["className", "component"]);
    var ownerState = _extends({}, props, {
      component: component
    });
    var classes = useUtilityClasses$1l(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(CardContentRoot, _extends({
      as: component,
      className: clsx(classes.root, className),
      ownerState: ownerState,
      ref: ref
    }, other));
  });
  CardContent.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var CardContent$1 = CardContent;

  function getCardHeaderUtilityClass(slot) {
    return generateUtilityClass('MuiCardHeader', slot);
  }
  var cardHeaderClasses = generateUtilityClasses('MuiCardHeader', ['root', 'avatar', 'action', 'content', 'title', 'subheader']);
  var cardHeaderClasses$1 = cardHeaderClasses;

  var useUtilityClasses$1k = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root'],
      avatar: ['avatar'],
      action: ['action'],
      content: ['content'],
      title: ['title'],
      subheader: ['subheader']
    };
    return composeClasses(slots, getCardHeaderUtilityClass, classes);
  };
  var CardHeaderRoot = styled$1('div', {
    name: 'MuiCardHeader',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return _extends(_defineProperty(_defineProperty({}, "& .".concat(cardHeaderClasses$1.title), styles.title), "& .".concat(cardHeaderClasses$1.subheader), styles.subheader), styles.root);
    }
  })({
    display: 'flex',
    alignItems: 'center',
    padding: 16
  });
  var CardHeaderAvatar = styled$1('div', {
    name: 'MuiCardHeader',
    slot: 'Avatar',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.avatar;
    }
  })({
    display: 'flex',
    flex: '0 0 auto',
    marginRight: 16
  });
  var CardHeaderAction = styled$1('div', {
    name: 'MuiCardHeader',
    slot: 'Action',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.action;
    }
  })({
    flex: '0 0 auto',
    alignSelf: 'flex-start',
    marginTop: -4,
    marginRight: -8,
    marginBottom: -4
  });
  var CardHeaderContent = styled$1('div', {
    name: 'MuiCardHeader',
    slot: 'Content',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.content;
    }
  })({
    flex: '1 1 auto'
  });
  var CardHeader = /*#__PURE__*/React__namespace.forwardRef(function CardHeader(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiCardHeader'
    });
    var action = props.action,
      avatar = props.avatar,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      _props$disableTypogra = props.disableTypography,
      disableTypography = _props$disableTypogra === void 0 ? false : _props$disableTypogra,
      subheaderProp = props.subheader,
      subheaderTypographyProps = props.subheaderTypographyProps,
      titleProp = props.title,
      titleTypographyProps = props.titleTypographyProps,
      other = _objectWithoutProperties(props, ["action", "avatar", "className", "component", "disableTypography", "subheader", "subheaderTypographyProps", "title", "titleTypographyProps"]);
    var ownerState = _extends({}, props, {
      component: component,
      disableTypography: disableTypography
    });
    var classes = useUtilityClasses$1k(ownerState);
    var title = titleProp;
    if (title != null && title.type !== Typography$1 && !disableTypography) {
      title = /*#__PURE__*/jsxRuntimeExports.jsx(Typography$1, _extends({
        variant: avatar ? 'body2' : 'h5',
        className: classes.title,
        component: "span",
        display: "block"
      }, titleTypographyProps, {
        children: title
      }));
    }
    var subheader = subheaderProp;
    if (subheader != null && subheader.type !== Typography$1 && !disableTypography) {
      subheader = /*#__PURE__*/jsxRuntimeExports.jsx(Typography$1, _extends({
        variant: avatar ? 'body2' : 'body1',
        className: classes.subheader,
        color: "text.secondary",
        component: "span",
        display: "block"
      }, subheaderTypographyProps, {
        children: subheader
      }));
    }
    return /*#__PURE__*/jsxRuntimeExports.jsxs(CardHeaderRoot, _extends({
      className: clsx(classes.root, className),
      as: component,
      ref: ref,
      ownerState: ownerState
    }, other, {
      children: [avatar && /*#__PURE__*/jsxRuntimeExports.jsx(CardHeaderAvatar, {
        className: classes.avatar,
        ownerState: ownerState,
        children: avatar
      }), /*#__PURE__*/jsxRuntimeExports.jsxs(CardHeaderContent, {
        className: classes.content,
        ownerState: ownerState,
        children: [title, subheader]
      }), action && /*#__PURE__*/jsxRuntimeExports.jsx(CardHeaderAction, {
        className: classes.action,
        ownerState: ownerState,
        children: action
      })]
    }));
  });
  CardHeader.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The action to display in the card header.
     */
    action: PropTypes.node,
    /**
     * The Avatar element to display.
     */
    avatar: PropTypes.node,
    /**
     * @ignore
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, `subheader` and `title` won't be wrapped by a Typography component.
     * This can be useful to render an alternative Typography variant by wrapping
     * the `title` text, and optional `subheader` text
     * with the Typography component.
     * @default false
     */
    disableTypography: PropTypes.bool,
    /**
     * The content of the component.
     */
    subheader: PropTypes.node,
    /**
     * These props will be forwarded to the subheader
     * (as long as disableTypography is not `true`).
     */
    subheaderTypographyProps: PropTypes.object,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The content of the component.
     */
    title: PropTypes.node,
    /**
     * These props will be forwarded to the title
     * (as long as disableTypography is not `true`).
     */
    titleTypographyProps: PropTypes.object
  } ;
  var CardHeader$1 = CardHeader;

  function getCardMediaUtilityClass(slot) {
    return generateUtilityClass('MuiCardMedia', slot);
  }
  var cardMediaClasses = generateUtilityClasses('MuiCardMedia', ['root', 'media', 'img']);
  var cardMediaClasses$1 = cardMediaClasses;

  var useUtilityClasses$1j = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      isMediaComponent = ownerState.isMediaComponent,
      isImageComponent = ownerState.isImageComponent;
    var slots = {
      root: ['root', isMediaComponent && 'media', isImageComponent && 'img']
    };
    return composeClasses(slots, getCardMediaUtilityClass, classes);
  };
  var CardMediaRoot = styled$1('div', {
    name: 'MuiCardMedia',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      var isMediaComponent = ownerState.isMediaComponent,
        isImageComponent = ownerState.isImageComponent;
      return [styles.root, isMediaComponent && styles.media, isImageComponent && styles.img];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends({
      display: 'block',
      backgroundSize: 'cover',
      backgroundRepeat: 'no-repeat',
      backgroundPosition: 'center'
    }, ownerState.isMediaComponent && {
      width: '100%'
    }, ownerState.isImageComponent && {
      // ⚠️ object-fit is not supported by IE11.
      objectFit: 'cover'
    });
  });
  var MEDIA_COMPONENTS = ['video', 'audio', 'picture', 'iframe', 'img'];
  var IMAGE_COMPONENTS = ['picture', 'img'];
  var CardMedia = /*#__PURE__*/React__namespace.forwardRef(function CardMedia(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiCardMedia'
    });
    var children = props.children,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      image = props.image,
      src = props.src,
      style = props.style,
      other = _objectWithoutProperties(props, ["children", "className", "component", "image", "src", "style"]);
    var isMediaComponent = MEDIA_COMPONENTS.indexOf(component) !== -1;
    var composedStyle = !isMediaComponent && image ? _extends({
      backgroundImage: "url(\"".concat(image, "\")")
    }, style) : style;
    var ownerState = _extends({}, props, {
      component: component,
      isMediaComponent: isMediaComponent,
      isImageComponent: IMAGE_COMPONENTS.indexOf(component) !== -1
    });
    var classes = useUtilityClasses$1j(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(CardMediaRoot, _extends({
      className: clsx(classes.root, className),
      as: component,
      role: !isMediaComponent && image ? 'img' : undefined,
      ref: ref,
      style: composedStyle,
      ownerState: ownerState,
      src: isMediaComponent ? image || src : undefined
    }, other, {
      children: children
    }));
  });
  CardMedia.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: chainPropTypes(PropTypes.node, function (props) {
      if (!props.children && !props.image && !props.src && !props.component) {
        return new Error('MUI: Either `children`, `image`, `src` or `component` prop must be specified.');
      }
      return null;
    }),
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * Image to be displayed as a background image.
     * Either `image` or `src` prop must be specified.
     * Note that caller must specify height otherwise the image will not be visible.
     */
    image: PropTypes.string,
    /**
     * An alias for `image` property.
     * Available only with media components.
     * Media components: `video`, `audio`, `picture`, `iframe`, `img`.
     */
    src: PropTypes.string,
    /**
     * @ignore
     */
    style: PropTypes.object,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var CardMedia$1 = CardMedia;

  function getSwitchBaseUtilityClass(slot) {
    return generateUtilityClass('PrivateSwitchBase', slot);
  }
  generateUtilityClasses('PrivateSwitchBase', ['root', 'checked', 'disabled', 'input', 'edgeStart', 'edgeEnd']);

  var useUtilityClasses$1i = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      checked = ownerState.checked,
      disabled = ownerState.disabled,
      edge = ownerState.edge;
    var slots = {
      root: ['root', checked && 'checked', disabled && 'disabled', edge && "edge".concat(capitalize(edge))],
      input: ['input']
    };
    return composeClasses(slots, getSwitchBaseUtilityClass, classes);
  };
  var SwitchBaseRoot = styled$1(ButtonBase$1)(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends({
      padding: 9,
      borderRadius: '50%'
    }, ownerState.edge === 'start' && {
      marginLeft: ownerState.size === 'small' ? -3 : -12
    }, ownerState.edge === 'end' && {
      marginRight: ownerState.size === 'small' ? -3 : -12
    });
  });
  var SwitchBaseInput = styled$1('input', {
    shouldForwardProp: rootShouldForwardProp$1
  })({
    cursor: 'inherit',
    position: 'absolute',
    opacity: 0,
    width: '100%',
    height: '100%',
    top: 0,
    left: 0,
    margin: 0,
    padding: 0,
    zIndex: 1
  });

  /**
   * @ignore - internal component.
   */
  var SwitchBase = /*#__PURE__*/React__namespace.forwardRef(function SwitchBase(props, ref) {
    var autoFocus = props.autoFocus,
      checkedProp = props.checked,
      checkedIcon = props.checkedIcon,
      className = props.className,
      defaultChecked = props.defaultChecked,
      disabledProp = props.disabled,
      _props$disableFocusRi = props.disableFocusRipple,
      disableFocusRipple = _props$disableFocusRi === void 0 ? false : _props$disableFocusRi,
      _props$edge = props.edge,
      edge = _props$edge === void 0 ? false : _props$edge,
      icon = props.icon,
      id = props.id,
      inputProps = props.inputProps,
      inputRef = props.inputRef,
      name = props.name,
      onBlur = props.onBlur,
      onChange = props.onChange,
      onFocus = props.onFocus,
      readOnly = props.readOnly,
      _props$required = props.required,
      required = _props$required === void 0 ? false : _props$required,
      tabIndex = props.tabIndex,
      type = props.type,
      value = props.value,
      other = _objectWithoutProperties(props, ["autoFocus", "checked", "checkedIcon", "className", "defaultChecked", "disabled", "disableFocusRipple", "edge", "icon", "id", "inputProps", "inputRef", "name", "onBlur", "onChange", "onFocus", "readOnly", "required", "tabIndex", "type", "value"]);
    var _useControlled = useControlled({
        controlled: checkedProp,
        "default": Boolean(defaultChecked),
        name: 'SwitchBase',
        state: 'checked'
      }),
      _useControlled2 = _slicedToArray(_useControlled, 2),
      checked = _useControlled2[0],
      setCheckedState = _useControlled2[1];
    var muiFormControl = useFormControl();
    var handleFocus = function handleFocus(event) {
      if (onFocus) {
        onFocus(event);
      }
      if (muiFormControl && muiFormControl.onFocus) {
        muiFormControl.onFocus(event);
      }
    };
    var handleBlur = function handleBlur(event) {
      if (onBlur) {
        onBlur(event);
      }
      if (muiFormControl && muiFormControl.onBlur) {
        muiFormControl.onBlur(event);
      }
    };
    var handleInputChange = function handleInputChange(event) {
      // Workaround for https://github.com/facebook/react/issues/9023
      if (event.nativeEvent.defaultPrevented) {
        return;
      }
      var newChecked = event.target.checked;
      setCheckedState(newChecked);
      if (onChange) {
        // TODO v6: remove the second argument.
        onChange(event, newChecked);
      }
    };
    var disabled = disabledProp;
    if (muiFormControl) {
      if (typeof disabled === 'undefined') {
        disabled = muiFormControl.disabled;
      }
    }
    var hasLabelFor = type === 'checkbox' || type === 'radio';
    var ownerState = _extends({}, props, {
      checked: checked,
      disabled: disabled,
      disableFocusRipple: disableFocusRipple,
      edge: edge
    });
    var classes = useUtilityClasses$1i(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(SwitchBaseRoot, _extends({
      component: "span",
      className: clsx(classes.root, className),
      centerRipple: true,
      focusRipple: !disableFocusRipple,
      disabled: disabled,
      tabIndex: null,
      role: undefined,
      onFocus: handleFocus,
      onBlur: handleBlur,
      ownerState: ownerState,
      ref: ref
    }, other, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsx(SwitchBaseInput, _extends({
        autoFocus: autoFocus,
        checked: checkedProp,
        defaultChecked: defaultChecked,
        className: classes.input,
        disabled: disabled,
        id: hasLabelFor ? id : undefined,
        name: name,
        onChange: handleInputChange,
        readOnly: readOnly,
        ref: inputRef,
        required: required,
        ownerState: ownerState,
        tabIndex: tabIndex,
        type: type
      }, type === 'checkbox' && value === undefined ? {} : {
        value: value
      }, inputProps)), checked ? checkedIcon : icon]
    }));
  });

  // NB: If changed, please update Checkbox, Switch and Radio
  // so that the API documentation is updated.
  SwitchBase.propTypes = {
    /**
     * If `true`, the `input` element is focused during the first mount.
     */
    autoFocus: PropTypes.bool,
    /**
     * If `true`, the component is checked.
     */
    checked: PropTypes.bool,
    /**
     * The icon to display when the component is checked.
     */
    checkedIcon: PropTypes.node.isRequired,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * @ignore
     */
    defaultChecked: PropTypes.bool,
    /**
     * If `true`, the component is disabled.
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the  keyboard focus ripple is disabled.
     * @default false
     */
    disableFocusRipple: PropTypes.bool,
    /**
     * If given, uses a negative margin to counteract the padding on one
     * side (this is often helpful for aligning the left or right
     * side of the icon with content above or below, without ruining the border
     * size and shape).
     * @default false
     */
    edge: PropTypes.oneOf(['end', 'start', false]),
    /**
     * The icon to display when the component is unchecked.
     */
    icon: PropTypes.node.isRequired,
    /**
     * The id of the `input` element.
     */
    id: PropTypes.string,
    /**
     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
     */
    inputProps: PropTypes.object,
    /**
     * Pass a ref to the `input` element.
     */
    inputRef: refType$1,
    /*
     * @ignore
     */
    name: PropTypes.string,
    /**
     * @ignore
     */
    onBlur: PropTypes.func,
    /**
     * Callback fired when the state is changed.
     *
     * @param {object} event The event source of the callback.
     * You can pull out the new checked state by accessing `event.target.checked` (boolean).
     */
    onChange: PropTypes.func,
    /**
     * @ignore
     */
    onFocus: PropTypes.func,
    /**
     * It prevents the user from changing the value of the field
     * (not from interacting with the field).
     */
    readOnly: PropTypes.bool,
    /**
     * If `true`, the `input` element is required.
     */
    required: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.object,
    /**
     * @ignore
     */
    tabIndex: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * The input component prop `type`.
     */
    type: PropTypes.string.isRequired,
    /**
     * The value of the component.
     */
    value: PropTypes.any
  } ;
  var SwitchBase$1 = SwitchBase;

  var CheckBoxOutlineBlankIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M19 5v14H5V5h14m0-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"
  }), 'CheckBoxOutlineBlank');

  var CheckBoxIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-9 14l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"
  }), 'CheckBox');

  var IndeterminateCheckBoxIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10H7v-2h10v2z"
  }), 'IndeterminateCheckBox');

  function getCheckboxUtilityClass(slot) {
    return generateUtilityClass('MuiCheckbox', slot);
  }
  var checkboxClasses = generateUtilityClasses('MuiCheckbox', ['root', 'checked', 'disabled', 'indeterminate', 'colorPrimary', 'colorSecondary', 'sizeSmall', 'sizeMedium']);
  var checkboxClasses$1 = checkboxClasses;

  var useUtilityClasses$1h = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      indeterminate = ownerState.indeterminate,
      color = ownerState.color,
      size = ownerState.size;
    var slots = {
      root: ['root', indeterminate && 'indeterminate', "color".concat(capitalize(color)), "size".concat(capitalize(size))]
    };
    var composedClasses = composeClasses(slots, getCheckboxUtilityClass, classes);
    return _extends({}, classes, composedClasses);
  };
  var CheckboxRoot = styled$1(SwitchBase$1, {
    shouldForwardProp: function shouldForwardProp(prop) {
      return rootShouldForwardProp$1(prop) || prop === 'classes';
    },
    name: 'MuiCheckbox',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.indeterminate && styles.indeterminate, styles["size".concat(capitalize(ownerState.size))], ownerState.color !== 'default' && styles["color".concat(capitalize(ownerState.color))]];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      color: (theme.vars || theme).palette.text.secondary
    }, !ownerState.disableRipple && {
      '&:hover': {
        backgroundColor: theme.vars ? "rgba(".concat(ownerState.color === 'default' ? theme.vars.palette.action.activeChannel : theme.vars.palette[ownerState.color].mainChannel, " / ").concat(theme.vars.palette.action.hoverOpacity, ")") : alpha(ownerState.color === 'default' ? theme.palette.action.active : theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: 'transparent'
        }
      }
    }, ownerState.color !== 'default' && _defineProperty(_defineProperty({}, "&.".concat(checkboxClasses$1.checked, ", &.").concat(checkboxClasses$1.indeterminate), {
      color: (theme.vars || theme).palette[ownerState.color].main
    }), "&.".concat(checkboxClasses$1.disabled), {
      color: (theme.vars || theme).palette.action.disabled
    }));
  });
  var defaultCheckedIcon$1 = /*#__PURE__*/jsxRuntimeExports.jsx(CheckBoxIcon, {});
  var defaultIcon$2 = /*#__PURE__*/jsxRuntimeExports.jsx(CheckBoxOutlineBlankIcon, {});
  var defaultIndeterminateIcon = /*#__PURE__*/jsxRuntimeExports.jsx(IndeterminateCheckBoxIcon, {});
  var Checkbox = /*#__PURE__*/React__namespace.forwardRef(function Checkbox(inProps, ref) {
    var _icon$props$fontSize, _indeterminateIcon$pr;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiCheckbox'
    });
    var _props$checkedIcon = props.checkedIcon,
      checkedIcon = _props$checkedIcon === void 0 ? defaultCheckedIcon$1 : _props$checkedIcon,
      _props$color = props.color,
      color = _props$color === void 0 ? 'primary' : _props$color,
      _props$icon = props.icon,
      iconProp = _props$icon === void 0 ? defaultIcon$2 : _props$icon,
      _props$indeterminate = props.indeterminate,
      indeterminate = _props$indeterminate === void 0 ? false : _props$indeterminate,
      _props$indeterminateI = props.indeterminateIcon,
      indeterminateIconProp = _props$indeterminateI === void 0 ? defaultIndeterminateIcon : _props$indeterminateI,
      inputProps = props.inputProps,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      className = props.className,
      other = _objectWithoutProperties(props, ["checkedIcon", "color", "icon", "indeterminate", "indeterminateIcon", "inputProps", "size", "className"]);
    var icon = indeterminate ? indeterminateIconProp : iconProp;
    var indeterminateIcon = indeterminate ? indeterminateIconProp : checkedIcon;
    var ownerState = _extends({}, props, {
      color: color,
      indeterminate: indeterminate,
      size: size
    });
    var classes = useUtilityClasses$1h(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(CheckboxRoot, _extends({
      type: "checkbox",
      inputProps: _extends({
        'data-indeterminate': indeterminate
      }, inputProps),
      icon: /*#__PURE__*/React__namespace.cloneElement(icon, {
        fontSize: (_icon$props$fontSize = icon.props.fontSize) != null ? _icon$props$fontSize : size
      }),
      checkedIcon: /*#__PURE__*/React__namespace.cloneElement(indeterminateIcon, {
        fontSize: (_indeterminateIcon$pr = indeterminateIcon.props.fontSize) != null ? _indeterminateIcon$pr : size
      }),
      ownerState: ownerState,
      ref: ref,
      className: clsx(classes.root, className)
    }, other, {
      classes: classes
    }));
  });
  Checkbox.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * If `true`, the component is checked.
     */
    checked: PropTypes.bool,
    /**
     * The icon to display when the component is checked.
     * @default <CheckBoxIcon />
     */
    checkedIcon: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'primary'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['default', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * The default checked state. Use when the component is not controlled.
     */
    defaultChecked: PropTypes.bool,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the ripple effect is disabled.
     * @default false
     */
    disableRipple: PropTypes.bool,
    /**
     * The icon to display when the component is unchecked.
     * @default <CheckBoxOutlineBlankIcon />
     */
    icon: PropTypes.node,
    /**
     * The id of the `input` element.
     */
    id: PropTypes.string,
    /**
     * If `true`, the component appears indeterminate.
     * This does not set the native input element to indeterminate due
     * to inconsistent behavior across browsers.
     * However, we set a `data-indeterminate` attribute on the `input`.
     * @default false
     */
    indeterminate: PropTypes.bool,
    /**
     * The icon to display when the component is indeterminate.
     * @default <IndeterminateCheckBoxIcon />
     */
    indeterminateIcon: PropTypes.node,
    /**
     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
     */
    inputProps: PropTypes.object,
    /**
     * Pass a ref to the `input` element.
     */
    inputRef: refType$1,
    /**
     * Callback fired when the state is changed.
     *
     * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.
     * You can pull out the new checked state by accessing `event.target.checked` (boolean).
     */
    onChange: PropTypes.func,
    /**
     * If `true`, the `input` element is required.
     * @default false
     */
    required: PropTypes.bool,
    /**
     * The size of the component.
     * `small` is equivalent to the dense checkbox styling.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['medium', 'small']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The value of the component. The DOM API casts this to a string.
     * The browser uses "on" as the default value.
     */
    value: PropTypes.any
  } ;
  var Checkbox$1 = Checkbox;

  function getCircularProgressUtilityClass(slot) {
    return generateUtilityClass('MuiCircularProgress', slot);
  }
  var circularProgressClasses = generateUtilityClasses('MuiCircularProgress', ['root', 'determinate', 'indeterminate', 'colorPrimary', 'colorSecondary', 'svg', 'circle', 'circleDeterminate', 'circleIndeterminate', 'circleDisableShrink']);
  var circularProgressClasses$1 = circularProgressClasses;

  var _templateObject$2, _templateObject2$2, _templateObject3$2, _templateObject4$2;
  var SIZE = 44;
  var circularRotateKeyframe = keyframes(_templateObject$2 || (_templateObject$2 = _taggedTemplateLiteral(["\n  0% {\n    transform: rotate(0deg);\n  }\n\n  100% {\n    transform: rotate(360deg);\n  }\n"])));
  var circularDashKeyframe = keyframes(_templateObject2$2 || (_templateObject2$2 = _taggedTemplateLiteral(["\n  0% {\n    stroke-dasharray: 1px, 200px;\n    stroke-dashoffset: 0;\n  }\n\n  50% {\n    stroke-dasharray: 100px, 200px;\n    stroke-dashoffset: -15px;\n  }\n\n  100% {\n    stroke-dasharray: 100px, 200px;\n    stroke-dashoffset: -125px;\n  }\n"])));
  var useUtilityClasses$1g = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      variant = ownerState.variant,
      color = ownerState.color,
      disableShrink = ownerState.disableShrink;
    var slots = {
      root: ['root', variant, "color".concat(capitalize(color))],
      svg: ['svg'],
      circle: ['circle', "circle".concat(capitalize(variant)), disableShrink && 'circleDisableShrink']
    };
    return composeClasses(slots, getCircularProgressUtilityClass, classes);
  };
  var CircularProgressRoot = styled$1('span', {
    name: 'MuiCircularProgress',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.variant], styles["color".concat(capitalize(ownerState.color))]];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState,
      theme = _ref.theme;
    return _extends({
      display: 'inline-block'
    }, ownerState.variant === 'determinate' && {
      transition: theme.transitions.create('transform')
    }, ownerState.color !== 'inherit' && {
      color: (theme.vars || theme).palette[ownerState.color].main
    });
  }, function (_ref2) {
    var ownerState = _ref2.ownerState;
    return ownerState.variant === 'indeterminate' && css(_templateObject3$2 || (_templateObject3$2 = _taggedTemplateLiteral(["\n      animation: ", " 1.4s linear infinite;\n    "])), circularRotateKeyframe);
  });
  var CircularProgressSVG = styled$1('svg', {
    name: 'MuiCircularProgress',
    slot: 'Svg',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.svg;
    }
  })({
    display: 'block' // Keeps the progress centered
  });
  var CircularProgressCircle = styled$1('circle', {
    name: 'MuiCircularProgress',
    slot: 'Circle',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.circle, styles["circle".concat(capitalize(ownerState.variant))], ownerState.disableShrink && styles.circleDisableShrink];
    }
  })(function (_ref3) {
    var ownerState = _ref3.ownerState,
      theme = _ref3.theme;
    return _extends({
      stroke: 'currentColor'
    }, ownerState.variant === 'determinate' && {
      transition: theme.transitions.create('stroke-dashoffset')
    }, ownerState.variant === 'indeterminate' && {
      // Some default value that looks fine waiting for the animation to kicks in.
      strokeDasharray: '80px, 200px',
      strokeDashoffset: 0 // Add the unit to fix a Edge 16 and below bug.
    });
  }, function (_ref4) {
    var ownerState = _ref4.ownerState;
    return ownerState.variant === 'indeterminate' && !ownerState.disableShrink && css(_templateObject4$2 || (_templateObject4$2 = _taggedTemplateLiteral(["\n      animation: ", " 1.4s ease-in-out infinite;\n    "])), circularDashKeyframe);
  });

  /**
   * ## ARIA
   *
   * If the progress bar is describing the loading progress of a particular region of a page,
   * you should use `aria-describedby` to point to the progress bar, and set the `aria-busy`
   * attribute to `true` on that region until it has finished loading.
   */
  var CircularProgress = /*#__PURE__*/React__namespace.forwardRef(function CircularProgress(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiCircularProgress'
    });
    var className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'primary' : _props$color,
      _props$disableShrink = props.disableShrink,
      disableShrink = _props$disableShrink === void 0 ? false : _props$disableShrink,
      _props$size = props.size,
      size = _props$size === void 0 ? 40 : _props$size,
      style = props.style,
      _props$thickness = props.thickness,
      thickness = _props$thickness === void 0 ? 3.6 : _props$thickness,
      _props$value = props.value,
      value = _props$value === void 0 ? 0 : _props$value,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'indeterminate' : _props$variant,
      other = _objectWithoutProperties(props, ["className", "color", "disableShrink", "size", "style", "thickness", "value", "variant"]);
    var ownerState = _extends({}, props, {
      color: color,
      disableShrink: disableShrink,
      size: size,
      thickness: thickness,
      value: value,
      variant: variant
    });
    var classes = useUtilityClasses$1g(ownerState);
    var circleStyle = {};
    var rootStyle = {};
    var rootProps = {};
    if (variant === 'determinate') {
      var circumference = 2 * Math.PI * ((SIZE - thickness) / 2);
      circleStyle.strokeDasharray = circumference.toFixed(3);
      rootProps['aria-valuenow'] = Math.round(value);
      circleStyle.strokeDashoffset = "".concat(((100 - value) / 100 * circumference).toFixed(3), "px");
      rootStyle.transform = 'rotate(-90deg)';
    }
    return /*#__PURE__*/jsxRuntimeExports.jsx(CircularProgressRoot, _extends({
      className: clsx(classes.root, className),
      style: _extends({
        width: size,
        height: size
      }, rootStyle, style),
      ownerState: ownerState,
      ref: ref,
      role: "progressbar"
    }, rootProps, other, {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(CircularProgressSVG, {
        className: classes.svg,
        ownerState: ownerState,
        viewBox: "".concat(SIZE / 2, " ").concat(SIZE / 2, " ").concat(SIZE, " ").concat(SIZE),
        children: /*#__PURE__*/jsxRuntimeExports.jsx(CircularProgressCircle, {
          className: classes.circle,
          style: circleStyle,
          ownerState: ownerState,
          cx: SIZE,
          cy: SIZE,
          r: (SIZE - thickness) / 2,
          fill: "none",
          strokeWidth: thickness
        })
      })
    }));
  });
  CircularProgress.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'primary'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['inherit', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * If `true`, the shrink animation is disabled.
     * This only works if variant is `indeterminate`.
     * @default false
     */
    disableShrink: chainPropTypes(PropTypes.bool, function (props) {
      if (props.disableShrink && props.variant && props.variant !== 'indeterminate') {
        return new Error('MUI: You have provided the `disableShrink` prop ' + 'with a variant other than `indeterminate`. This will have no effect.');
      }
      return null;
    }),
    /**
     * The size of the component.
     * If using a number, the pixel unit is assumed.
     * If using a string, you need to provide the CSS unit, for example '3rem'.
     * @default 40
     */
    size: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * @ignore
     */
    style: PropTypes.object,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The thickness of the circle.
     * @default 3.6
     */
    thickness: PropTypes.number,
    /**
     * The value of the progress indicator for the determinate variant.
     * Value between 0 and 100.
     * @default 0
     */
    value: PropTypes.number,
    /**
     * The variant to use.
     * Use indeterminate when there is no progress value.
     * @default 'indeterminate'
     */
    variant: PropTypes.oneOf(['determinate', 'indeterminate'])
  } ;
  var CircularProgress$1 = CircularProgress;

  function mapEventPropToEvent(eventProp) {
    return eventProp.substring(2).toLowerCase();
  }
  function clickedRootScrollbar(event, doc) {
    return doc.documentElement.clientWidth < event.clientX || doc.documentElement.clientHeight < event.clientY;
  }
  /**
   * Listen for click events that occur somewhere in the document, outside of the element itself.
   * For instance, if you need to hide a menu when people click anywhere else on your page.
   *
   * Demos:
   *
   * - [Click-Away Listener](https://mui.com/material-ui/react-click-away-listener/)
   * - [Menu](https://mui.com/material-ui/react-menu/)
   *
   * API:
   *
   * - [ClickAwayListener API](https://mui.com/material-ui/api/click-away-listener/)
   */
  function ClickAwayListener(props) {
    var children = props.children,
      _props$disableReactTr = props.disableReactTree,
      disableReactTree = _props$disableReactTr === void 0 ? false : _props$disableReactTr,
      _props$mouseEvent = props.mouseEvent,
      mouseEvent = _props$mouseEvent === void 0 ? 'onClick' : _props$mouseEvent,
      onClickAway = props.onClickAway,
      _props$touchEvent = props.touchEvent,
      touchEvent = _props$touchEvent === void 0 ? 'onTouchEnd' : _props$touchEvent;
    var movedRef = React__namespace.useRef(false);
    var nodeRef = React__namespace.useRef(null);
    var activatedRef = React__namespace.useRef(false);
    var syntheticEventRef = React__namespace.useRef(false);
    React__namespace.useEffect(function () {
      // Ensure that this component is not "activated" synchronously.
      // https://github.com/facebook/react/issues/20074
      setTimeout(function () {
        activatedRef.current = true;
      }, 0);
      return function () {
        activatedRef.current = false;
      };
    }, []);
    var handleRef = useForkRef(getReactElementRef(children), nodeRef);

    // The handler doesn't take event.defaultPrevented into account:
    //
    // event.preventDefault() is meant to stop default behaviors like
    // clicking a checkbox to check it, hitting a button to submit a form,
    // and hitting left arrow to move the cursor in a text input etc.
    // Only special HTML elements have these default behaviors.
    var handleClickAway = useEventCallback(function (event) {
      // Given developers can stop the propagation of the synthetic event,
      // we can only be confident with a positive value.
      var insideReactTree = syntheticEventRef.current;
      syntheticEventRef.current = false;
      var doc = ownerDocument(nodeRef.current);

      // 1. IE11 support, which trigger the handleClickAway even after the unbind
      // 2. The child might render null.
      // 3. Behave like a blur listener.
      if (!activatedRef.current || !nodeRef.current || 'clientX' in event && clickedRootScrollbar(event, doc)) {
        return;
      }

      // Do not act if user performed touchmove
      if (movedRef.current) {
        movedRef.current = false;
        return;
      }
      var insideDOM;

      // If not enough, can use https://github.com/DieterHolvoet/event-propagation-path/blob/master/propagationPath.js
      if (event.composedPath) {
        insideDOM = event.composedPath().indexOf(nodeRef.current) > -1;
      } else {
        insideDOM = !doc.documentElement.contains(
        // @ts-expect-error returns `false` as intended when not dispatched from a Node
        event.target) || nodeRef.current.contains(
        // @ts-expect-error returns `false` as intended when not dispatched from a Node
        event.target);
      }
      if (!insideDOM && (disableReactTree || !insideReactTree)) {
        onClickAway(event);
      }
    });

    // Keep track of mouse/touch events that bubbled up through the portal.
    var createHandleSynthetic = function createHandleSynthetic(handlerName) {
      return function (event) {
        syntheticEventRef.current = true;
        var childrenPropsHandler = children.props[handlerName];
        if (childrenPropsHandler) {
          childrenPropsHandler(event);
        }
      };
    };
    var childrenProps = {
      ref: handleRef
    };
    if (touchEvent !== false) {
      childrenProps[touchEvent] = createHandleSynthetic(touchEvent);
    }
    React__namespace.useEffect(function () {
      if (touchEvent !== false) {
        var mappedTouchEvent = mapEventPropToEvent(touchEvent);
        var doc = ownerDocument(nodeRef.current);
        var handleTouchMove = function handleTouchMove() {
          movedRef.current = true;
        };
        doc.addEventListener(mappedTouchEvent, handleClickAway);
        doc.addEventListener('touchmove', handleTouchMove);
        return function () {
          doc.removeEventListener(mappedTouchEvent, handleClickAway);
          doc.removeEventListener('touchmove', handleTouchMove);
        };
      }
      return undefined;
    }, [handleClickAway, touchEvent]);
    if (mouseEvent !== false) {
      childrenProps[mouseEvent] = createHandleSynthetic(mouseEvent);
    }
    React__namespace.useEffect(function () {
      if (mouseEvent !== false) {
        var mappedMouseEvent = mapEventPropToEvent(mouseEvent);
        var doc = ownerDocument(nodeRef.current);
        doc.addEventListener(mappedMouseEvent, handleClickAway);
        return function () {
          doc.removeEventListener(mappedMouseEvent, handleClickAway);
        };
      }
      return undefined;
    }, [handleClickAway, mouseEvent]);
    return /*#__PURE__*/jsxRuntimeExports.jsx(React__namespace.Fragment, {
      children: /*#__PURE__*/React__namespace.cloneElement(children, childrenProps)
    });
  }
  ClickAwayListener.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The wrapped element.
     */
    children: elementAcceptingRef$1.isRequired,
    /**
     * If `true`, the React tree is ignored and only the DOM tree is considered.
     * This prop changes how portaled elements are handled.
     * @default false
     */
    disableReactTree: PropTypes.bool,
    /**
     * The mouse event to listen to. You can disable the listener by providing `false`.
     * @default 'onClick'
     */
    mouseEvent: PropTypes.oneOf(['onClick', 'onMouseDown', 'onMouseUp', 'onPointerDown', 'onPointerUp', false]),
    /**
     * Callback fired when a "click away" event is detected.
     */
    onClickAway: PropTypes.func.isRequired,
    /**
     * The touch event to listen to. You can disable the listener by providing `false`.
     * @default 'onTouchEnd'
     */
    touchEvent: PropTypes.oneOf(['onTouchEnd', 'onTouchStart', false])
  } ;
  {
    // eslint-disable-next-line
    ClickAwayListener['propTypes' + ''] = exactProp(ClickAwayListener.propTypes);
  }

  var Container = createContainer({
    createStyledComponent: styled$1('div', {
      name: 'MuiContainer',
      slot: 'Root',
      overridesResolver: function overridesResolver(props, styles) {
        var ownerState = props.ownerState;
        return [styles.root, styles["maxWidth".concat(capitalize(String(ownerState.maxWidth)))], ownerState.fixed && styles.fixed, ownerState.disableGutters && styles.disableGutters];
      }
    }),
    useThemeProps: function useThemeProps(inProps) {
      return useDefaultProps({
        props: inProps,
        name: 'MuiContainer'
      });
    }
  });
  Container.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * @ignore
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, the left and right padding is removed.
     * @default false
     */
    disableGutters: PropTypes.bool,
    /**
     * Set the max-width to match the min-width of the current breakpoint.
     * This is useful if you'd prefer to design for a fixed set of sizes
     * instead of trying to accommodate a fully fluid viewport.
     * It's fluid by default.
     * @default false
     */
    fixed: PropTypes.bool,
    /**
     * Determine the max-width of the container.
     * The container width grows with the size of the screen.
     * Set to `false` to disable `maxWidth`.
     * @default 'lg'
     */
    maxWidth: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl', false]), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var Container$1 = Container;

  function getContainerUtilityClass(slot) {
    return generateUtilityClass('MuiContainer', slot);
  }
  var containerClasses = generateUtilityClasses('MuiContainer', ['root', 'disableGutters', 'fixed', 'maxWidthXs', 'maxWidthSm', 'maxWidthMd', 'maxWidthLg', 'maxWidthXl']);
  var containerClasses$1 = containerClasses;

  var html = function html(theme, enableColorScheme) {
    return _extends({
      WebkitFontSmoothing: 'antialiased',
      // Antialiasing.
      MozOsxFontSmoothing: 'grayscale',
      // Antialiasing.
      // Change from `box-sizing: content-box` so that `width`
      // is not affected by `padding` or `border`.
      boxSizing: 'border-box',
      // Fix font resize problem in iOS
      WebkitTextSizeAdjust: '100%'
    }, enableColorScheme && !theme.vars && {
      colorScheme: theme.palette.mode
    });
  };
  var body = function body(theme) {
    return _extends({
      color: (theme.vars || theme).palette.text.primary
    }, theme.typography.body1, {
      backgroundColor: (theme.vars || theme).palette.background["default"],
      '@media print': {
        // Save printer ink.
        backgroundColor: (theme.vars || theme).palette.common.white
      }
    });
  };
  var _styles = function styles(theme) {
    var _theme$components;
    var enableColorScheme = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    var colorSchemeStyles = {};
    if (enableColorScheme && theme.colorSchemes) {
      Object.entries(theme.colorSchemes).forEach(function (_ref) {
        var _scheme$palette;
        var _ref2 = _slicedToArray(_ref, 2),
          key = _ref2[0],
          scheme = _ref2[1];
        colorSchemeStyles[theme.getColorSchemeSelector(key).replace(/\s*&/, '')] = {
          colorScheme: (_scheme$palette = scheme.palette) == null ? void 0 : _scheme$palette.mode
        };
      });
    }
    var defaultStyles = _extends({
      html: html(theme, enableColorScheme),
      '*, *::before, *::after': {
        boxSizing: 'inherit'
      },
      'strong, b': {
        fontWeight: theme.typography.fontWeightBold
      },
      body: _extends({
        margin: 0
      }, body(theme), {
        // Add support for document.body.requestFullScreen().
        // Other elements, if background transparent, are not supported.
        '&::backdrop': {
          backgroundColor: (theme.vars || theme).palette.background["default"]
        }
      })
    }, colorSchemeStyles);
    var themeOverrides = (_theme$components = theme.components) == null || (_theme$components = _theme$components.MuiCssBaseline) == null ? void 0 : _theme$components.styleOverrides;
    if (themeOverrides) {
      defaultStyles = [defaultStyles, themeOverrides];
    }
    return defaultStyles;
  };
  function CssBaseline(inProps) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiCssBaseline'
    });
    var children = props.children,
      _props$enableColorSch = props.enableColorScheme,
      enableColorScheme = _props$enableColorSch === void 0 ? false : _props$enableColorSch;
    return /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsx(GlobalStyles, {
        styles: function styles(theme) {
          return _styles(theme, enableColorScheme);
        }
      }), children]
    });
  }
  CssBaseline.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * You can wrap a node.
     */
    children: PropTypes.node,
    /**
     * Enable `color-scheme` CSS property to use `theme.palette.mode`.
     * For more details, check out https://developer.mozilla.org/en-US/docs/Web/CSS/color-scheme
     * For browser support, check out https://caniuse.com/?search=color-scheme
     * @default false
     */
    enableColorScheme: PropTypes.bool
  } ;

  // track, thumb and active are derived from macOS 10.15.7
  var scrollBar = {
    track: '#2b2b2b',
    thumb: '#6b6b6b',
    active: '#959595'
  };
  function darkScrollbar() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : scrollBar;
    return {
      scrollbarColor: "".concat(options.thumb, " ").concat(options.track),
      '&::-webkit-scrollbar, & *::-webkit-scrollbar': {
        backgroundColor: options.track
      },
      '&::-webkit-scrollbar-thumb, & *::-webkit-scrollbar-thumb': {
        borderRadius: 8,
        backgroundColor: options.thumb,
        minHeight: 24,
        border: "3px solid ".concat(options.track)
      },
      '&::-webkit-scrollbar-thumb:focus, & *::-webkit-scrollbar-thumb:focus': {
        backgroundColor: options.active
      },
      '&::-webkit-scrollbar-thumb:active, & *::-webkit-scrollbar-thumb:active': {
        backgroundColor: options.active
      },
      '&::-webkit-scrollbar-thumb:hover, & *::-webkit-scrollbar-thumb:hover': {
        backgroundColor: options.active
      },
      '&::-webkit-scrollbar-corner, & *::-webkit-scrollbar-corner': {
        backgroundColor: options.track
      }
    };
  }

  // Is a vertical scrollbar displayed?
  function isOverflowing(container) {
    var doc = ownerDocument(container);
    if (doc.body === container) {
      return ownerWindow(container).innerWidth > doc.documentElement.clientWidth;
    }
    return container.scrollHeight > container.clientHeight;
  }
  function ariaHidden(element, show) {
    if (show) {
      element.setAttribute('aria-hidden', 'true');
    } else {
      element.removeAttribute('aria-hidden');
    }
  }
  function getPaddingRight(element) {
    return parseInt(ownerWindow(element).getComputedStyle(element).paddingRight, 10) || 0;
  }
  function isAriaHiddenForbiddenOnElement(element) {
    // The forbidden HTML tags are the ones from ARIA specification that
    // can be children of body and can't have aria-hidden attribute.
    // cf. https://www.w3.org/TR/html-aria/#docconformance
    var forbiddenTagNames = ['TEMPLATE', 'SCRIPT', 'STYLE', 'LINK', 'MAP', 'META', 'NOSCRIPT', 'PICTURE', 'COL', 'COLGROUP', 'PARAM', 'SLOT', 'SOURCE', 'TRACK'];
    var isForbiddenTagName = forbiddenTagNames.indexOf(element.tagName) !== -1;
    var isInputHidden = element.tagName === 'INPUT' && element.getAttribute('type') === 'hidden';
    return isForbiddenTagName || isInputHidden;
  }
  function ariaHiddenSiblings(container, mountElement, currentElement, elementsToExclude, show) {
    var blacklist = [mountElement, currentElement].concat(_toConsumableArray(elementsToExclude));
    [].forEach.call(container.children, function (element) {
      var isNotExcludedElement = blacklist.indexOf(element) === -1;
      var isNotForbiddenElement = !isAriaHiddenForbiddenOnElement(element);
      if (isNotExcludedElement && isNotForbiddenElement) {
        ariaHidden(element, show);
      }
    });
  }
  function findIndexOf(items, callback) {
    var idx = -1;
    items.some(function (item, index) {
      if (callback(item)) {
        idx = index;
        return true;
      }
      return false;
    });
    return idx;
  }
  function handleContainer(containerInfo, props) {
    var restoreStyle = [];
    var container = containerInfo.container;
    if (!props.disableScrollLock) {
      if (isOverflowing(container)) {
        // Compute the size before applying overflow hidden to avoid any scroll jumps.
        var scrollbarSize = getScrollbarSize(ownerDocument(container));
        restoreStyle.push({
          value: container.style.paddingRight,
          property: 'padding-right',
          el: container
        });
        // Use computed style, here to get the real padding to add our scrollbar width.
        container.style.paddingRight = "".concat(getPaddingRight(container) + scrollbarSize, "px");

        // .mui-fixed is a global helper.
        var fixedElements = ownerDocument(container).querySelectorAll('.mui-fixed');
        [].forEach.call(fixedElements, function (element) {
          restoreStyle.push({
            value: element.style.paddingRight,
            property: 'padding-right',
            el: element
          });
          element.style.paddingRight = "".concat(getPaddingRight(element) + scrollbarSize, "px");
        });
      }
      var scrollContainer;
      if (container.parentNode instanceof DocumentFragment) {
        scrollContainer = ownerDocument(container).body;
      } else {
        // Support html overflow-y: auto for scroll stability between pages
        // https://css-tricks.com/snippets/css/force-vertical-scrollbar/
        var parent = container.parentElement;
        var containerWindow = ownerWindow(container);
        scrollContainer = (parent == null ? void 0 : parent.nodeName) === 'HTML' && containerWindow.getComputedStyle(parent).overflowY === 'scroll' ? parent : container;
      }

      // Block the scroll even if no scrollbar is visible to account for mobile keyboard
      // screensize shrink.
      restoreStyle.push({
        value: scrollContainer.style.overflow,
        property: 'overflow',
        el: scrollContainer
      }, {
        value: scrollContainer.style.overflowX,
        property: 'overflow-x',
        el: scrollContainer
      }, {
        value: scrollContainer.style.overflowY,
        property: 'overflow-y',
        el: scrollContainer
      });
      scrollContainer.style.overflow = 'hidden';
    }
    var restore = function restore() {
      restoreStyle.forEach(function (_ref) {
        var value = _ref.value,
          el = _ref.el,
          property = _ref.property;
        if (value) {
          el.style.setProperty(property, value);
        } else {
          el.style.removeProperty(property);
        }
      });
    };
    return restore;
  }
  function getHiddenSiblings(container) {
    var hiddenSiblings = [];
    [].forEach.call(container.children, function (element) {
      if (element.getAttribute('aria-hidden') === 'true') {
        hiddenSiblings.push(element);
      }
    });
    return hiddenSiblings;
  }
  /**
   * @ignore - do not document.
   *
   * Proper state management for containers and the modals in those containers.
   * Simplified, but inspired by react-overlay's ModalManager class.
   * Used by the Modal to ensure proper styling of containers.
   */
  var ModalManager = /*#__PURE__*/function () {
    function ModalManager() {
      _classCallCheck(this, ModalManager);
      this.containers = void 0;
      this.modals = void 0;
      this.modals = [];
      this.containers = [];
    }
    _createClass(ModalManager, [{
      key: "add",
      value: function add(modal, container) {
        var modalIndex = this.modals.indexOf(modal);
        if (modalIndex !== -1) {
          return modalIndex;
        }
        modalIndex = this.modals.length;
        this.modals.push(modal);

        // If the modal we are adding is already in the DOM.
        if (modal.modalRef) {
          ariaHidden(modal.modalRef, false);
        }
        var hiddenSiblings = getHiddenSiblings(container);
        ariaHiddenSiblings(container, modal.mount, modal.modalRef, hiddenSiblings, true);
        var containerIndex = findIndexOf(this.containers, function (item) {
          return item.container === container;
        });
        if (containerIndex !== -1) {
          this.containers[containerIndex].modals.push(modal);
          return modalIndex;
        }
        this.containers.push({
          modals: [modal],
          container: container,
          restore: null,
          hiddenSiblings: hiddenSiblings
        });
        return modalIndex;
      }
    }, {
      key: "mount",
      value: function mount(modal, props) {
        var containerIndex = findIndexOf(this.containers, function (item) {
          return item.modals.indexOf(modal) !== -1;
        });
        var containerInfo = this.containers[containerIndex];
        if (!containerInfo.restore) {
          containerInfo.restore = handleContainer(containerInfo, props);
        }
      }
    }, {
      key: "remove",
      value: function remove(modal) {
        var ariaHiddenState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
        var modalIndex = this.modals.indexOf(modal);
        if (modalIndex === -1) {
          return modalIndex;
        }
        var containerIndex = findIndexOf(this.containers, function (item) {
          return item.modals.indexOf(modal) !== -1;
        });
        var containerInfo = this.containers[containerIndex];
        containerInfo.modals.splice(containerInfo.modals.indexOf(modal), 1);
        this.modals.splice(modalIndex, 1);

        // If that was the last modal in a container, clean up the container.
        if (containerInfo.modals.length === 0) {
          // The modal might be closed before it had the chance to be mounted in the DOM.
          if (containerInfo.restore) {
            containerInfo.restore();
          }
          if (modal.modalRef) {
            // In case the modal wasn't in the DOM yet.
            ariaHidden(modal.modalRef, ariaHiddenState);
          }
          ariaHiddenSiblings(containerInfo.container, modal.mount, modal.modalRef, containerInfo.hiddenSiblings, false);
          this.containers.splice(containerIndex, 1);
        } else {
          // Otherwise make sure the next top modal is visible to a screen reader.
          var nextTop = containerInfo.modals[containerInfo.modals.length - 1];
          // as soon as a modal is adding its modalRef is undefined. it can't set
          // aria-hidden because the dom element doesn't exist either
          // when modal was unmounted before modalRef gets null
          if (nextTop.modalRef) {
            ariaHidden(nextTop.modalRef, false);
          }
        }
        return modalIndex;
      }
    }, {
      key: "isTopModal",
      value: function isTopModal(modal) {
        return this.modals.length > 0 && this.modals[this.modals.length - 1] === modal;
      }
    }]);
    return ModalManager;
  }();

  // Inspired by https://github.com/focus-trap/tabbable
  var candidatesSelector = ['input', 'select', 'textarea', 'a[href]', 'button', '[tabindex]', 'audio[controls]', 'video[controls]', '[contenteditable]:not([contenteditable="false"])'].join(',');
  function getTabIndex(node) {
    var tabindexAttr = parseInt(node.getAttribute('tabindex') || '', 10);
    if (!Number.isNaN(tabindexAttr)) {
      return tabindexAttr;
    }

    // Browsers do not return `tabIndex` correctly for contentEditable nodes;
    // https://bugs.chromium.org/p/chromium/issues/detail?id=661108&q=contenteditable%20tabindex&can=2
    // so if they don't have a tabindex attribute specifically set, assume it's 0.
    // in Chrome, <details/>, <audio controls/> and <video controls/> elements get a default
    //  `tabIndex` of -1 when the 'tabindex' attribute isn't specified in the DOM,
    //  yet they are still part of the regular tab order; in FF, they get a default
    //  `tabIndex` of 0; since Chrome still puts those elements in the regular tab
    //  order, consider their tab index to be 0.
    if (node.contentEditable === 'true' || (node.nodeName === 'AUDIO' || node.nodeName === 'VIDEO' || node.nodeName === 'DETAILS') && node.getAttribute('tabindex') === null) {
      return 0;
    }
    return node.tabIndex;
  }
  function isNonTabbableRadio(node) {
    if (node.tagName !== 'INPUT' || node.type !== 'radio') {
      return false;
    }
    if (!node.name) {
      return false;
    }
    var getRadio = function getRadio(selector) {
      return node.ownerDocument.querySelector("input[type=\"radio\"]".concat(selector));
    };
    var roving = getRadio("[name=\"".concat(node.name, "\"]:checked"));
    if (!roving) {
      roving = getRadio("[name=\"".concat(node.name, "\"]"));
    }
    return roving !== node;
  }
  function isNodeMatchingSelectorFocusable(node) {
    if (node.disabled || node.tagName === 'INPUT' && node.type === 'hidden' || isNonTabbableRadio(node)) {
      return false;
    }
    return true;
  }
  function defaultGetTabbable(root) {
    var regularTabNodes = [];
    var orderedTabNodes = [];
    Array.from(root.querySelectorAll(candidatesSelector)).forEach(function (node, i) {
      var nodeTabIndex = getTabIndex(node);
      if (nodeTabIndex === -1 || !isNodeMatchingSelectorFocusable(node)) {
        return;
      }
      if (nodeTabIndex === 0) {
        regularTabNodes.push(node);
      } else {
        orderedTabNodes.push({
          documentOrder: i,
          tabIndex: nodeTabIndex,
          node: node
        });
      }
    });
    return orderedTabNodes.sort(function (a, b) {
      return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
    }).map(function (a) {
      return a.node;
    }).concat(regularTabNodes);
  }
  function defaultIsEnabled() {
    return true;
  }

  /**
   * @ignore - internal component.
   */
  function FocusTrap(props) {
    var children = props.children,
      _props$disableAutoFoc = props.disableAutoFocus,
      disableAutoFocus = _props$disableAutoFoc === void 0 ? false : _props$disableAutoFoc,
      _props$disableEnforce = props.disableEnforceFocus,
      disableEnforceFocus = _props$disableEnforce === void 0 ? false : _props$disableEnforce,
      _props$disableRestore = props.disableRestoreFocus,
      disableRestoreFocus = _props$disableRestore === void 0 ? false : _props$disableRestore,
      _props$getTabbable = props.getTabbable,
      getTabbable = _props$getTabbable === void 0 ? defaultGetTabbable : _props$getTabbable,
      _props$isEnabled = props.isEnabled,
      isEnabled = _props$isEnabled === void 0 ? defaultIsEnabled : _props$isEnabled,
      open = props.open;
    var ignoreNextEnforceFocus = React__namespace.useRef(false);
    var sentinelStart = React__namespace.useRef(null);
    var sentinelEnd = React__namespace.useRef(null);
    var nodeToRestore = React__namespace.useRef(null);
    var reactFocusEventTarget = React__namespace.useRef(null);
    // This variable is useful when disableAutoFocus is true.
    // It waits for the active element to move into the component to activate.
    var activated = React__namespace.useRef(false);
    var rootRef = React__namespace.useRef(null);
    var handleRef = useForkRef(getReactElementRef(children), rootRef);
    var lastKeydown = React__namespace.useRef(null);
    React__namespace.useEffect(function () {
      // We might render an empty child.
      if (!open || !rootRef.current) {
        return;
      }
      activated.current = !disableAutoFocus;
    }, [disableAutoFocus, open]);
    React__namespace.useEffect(function () {
      // We might render an empty child.
      if (!open || !rootRef.current) {
        return;
      }
      var doc = ownerDocument(rootRef.current);
      if (!rootRef.current.contains(doc.activeElement)) {
        if (!rootRef.current.hasAttribute('tabIndex')) {
          {
            console.error(['MUI: The modal content node does not accept focus.', 'For the benefit of assistive technologies, ' + 'the tabIndex of the node is being set to "-1".'].join('\n'));
          }
          rootRef.current.setAttribute('tabIndex', '-1');
        }
        if (activated.current) {
          rootRef.current.focus();
        }
      }
      return function () {
        // restoreLastFocus()
        if (!disableRestoreFocus) {
          // In IE11 it is possible for document.activeElement to be null resulting
          // in nodeToRestore.current being null.
          // Not all elements in IE11 have a focus method.
          // Once IE11 support is dropped the focus() call can be unconditional.
          if (nodeToRestore.current && nodeToRestore.current.focus) {
            ignoreNextEnforceFocus.current = true;
            nodeToRestore.current.focus();
          }
          nodeToRestore.current = null;
        }
      };
      // Missing `disableRestoreFocus` which is fine.
      // We don't support changing that prop on an open FocusTrap
      // eslint-disable-next-line react-hooks/exhaustive-deps
    }, [open]);
    React__namespace.useEffect(function () {
      // We might render an empty child.
      if (!open || !rootRef.current) {
        return;
      }
      var doc = ownerDocument(rootRef.current);
      var loopFocus = function loopFocus(nativeEvent) {
        lastKeydown.current = nativeEvent;
        if (disableEnforceFocus || !isEnabled() || nativeEvent.key !== 'Tab') {
          return;
        }

        // Make sure the next tab starts from the right place.
        // doc.activeElement refers to the origin.
        if (doc.activeElement === rootRef.current && nativeEvent.shiftKey) {
          // We need to ignore the next contain as
          // it will try to move the focus back to the rootRef element.
          ignoreNextEnforceFocus.current = true;
          if (sentinelEnd.current) {
            sentinelEnd.current.focus();
          }
        }
      };
      var contain = function contain() {
        var rootElement = rootRef.current;

        // Cleanup functions are executed lazily in React 17.
        // Contain can be called between the component being unmounted and its cleanup function being run.
        if (rootElement === null) {
          return;
        }
        if (!doc.hasFocus() || !isEnabled() || ignoreNextEnforceFocus.current) {
          ignoreNextEnforceFocus.current = false;
          return;
        }

        // The focus is already inside
        if (rootElement.contains(doc.activeElement)) {
          return;
        }

        // The disableEnforceFocus is set and the focus is outside of the focus trap (and sentinel nodes)
        if (disableEnforceFocus && doc.activeElement !== sentinelStart.current && doc.activeElement !== sentinelEnd.current) {
          return;
        }

        // if the focus event is not coming from inside the children's react tree, reset the refs
        if (doc.activeElement !== reactFocusEventTarget.current) {
          reactFocusEventTarget.current = null;
        } else if (reactFocusEventTarget.current !== null) {
          return;
        }
        if (!activated.current) {
          return;
        }
        var tabbable = [];
        if (doc.activeElement === sentinelStart.current || doc.activeElement === sentinelEnd.current) {
          tabbable = getTabbable(rootRef.current);
        }

        // one of the sentinel nodes was focused, so move the focus
        // to the first/last tabbable element inside the focus trap
        if (tabbable.length > 0) {
          var _lastKeydown$current, _lastKeydown$current2;
          var isShiftTab = Boolean(((_lastKeydown$current = lastKeydown.current) == null ? void 0 : _lastKeydown$current.shiftKey) && ((_lastKeydown$current2 = lastKeydown.current) == null ? void 0 : _lastKeydown$current2.key) === 'Tab');
          var focusNext = tabbable[0];
          var focusPrevious = tabbable[tabbable.length - 1];
          if (typeof focusNext !== 'string' && typeof focusPrevious !== 'string') {
            if (isShiftTab) {
              focusPrevious.focus();
            } else {
              focusNext.focus();
            }
          }
          // no tabbable elements in the trap focus or the focus was outside of the focus trap
        } else {
          rootElement.focus();
        }
      };
      doc.addEventListener('focusin', contain);
      doc.addEventListener('keydown', loopFocus, true);

      // With Edge, Safari and Firefox, no focus related events are fired when the focused area stops being a focused area.
      // for example https://bugzilla.mozilla.org/show_bug.cgi?id=559561.
      // Instead, we can look if the active element was restored on the BODY element.
      //
      // The whatwg spec defines how the browser should behave but does not explicitly mention any events:
      // https://html.spec.whatwg.org/multipage/interaction.html#focus-fixup-rule.
      var interval = setInterval(function () {
        if (doc.activeElement && doc.activeElement.tagName === 'BODY') {
          contain();
        }
      }, 50);
      return function () {
        clearInterval(interval);
        doc.removeEventListener('focusin', contain);
        doc.removeEventListener('keydown', loopFocus, true);
      };
    }, [disableAutoFocus, disableEnforceFocus, disableRestoreFocus, isEnabled, open, getTabbable]);
    var onFocus = function onFocus(event) {
      if (nodeToRestore.current === null) {
        nodeToRestore.current = event.relatedTarget;
      }
      activated.current = true;
      reactFocusEventTarget.current = event.target;
      var childrenPropsHandler = children.props.onFocus;
      if (childrenPropsHandler) {
        childrenPropsHandler(event);
      }
    };
    var handleFocusSentinel = function handleFocusSentinel(event) {
      if (nodeToRestore.current === null) {
        nodeToRestore.current = event.relatedTarget;
      }
      activated.current = true;
    };
    return /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsx("div", {
        tabIndex: open ? 0 : -1,
        onFocus: handleFocusSentinel,
        ref: sentinelStart,
        "data-testid": "sentinelStart"
      }), /*#__PURE__*/React__namespace.cloneElement(children, {
        ref: handleRef,
        onFocus: onFocus
      }), /*#__PURE__*/jsxRuntimeExports.jsx("div", {
        tabIndex: open ? 0 : -1,
        onFocus: handleFocusSentinel,
        ref: sentinelEnd,
        "data-testid": "sentinelEnd"
      })]
    });
  }
  FocusTrap.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * A single child content element.
     */
    children: elementAcceptingRef$1,
    /**
     * If `true`, the focus trap will not automatically shift focus to itself when it opens, and
     * replace it to the last focused element when it closes.
     * This also works correctly with any focus trap children that have the `disableAutoFocus` prop.
     *
     * Generally this should never be set to `true` as it makes the focus trap less
     * accessible to assistive technologies, like screen readers.
     * @default false
     */
    disableAutoFocus: PropTypes.bool,
    /**
     * If `true`, the focus trap will not prevent focus from leaving the focus trap while open.
     *
     * Generally this should never be set to `true` as it makes the focus trap less
     * accessible to assistive technologies, like screen readers.
     * @default false
     */
    disableEnforceFocus: PropTypes.bool,
    /**
     * If `true`, the focus trap will not restore focus to previously focused element once
     * focus trap is hidden or unmounted.
     * @default false
     */
    disableRestoreFocus: PropTypes.bool,
    /**
     * Returns an array of ordered tabbable nodes (i.e. in tab order) within the root.
     * For instance, you can provide the "tabbable" npm dependency.
     * @param {HTMLElement} root
     */
    getTabbable: PropTypes.func,
    /**
     * This prop extends the `open` prop.
     * It allows to toggle the open state without having to wait for a rerender when changing the `open` prop.
     * This prop should be memoized.
     * It can be used to support multiple focus trap mounted at the same time.
     * @default function defaultIsEnabled(): boolean {
     *   return true;
     * }
     */
    isEnabled: PropTypes.func,
    /**
     * If `true`, focus is locked.
     */
    open: PropTypes.bool.isRequired
  } ;
  {
    // eslint-disable-next-line
    FocusTrap['propTypes' + ''] = exactProp(FocusTrap.propTypes);
  }

  function getContainer(container) {
    return typeof container === 'function' ? container() : container;
  }
  function getHasTransition(children) {
    return children ? children.props.hasOwnProperty('in') : false;
  }

  // A modal manager used to track and manage the state of open Modals.
  // Modals don't open on the server so this won't conflict with concurrent requests.
  var defaultManager = new ModalManager();
  /**
   *
   * Demos:
   *
   * - [Modal](https://mui.com/base-ui/react-modal/#hook)
   *
   * API:
   *
   * - [useModal API](https://mui.com/base-ui/react-modal/hooks-api/#use-modal)
   */
  function useModal(parameters) {
    var container = parameters.container,
      _parameters$disableEs = parameters.disableEscapeKeyDown,
      disableEscapeKeyDown = _parameters$disableEs === void 0 ? false : _parameters$disableEs,
      _parameters$disableSc = parameters.disableScrollLock,
      disableScrollLock = _parameters$disableSc === void 0 ? false : _parameters$disableSc,
      _parameters$manager = parameters.manager,
      manager = _parameters$manager === void 0 ? defaultManager : _parameters$manager,
      _parameters$closeAfte = parameters.closeAfterTransition,
      closeAfterTransition = _parameters$closeAfte === void 0 ? false : _parameters$closeAfte,
      onTransitionEnter = parameters.onTransitionEnter,
      onTransitionExited = parameters.onTransitionExited,
      children = parameters.children,
      onClose = parameters.onClose,
      open = parameters.open,
      rootRef = parameters.rootRef; // @ts-ignore internal logic
    var modal = React__namespace.useRef({});
    var mountNodeRef = React__namespace.useRef(null);
    var modalRef = React__namespace.useRef(null);
    var handleRef = useForkRef(modalRef, rootRef);
    var _React$useState = React__namespace.useState(!open),
      exited = _React$useState[0],
      setExited = _React$useState[1];
    var hasTransition = getHasTransition(children);
    var ariaHiddenProp = true;
    if (parameters['aria-hidden'] === 'false' || parameters['aria-hidden'] === false) {
      ariaHiddenProp = false;
    }
    var getDoc = function getDoc() {
      return ownerDocument(mountNodeRef.current);
    };
    var getModal = function getModal() {
      modal.current.modalRef = modalRef.current;
      modal.current.mount = mountNodeRef.current;
      return modal.current;
    };
    var handleMounted = function handleMounted() {
      manager.mount(getModal(), {
        disableScrollLock: disableScrollLock
      });

      // Fix a bug on Chrome where the scroll isn't initially 0.
      if (modalRef.current) {
        modalRef.current.scrollTop = 0;
      }
    };
    var handleOpen = useEventCallback(function () {
      var resolvedContainer = getContainer(container) || getDoc().body;
      manager.add(getModal(), resolvedContainer);

      // The element was already mounted.
      if (modalRef.current) {
        handleMounted();
      }
    });
    var isTopModal = React__namespace.useCallback(function () {
      return manager.isTopModal(getModal());
    }, [manager]);
    var handlePortalRef = useEventCallback(function (node) {
      mountNodeRef.current = node;
      if (!node) {
        return;
      }
      if (open && isTopModal()) {
        handleMounted();
      } else if (modalRef.current) {
        ariaHidden(modalRef.current, ariaHiddenProp);
      }
    });
    var handleClose = React__namespace.useCallback(function () {
      manager.remove(getModal(), ariaHiddenProp);
    }, [ariaHiddenProp, manager]);
    React__namespace.useEffect(function () {
      return function () {
        handleClose();
      };
    }, [handleClose]);
    React__namespace.useEffect(function () {
      if (open) {
        handleOpen();
      } else if (!hasTransition || !closeAfterTransition) {
        handleClose();
      }
    }, [open, handleClose, hasTransition, closeAfterTransition, handleOpen]);
    var createHandleKeyDown = function createHandleKeyDown(otherHandlers) {
      return function (event) {
        var _otherHandlers$onKeyD;
        (_otherHandlers$onKeyD = otherHandlers.onKeyDown) == null || _otherHandlers$onKeyD.call(otherHandlers, event);

        // The handler doesn't take event.defaultPrevented into account:
        //
        // event.preventDefault() is meant to stop default behaviors like
        // clicking a checkbox to check it, hitting a button to submit a form,
        // and hitting left arrow to move the cursor in a text input etc.
        // Only special HTML elements have these default behaviors.
        if (event.key !== 'Escape' || event.which === 229 ||
        // Wait until IME is settled.
        !isTopModal()) {
          return;
        }
        if (!disableEscapeKeyDown) {
          // Swallow the event, in case someone is listening for the escape key on the body.
          event.stopPropagation();
          if (onClose) {
            onClose(event, 'escapeKeyDown');
          }
        }
      };
    };
    var createHandleBackdropClick = function createHandleBackdropClick(otherHandlers) {
      return function (event) {
        var _otherHandlers$onClic;
        (_otherHandlers$onClic = otherHandlers.onClick) == null || _otherHandlers$onClic.call(otherHandlers, event);
        if (event.target !== event.currentTarget) {
          return;
        }
        if (onClose) {
          onClose(event, 'backdropClick');
        }
      };
    };
    var getRootProps = function getRootProps() {
      var otherHandlers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var propsEventHandlers = extractEventHandlers(parameters);

      // The custom event handlers shouldn't be spread on the root element
      delete propsEventHandlers.onTransitionEnter;
      delete propsEventHandlers.onTransitionExited;
      var externalEventHandlers = _extends({}, propsEventHandlers, otherHandlers);
      return _extends({
        role: 'presentation'
      }, externalEventHandlers, {
        onKeyDown: createHandleKeyDown(externalEventHandlers),
        ref: handleRef
      });
    };
    var getBackdropProps = function getBackdropProps() {
      var otherHandlers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var externalEventHandlers = otherHandlers;
      return _extends({
        'aria-hidden': true
      }, externalEventHandlers, {
        onClick: createHandleBackdropClick(externalEventHandlers),
        open: open
      });
    };
    var getTransitionProps = function getTransitionProps() {
      var handleEnter = function handleEnter() {
        setExited(false);
        if (onTransitionEnter) {
          onTransitionEnter();
        }
      };
      var handleExited = function handleExited() {
        setExited(true);
        if (onTransitionExited) {
          onTransitionExited();
        }
        if (closeAfterTransition) {
          handleClose();
        }
      };
      return {
        onEnter: createChainedFunction(handleEnter, children == null ? void 0 : children.props.onEnter),
        onExited: createChainedFunction(handleExited, children == null ? void 0 : children.props.onExited)
      };
    };
    return {
      getRootProps: getRootProps,
      getBackdropProps: getBackdropProps,
      getTransitionProps: getTransitionProps,
      rootRef: handleRef,
      portalRef: handlePortalRef,
      isTopModal: isTopModal,
      exited: exited,
      hasTransition: hasTransition
    };
  }

  function getModalUtilityClass(slot) {
    return generateUtilityClass('MuiModal', slot);
  }
  var modalClasses = generateUtilityClasses('MuiModal', ['root', 'hidden', 'backdrop']);
  var modalClasses$1 = modalClasses;

  var useUtilityClasses$1f = function useUtilityClasses(ownerState) {
    var open = ownerState.open,
      exited = ownerState.exited,
      classes = ownerState.classes;
    var slots = {
      root: ['root', !open && exited && 'hidden'],
      backdrop: ['backdrop']
    };
    return composeClasses(slots, getModalUtilityClass, classes);
  };
  var ModalRoot = styled$1('div', {
    name: 'MuiModal',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, !ownerState.open && ownerState.exited && styles.hidden];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      position: 'fixed',
      zIndex: (theme.vars || theme).zIndex.modal,
      right: 0,
      bottom: 0,
      top: 0,
      left: 0
    }, !ownerState.open && ownerState.exited && {
      visibility: 'hidden'
    });
  });
  var ModalBackdrop = styled$1(Backdrop$1, {
    name: 'MuiModal',
    slot: 'Backdrop',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.backdrop;
    }
  })({
    zIndex: -1
  });

  /**
   * Modal is a lower-level construct that is leveraged by the following components:
   *
   * - [Dialog](/material-ui/api/dialog/)
   * - [Drawer](/material-ui/api/drawer/)
   * - [Menu](/material-ui/api/menu/)
   * - [Popover](/material-ui/api/popover/)
   *
   * If you are creating a modal dialog, you probably want to use the [Dialog](/material-ui/api/dialog/) component
   * rather than directly using Modal.
   *
   * This component shares many concepts with [react-overlays](https://react-bootstrap.github.io/react-overlays/#modals).
   */
  var Modal = /*#__PURE__*/React__namespace.forwardRef(function Modal(inProps, ref) {
    var _ref2, _slots$root, _ref3, _slots$backdrop, _slotProps$root, _slotProps$backdrop;
    var props = useDefaultProps({
      name: 'MuiModal',
      props: inProps
    });
    var _props$BackdropCompon = props.BackdropComponent,
      BackdropComponent = _props$BackdropCompon === void 0 ? ModalBackdrop : _props$BackdropCompon,
      BackdropProps = props.BackdropProps;
      props.classes;
      var className = props.className,
      _props$closeAfterTran = props.closeAfterTransition,
      closeAfterTransition = _props$closeAfterTran === void 0 ? false : _props$closeAfterTran,
      children = props.children,
      container = props.container,
      component = props.component,
      _props$components = props.components,
      components = _props$components === void 0 ? {} : _props$components,
      _props$componentsProp = props.componentsProps,
      componentsProps = _props$componentsProp === void 0 ? {} : _props$componentsProp,
      _props$disableAutoFoc = props.disableAutoFocus,
      disableAutoFocus = _props$disableAutoFoc === void 0 ? false : _props$disableAutoFoc,
      _props$disableEnforce = props.disableEnforceFocus,
      disableEnforceFocus = _props$disableEnforce === void 0 ? false : _props$disableEnforce,
      _props$disableEscapeK = props.disableEscapeKeyDown,
      disableEscapeKeyDown = _props$disableEscapeK === void 0 ? false : _props$disableEscapeK,
      _props$disablePortal = props.disablePortal,
      disablePortal = _props$disablePortal === void 0 ? false : _props$disablePortal,
      _props$disableRestore = props.disableRestoreFocus,
      disableRestoreFocus = _props$disableRestore === void 0 ? false : _props$disableRestore,
      _props$disableScrollL = props.disableScrollLock,
      disableScrollLock = _props$disableScrollL === void 0 ? false : _props$disableScrollL,
      _props$hideBackdrop = props.hideBackdrop,
      hideBackdrop = _props$hideBackdrop === void 0 ? false : _props$hideBackdrop,
      _props$keepMounted = props.keepMounted,
      keepMounted = _props$keepMounted === void 0 ? false : _props$keepMounted,
      onBackdropClick = props.onBackdropClick;
      props.onClose;
      props.onTransitionEnter;
      props.onTransitionExited;
      var open = props.open,
      slotProps = props.slotProps,
      slots = props.slots;
      props.theme;
      var other = _objectWithoutProperties(props, ["BackdropComponent", "BackdropProps", "classes", "className", "closeAfterTransition", "children", "container", "component", "components", "componentsProps", "disableAutoFocus", "disableEnforceFocus", "disableEscapeKeyDown", "disablePortal", "disableRestoreFocus", "disableScrollLock", "hideBackdrop", "keepMounted", "onBackdropClick", "onClose", "onTransitionEnter", "onTransitionExited", "open", "slotProps", "slots", "theme"]);
    var propsWithDefaults = _extends({}, props, {
      closeAfterTransition: closeAfterTransition,
      disableAutoFocus: disableAutoFocus,
      disableEnforceFocus: disableEnforceFocus,
      disableEscapeKeyDown: disableEscapeKeyDown,
      disablePortal: disablePortal,
      disableRestoreFocus: disableRestoreFocus,
      disableScrollLock: disableScrollLock,
      hideBackdrop: hideBackdrop,
      keepMounted: keepMounted
    });
    var _useModal = useModal(_extends({}, propsWithDefaults, {
        rootRef: ref
      })),
      getRootProps = _useModal.getRootProps,
      getBackdropProps = _useModal.getBackdropProps,
      getTransitionProps = _useModal.getTransitionProps,
      portalRef = _useModal.portalRef,
      isTopModal = _useModal.isTopModal,
      exited = _useModal.exited,
      hasTransition = _useModal.hasTransition;
    var ownerState = _extends({}, propsWithDefaults, {
      exited: exited
    });
    var classes = useUtilityClasses$1f(ownerState);
    var childProps = {};
    if (children.props.tabIndex === undefined) {
      childProps.tabIndex = '-1';
    }

    // It's a Transition like component
    if (hasTransition) {
      var _getTransitionProps = getTransitionProps(),
        onEnter = _getTransitionProps.onEnter,
        onExited = _getTransitionProps.onExited;
      childProps.onEnter = onEnter;
      childProps.onExited = onExited;
    }
    var RootSlot = (_ref2 = (_slots$root = slots == null ? void 0 : slots.root) != null ? _slots$root : components.Root) != null ? _ref2 : ModalRoot;
    var BackdropSlot = (_ref3 = (_slots$backdrop = slots == null ? void 0 : slots.backdrop) != null ? _slots$backdrop : components.Backdrop) != null ? _ref3 : BackdropComponent;
    var rootSlotProps = (_slotProps$root = slotProps == null ? void 0 : slotProps.root) != null ? _slotProps$root : componentsProps.root;
    var backdropSlotProps = (_slotProps$backdrop = slotProps == null ? void 0 : slotProps.backdrop) != null ? _slotProps$backdrop : componentsProps.backdrop;
    var rootProps = useSlotProps({
      elementType: RootSlot,
      externalSlotProps: rootSlotProps,
      externalForwardedProps: other,
      getSlotProps: getRootProps,
      additionalProps: {
        ref: ref,
        as: component
      },
      ownerState: ownerState,
      className: clsx(className, rootSlotProps == null ? void 0 : rootSlotProps.className, classes == null ? void 0 : classes.root, !ownerState.open && ownerState.exited && (classes == null ? void 0 : classes.hidden))
    });
    var backdropProps = useSlotProps({
      elementType: BackdropSlot,
      externalSlotProps: backdropSlotProps,
      additionalProps: BackdropProps,
      getSlotProps: function getSlotProps(otherHandlers) {
        return getBackdropProps(_extends({}, otherHandlers, {
          onClick: function onClick(e) {
            if (onBackdropClick) {
              onBackdropClick(e);
            }
            if (otherHandlers != null && otherHandlers.onClick) {
              otherHandlers.onClick(e);
            }
          }
        }));
      },
      className: clsx(backdropSlotProps == null ? void 0 : backdropSlotProps.className, BackdropProps == null ? void 0 : BackdropProps.className, classes == null ? void 0 : classes.backdrop),
      ownerState: ownerState
    });
    if (!keepMounted && !open && (!hasTransition || exited)) {
      return null;
    }
    return /*#__PURE__*/jsxRuntimeExports.jsx(Portal$1, {
      ref: portalRef,
      container: container,
      disablePortal: disablePortal,
      children: /*#__PURE__*/jsxRuntimeExports.jsxs(RootSlot, _extends({}, rootProps, {
        children: [!hideBackdrop && BackdropComponent ? /*#__PURE__*/jsxRuntimeExports.jsx(BackdropSlot, _extends({}, backdropProps)) : null, /*#__PURE__*/jsxRuntimeExports.jsx(FocusTrap, {
          disableEnforceFocus: disableEnforceFocus,
          disableAutoFocus: disableAutoFocus,
          disableRestoreFocus: disableRestoreFocus,
          isEnabled: isTopModal,
          open: open,
          children: /*#__PURE__*/React__namespace.cloneElement(children, childProps)
        })]
      }))
    });
  });
  Modal.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * A backdrop component. This prop enables custom backdrop rendering.
     * @deprecated Use `slots.backdrop` instead. While this prop currently works, it will be removed in the next major version.
     * Use the `slots.backdrop` prop to make your application ready for the next version of Material UI.
     * @default styled(Backdrop, {
     *   name: 'MuiModal',
     *   slot: 'Backdrop',
     *   overridesResolver: (props, styles) => {
     *     return styles.backdrop;
     *   },
     * })({
     *   zIndex: -1,
     * })
     */
    BackdropComponent: PropTypes.elementType,
    /**
     * Props applied to the [`Backdrop`](/material-ui/api/backdrop/) element.
     * @deprecated Use `slotProps.backdrop` instead.
     */
    BackdropProps: PropTypes.object,
    /**
     * A single child content element.
     */
    children: elementAcceptingRef$1.isRequired,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * When set to true the Modal waits until a nested Transition is completed before closing.
     * @default false
     */
    closeAfterTransition: PropTypes.bool,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `slots` prop.
     * It's recommended to use the `slots` prop instead.
     *
     * @default {}
     */
    components: PropTypes.shape({
      Backdrop: PropTypes.elementType,
      Root: PropTypes.elementType
    }),
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `slotProps` prop.
     * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.
     *
     * @default {}
     */
    componentsProps: PropTypes.shape({
      backdrop: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * An HTML element or function that returns one.
     * The `container` will have the portal children appended to it.
     *
     * You can also provide a callback, which is called in a React layout effect.
     * This lets you set the container from a ref, and also makes server-side rendering possible.
     *
     * By default, it uses the body of the top-level document object,
     * so it's simply `document.body` most of the time.
     */
    container: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.func]),
    /**
     * If `true`, the modal will not automatically shift focus to itself when it opens, and
     * replace it to the last focused element when it closes.
     * This also works correctly with any modal children that have the `disableAutoFocus` prop.
     *
     * Generally this should never be set to `true` as it makes the modal less
     * accessible to assistive technologies, like screen readers.
     * @default false
     */
    disableAutoFocus: PropTypes.bool,
    /**
     * If `true`, the modal will not prevent focus from leaving the modal while open.
     *
     * Generally this should never be set to `true` as it makes the modal less
     * accessible to assistive technologies, like screen readers.
     * @default false
     */
    disableEnforceFocus: PropTypes.bool,
    /**
     * If `true`, hitting escape will not fire the `onClose` callback.
     * @default false
     */
    disableEscapeKeyDown: PropTypes.bool,
    /**
     * The `children` will be under the DOM hierarchy of the parent component.
     * @default false
     */
    disablePortal: PropTypes.bool,
    /**
     * If `true`, the modal will not restore focus to previously focused element once
     * modal is hidden or unmounted.
     * @default false
     */
    disableRestoreFocus: PropTypes.bool,
    /**
     * Disable the scroll lock behavior.
     * @default false
     */
    disableScrollLock: PropTypes.bool,
    /**
     * If `true`, the backdrop is not rendered.
     * @default false
     */
    hideBackdrop: PropTypes.bool,
    /**
     * Always keep the children in the DOM.
     * This prop can be useful in SEO situation or
     * when you want to maximize the responsiveness of the Modal.
     * @default false
     */
    keepMounted: PropTypes.bool,
    /**
     * Callback fired when the backdrop is clicked.
     * @deprecated Use the `onClose` prop with the `reason` argument to handle the `backdropClick` events.
     */
    onBackdropClick: PropTypes.func,
    /**
     * Callback fired when the component requests to be closed.
     * The `reason` parameter can optionally be used to control the response to `onClose`.
     *
     * @param {object} event The event source of the callback.
     * @param {string} reason Can be: `"escapeKeyDown"`, `"backdropClick"`.
     */
    onClose: PropTypes.func,
    /**
     * A function called when a transition enters.
     */
    onTransitionEnter: PropTypes.func,
    /**
     * A function called when a transition has exited.
     */
    onTransitionExited: PropTypes.func,
    /**
     * If `true`, the component is shown.
     */
    open: PropTypes.bool.isRequired,
    /**
     * The props used for each slot inside the Modal.
     * @default {}
     */
    slotProps: PropTypes.shape({
      backdrop: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * The components used for each slot inside the Modal.
     * Either a string to use a HTML element or a component.
     * @default {}
     */
    slots: PropTypes.shape({
      backdrop: PropTypes.elementType,
      root: PropTypes.elementType
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var Modal$1 = Modal;

  function getDialogUtilityClass(slot) {
    return generateUtilityClass('MuiDialog', slot);
  }
  var dialogClasses = generateUtilityClasses('MuiDialog', ['root', 'scrollPaper', 'scrollBody', 'container', 'paper', 'paperScrollPaper', 'paperScrollBody', 'paperWidthFalse', 'paperWidthXs', 'paperWidthSm', 'paperWidthMd', 'paperWidthLg', 'paperWidthXl', 'paperFullWidth', 'paperFullScreen']);
  var dialogClasses$1 = dialogClasses;

  var DialogContext = /*#__PURE__*/React__namespace.createContext({});
  {
    DialogContext.displayName = 'DialogContext';
  }
  var DialogContext$1 = DialogContext;

  var DialogBackdrop = styled$1(Backdrop$1, {
    name: 'MuiDialog',
    slot: 'Backdrop',
    overrides: function overrides(props, styles) {
      return styles.backdrop;
    }
  })({
    // Improve scrollable dialog support.
    zIndex: -1
  });
  var useUtilityClasses$1e = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      scroll = ownerState.scroll,
      maxWidth = ownerState.maxWidth,
      fullWidth = ownerState.fullWidth,
      fullScreen = ownerState.fullScreen;
    var slots = {
      root: ['root'],
      container: ['container', "scroll".concat(capitalize(scroll))],
      paper: ['paper', "paperScroll".concat(capitalize(scroll)), "paperWidth".concat(capitalize(String(maxWidth))), fullWidth && 'paperFullWidth', fullScreen && 'paperFullScreen']
    };
    return composeClasses(slots, getDialogUtilityClass, classes);
  };
  var DialogRoot = styled$1(Modal$1, {
    name: 'MuiDialog',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })({
    '@media print': {
      // Use !important to override the Modal inline-style.
      position: 'absolute !important'
    }
  });
  var DialogContainer = styled$1('div', {
    name: 'MuiDialog',
    slot: 'Container',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.container, styles["scroll".concat(capitalize(ownerState.scroll))]];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends({
      height: '100%',
      '@media print': {
        height: 'auto'
      },
      // We disable the focus ring for mouse, touch and keyboard users.
      outline: 0
    }, ownerState.scroll === 'paper' && {
      display: 'flex',
      justifyContent: 'center',
      alignItems: 'center'
    }, ownerState.scroll === 'body' && {
      overflowY: 'auto',
      overflowX: 'hidden',
      textAlign: 'center',
      '&::after': {
        content: '""',
        display: 'inline-block',
        verticalAlign: 'middle',
        height: '100%',
        width: '0'
      }
    });
  });
  var DialogPaper = styled$1(Paper$1, {
    name: 'MuiDialog',
    slot: 'Paper',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.paper, styles["scrollPaper".concat(capitalize(ownerState.scroll))], styles["paperWidth".concat(capitalize(String(ownerState.maxWidth)))], ownerState.fullWidth && styles.paperFullWidth, ownerState.fullScreen && styles.paperFullScreen];
    }
  })(function (_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    return _extends({
      margin: 32,
      position: 'relative',
      overflowY: 'auto',
      // Fix IE11 issue, to remove at some point.
      '@media print': {
        overflowY: 'visible',
        boxShadow: 'none'
      }
    }, ownerState.scroll === 'paper' && {
      display: 'flex',
      flexDirection: 'column',
      maxHeight: 'calc(100% - 64px)'
    }, ownerState.scroll === 'body' && {
      display: 'inline-block',
      verticalAlign: 'middle',
      textAlign: 'left' // 'initial' doesn't work on IE11
    }, !ownerState.maxWidth && {
      maxWidth: 'calc(100% - 64px)'
    }, ownerState.maxWidth === 'xs' && _defineProperty({
      maxWidth: theme.breakpoints.unit === 'px' ? Math.max(theme.breakpoints.values.xs, 444) : "max(".concat(theme.breakpoints.values.xs).concat(theme.breakpoints.unit, ", 444px)")
    }, "&.".concat(dialogClasses$1.paperScrollBody), _defineProperty({}, theme.breakpoints.down(Math.max(theme.breakpoints.values.xs, 444) + 32 * 2), {
      maxWidth: 'calc(100% - 64px)'
    })), ownerState.maxWidth && ownerState.maxWidth !== 'xs' && _defineProperty({
      maxWidth: "".concat(theme.breakpoints.values[ownerState.maxWidth]).concat(theme.breakpoints.unit)
    }, "&.".concat(dialogClasses$1.paperScrollBody), _defineProperty({}, theme.breakpoints.down(theme.breakpoints.values[ownerState.maxWidth] + 32 * 2), {
      maxWidth: 'calc(100% - 64px)'
    })), ownerState.fullWidth && {
      width: 'calc(100% - 64px)'
    }, ownerState.fullScreen && _defineProperty({
      margin: 0,
      width: '100%',
      maxWidth: '100%',
      height: '100%',
      maxHeight: 'none',
      borderRadius: 0
    }, "&.".concat(dialogClasses$1.paperScrollBody), {
      margin: 0,
      maxWidth: '100%'
    }));
  });

  /**
   * Dialogs are overlaid modal paper based components with a backdrop.
   */
  var Dialog = /*#__PURE__*/React__namespace.forwardRef(function Dialog(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiDialog'
    });
    var theme = useTheme();
    var defaultTransitionDuration = {
      enter: theme.transitions.duration.enteringScreen,
      exit: theme.transitions.duration.leavingScreen
    };
    var ariaDescribedby = props['aria-describedby'],
      ariaLabelledbyProp = props['aria-labelledby'],
      BackdropComponent = props.BackdropComponent,
      BackdropProps = props.BackdropProps,
      children = props.children,
      className = props.className,
      _props$disableEscapeK = props.disableEscapeKeyDown,
      disableEscapeKeyDown = _props$disableEscapeK === void 0 ? false : _props$disableEscapeK,
      _props$fullScreen = props.fullScreen,
      fullScreen = _props$fullScreen === void 0 ? false : _props$fullScreen,
      _props$fullWidth = props.fullWidth,
      fullWidth = _props$fullWidth === void 0 ? false : _props$fullWidth,
      _props$maxWidth = props.maxWidth,
      maxWidth = _props$maxWidth === void 0 ? 'sm' : _props$maxWidth,
      onBackdropClick = props.onBackdropClick,
      onClick = props.onClick,
      onClose = props.onClose,
      open = props.open,
      _props$PaperComponent = props.PaperComponent,
      PaperComponent = _props$PaperComponent === void 0 ? Paper$1 : _props$PaperComponent,
      _props$PaperProps = props.PaperProps,
      PaperProps = _props$PaperProps === void 0 ? {} : _props$PaperProps,
      _props$scroll = props.scroll,
      scroll = _props$scroll === void 0 ? 'paper' : _props$scroll,
      _props$TransitionComp = props.TransitionComponent,
      TransitionComponent = _props$TransitionComp === void 0 ? Fade$1 : _props$TransitionComp,
      _props$transitionDura = props.transitionDuration,
      transitionDuration = _props$transitionDura === void 0 ? defaultTransitionDuration : _props$transitionDura,
      TransitionProps = props.TransitionProps,
      other = _objectWithoutProperties(props, ["aria-describedby", "aria-labelledby", "BackdropComponent", "BackdropProps", "children", "className", "disableEscapeKeyDown", "fullScreen", "fullWidth", "maxWidth", "onBackdropClick", "onClick", "onClose", "open", "PaperComponent", "PaperProps", "scroll", "TransitionComponent", "transitionDuration", "TransitionProps"]);
    var ownerState = _extends({}, props, {
      disableEscapeKeyDown: disableEscapeKeyDown,
      fullScreen: fullScreen,
      fullWidth: fullWidth,
      maxWidth: maxWidth,
      scroll: scroll
    });
    var classes = useUtilityClasses$1e(ownerState);
    var backdropClick = React__namespace.useRef();
    var handleMouseDown = function handleMouseDown(event) {
      // We don't want to close the dialog when clicking the dialog content.
      // Make sure the event starts and ends on the same DOM element.
      backdropClick.current = event.target === event.currentTarget;
    };
    var handleBackdropClick = function handleBackdropClick(event) {
      if (onClick) {
        onClick(event);
      }

      // Ignore the events not coming from the "backdrop".
      if (!backdropClick.current) {
        return;
      }
      backdropClick.current = null;
      if (onBackdropClick) {
        onBackdropClick(event);
      }
      if (onClose) {
        onClose(event, 'backdropClick');
      }
    };
    var ariaLabelledby = useId(ariaLabelledbyProp);
    var dialogContextValue = React__namespace.useMemo(function () {
      return {
        titleId: ariaLabelledby
      };
    }, [ariaLabelledby]);
    return /*#__PURE__*/jsxRuntimeExports.jsx(DialogRoot, _extends({
      className: clsx(classes.root, className),
      closeAfterTransition: true,
      components: {
        Backdrop: DialogBackdrop
      },
      componentsProps: {
        backdrop: _extends({
          transitionDuration: transitionDuration,
          as: BackdropComponent
        }, BackdropProps)
      },
      disableEscapeKeyDown: disableEscapeKeyDown,
      onClose: onClose,
      open: open,
      ref: ref,
      onClick: handleBackdropClick,
      ownerState: ownerState
    }, other, {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(TransitionComponent, _extends({
        appear: true,
        "in": open,
        timeout: transitionDuration,
        role: "presentation"
      }, TransitionProps, {
        children: /*#__PURE__*/jsxRuntimeExports.jsx(DialogContainer, {
          className: clsx(classes.container),
          onMouseDown: handleMouseDown,
          ownerState: ownerState,
          children: /*#__PURE__*/jsxRuntimeExports.jsx(DialogPaper, _extends({
            as: PaperComponent,
            elevation: 24,
            role: "dialog",
            "aria-describedby": ariaDescribedby,
            "aria-labelledby": ariaLabelledby
          }, PaperProps, {
            className: clsx(classes.paper, PaperProps.className),
            ownerState: ownerState,
            children: /*#__PURE__*/jsxRuntimeExports.jsx(DialogContext$1.Provider, {
              value: dialogContextValue,
              children: children
            })
          }))
        })
      }))
    }));
  });
  Dialog.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The id(s) of the element(s) that describe the dialog.
     */
    'aria-describedby': PropTypes.string,
    /**
     * The id(s) of the element(s) that label the dialog.
     */
    'aria-labelledby': PropTypes.string,
    /**
     * A backdrop component. This prop enables custom backdrop rendering.
     * @deprecated Use `slots.backdrop` instead. While this prop currently works, it will be removed in the next major version.
     * Use the `slots.backdrop` prop to make your application ready for the next version of Material UI.
     * @default styled(Backdrop, {
     *   name: 'MuiModal',
     *   slot: 'Backdrop',
     *   overridesResolver: (props, styles) => {
     *     return styles.backdrop;
     *   },
     * })({
     *   zIndex: -1,
     * })
     */
    BackdropComponent: PropTypes.elementType,
    /**
     * @ignore
     */
    BackdropProps: PropTypes.object,
    /**
     * Dialog children, usually the included sub-components.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * If `true`, hitting escape will not fire the `onClose` callback.
     * @default false
     */
    disableEscapeKeyDown: PropTypes.bool,
    /**
     * If `true`, the dialog is full-screen.
     * @default false
     */
    fullScreen: PropTypes.bool,
    /**
     * If `true`, the dialog stretches to `maxWidth`.
     *
     * Notice that the dialog width grow is limited by the default margin.
     * @default false
     */
    fullWidth: PropTypes.bool,
    /**
     * Determine the max-width of the dialog.
     * The dialog width grows with the size of the screen.
     * Set to `false` to disable `maxWidth`.
     * @default 'sm'
     */
    maxWidth: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl', false]), PropTypes.string]),
    /**
     * Callback fired when the backdrop is clicked.
     * @deprecated Use the `onClose` prop with the `reason` argument to handle the `backdropClick` events.
     */
    onBackdropClick: PropTypes.func,
    /**
     * @ignore
     */
    onClick: PropTypes.func,
    /**
     * Callback fired when the component requests to be closed.
     *
     * @param {object} event The event source of the callback.
     * @param {string} reason Can be: `"escapeKeyDown"`, `"backdropClick"`.
     */
    onClose: PropTypes.func,
    /**
     * If `true`, the component is shown.
     */
    open: PropTypes.bool.isRequired,
    /**
     * The component used to render the body of the dialog.
     * @default Paper
     */
    PaperComponent: PropTypes.elementType,
    /**
     * Props applied to the [`Paper`](/material-ui/api/paper/) element.
     * @default {}
     */
    PaperProps: PropTypes.object,
    /**
     * Determine the container for scrolling the dialog.
     * @default 'paper'
     */
    scroll: PropTypes.oneOf(['body', 'paper']),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The component used for the transition.
     * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
     * @default Fade
     */
    TransitionComponent: PropTypes.elementType,
    /**
     * The duration for the transition, in milliseconds.
     * You may specify a single timeout for all transitions, or individually with an object.
     * @default {
     *   enter: theme.transitions.duration.enteringScreen,
     *   exit: theme.transitions.duration.leavingScreen,
     * }
     */
    transitionDuration: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
      appear: PropTypes.number,
      enter: PropTypes.number,
      exit: PropTypes.number
    })]),
    /**
     * Props applied to the transition element.
     * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
     */
    TransitionProps: PropTypes.object
  } ;
  var Dialog$1 = Dialog;

  function getDialogActionsUtilityClass(slot) {
    return generateUtilityClass('MuiDialogActions', slot);
  }
  var dialogActionsClasses = generateUtilityClasses('MuiDialogActions', ['root', 'spacing']);
  var dialogActionsClasses$1 = dialogActionsClasses;

  var useUtilityClasses$1d = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      disableSpacing = ownerState.disableSpacing;
    var slots = {
      root: ['root', !disableSpacing && 'spacing']
    };
    return composeClasses(slots, getDialogActionsUtilityClass, classes);
  };
  var DialogActionsRoot = styled$1('div', {
    name: 'MuiDialogActions',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, !ownerState.disableSpacing && styles.spacing];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends({
      display: 'flex',
      alignItems: 'center',
      padding: 8,
      justifyContent: 'flex-end',
      flex: '0 0 auto'
    }, !ownerState.disableSpacing && {
      '& > :not(style) ~ :not(style)': {
        marginLeft: 8
      }
    });
  });
  var DialogActions = /*#__PURE__*/React__namespace.forwardRef(function DialogActions(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiDialogActions'
    });
    var className = props.className,
      _props$disableSpacing = props.disableSpacing,
      disableSpacing = _props$disableSpacing === void 0 ? false : _props$disableSpacing,
      other = _objectWithoutProperties(props, ["className", "disableSpacing"]);
    var ownerState = _extends({}, props, {
      disableSpacing: disableSpacing
    });
    var classes = useUtilityClasses$1d(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(DialogActionsRoot, _extends({
      className: clsx(classes.root, className),
      ownerState: ownerState,
      ref: ref
    }, other));
  });
  DialogActions.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * If `true`, the actions do not have additional margin.
     * @default false
     */
    disableSpacing: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var DialogActions$1 = DialogActions;

  function getDialogContentUtilityClass(slot) {
    return generateUtilityClass('MuiDialogContent', slot);
  }
  var dialogContentClasses = generateUtilityClasses('MuiDialogContent', ['root', 'dividers']);
  var dialogContentClasses$1 = dialogContentClasses;

  function getDialogTitleUtilityClass(slot) {
    return generateUtilityClass('MuiDialogTitle', slot);
  }
  var dialogTitleClasses = generateUtilityClasses('MuiDialogTitle', ['root']);
  var dialogTitleClasses$1 = dialogTitleClasses;

  var useUtilityClasses$1c = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      dividers = ownerState.dividers;
    var slots = {
      root: ['root', dividers && 'dividers']
    };
    return composeClasses(slots, getDialogContentUtilityClass, classes);
  };
  var DialogContentRoot = styled$1('div', {
    name: 'MuiDialogContent',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.dividers && styles.dividers];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      flex: '1 1 auto',
      // Add iOS momentum scrolling for iOS < 13.0
      WebkitOverflowScrolling: 'touch',
      overflowY: 'auto',
      padding: '20px 24px'
    }, ownerState.dividers ? {
      padding: '16px 24px',
      borderTop: "1px solid ".concat((theme.vars || theme).palette.divider),
      borderBottom: "1px solid ".concat((theme.vars || theme).palette.divider)
    } : _defineProperty({}, ".".concat(dialogTitleClasses$1.root, " + &"), {
      paddingTop: 0
    }));
  });
  var DialogContent = /*#__PURE__*/React__namespace.forwardRef(function DialogContent(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiDialogContent'
    });
    var className = props.className,
      _props$dividers = props.dividers,
      dividers = _props$dividers === void 0 ? false : _props$dividers,
      other = _objectWithoutProperties(props, ["className", "dividers"]);
    var ownerState = _extends({}, props, {
      dividers: dividers
    });
    var classes = useUtilityClasses$1c(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(DialogContentRoot, _extends({
      className: clsx(classes.root, className),
      ownerState: ownerState,
      ref: ref
    }, other));
  });
  DialogContent.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * Display the top and bottom dividers.
     * @default false
     */
    dividers: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var DialogContent$1 = DialogContent;

  function getDialogContentTextUtilityClass(slot) {
    return generateUtilityClass('MuiDialogContentText', slot);
  }
  var dialogContentTextClasses = generateUtilityClasses('MuiDialogContentText', ['root']);
  var dialogContentTextClasses$1 = dialogContentTextClasses;

  var useUtilityClasses$1b = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    var composedClasses = composeClasses(slots, getDialogContentTextUtilityClass, classes);
    return _extends({}, classes, composedClasses);
  };
  var DialogContentTextRoot = styled$1(Typography$1, {
    shouldForwardProp: function shouldForwardProp(prop) {
      return rootShouldForwardProp$1(prop) || prop === 'classes';
    },
    name: 'MuiDialogContentText',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })({});
  var DialogContentText = /*#__PURE__*/React__namespace.forwardRef(function DialogContentText(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiDialogContentText'
    });
    props.children;
      var className = props.className,
      ownerState = _objectWithoutProperties(props, ["children", "className"]);
    var classes = useUtilityClasses$1b(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(DialogContentTextRoot, _extends({
      component: "p",
      variant: "body1",
      color: "text.secondary",
      ref: ref,
      ownerState: ownerState,
      className: clsx(classes.root, className)
    }, props, {
      classes: classes
    }));
  });
  DialogContentText.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var DialogContentText$1 = DialogContentText;

  var useUtilityClasses$1a = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    return composeClasses(slots, getDialogTitleUtilityClass, classes);
  };
  var DialogTitleRoot = styled$1(Typography$1, {
    name: 'MuiDialogTitle',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })({
    padding: '16px 24px',
    flex: '0 0 auto'
  });
  var DialogTitle = /*#__PURE__*/React__namespace.forwardRef(function DialogTitle(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiDialogTitle'
    });
    var className = props.className,
      idProp = props.id,
      other = _objectWithoutProperties(props, ["className", "id"]);
    var ownerState = props;
    var classes = useUtilityClasses$1a(ownerState);
    var _React$useContext = React__namespace.useContext(DialogContext$1),
      _React$useContext$tit = _React$useContext.titleId,
      titleId = _React$useContext$tit === void 0 ? idProp : _React$useContext$tit;
    return /*#__PURE__*/jsxRuntimeExports.jsx(DialogTitleRoot, _extends({
      component: "h2",
      className: clsx(classes.root, className),
      ownerState: ownerState,
      ref: ref,
      variant: "h6",
      id: idProp != null ? idProp : titleId
    }, other));
  });
  DialogTitle.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * @ignore
     */
    id: PropTypes.string,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var DialogTitle$1 = DialogTitle;

  function getDividerUtilityClass(slot) {
    return generateUtilityClass('MuiDivider', slot);
  }
  var dividerClasses = generateUtilityClasses('MuiDivider', ['root', 'absolute', 'fullWidth', 'inset', 'middle', 'flexItem', 'light', 'vertical', 'withChildren', 'withChildrenVertical', 'textAlignRight', 'textAlignLeft', 'wrapper', 'wrapperVertical']);
  var dividerClasses$1 = dividerClasses;

  var useUtilityClasses$19 = function useUtilityClasses(ownerState) {
    var absolute = ownerState.absolute,
      children = ownerState.children,
      classes = ownerState.classes,
      flexItem = ownerState.flexItem,
      light = ownerState.light,
      orientation = ownerState.orientation,
      textAlign = ownerState.textAlign,
      variant = ownerState.variant;
    var slots = {
      root: ['root', absolute && 'absolute', variant, light && 'light', orientation === 'vertical' && 'vertical', flexItem && 'flexItem', children && 'withChildren', children && orientation === 'vertical' && 'withChildrenVertical', textAlign === 'right' && orientation !== 'vertical' && 'textAlignRight', textAlign === 'left' && orientation !== 'vertical' && 'textAlignLeft'],
      wrapper: ['wrapper', orientation === 'vertical' && 'wrapperVertical']
    };
    return composeClasses(slots, getDividerUtilityClass, classes);
  };
  var DividerRoot = styled$1('div', {
    name: 'MuiDivider',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.absolute && styles.absolute, styles[ownerState.variant], ownerState.light && styles.light, ownerState.orientation === 'vertical' && styles.vertical, ownerState.flexItem && styles.flexItem, ownerState.children && styles.withChildren, ownerState.children && ownerState.orientation === 'vertical' && styles.withChildrenVertical, ownerState.textAlign === 'right' && ownerState.orientation !== 'vertical' && styles.textAlignRight, ownerState.textAlign === 'left' && ownerState.orientation !== 'vertical' && styles.textAlignLeft];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      margin: 0,
      // Reset browser default style.
      flexShrink: 0,
      borderWidth: 0,
      borderStyle: 'solid',
      borderColor: (theme.vars || theme).palette.divider,
      borderBottomWidth: 'thin'
    }, ownerState.absolute && {
      position: 'absolute',
      bottom: 0,
      left: 0,
      width: '100%'
    }, ownerState.light && {
      borderColor: theme.vars ? "rgba(".concat(theme.vars.palette.dividerChannel, " / 0.08)") : alpha(theme.palette.divider, 0.08)
    }, ownerState.variant === 'inset' && {
      marginLeft: 72
    }, ownerState.variant === 'middle' && ownerState.orientation === 'horizontal' && {
      marginLeft: theme.spacing(2),
      marginRight: theme.spacing(2)
    }, ownerState.variant === 'middle' && ownerState.orientation === 'vertical' && {
      marginTop: theme.spacing(1),
      marginBottom: theme.spacing(1)
    }, ownerState.orientation === 'vertical' && {
      height: '100%',
      borderBottomWidth: 0,
      borderRightWidth: 'thin'
    }, ownerState.flexItem && {
      alignSelf: 'stretch',
      height: 'auto'
    });
  }, function (_ref2) {
    var ownerState = _ref2.ownerState;
    return _extends({}, ownerState.children && {
      display: 'flex',
      whiteSpace: 'nowrap',
      textAlign: 'center',
      border: 0,
      borderTopStyle: 'solid',
      borderLeftStyle: 'solid',
      '&::before, &::after': {
        content: '""',
        alignSelf: 'center'
      }
    });
  }, function (_ref3) {
    var theme = _ref3.theme,
      ownerState = _ref3.ownerState;
    return _extends({}, ownerState.children && ownerState.orientation !== 'vertical' && {
      '&::before, &::after': {
        width: '100%',
        borderTop: "thin solid ".concat((theme.vars || theme).palette.divider),
        borderTopStyle: 'inherit'
      }
    });
  }, function (_ref4) {
    var theme = _ref4.theme,
      ownerState = _ref4.ownerState;
    return _extends({}, ownerState.children && ownerState.orientation === 'vertical' && {
      flexDirection: 'column',
      '&::before, &::after': {
        height: '100%',
        borderLeft: "thin solid ".concat((theme.vars || theme).palette.divider),
        borderLeftStyle: 'inherit'
      }
    });
  }, function (_ref5) {
    var ownerState = _ref5.ownerState;
    return _extends({}, ownerState.textAlign === 'right' && ownerState.orientation !== 'vertical' && {
      '&::before': {
        width: '90%'
      },
      '&::after': {
        width: '10%'
      }
    }, ownerState.textAlign === 'left' && ownerState.orientation !== 'vertical' && {
      '&::before': {
        width: '10%'
      },
      '&::after': {
        width: '90%'
      }
    });
  });
  var DividerWrapper = styled$1('span', {
    name: 'MuiDivider',
    slot: 'Wrapper',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.wrapper, ownerState.orientation === 'vertical' && styles.wrapperVertical];
    }
  })(function (_ref6) {
    var theme = _ref6.theme,
      ownerState = _ref6.ownerState;
    return _extends({
      display: 'inline-block',
      paddingLeft: "calc(".concat(theme.spacing(1), " * 1.2)"),
      paddingRight: "calc(".concat(theme.spacing(1), " * 1.2)")
    }, ownerState.orientation === 'vertical' && {
      paddingTop: "calc(".concat(theme.spacing(1), " * 1.2)"),
      paddingBottom: "calc(".concat(theme.spacing(1), " * 1.2)")
    });
  });
  var Divider = /*#__PURE__*/React__namespace.forwardRef(function Divider(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiDivider'
    });
    var _props$absolute = props.absolute,
      absolute = _props$absolute === void 0 ? false : _props$absolute,
      children = props.children,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? children ? 'div' : 'hr' : _props$component,
      _props$flexItem = props.flexItem,
      flexItem = _props$flexItem === void 0 ? false : _props$flexItem,
      _props$light = props.light,
      light = _props$light === void 0 ? false : _props$light,
      _props$orientation = props.orientation,
      orientation = _props$orientation === void 0 ? 'horizontal' : _props$orientation,
      _props$role = props.role,
      role = _props$role === void 0 ? component !== 'hr' ? 'separator' : undefined : _props$role,
      _props$textAlign = props.textAlign,
      textAlign = _props$textAlign === void 0 ? 'center' : _props$textAlign,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'fullWidth' : _props$variant,
      other = _objectWithoutProperties(props, ["absolute", "children", "className", "component", "flexItem", "light", "orientation", "role", "textAlign", "variant"]);
    var ownerState = _extends({}, props, {
      absolute: absolute,
      component: component,
      flexItem: flexItem,
      light: light,
      orientation: orientation,
      role: role,
      textAlign: textAlign,
      variant: variant
    });
    var classes = useUtilityClasses$19(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(DividerRoot, _extends({
      as: component,
      className: clsx(classes.root, className),
      role: role,
      ref: ref,
      ownerState: ownerState
    }, other, {
      children: children ? /*#__PURE__*/jsxRuntimeExports.jsx(DividerWrapper, {
        className: classes.wrapper,
        ownerState: ownerState,
        children: children
      }) : null
    }));
  });

  /**
   * The following flag is used to ensure that this component isn't tabbable i.e.
   * does not get highlight/focus inside of MUI List.
   */
  Divider.muiSkipListHighlight = true;
  Divider.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Absolutely position the element.
     * @default false
     */
    absolute: PropTypes.bool,
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, a vertical divider will have the correct height when used in flex container.
     * (By default, a vertical divider will have a calculated height of `0px` if it is the child of a flex container.)
     * @default false
     */
    flexItem: PropTypes.bool,
    /**
     * If `true`, the divider will have a lighter color.
     * @default false
     * @deprecated Use <Divider sx={{ opacity: 0.6 }} /> (or any opacity or color) instead. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/)
     */
    light: PropTypes.bool,
    /**
     * The component orientation.
     * @default 'horizontal'
     */
    orientation: PropTypes.oneOf(['horizontal', 'vertical']),
    /**
     * @ignore
     */
    role: PropTypes /* @typescript-to-proptypes-ignore */.string,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The text alignment.
     * @default 'center'
     */
    textAlign: PropTypes.oneOf(['center', 'left', 'right']),
    /**
     * The variant to use.
     * @default 'fullWidth'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['fullWidth', 'inset', 'middle']), PropTypes.string])
  } ;
  var Divider$1 = Divider;

  function getTranslateValue(direction, node, resolvedContainer) {
    var rect = node.getBoundingClientRect();
    var containerRect = resolvedContainer && resolvedContainer.getBoundingClientRect();
    var containerWindow = ownerWindow(node);
    var transform;
    if (node.fakeTransform) {
      transform = node.fakeTransform;
    } else {
      var computedStyle = containerWindow.getComputedStyle(node);
      transform = computedStyle.getPropertyValue('-webkit-transform') || computedStyle.getPropertyValue('transform');
    }
    var offsetX = 0;
    var offsetY = 0;
    if (transform && transform !== 'none' && typeof transform === 'string') {
      var transformValues = transform.split('(')[1].split(')')[0].split(',');
      offsetX = parseInt(transformValues[4], 10);
      offsetY = parseInt(transformValues[5], 10);
    }
    if (direction === 'left') {
      if (containerRect) {
        return "translateX(".concat(containerRect.right + offsetX - rect.left, "px)");
      }
      return "translateX(".concat(containerWindow.innerWidth + offsetX - rect.left, "px)");
    }
    if (direction === 'right') {
      if (containerRect) {
        return "translateX(-".concat(rect.right - containerRect.left - offsetX, "px)");
      }
      return "translateX(-".concat(rect.left + rect.width - offsetX, "px)");
    }
    if (direction === 'up') {
      if (containerRect) {
        return "translateY(".concat(containerRect.bottom + offsetY - rect.top, "px)");
      }
      return "translateY(".concat(containerWindow.innerHeight + offsetY - rect.top, "px)");
    }

    // direction === 'down'
    if (containerRect) {
      return "translateY(-".concat(rect.top - containerRect.top + rect.height - offsetY, "px)");
    }
    return "translateY(-".concat(rect.top + rect.height - offsetY, "px)");
  }
  function resolveContainer(containerPropProp) {
    return typeof containerPropProp === 'function' ? containerPropProp() : containerPropProp;
  }
  function setTranslateValue(direction, node, containerProp) {
    var resolvedContainer = resolveContainer(containerProp);
    var transform = getTranslateValue(direction, node, resolvedContainer);
    if (transform) {
      node.style.webkitTransform = transform;
      node.style.transform = transform;
    }
  }

  /**
   * The Slide transition is used by the [Drawer](/material-ui/react-drawer/) component.
   * It uses [react-transition-group](https://github.com/reactjs/react-transition-group) internally.
   */
  var Slide = /*#__PURE__*/React__namespace.forwardRef(function Slide(props, ref) {
    var theme = useTheme();
    var defaultEasing = {
      enter: theme.transitions.easing.easeOut,
      exit: theme.transitions.easing.sharp
    };
    var defaultTimeout = {
      enter: theme.transitions.duration.enteringScreen,
      exit: theme.transitions.duration.leavingScreen
    };
    var addEndListener = props.addEndListener,
      _props$appear = props.appear,
      appear = _props$appear === void 0 ? true : _props$appear,
      _children = props.children,
      containerProp = props.container,
      _props$direction = props.direction,
      direction = _props$direction === void 0 ? 'down' : _props$direction,
      _props$easing = props.easing,
      easingProp = _props$easing === void 0 ? defaultEasing : _props$easing,
      inProp = props["in"],
      onEnter = props.onEnter,
      onEntered = props.onEntered,
      onEntering = props.onEntering,
      onExit = props.onExit,
      onExited = props.onExited,
      onExiting = props.onExiting,
      style = props.style,
      _props$timeout = props.timeout,
      timeout = _props$timeout === void 0 ? defaultTimeout : _props$timeout,
      _props$TransitionComp = props.TransitionComponent,
      TransitionComponent = _props$TransitionComp === void 0 ? Transition$1 : _props$TransitionComp,
      other = _objectWithoutProperties(props, ["addEndListener", "appear", "children", "container", "direction", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "style", "timeout", "TransitionComponent"]);
    var childrenRef = React__namespace.useRef(null);
    var handleRef = useForkRef(getReactElementRef(_children), childrenRef, ref);
    var normalizedTransitionCallback = function normalizedTransitionCallback(callback) {
      return function (isAppearing) {
        if (callback) {
          // onEnterXxx and onExitXxx callbacks have a different arguments.length value.
          if (isAppearing === undefined) {
            callback(childrenRef.current);
          } else {
            callback(childrenRef.current, isAppearing);
          }
        }
      };
    };
    var handleEnter = normalizedTransitionCallback(function (node, isAppearing) {
      setTranslateValue(direction, node, containerProp);
      reflow(node);
      if (onEnter) {
        onEnter(node, isAppearing);
      }
    });
    var handleEntering = normalizedTransitionCallback(function (node, isAppearing) {
      var transitionProps = getTransitionProps({
        timeout: timeout,
        style: style,
        easing: easingProp
      }, {
        mode: 'enter'
      });
      node.style.webkitTransition = theme.transitions.create('-webkit-transform', _extends({}, transitionProps));
      node.style.transition = theme.transitions.create('transform', _extends({}, transitionProps));
      node.style.webkitTransform = 'none';
      node.style.transform = 'none';
      if (onEntering) {
        onEntering(node, isAppearing);
      }
    });
    var handleEntered = normalizedTransitionCallback(onEntered);
    var handleExiting = normalizedTransitionCallback(onExiting);
    var handleExit = normalizedTransitionCallback(function (node) {
      var transitionProps = getTransitionProps({
        timeout: timeout,
        style: style,
        easing: easingProp
      }, {
        mode: 'exit'
      });
      node.style.webkitTransition = theme.transitions.create('-webkit-transform', transitionProps);
      node.style.transition = theme.transitions.create('transform', transitionProps);
      setTranslateValue(direction, node, containerProp);
      if (onExit) {
        onExit(node);
      }
    });
    var handleExited = normalizedTransitionCallback(function (node) {
      // No need for transitions when the component is hidden
      node.style.webkitTransition = '';
      node.style.transition = '';
      if (onExited) {
        onExited(node);
      }
    });
    var handleAddEndListener = function handleAddEndListener(next) {
      if (addEndListener) {
        // Old call signature before `react-transition-group` implemented `nodeRef`
        addEndListener(childrenRef.current, next);
      }
    };
    var updatePosition = React__namespace.useCallback(function () {
      if (childrenRef.current) {
        setTranslateValue(direction, childrenRef.current, containerProp);
      }
    }, [direction, containerProp]);
    React__namespace.useEffect(function () {
      // Skip configuration where the position is screen size invariant.
      if (inProp || direction === 'down' || direction === 'right') {
        return undefined;
      }
      var handleResize = debounce$1(function () {
        if (childrenRef.current) {
          setTranslateValue(direction, childrenRef.current, containerProp);
        }
      });
      var containerWindow = ownerWindow(childrenRef.current);
      containerWindow.addEventListener('resize', handleResize);
      return function () {
        handleResize.clear();
        containerWindow.removeEventListener('resize', handleResize);
      };
    }, [direction, inProp, containerProp]);
    React__namespace.useEffect(function () {
      if (!inProp) {
        // We need to update the position of the drawer when the direction change and
        // when it's hidden.
        updatePosition();
      }
    }, [inProp, updatePosition]);
    return /*#__PURE__*/jsxRuntimeExports.jsx(TransitionComponent, _extends({
      nodeRef: childrenRef,
      onEnter: handleEnter,
      onEntered: handleEntered,
      onEntering: handleEntering,
      onExit: handleExit,
      onExited: handleExited,
      onExiting: handleExiting,
      addEndListener: handleAddEndListener,
      appear: appear,
      "in": inProp,
      timeout: timeout
    }, other, {
      children: function children(state, childProps) {
        return /*#__PURE__*/React__namespace.cloneElement(_children, _extends({
          ref: handleRef,
          style: _extends({
            visibility: state === 'exited' && !inProp ? 'hidden' : undefined
          }, style, _children.props.style)
        }, childProps));
      }
    }));
  });
  Slide.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Add a custom transition end trigger. Called with the transitioning DOM
     * node and a done callback. Allows for more fine grained transition end
     * logic. Note: Timeouts are still used as a fallback if provided.
     */
    addEndListener: PropTypes.func,
    /**
     * Perform the enter transition when it first mounts if `in` is also `true`.
     * Set this to `false` to disable this behavior.
     * @default true
     */
    appear: PropTypes.bool,
    /**
     * A single child content element.
     */
    children: elementAcceptingRef$1.isRequired,
    /**
     * An HTML element, or a function that returns one.
     * It's used to set the container the Slide is transitioning from.
     */
    container: chainPropTypes(PropTypes.oneOfType([HTMLElementType, PropTypes.func]), function (props) {
      if (props.open) {
        var resolvedContainer = resolveContainer(props.container);
        if (resolvedContainer && resolvedContainer.nodeType === 1) {
          var box = resolvedContainer.getBoundingClientRect();
          if (box.top === 0 && box.left === 0 && box.right === 0 && box.bottom === 0) {
            return new Error(['MUI: The `container` prop provided to the component is invalid.', 'The anchor element should be part of the document layout.', "Make sure the element is present in the document or that it's not display none."].join('\n'));
          }
        } else if (!resolvedContainer || typeof resolvedContainer.getBoundingClientRect !== 'function' || resolvedContainer.contextElement != null && resolvedContainer.contextElement.nodeType !== 1) {
          return new Error(['MUI: The `container` prop provided to the component is invalid.', 'It should be an HTML element instance.'].join('\n'));
        }
      }
      return null;
    }),
    /**
     * Direction the child node will enter from.
     * @default 'down'
     */
    direction: PropTypes.oneOf(['down', 'left', 'right', 'up']),
    /**
     * The transition timing function.
     * You may specify a single easing or a object containing enter and exit values.
     * @default {
     *   enter: theme.transitions.easing.easeOut,
     *   exit: theme.transitions.easing.sharp,
     * }
     */
    easing: PropTypes.oneOfType([PropTypes.shape({
      enter: PropTypes.string,
      exit: PropTypes.string
    }), PropTypes.string]),
    /**
     * If `true`, the component will transition in.
     */
    "in": PropTypes.bool,
    /**
     * @ignore
     */
    onEnter: PropTypes.func,
    /**
     * @ignore
     */
    onEntered: PropTypes.func,
    /**
     * @ignore
     */
    onEntering: PropTypes.func,
    /**
     * @ignore
     */
    onExit: PropTypes.func,
    /**
     * @ignore
     */
    onExited: PropTypes.func,
    /**
     * @ignore
     */
    onExiting: PropTypes.func,
    /**
     * @ignore
     */
    style: PropTypes.object,
    /**
     * The duration for the transition, in milliseconds.
     * You may specify a single timeout for all transitions, or individually with an object.
     * @default {
     *   enter: theme.transitions.duration.enteringScreen,
     *   exit: theme.transitions.duration.leavingScreen,
     * }
     */
    timeout: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
      appear: PropTypes.number,
      enter: PropTypes.number,
      exit: PropTypes.number
    })])
  } ;
  var Slide$1 = Slide;

  function getDrawerUtilityClass(slot) {
    return generateUtilityClass('MuiDrawer', slot);
  }
  var drawerClasses = generateUtilityClasses('MuiDrawer', ['root', 'docked', 'paper', 'paperAnchorLeft', 'paperAnchorRight', 'paperAnchorTop', 'paperAnchorBottom', 'paperAnchorDockedLeft', 'paperAnchorDockedRight', 'paperAnchorDockedTop', 'paperAnchorDockedBottom', 'modal']);
  var drawerClasses$1 = drawerClasses;

  var overridesResolver$5 = function overridesResolver(props, styles) {
    var ownerState = props.ownerState;
    return [styles.root, (ownerState.variant === 'permanent' || ownerState.variant === 'persistent') && styles.docked, styles.modal];
  };
  var useUtilityClasses$18 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      anchor = ownerState.anchor,
      variant = ownerState.variant;
    var slots = {
      root: ['root'],
      docked: [(variant === 'permanent' || variant === 'persistent') && 'docked'],
      modal: ['modal'],
      paper: ['paper', "paperAnchor".concat(capitalize(anchor)), variant !== 'temporary' && "paperAnchorDocked".concat(capitalize(anchor))]
    };
    return composeClasses(slots, getDrawerUtilityClass, classes);
  };
  var DrawerRoot = styled$1(Modal$1, {
    name: 'MuiDrawer',
    slot: 'Root',
    overridesResolver: overridesResolver$5
  })(function (_ref) {
    var theme = _ref.theme;
    return {
      zIndex: (theme.vars || theme).zIndex.drawer
    };
  });
  var DrawerDockedRoot = styled$1('div', {
    shouldForwardProp: rootShouldForwardProp$1,
    name: 'MuiDrawer',
    slot: 'Docked',
    skipVariantsResolver: false,
    overridesResolver: overridesResolver$5
  })({
    flex: '0 0 auto'
  });
  var DrawerPaper = styled$1(Paper$1, {
    name: 'MuiDrawer',
    slot: 'Paper',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.paper, styles["paperAnchor".concat(capitalize(ownerState.anchor))], ownerState.variant !== 'temporary' && styles["paperAnchorDocked".concat(capitalize(ownerState.anchor))]];
    }
  })(function (_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    return _extends({
      overflowY: 'auto',
      display: 'flex',
      flexDirection: 'column',
      height: '100%',
      flex: '1 0 auto',
      zIndex: (theme.vars || theme).zIndex.drawer,
      // Add iOS momentum scrolling for iOS < 13.0
      WebkitOverflowScrolling: 'touch',
      // temporary style
      position: 'fixed',
      top: 0,
      // We disable the focus ring for mouse, touch and keyboard users.
      // At some point, it would be better to keep it for keyboard users.
      // :focus-ring CSS pseudo-class will help.
      outline: 0
    }, ownerState.anchor === 'left' && {
      left: 0
    }, ownerState.anchor === 'top' && {
      top: 0,
      left: 0,
      right: 0,
      height: 'auto',
      maxHeight: '100%'
    }, ownerState.anchor === 'right' && {
      right: 0
    }, ownerState.anchor === 'bottom' && {
      top: 'auto',
      left: 0,
      bottom: 0,
      right: 0,
      height: 'auto',
      maxHeight: '100%'
    }, ownerState.anchor === 'left' && ownerState.variant !== 'temporary' && {
      borderRight: "1px solid ".concat((theme.vars || theme).palette.divider)
    }, ownerState.anchor === 'top' && ownerState.variant !== 'temporary' && {
      borderBottom: "1px solid ".concat((theme.vars || theme).palette.divider)
    }, ownerState.anchor === 'right' && ownerState.variant !== 'temporary' && {
      borderLeft: "1px solid ".concat((theme.vars || theme).palette.divider)
    }, ownerState.anchor === 'bottom' && ownerState.variant !== 'temporary' && {
      borderTop: "1px solid ".concat((theme.vars || theme).palette.divider)
    });
  });
  var oppositeDirection = {
    left: 'right',
    right: 'left',
    top: 'down',
    bottom: 'up'
  };
  function isHorizontal(anchor) {
    return ['left', 'right'].indexOf(anchor) !== -1;
  }
  function getAnchor(_ref3, anchor) {
    var direction = _ref3.direction;
    return direction === 'rtl' && isHorizontal(anchor) ? oppositeDirection[anchor] : anchor;
  }

  /**
   * The props of the [Modal](/material-ui/api/modal/) component are available
   * when `variant="temporary"` is set.
   */
  var Drawer = /*#__PURE__*/React__namespace.forwardRef(function Drawer(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiDrawer'
    });
    var theme = useTheme();
    var isRtl = useRtl();
    var defaultTransitionDuration = {
      enter: theme.transitions.duration.enteringScreen,
      exit: theme.transitions.duration.leavingScreen
    };
    var _props$anchor = props.anchor,
      anchorProp = _props$anchor === void 0 ? 'left' : _props$anchor,
      BackdropProps = props.BackdropProps,
      children = props.children,
      className = props.className,
      _props$elevation = props.elevation,
      elevation = _props$elevation === void 0 ? 16 : _props$elevation,
      _props$hideBackdrop = props.hideBackdrop,
      hideBackdrop = _props$hideBackdrop === void 0 ? false : _props$hideBackdrop,
      _props$ModalProps = props.ModalProps,
      _props$ModalProps2 = _props$ModalProps === void 0 ? {} : _props$ModalProps,
      BackdropPropsProp = _props$ModalProps2.BackdropProps,
      ModalProps = _objectWithoutProperties(_props$ModalProps2, ["BackdropProps"]),
      onClose = props.onClose,
      _props$open = props.open,
      open = _props$open === void 0 ? false : _props$open,
      _props$PaperProps = props.PaperProps,
      PaperProps = _props$PaperProps === void 0 ? {} : _props$PaperProps,
      SlideProps = props.SlideProps,
      _props$TransitionComp = props.TransitionComponent,
      TransitionComponent = _props$TransitionComp === void 0 ? Slide$1 : _props$TransitionComp,
      _props$transitionDura = props.transitionDuration,
      transitionDuration = _props$transitionDura === void 0 ? defaultTransitionDuration : _props$transitionDura,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'temporary' : _props$variant,
      other = _objectWithoutProperties(props, ["anchor", "BackdropProps", "children", "className", "elevation", "hideBackdrop", "ModalProps", "onClose", "open", "PaperProps", "SlideProps", "TransitionComponent", "transitionDuration", "variant"]); // Let's assume that the Drawer will always be rendered on user space.
    // We use this state is order to skip the appear transition during the
    // initial mount of the component.
    var mounted = React__namespace.useRef(false);
    React__namespace.useEffect(function () {
      mounted.current = true;
    }, []);
    var anchorInvariant = getAnchor({
      direction: isRtl ? 'rtl' : 'ltr'
    }, anchorProp);
    var anchor = anchorProp;
    var ownerState = _extends({}, props, {
      anchor: anchor,
      elevation: elevation,
      open: open,
      variant: variant
    }, other);
    var classes = useUtilityClasses$18(ownerState);
    var drawer = /*#__PURE__*/jsxRuntimeExports.jsx(DrawerPaper, _extends({
      elevation: variant === 'temporary' ? elevation : 0,
      square: true
    }, PaperProps, {
      className: clsx(classes.paper, PaperProps.className),
      ownerState: ownerState,
      children: children
    }));
    if (variant === 'permanent') {
      return /*#__PURE__*/jsxRuntimeExports.jsx(DrawerDockedRoot, _extends({
        className: clsx(classes.root, classes.docked, className),
        ownerState: ownerState,
        ref: ref
      }, other, {
        children: drawer
      }));
    }
    var slidingDrawer = /*#__PURE__*/jsxRuntimeExports.jsx(TransitionComponent, _extends({
      "in": open,
      direction: oppositeDirection[anchorInvariant],
      timeout: transitionDuration,
      appear: mounted.current
    }, SlideProps, {
      children: drawer
    }));
    if (variant === 'persistent') {
      return /*#__PURE__*/jsxRuntimeExports.jsx(DrawerDockedRoot, _extends({
        className: clsx(classes.root, classes.docked, className),
        ownerState: ownerState,
        ref: ref
      }, other, {
        children: slidingDrawer
      }));
    }

    // variant === temporary
    return /*#__PURE__*/jsxRuntimeExports.jsx(DrawerRoot, _extends({
      BackdropProps: _extends({}, BackdropProps, BackdropPropsProp, {
        transitionDuration: transitionDuration
      }),
      className: clsx(classes.root, classes.modal, className),
      open: open,
      ownerState: ownerState,
      onClose: onClose,
      hideBackdrop: hideBackdrop,
      ref: ref
    }, other, ModalProps, {
      children: slidingDrawer
    }));
  });
  Drawer.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Side from which the drawer will appear.
     * @default 'left'
     */
    anchor: PropTypes.oneOf(['bottom', 'left', 'right', 'top']),
    /**
     * @ignore
     */
    BackdropProps: PropTypes.object,
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The elevation of the drawer.
     * @default 16
     */
    elevation: integerPropType,
    /**
     * If `true`, the backdrop is not rendered.
     * @default false
     */
    hideBackdrop: PropTypes.bool,
    /**
     * Props applied to the [`Modal`](/material-ui/api/modal/) element.
     * @default {}
     */
    ModalProps: PropTypes.object,
    /**
     * Callback fired when the component requests to be closed.
     * The `reason` parameter can optionally be used to control the response to `onClose`.
     *
     * @param {object} event The event source of the callback.
     * @param {string} reason Can be: `"escapeKeyDown"`, `"backdropClick"`.
     */
    onClose: PropTypes.func,
    /**
     * If `true`, the component is shown.
     * @default false
     */
    open: PropTypes.bool,
    /**
     * Props applied to the [`Paper`](/material-ui/api/paper/) element.
     * @default {}
     */
    PaperProps: PropTypes.object,
    /**
     * Props applied to the [`Slide`](/material-ui/api/slide/) element.
     */
    SlideProps: PropTypes.object,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The duration for the transition, in milliseconds.
     * You may specify a single timeout for all transitions, or individually with an object.
     * @default {
     *   enter: theme.transitions.duration.enteringScreen,
     *   exit: theme.transitions.duration.leavingScreen,
     * }
     */
    transitionDuration: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
      appear: PropTypes.number,
      enter: PropTypes.number,
      exit: PropTypes.number
    })]),
    /**
     * The variant to use.
     * @default 'temporary'
     */
    variant: PropTypes.oneOf(['permanent', 'persistent', 'temporary'])
  } ;
  var Drawer$1 = Drawer;

  function getFabUtilityClass(slot) {
    return generateUtilityClass('MuiFab', slot);
  }
  var fabClasses = generateUtilityClasses('MuiFab', ['root', 'primary', 'secondary', 'extended', 'circular', 'focusVisible', 'disabled', 'colorInherit', 'sizeSmall', 'sizeMedium', 'sizeLarge', 'info', 'error', 'warning', 'success']);
  var fabClasses$1 = fabClasses;

  var useUtilityClasses$17 = function useUtilityClasses(ownerState) {
    var color = ownerState.color,
      variant = ownerState.variant,
      classes = ownerState.classes,
      size = ownerState.size;
    var slots = {
      root: ['root', variant, "size".concat(capitalize(size)), color === 'inherit' ? 'colorInherit' : color]
    };
    var composedClasses = composeClasses(slots, getFabUtilityClass, classes);
    return _extends({}, classes, composedClasses);
  };
  var FabRoot = styled$1(ButtonBase$1, {
    name: 'MuiFab',
    slot: 'Root',
    shouldForwardProp: function shouldForwardProp(prop) {
      return rootShouldForwardProp$1(prop) || prop === 'classes';
    },
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.variant], styles["size".concat(capitalize(ownerState.size))], ownerState.color === 'inherit' && styles.colorInherit, styles[capitalize(ownerState.size)], styles[ownerState.color]];
    }
  })(function (_ref) {
    var _theme$palette$getCon, _theme$palette;
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({}, theme.typography.button, _defineProperty({
      minHeight: 36,
      transition: theme.transitions.create(['background-color', 'box-shadow', 'border-color'], {
        duration: theme.transitions.duration["short"]
      }),
      borderRadius: '50%',
      padding: 0,
      minWidth: 0,
      width: 56,
      height: 56,
      zIndex: (theme.vars || theme).zIndex.fab,
      boxShadow: (theme.vars || theme).shadows[6],
      '&:active': {
        boxShadow: (theme.vars || theme).shadows[12]
      },
      color: theme.vars ? theme.vars.palette.text.primary : (_theme$palette$getCon = (_theme$palette = theme.palette).getContrastText) == null ? void 0 : _theme$palette$getCon.call(_theme$palette, theme.palette.grey[300]),
      backgroundColor: (theme.vars || theme).palette.grey[300],
      '&:hover': {
        backgroundColor: (theme.vars || theme).palette.grey.A100,
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: (theme.vars || theme).palette.grey[300]
        },
        textDecoration: 'none'
      }
    }, "&.".concat(fabClasses$1.focusVisible), {
      boxShadow: (theme.vars || theme).shadows[6]
    }), ownerState.size === 'small' && {
      width: 40,
      height: 40
    }, ownerState.size === 'medium' && {
      width: 48,
      height: 48
    }, ownerState.variant === 'extended' && {
      borderRadius: 48 / 2,
      padding: '0 16px',
      width: 'auto',
      minHeight: 'auto',
      minWidth: 48,
      height: 48
    }, ownerState.variant === 'extended' && ownerState.size === 'small' && {
      width: 'auto',
      padding: '0 8px',
      borderRadius: 34 / 2,
      minWidth: 34,
      height: 34
    }, ownerState.variant === 'extended' && ownerState.size === 'medium' && {
      width: 'auto',
      padding: '0 16px',
      borderRadius: 40 / 2,
      minWidth: 40,
      height: 40
    }, ownerState.color === 'inherit' && {
      color: 'inherit'
    });
  }, function (_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    return _extends({}, ownerState.color !== 'inherit' && ownerState.color !== 'default' && (theme.vars || theme).palette[ownerState.color] != null && {
      color: (theme.vars || theme).palette[ownerState.color].contrastText,
      backgroundColor: (theme.vars || theme).palette[ownerState.color].main,
      '&:hover': {
        backgroundColor: (theme.vars || theme).palette[ownerState.color].dark,
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: (theme.vars || theme).palette[ownerState.color].main
        }
      }
    });
  }, function (_ref3) {
    var theme = _ref3.theme;
    return _defineProperty({}, "&.".concat(fabClasses$1.disabled), {
      color: (theme.vars || theme).palette.action.disabled,
      boxShadow: (theme.vars || theme).shadows[0],
      backgroundColor: (theme.vars || theme).palette.action.disabledBackground
    });
  });
  var Fab = /*#__PURE__*/React__namespace.forwardRef(function Fab(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiFab'
    });
    var children = props.children,
      className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'default' : _props$color,
      _props$component = props.component,
      component = _props$component === void 0 ? 'button' : _props$component,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$disableFocusRi = props.disableFocusRipple,
      disableFocusRipple = _props$disableFocusRi === void 0 ? false : _props$disableFocusRi,
      focusVisibleClassName = props.focusVisibleClassName,
      _props$size = props.size,
      size = _props$size === void 0 ? 'large' : _props$size,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'circular' : _props$variant,
      other = _objectWithoutProperties(props, ["children", "className", "color", "component", "disabled", "disableFocusRipple", "focusVisibleClassName", "size", "variant"]);
    var ownerState = _extends({}, props, {
      color: color,
      component: component,
      disabled: disabled,
      disableFocusRipple: disableFocusRipple,
      size: size,
      variant: variant
    });
    var classes = useUtilityClasses$17(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(FabRoot, _extends({
      className: clsx(classes.root, className),
      component: component,
      disabled: disabled,
      focusRipple: !disableFocusRipple,
      focusVisibleClassName: clsx(classes.focusVisible, focusVisibleClassName),
      ownerState: ownerState,
      ref: ref
    }, other, {
      classes: classes,
      children: children
    }));
  });
  Fab.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'default'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['default', 'error', 'info', 'inherit', 'primary', 'secondary', 'success', 'warning']), PropTypes.string]),
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the  keyboard focus ripple is disabled.
     * @default false
     */
    disableFocusRipple: PropTypes.bool,
    /**
     * If `true`, the ripple effect is disabled.
     */
    disableRipple: PropTypes.bool,
    /**
     * @ignore
     */
    focusVisibleClassName: PropTypes.string,
    /**
     * The URL to link to when the button is clicked.
     * If defined, an `a` element will be used as the root node.
     */
    href: PropTypes.string,
    /**
     * The size of the component.
     * `small` is equivalent to the dense button styling.
     * @default 'large'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['small', 'medium', 'large']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The variant to use.
     * @default 'circular'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['circular', 'extended']), PropTypes.string])
  } ;
  var Fab$1 = Fab;

  var useUtilityClasses$16 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      disableUnderline = ownerState.disableUnderline;
    var slots = {
      root: ['root', !disableUnderline && 'underline'],
      input: ['input']
    };
    var composedClasses = composeClasses(slots, getFilledInputUtilityClass, classes);
    return _extends({}, classes, composedClasses);
  };
  var FilledInputRoot = styled$1(InputBaseRoot, {
    shouldForwardProp: function shouldForwardProp(prop) {
      return rootShouldForwardProp$1(prop) || prop === 'classes';
    },
    name: 'MuiFilledInput',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [].concat(_toConsumableArray(rootOverridesResolver(props, styles)), [!ownerState.disableUnderline && styles.underline]);
    }
  })(function (_ref) {
    var _palette;
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    var light = theme.palette.mode === 'light';
    var bottomLineColor = light ? 'rgba(0, 0, 0, 0.42)' : 'rgba(255, 255, 255, 0.7)';
    var backgroundColor = light ? 'rgba(0, 0, 0, 0.06)' : 'rgba(255, 255, 255, 0.09)';
    var hoverBackground = light ? 'rgba(0, 0, 0, 0.09)' : 'rgba(255, 255, 255, 0.13)';
    var disabledBackground = light ? 'rgba(0, 0, 0, 0.12)' : 'rgba(255, 255, 255, 0.12)';
    return _extends(_defineProperty(_defineProperty({
      position: 'relative',
      backgroundColor: theme.vars ? theme.vars.palette.FilledInput.bg : backgroundColor,
      borderTopLeftRadius: (theme.vars || theme).shape.borderRadius,
      borderTopRightRadius: (theme.vars || theme).shape.borderRadius,
      transition: theme.transitions.create('background-color', {
        duration: theme.transitions.duration.shorter,
        easing: theme.transitions.easing.easeOut
      }),
      '&:hover': {
        backgroundColor: theme.vars ? theme.vars.palette.FilledInput.hoverBg : hoverBackground,
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: theme.vars ? theme.vars.palette.FilledInput.bg : backgroundColor
        }
      }
    }, "&.".concat(filledInputClasses$1.focused), {
      backgroundColor: theme.vars ? theme.vars.palette.FilledInput.bg : backgroundColor
    }), "&.".concat(filledInputClasses$1.disabled), {
      backgroundColor: theme.vars ? theme.vars.palette.FilledInput.disabledBg : disabledBackground
    }), !ownerState.disableUnderline && _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
      '&::after': {
        borderBottom: "2px solid ".concat((_palette = (theme.vars || theme).palette[ownerState.color || 'primary']) == null ? void 0 : _palette.main),
        left: 0,
        bottom: 0,
        // Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
        content: '""',
        position: 'absolute',
        right: 0,
        transform: 'scaleX(0)',
        transition: theme.transitions.create('transform', {
          duration: theme.transitions.duration.shorter,
          easing: theme.transitions.easing.easeOut
        }),
        pointerEvents: 'none' // Transparent to the hover style.
      }
    }, "&.".concat(filledInputClasses$1.focused, ":after"), {
      // translateX(0) is a workaround for Safari transform scale bug
      // See https://github.com/mui/material-ui/issues/31766
      transform: 'scaleX(1) translateX(0)'
    }), "&.".concat(filledInputClasses$1.error), {
      '&::before, &::after': {
        borderBottomColor: (theme.vars || theme).palette.error.main
      }
    }), '&::before', {
      borderBottom: "1px solid ".concat(theme.vars ? "rgba(".concat(theme.vars.palette.common.onBackgroundChannel, " / ").concat(theme.vars.opacity.inputUnderline, ")") : bottomLineColor),
      left: 0,
      bottom: 0,
      // Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
      content: '"\\00a0"',
      position: 'absolute',
      right: 0,
      transition: theme.transitions.create('border-bottom-color', {
        duration: theme.transitions.duration.shorter
      }),
      pointerEvents: 'none' // Transparent to the hover style.
    }), "&:hover:not(.".concat(filledInputClasses$1.disabled, ", .").concat(filledInputClasses$1.error, "):before"), {
      borderBottom: "1px solid ".concat((theme.vars || theme).palette.text.primary)
    }), "&.".concat(filledInputClasses$1.disabled, ":before"), {
      borderBottomStyle: 'dotted'
    }), ownerState.startAdornment && {
      paddingLeft: 12
    }, ownerState.endAdornment && {
      paddingRight: 12
    }, ownerState.multiline && _extends({
      padding: '25px 12px 8px'
    }, ownerState.size === 'small' && {
      paddingTop: 21,
      paddingBottom: 4
    }, ownerState.hiddenLabel && {
      paddingTop: 16,
      paddingBottom: 17
    }, ownerState.hiddenLabel && ownerState.size === 'small' && {
      paddingTop: 8,
      paddingBottom: 9
    }));
  });
  var FilledInputInput = styled$1(InputBaseComponent, {
    name: 'MuiFilledInput',
    slot: 'Input',
    overridesResolver: inputOverridesResolver
  })(function (_ref3) {
    var theme = _ref3.theme,
      ownerState = _ref3.ownerState;
    return _extends({
      paddingTop: 25,
      paddingRight: 12,
      paddingBottom: 8,
      paddingLeft: 12
    }, !theme.vars && {
      '&:-webkit-autofill': {
        WebkitBoxShadow: theme.palette.mode === 'light' ? null : '0 0 0 100px #266798 inset',
        WebkitTextFillColor: theme.palette.mode === 'light' ? null : '#fff',
        caretColor: theme.palette.mode === 'light' ? null : '#fff',
        borderTopLeftRadius: 'inherit',
        borderTopRightRadius: 'inherit'
      }
    }, theme.vars && _defineProperty({
      '&:-webkit-autofill': {
        borderTopLeftRadius: 'inherit',
        borderTopRightRadius: 'inherit'
      }
    }, theme.getColorSchemeSelector('dark'), {
      '&:-webkit-autofill': {
        WebkitBoxShadow: '0 0 0 100px #266798 inset',
        WebkitTextFillColor: '#fff',
        caretColor: '#fff'
      }
    }), ownerState.size === 'small' && {
      paddingTop: 21,
      paddingBottom: 4
    }, ownerState.hiddenLabel && {
      paddingTop: 16,
      paddingBottom: 17
    }, ownerState.startAdornment && {
      paddingLeft: 0
    }, ownerState.endAdornment && {
      paddingRight: 0
    }, ownerState.hiddenLabel && ownerState.size === 'small' && {
      paddingTop: 8,
      paddingBottom: 9
    }, ownerState.multiline && {
      paddingTop: 0,
      paddingBottom: 0,
      paddingLeft: 0,
      paddingRight: 0
    });
  });
  var FilledInput = /*#__PURE__*/React__namespace.forwardRef(function FilledInput(inProps, ref) {
    var _ref5, _slots$root, _ref6, _slots$input;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiFilledInput'
    });
    props.disableUnderline;
      var _props$components = props.components,
      components = _props$components === void 0 ? {} : _props$components,
      componentsPropsProp = props.componentsProps,
      _props$fullWidth = props.fullWidth,
      fullWidth = _props$fullWidth === void 0 ? false : _props$fullWidth;
      props.hiddenLabel;
      var _props$inputComponent = props.inputComponent,
      inputComponent = _props$inputComponent === void 0 ? 'input' : _props$inputComponent,
      _props$multiline = props.multiline,
      multiline = _props$multiline === void 0 ? false : _props$multiline,
      slotProps = props.slotProps,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      _props$type = props.type,
      type = _props$type === void 0 ? 'text' : _props$type,
      other = _objectWithoutProperties(props, ["disableUnderline", "components", "componentsProps", "fullWidth", "hiddenLabel", "inputComponent", "multiline", "slotProps", "slots", "type"]);
    var ownerState = _extends({}, props, {
      fullWidth: fullWidth,
      inputComponent: inputComponent,
      multiline: multiline,
      type: type
    });
    var classes = useUtilityClasses$16(props);
    var filledInputComponentsProps = {
      root: {
        ownerState: ownerState
      },
      input: {
        ownerState: ownerState
      }
    };
    var componentsProps = (slotProps != null ? slotProps : componentsPropsProp) ? deepmerge(filledInputComponentsProps, slotProps != null ? slotProps : componentsPropsProp) : filledInputComponentsProps;
    var RootSlot = (_ref5 = (_slots$root = slots.root) != null ? _slots$root : components.Root) != null ? _ref5 : FilledInputRoot;
    var InputSlot = (_ref6 = (_slots$input = slots.input) != null ? _slots$input : components.Input) != null ? _ref6 : FilledInputInput;
    return /*#__PURE__*/jsxRuntimeExports.jsx(InputBase$1, _extends({
      slots: {
        root: RootSlot,
        input: InputSlot
      },
      componentsProps: componentsProps,
      fullWidth: fullWidth,
      inputComponent: inputComponent,
      multiline: multiline,
      ref: ref,
      type: type
    }, other, {
      classes: classes
    }));
  });
  FilledInput.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * This prop helps users to fill forms faster, especially on mobile devices.
     * The name can be confusing, as it's more like an autofill.
     * You can learn more about it [following the specification](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill).
     */
    autoComplete: PropTypes.string,
    /**
     * If `true`, the `input` element is focused during the first mount.
     */
    autoFocus: PropTypes.bool,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * The prop defaults to the value (`'primary'`) inherited from the parent FormControl component.
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['primary', 'secondary']), PropTypes.string]),
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `slots` prop.
     * It's recommended to use the `slots` prop instead.
     *
     * @default {}
     */
    components: PropTypes.shape({
      Input: PropTypes.elementType,
      Root: PropTypes.elementType
    }),
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `slotProps` prop.
     * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.
     *
     * @default {}
     */
    componentsProps: PropTypes.shape({
      input: PropTypes.object,
      root: PropTypes.object
    }),
    /**
     * The default value. Use when the component is not controlled.
     */
    defaultValue: PropTypes.any,
    /**
     * If `true`, the component is disabled.
     * The prop defaults to the value (`false`) inherited from the parent FormControl component.
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the input will not have an underline.
     */
    disableUnderline: PropTypes.bool,
    /**
     * End `InputAdornment` for this component.
     */
    endAdornment: PropTypes.node,
    /**
     * If `true`, the `input` will indicate an error.
     * The prop defaults to the value (`false`) inherited from the parent FormControl component.
     */
    error: PropTypes.bool,
    /**
     * If `true`, the `input` will take up the full width of its container.
     * @default false
     */
    fullWidth: PropTypes.bool,
    /**
     * If `true`, the label is hidden.
     * This is used to increase density for a `FilledInput`.
     * Be sure to add `aria-label` to the `input` element.
     * @default false
     */
    hiddenLabel: PropTypes.bool,
    /**
     * The id of the `input` element.
     */
    id: PropTypes.string,
    /**
     * The component used for the `input` element.
     * Either a string to use a HTML element or a component.
     * @default 'input'
     */
    inputComponent: PropTypes.elementType,
    /**
     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
     * @default {}
     */
    inputProps: PropTypes.object,
    /**
     * Pass a ref to the `input` element.
     */
    inputRef: refType$1,
    /**
     * If `dense`, will adjust vertical spacing. This is normally obtained via context from
     * FormControl.
     * The prop defaults to the value (`'none'`) inherited from the parent FormControl component.
     */
    margin: PropTypes.oneOf(['dense', 'none']),
    /**
     * Maximum number of rows to display when multiline option is set to true.
     */
    maxRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * Minimum number of rows to display when multiline option is set to true.
     */
    minRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * If `true`, a [TextareaAutosize](/material-ui/react-textarea-autosize/) element is rendered.
     * @default false
     */
    multiline: PropTypes.bool,
    /**
     * Name attribute of the `input` element.
     */
    name: PropTypes.string,
    /**
     * Callback fired when the value is changed.
     *
     * @param {React.ChangeEvent<HTMLTextAreaElement | HTMLInputElement>} event The event source of the callback.
     * You can pull out the new value by accessing `event.target.value` (string).
     */
    onChange: PropTypes.func,
    /**
     * The short hint displayed in the `input` before the user enters a value.
     */
    placeholder: PropTypes.string,
    /**
     * It prevents the user from changing the value of the field
     * (not from interacting with the field).
     */
    readOnly: PropTypes.bool,
    /**
     * If `true`, the `input` element is required.
     * The prop defaults to the value (`false`) inherited from the parent FormControl component.
     */
    required: PropTypes.bool,
    /**
     * Number of rows to display when multiline option is set to true.
     */
    rows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `componentsProps` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slotProps: PropTypes.shape({
      input: PropTypes.object,
      root: PropTypes.object
    }),
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `components` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slots: PropTypes.shape({
      input: PropTypes.elementType,
      root: PropTypes.elementType
    }),
    /**
     * Start `InputAdornment` for this component.
     */
    startAdornment: PropTypes.node,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * Type of the `input` element. It should be [a valid HTML5 input type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Form_%3Cinput%3E_types).
     * @default 'text'
     */
    type: PropTypes.string,
    /**
     * The value of the `input` element, required for a controlled component.
     */
    value: PropTypes.any
  } ;
  FilledInput.muiName = 'Input';
  var FilledInput$1 = FilledInput;

  function getFormControlUtilityClasses(slot) {
    return generateUtilityClass('MuiFormControl', slot);
  }
  var formControlClasses = generateUtilityClasses('MuiFormControl', ['root', 'marginNone', 'marginNormal', 'marginDense', 'fullWidth', 'disabled']);
  var formControlClasses$1 = formControlClasses;

  var useUtilityClasses$15 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      margin = ownerState.margin,
      fullWidth = ownerState.fullWidth;
    var slots = {
      root: ['root', margin !== 'none' && "margin".concat(capitalize(margin)), fullWidth && 'fullWidth']
    };
    return composeClasses(slots, getFormControlUtilityClasses, classes);
  };
  var FormControlRoot = styled$1('div', {
    name: 'MuiFormControl',
    slot: 'Root',
    overridesResolver: function overridesResolver(_ref, styles) {
      var ownerState = _ref.ownerState;
      return _extends({}, styles.root, styles["margin".concat(capitalize(ownerState.margin))], ownerState.fullWidth && styles.fullWidth);
    }
  })(function (_ref2) {
    var ownerState = _ref2.ownerState;
    return _extends({
      display: 'inline-flex',
      flexDirection: 'column',
      position: 'relative',
      // Reset fieldset default style.
      minWidth: 0,
      padding: 0,
      margin: 0,
      border: 0,
      verticalAlign: 'top'
    }, ownerState.margin === 'normal' && {
      marginTop: 16,
      marginBottom: 8
    }, ownerState.margin === 'dense' && {
      marginTop: 8,
      marginBottom: 4
    }, ownerState.fullWidth && {
      width: '100%'
    });
  });

  /**
   * Provides context such as filled/focused/error/required for form inputs.
   * Relying on the context provides high flexibility and ensures that the state always stays
   * consistent across the children of the `FormControl`.
   * This context is used by the following components:
   *
   *  - FormLabel
   *  - FormHelperText
   *  - Input
   *  - InputLabel
   *
   * You can find one composition example below and more going to [the demos](/material-ui/react-text-field/#components).
   *
   * ```jsx
   * <FormControl>
   *   <InputLabel htmlFor="my-input">Email address</InputLabel>
   *   <Input id="my-input" aria-describedby="my-helper-text" />
   *   <FormHelperText id="my-helper-text">We'll never share your email.</FormHelperText>
   * </FormControl>
   * ```
   *
   * ⚠️ Only one `InputBase` can be used within a FormControl because it creates visual inconsistencies.
   * For instance, only one input can be focused at the same time, the state shouldn't be shared.
   */
  var FormControl = /*#__PURE__*/React__namespace.forwardRef(function FormControl(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiFormControl'
    });
    var children = props.children,
      className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'primary' : _props$color,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$error = props.error,
      error = _props$error === void 0 ? false : _props$error,
      visuallyFocused = props.focused,
      _props$fullWidth = props.fullWidth,
      fullWidth = _props$fullWidth === void 0 ? false : _props$fullWidth,
      _props$hiddenLabel = props.hiddenLabel,
      hiddenLabel = _props$hiddenLabel === void 0 ? false : _props$hiddenLabel,
      _props$margin = props.margin,
      margin = _props$margin === void 0 ? 'none' : _props$margin,
      _props$required = props.required,
      required = _props$required === void 0 ? false : _props$required,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'outlined' : _props$variant,
      other = _objectWithoutProperties(props, ["children", "className", "color", "component", "disabled", "error", "focused", "fullWidth", "hiddenLabel", "margin", "required", "size", "variant"]);
    var ownerState = _extends({}, props, {
      color: color,
      component: component,
      disabled: disabled,
      error: error,
      fullWidth: fullWidth,
      hiddenLabel: hiddenLabel,
      margin: margin,
      required: required,
      size: size,
      variant: variant
    });
    var classes = useUtilityClasses$15(ownerState);
    var _React$useState = React__namespace.useState(function () {
        // We need to iterate through the children and find the Input in order
        // to fully support server-side rendering.
        var initialAdornedStart = false;
        if (children) {
          React__namespace.Children.forEach(children, function (child) {
            if (!isMuiElement(child, ['Input', 'Select'])) {
              return;
            }
            var input = isMuiElement(child, ['Select']) ? child.props.input : child;
            if (input && isAdornedStart(input.props)) {
              initialAdornedStart = true;
            }
          });
        }
        return initialAdornedStart;
      }),
      adornedStart = _React$useState[0],
      setAdornedStart = _React$useState[1];
    var _React$useState2 = React__namespace.useState(function () {
        // We need to iterate through the children and find the Input in order
        // to fully support server-side rendering.
        var initialFilled = false;
        if (children) {
          React__namespace.Children.forEach(children, function (child) {
            if (!isMuiElement(child, ['Input', 'Select'])) {
              return;
            }
            if (isFilled(child.props, true) || isFilled(child.props.inputProps, true)) {
              initialFilled = true;
            }
          });
        }
        return initialFilled;
      }),
      filled = _React$useState2[0],
      setFilled = _React$useState2[1];
    var _React$useState3 = React__namespace.useState(false),
      focusedState = _React$useState3[0],
      setFocused = _React$useState3[1];
    if (disabled && focusedState) {
      setFocused(false);
    }
    var focused = visuallyFocused !== undefined && !disabled ? visuallyFocused : focusedState;
    var registerEffect;
    {
      // eslint-disable-next-line react-hooks/rules-of-hooks
      var registeredInput = React__namespace.useRef(false);
      registerEffect = function registerEffect() {
        if (registeredInput.current) {
          console.error(['MUI: There are multiple `InputBase` components inside a FormControl.', 'This creates visual inconsistencies, only use one `InputBase`.'].join('\n'));
        }
        registeredInput.current = true;
        return function () {
          registeredInput.current = false;
        };
      };
    }
    var childContext = React__namespace.useMemo(function () {
      return {
        adornedStart: adornedStart,
        setAdornedStart: setAdornedStart,
        color: color,
        disabled: disabled,
        error: error,
        filled: filled,
        focused: focused,
        fullWidth: fullWidth,
        hiddenLabel: hiddenLabel,
        size: size,
        onBlur: function onBlur() {
          setFocused(false);
        },
        onEmpty: function onEmpty() {
          setFilled(false);
        },
        onFilled: function onFilled() {
          setFilled(true);
        },
        onFocus: function onFocus() {
          setFocused(true);
        },
        registerEffect: registerEffect,
        required: required,
        variant: variant
      };
    }, [adornedStart, color, disabled, error, filled, focused, fullWidth, hiddenLabel, registerEffect, required, size, variant]);
    return /*#__PURE__*/jsxRuntimeExports.jsx(FormControlContext$1.Provider, {
      value: childContext,
      children: /*#__PURE__*/jsxRuntimeExports.jsx(FormControlRoot, _extends({
        as: component,
        ownerState: ownerState,
        className: clsx(classes.root, className),
        ref: ref
      }, other, {
        children: children
      }))
    });
  });
  FormControl.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'primary'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, the label, input and helper text should be displayed in a disabled state.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the label is displayed in an error state.
     * @default false
     */
    error: PropTypes.bool,
    /**
     * If `true`, the component is displayed in focused state.
     */
    focused: PropTypes.bool,
    /**
     * If `true`, the component will take up the full width of its container.
     * @default false
     */
    fullWidth: PropTypes.bool,
    /**
     * If `true`, the label is hidden.
     * This is used to increase density for a `FilledInput`.
     * Be sure to add `aria-label` to the `input` element.
     * @default false
     */
    hiddenLabel: PropTypes.bool,
    /**
     * If `dense` or `normal`, will adjust vertical spacing of this and contained components.
     * @default 'none'
     */
    margin: PropTypes.oneOf(['dense', 'none', 'normal']),
    /**
     * If `true`, the label will indicate that the `input` is required.
     * @default false
     */
    required: PropTypes.bool,
    /**
     * The size of the component.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['medium', 'small']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The variant to use.
     * @default 'outlined'
     */
    variant: PropTypes.oneOf(['filled', 'outlined', 'standard'])
  } ;
  var FormControl$1 = FormControl;

  var Stack = createStack({
    createStyledComponent: styled$1('div', {
      name: 'MuiStack',
      slot: 'Root',
      overridesResolver: function overridesResolver(props, styles) {
        return styles.root;
      }
    }),
    useThemeProps: function useThemeProps(inProps) {
      return useDefaultProps({
        props: inProps,
        name: 'MuiStack'
      });
    }
  });
  Stack.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * Defines the `flex-direction` style property.
     * It is applied for all screen sizes.
     * @default 'column'
     */
    direction: PropTypes.oneOfType([PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row']), PropTypes.arrayOf(PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row'])), PropTypes.object]),
    /**
     * Add an element between each child.
     */
    divider: PropTypes.node,
    /**
     * Defines the space between immediate children.
     * @default 0
     */
    spacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),
    /**
     * The system prop, which allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * If `true`, the CSS flexbox `gap` is used instead of applying `margin` to children.
     *
     * While CSS `gap` removes the [known limitations](https://mui.com/joy-ui/react-stack/#limitations),
     * it is not fully supported in some browsers. We recommend checking https://caniuse.com/?search=flex%20gap before using this flag.
     *
     * To enable this flag globally, follow the [theme's default props](https://mui.com/material-ui/customization/theme-components/#default-props) configuration.
     * @default false
     */
    useFlexGap: PropTypes.bool
  } ;
  var Stack$1 = Stack;

  var stackClasses = generateUtilityClasses('MuiStack', ['root']);
  var stackClasses$1 = stackClasses;

  function getFormControlLabelUtilityClasses(slot) {
    return generateUtilityClass('MuiFormControlLabel', slot);
  }
  var formControlLabelClasses = generateUtilityClasses('MuiFormControlLabel', ['root', 'labelPlacementStart', 'labelPlacementTop', 'labelPlacementBottom', 'disabled', 'label', 'error', 'required', 'asterisk']);
  var formControlLabelClasses$1 = formControlLabelClasses;

  var useUtilityClasses$14 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      disabled = ownerState.disabled,
      labelPlacement = ownerState.labelPlacement,
      error = ownerState.error,
      required = ownerState.required;
    var slots = {
      root: ['root', disabled && 'disabled', "labelPlacement".concat(capitalize(labelPlacement)), error && 'error', required && 'required'],
      label: ['label', disabled && 'disabled'],
      asterisk: ['asterisk', error && 'error']
    };
    return composeClasses(slots, getFormControlLabelUtilityClasses, classes);
  };
  var FormControlLabelRoot = styled$1('label', {
    name: 'MuiFormControlLabel',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [_defineProperty({}, "& .".concat(formControlLabelClasses$1.label), styles.label), styles.root, styles["labelPlacement".concat(capitalize(ownerState.labelPlacement))]];
    }
  })(function (_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    return _extends(_defineProperty({
      display: 'inline-flex',
      alignItems: 'center',
      cursor: 'pointer',
      // For correct alignment with the text.
      verticalAlign: 'middle',
      WebkitTapHighlightColor: 'transparent',
      marginLeft: -11,
      marginRight: 16
    }, "&.".concat(formControlLabelClasses$1.disabled), {
      cursor: 'default'
    }), ownerState.labelPlacement === 'start' && {
      flexDirection: 'row-reverse',
      marginLeft: 16,
      // used for row presentation of radio/checkbox
      marginRight: -11
    }, ownerState.labelPlacement === 'top' && {
      flexDirection: 'column-reverse',
      marginLeft: 16
    }, ownerState.labelPlacement === 'bottom' && {
      flexDirection: 'column',
      marginLeft: 16
    }, _defineProperty({}, "& .".concat(formControlLabelClasses$1.label), _defineProperty({}, "&.".concat(formControlLabelClasses$1.disabled), {
      color: (theme.vars || theme).palette.text.disabled
    })));
  });
  var AsteriskComponent$1 = styled$1('span', {
    name: 'MuiFormControlLabel',
    slot: 'Asterisk',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.asterisk;
    }
  })(function (_ref3) {
    var theme = _ref3.theme;
    return _defineProperty({}, "&.".concat(formControlLabelClasses$1.error), {
      color: (theme.vars || theme).palette.error.main
    });
  });

  /**
   * Drop-in replacement of the `Radio`, `Switch` and `Checkbox` component.
   * Use this component if you want to display an extra label.
   */
  var FormControlLabel = /*#__PURE__*/React__namespace.forwardRef(function FormControlLabel(inProps, ref) {
    var _ref5, _slotProps$typography;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiFormControlLabel'
    });
    props.checked;
      var className = props.className,
      _props$componentsProp = props.componentsProps,
      componentsProps = _props$componentsProp === void 0 ? {} : _props$componentsProp,
      control = props.control,
      disabledProp = props.disabled,
      disableTypography = props.disableTypography;
      props.inputRef;
      var labelProp = props.label,
      _props$labelPlacement = props.labelPlacement,
      labelPlacement = _props$labelPlacement === void 0 ? 'end' : _props$labelPlacement;
      props.name;
      props.onChange;
      var requiredProp = props.required,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps;
      props.value;
      var other = _objectWithoutProperties(props, ["checked", "className", "componentsProps", "control", "disabled", "disableTypography", "inputRef", "label", "labelPlacement", "name", "onChange", "required", "slotProps", "value"]);
    var muiFormControl = useFormControl();
    var disabled = (_ref5 = disabledProp != null ? disabledProp : control.props.disabled) != null ? _ref5 : muiFormControl == null ? void 0 : muiFormControl.disabled;
    var required = requiredProp != null ? requiredProp : control.props.required;
    var controlProps = {
      disabled: disabled,
      required: required
    };
    ['checked', 'name', 'onChange', 'value', 'inputRef'].forEach(function (key) {
      if (typeof control.props[key] === 'undefined' && typeof props[key] !== 'undefined') {
        controlProps[key] = props[key];
      }
    });
    var fcs = formControlState({
      props: props,
      muiFormControl: muiFormControl,
      states: ['error']
    });
    var ownerState = _extends({}, props, {
      disabled: disabled,
      labelPlacement: labelPlacement,
      required: required,
      error: fcs.error
    });
    var classes = useUtilityClasses$14(ownerState);
    var typographySlotProps = (_slotProps$typography = slotProps.typography) != null ? _slotProps$typography : componentsProps.typography;
    var label = labelProp;
    if (label != null && label.type !== Typography$1 && !disableTypography) {
      label = /*#__PURE__*/jsxRuntimeExports.jsx(Typography$1, _extends({
        component: "span"
      }, typographySlotProps, {
        className: clsx(classes.label, typographySlotProps == null ? void 0 : typographySlotProps.className),
        children: label
      }));
    }
    return /*#__PURE__*/jsxRuntimeExports.jsxs(FormControlLabelRoot, _extends({
      className: clsx(classes.root, className),
      ownerState: ownerState,
      ref: ref
    }, other, {
      children: [/*#__PURE__*/React__namespace.cloneElement(control, controlProps), required ? /*#__PURE__*/jsxRuntimeExports.jsxs(Stack$1, {
        display: "block",
        children: [label, /*#__PURE__*/jsxRuntimeExports.jsxs(AsteriskComponent$1, {
          ownerState: ownerState,
          "aria-hidden": true,
          className: classes.asterisk,
          children: ["\u2009", '*']
        })]
      }) : label]
    }));
  });
  FormControlLabel.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * If `true`, the component appears selected.
     */
    checked: PropTypes.bool,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The props used for each slot inside.
     * @default {}
     */
    componentsProps: PropTypes.shape({
      typography: PropTypes.object
    }),
    /**
     * A control element. For instance, it can be a `Radio`, a `Switch` or a `Checkbox`.
     */
    control: PropTypes.element.isRequired,
    /**
     * If `true`, the control is disabled.
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the label is rendered as it is passed without an additional typography node.
     */
    disableTypography: PropTypes.bool,
    /**
     * Pass a ref to the `input` element.
     */
    inputRef: refType$1,
    /**
     * A text or an element to be used in an enclosing label element.
     */
    label: PropTypes.node,
    /**
     * The position of the label.
     * @default 'end'
     */
    labelPlacement: PropTypes.oneOf(['bottom', 'end', 'start', 'top']),
    /**
     * @ignore
     */
    name: PropTypes.string,
    /**
     * Callback fired when the state is changed.
     *
     * @param {React.SyntheticEvent} event The event source of the callback.
     * You can pull out the new checked state by accessing `event.target.checked` (boolean).
     */
    onChange: PropTypes.func,
    /**
     * If `true`, the label will indicate that the `input` is required.
     */
    required: PropTypes.bool,
    /**
     * The props used for each slot inside.
     * @default {}
     */
    slotProps: PropTypes.shape({
      typography: PropTypes.object
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The value of the component.
     */
    value: PropTypes.any
  } ;
  var FormControlLabel$1 = FormControlLabel;

  function getFormGroupUtilityClass(slot) {
    return generateUtilityClass('MuiFormGroup', slot);
  }
  var formGroupClasses = generateUtilityClasses('MuiFormGroup', ['root', 'row', 'error']);
  var formGroupClasses$1 = formGroupClasses;

  var useUtilityClasses$13 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      row = ownerState.row,
      error = ownerState.error;
    var slots = {
      root: ['root', row && 'row', error && 'error']
    };
    return composeClasses(slots, getFormGroupUtilityClass, classes);
  };
  var FormGroupRoot = styled$1('div', {
    name: 'MuiFormGroup',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.row && styles.row];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends({
      display: 'flex',
      flexDirection: 'column',
      flexWrap: 'wrap'
    }, ownerState.row && {
      flexDirection: 'row'
    });
  });

  /**
   * `FormGroup` wraps controls such as `Checkbox` and `Switch`.
   * It provides compact row layout.
   * For the `Radio`, you should be using the `RadioGroup` component instead of this one.
   */
  var FormGroup = /*#__PURE__*/React__namespace.forwardRef(function FormGroup(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiFormGroup'
    });
    var className = props.className,
      _props$row = props.row,
      row = _props$row === void 0 ? false : _props$row,
      other = _objectWithoutProperties(props, ["className", "row"]);
    var muiFormControl = useFormControl();
    var fcs = formControlState({
      props: props,
      muiFormControl: muiFormControl,
      states: ['error']
    });
    var ownerState = _extends({}, props, {
      row: row,
      error: fcs.error
    });
    var classes = useUtilityClasses$13(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(FormGroupRoot, _extends({
      className: clsx(classes.root, className),
      ownerState: ownerState,
      ref: ref
    }, other));
  });
  FormGroup.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * Display group of elements in a compact row.
     * @default false
     */
    row: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var FormGroup$1 = FormGroup;

  function getFormHelperTextUtilityClasses(slot) {
    return generateUtilityClass('MuiFormHelperText', slot);
  }
  var formHelperTextClasses = generateUtilityClasses('MuiFormHelperText', ['root', 'error', 'disabled', 'sizeSmall', 'sizeMedium', 'contained', 'focused', 'filled', 'required']);
  var formHelperTextClasses$1 = formHelperTextClasses;

  var _span$3;
  var useUtilityClasses$12 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      contained = ownerState.contained,
      size = ownerState.size,
      disabled = ownerState.disabled,
      error = ownerState.error,
      filled = ownerState.filled,
      focused = ownerState.focused,
      required = ownerState.required;
    var slots = {
      root: ['root', disabled && 'disabled', error && 'error', size && "size".concat(capitalize(size)), contained && 'contained', focused && 'focused', filled && 'filled', required && 'required']
    };
    return composeClasses(slots, getFormHelperTextUtilityClasses, classes);
  };
  var FormHelperTextRoot = styled$1('p', {
    name: 'MuiFormHelperText',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.size && styles["size".concat(capitalize(ownerState.size))], ownerState.contained && styles.contained, ownerState.filled && styles.filled];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      color: (theme.vars || theme).palette.text.secondary
    }, theme.typography.caption, _defineProperty(_defineProperty({
      textAlign: 'left',
      marginTop: 3,
      marginRight: 0,
      marginBottom: 0,
      marginLeft: 0
    }, "&.".concat(formHelperTextClasses$1.disabled), {
      color: (theme.vars || theme).palette.text.disabled
    }), "&.".concat(formHelperTextClasses$1.error), {
      color: (theme.vars || theme).palette.error.main
    }), ownerState.size === 'small' && {
      marginTop: 4
    }, ownerState.contained && {
      marginLeft: 14,
      marginRight: 14
    });
  });
  var FormHelperText = /*#__PURE__*/React__namespace.forwardRef(function FormHelperText(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiFormHelperText'
    });
    var children = props.children,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'p' : _props$component;
      props.disabled;
      props.error;
      props.filled;
      props.focused;
      props.margin;
      props.required;
      props.variant;
      var other = _objectWithoutProperties(props, ["children", "className", "component", "disabled", "error", "filled", "focused", "margin", "required", "variant"]);
    var muiFormControl = useFormControl();
    var fcs = formControlState({
      props: props,
      muiFormControl: muiFormControl,
      states: ['variant', 'size', 'disabled', 'error', 'filled', 'focused', 'required']
    });
    var ownerState = _extends({}, props, {
      component: component,
      contained: fcs.variant === 'filled' || fcs.variant === 'outlined',
      variant: fcs.variant,
      size: fcs.size,
      disabled: fcs.disabled,
      error: fcs.error,
      filled: fcs.filled,
      focused: fcs.focused,
      required: fcs.required
    });
    var classes = useUtilityClasses$12(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(FormHelperTextRoot, _extends({
      as: component,
      ownerState: ownerState,
      className: clsx(classes.root, className),
      ref: ref
    }, other, {
      children: children === ' ' ? // notranslate needed while Google Translate will not fix zero-width space issue
      _span$3 || (_span$3 = /*#__PURE__*/jsxRuntimeExports.jsx("span", {
        className: "notranslate",
        children: "\u200B"
      })) : children
    }));
  });
  FormHelperText.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     *
     * If `' '` is provided, the component reserves one line height for displaying a future message.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, the helper text should be displayed in a disabled state.
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, helper text should be displayed in an error state.
     */
    error: PropTypes.bool,
    /**
     * If `true`, the helper text should use filled classes key.
     */
    filled: PropTypes.bool,
    /**
     * If `true`, the helper text should use focused classes key.
     */
    focused: PropTypes.bool,
    /**
     * If `dense`, will adjust vertical spacing. This is normally obtained via context from
     * FormControl.
     */
    margin: PropTypes.oneOf(['dense']),
    /**
     * If `true`, the helper text should use required classes key.
     */
    required: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The variant to use.
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['filled', 'outlined', 'standard']), PropTypes.string])
  } ;
  var FormHelperText$1 = FormHelperText;

  function getFormLabelUtilityClasses(slot) {
    return generateUtilityClass('MuiFormLabel', slot);
  }
  var formLabelClasses = generateUtilityClasses('MuiFormLabel', ['root', 'colorSecondary', 'focused', 'disabled', 'error', 'filled', 'required', 'asterisk']);
  var formLabelClasses$1 = formLabelClasses;

  var useUtilityClasses$11 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      color = ownerState.color,
      focused = ownerState.focused,
      disabled = ownerState.disabled,
      error = ownerState.error,
      filled = ownerState.filled,
      required = ownerState.required;
    var slots = {
      root: ['root', "color".concat(capitalize(color)), disabled && 'disabled', error && 'error', filled && 'filled', focused && 'focused', required && 'required'],
      asterisk: ['asterisk', error && 'error']
    };
    return composeClasses(slots, getFormLabelUtilityClasses, classes);
  };
  var FormLabelRoot = styled$1('label', {
    name: 'MuiFormLabel',
    slot: 'Root',
    overridesResolver: function overridesResolver(_ref, styles) {
      var ownerState = _ref.ownerState;
      return _extends({}, styles.root, ownerState.color === 'secondary' && styles.colorSecondary, ownerState.filled && styles.filled);
    }
  })(function (_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    return _extends({
      color: (theme.vars || theme).palette.text.secondary
    }, theme.typography.body1, _defineProperty(_defineProperty(_defineProperty({
      lineHeight: '1.4375em',
      padding: 0,
      position: 'relative'
    }, "&.".concat(formLabelClasses$1.focused), {
      color: (theme.vars || theme).palette[ownerState.color].main
    }), "&.".concat(formLabelClasses$1.disabled), {
      color: (theme.vars || theme).palette.text.disabled
    }), "&.".concat(formLabelClasses$1.error), {
      color: (theme.vars || theme).palette.error.main
    }));
  });
  var AsteriskComponent = styled$1('span', {
    name: 'MuiFormLabel',
    slot: 'Asterisk',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.asterisk;
    }
  })(function (_ref3) {
    var theme = _ref3.theme;
    return _defineProperty({}, "&.".concat(formLabelClasses$1.error), {
      color: (theme.vars || theme).palette.error.main
    });
  });
  var FormLabel = /*#__PURE__*/React__namespace.forwardRef(function FormLabel(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiFormLabel'
    });
    var children = props.children,
      className = props.className;
      props.color;
      var _props$component = props.component,
      component = _props$component === void 0 ? 'label' : _props$component;
      props.disabled;
      props.error;
      props.filled;
      props.focused;
      props.required;
      var other = _objectWithoutProperties(props, ["children", "className", "color", "component", "disabled", "error", "filled", "focused", "required"]);
    var muiFormControl = useFormControl();
    var fcs = formControlState({
      props: props,
      muiFormControl: muiFormControl,
      states: ['color', 'required', 'focused', 'disabled', 'error', 'filled']
    });
    var ownerState = _extends({}, props, {
      color: fcs.color || 'primary',
      component: component,
      disabled: fcs.disabled,
      error: fcs.error,
      filled: fcs.filled,
      focused: fcs.focused,
      required: fcs.required
    });
    var classes = useUtilityClasses$11(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(FormLabelRoot, _extends({
      as: component,
      ownerState: ownerState,
      className: clsx(classes.root, className),
      ref: ref
    }, other, {
      children: [children, fcs.required && /*#__PURE__*/jsxRuntimeExports.jsxs(AsteriskComponent, {
        ownerState: ownerState,
        "aria-hidden": true,
        className: classes.asterisk,
        children: ["\u2009", '*']
      })]
    }));
  });
  FormLabel.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['error', 'info', 'primary', 'secondary', 'success', 'warning']), PropTypes.string]),
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, the label should be displayed in a disabled state.
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the label is displayed in an error state.
     */
    error: PropTypes.bool,
    /**
     * If `true`, the label should use filled classes key.
     */
    filled: PropTypes.bool,
    /**
     * If `true`, the input of this label is focused (used by `FormGroup` components).
     */
    focused: PropTypes.bool,
    /**
     * If `true`, the label will indicate that the `input` is required.
     */
    required: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var FormLabel$1 = FormLabel;

  /**
   * @ignore - internal component.
   */
  var GridContext = /*#__PURE__*/React__namespace.createContext();
  {
    GridContext.displayName = 'GridContext';
  }
  var GridContext$1 = GridContext;

  function getGridUtilityClass(slot) {
    return generateUtilityClass('MuiGrid', slot);
  }
  var SPACINGS$1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  var DIRECTIONS$1 = ['column-reverse', 'column', 'row-reverse', 'row'];
  var WRAPS$1 = ['nowrap', 'wrap-reverse', 'wrap'];
  var GRID_SIZES$1 = ['auto', true, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
  var gridClasses = generateUtilityClasses('MuiGrid', ['root', 'container', 'item', 'zeroMinWidth'].concat(_toConsumableArray(SPACINGS$1.map(function (spacing) {
    return "spacing-xs-".concat(spacing);
  })), _toConsumableArray(DIRECTIONS$1.map(function (direction) {
    return "direction-xs-".concat(direction);
  })), _toConsumableArray(WRAPS$1.map(function (wrap) {
    return "wrap-xs-".concat(wrap);
  })), _toConsumableArray(GRID_SIZES$1.map(function (size) {
    return "grid-xs-".concat(size);
  })), _toConsumableArray(GRID_SIZES$1.map(function (size) {
    return "grid-sm-".concat(size);
  })), _toConsumableArray(GRID_SIZES$1.map(function (size) {
    return "grid-md-".concat(size);
  })), _toConsumableArray(GRID_SIZES$1.map(function (size) {
    return "grid-lg-".concat(size);
  })), _toConsumableArray(GRID_SIZES$1.map(function (size) {
    return "grid-xl-".concat(size);
  }))));
  var gridClasses$1 = gridClasses;

  function getOffset(val) {
    var parse = parseFloat(val);
    return "".concat(parse).concat(String(val).replace(String(parse), '') || 'px');
  }
  function generateGrid(_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    var size;
    return theme.breakpoints.keys.reduce(function (globalStyles, breakpoint) {
      // Use side effect over immutability for better performance.
      var styles = {};
      if (ownerState[breakpoint]) {
        size = ownerState[breakpoint];
      }
      if (!size) {
        return globalStyles;
      }
      if (size === true) {
        // For the auto layouting
        styles = {
          flexBasis: 0,
          flexGrow: 1,
          maxWidth: '100%'
        };
      } else if (size === 'auto') {
        styles = {
          flexBasis: 'auto',
          flexGrow: 0,
          flexShrink: 0,
          maxWidth: 'none',
          width: 'auto'
        };
      } else {
        var columnsBreakpointValues = resolveBreakpointValues({
          values: ownerState.columns,
          breakpoints: theme.breakpoints.values
        });
        var columnValue = _typeof(columnsBreakpointValues) === 'object' ? columnsBreakpointValues[breakpoint] : columnsBreakpointValues;
        if (columnValue === undefined || columnValue === null) {
          return globalStyles;
        }
        // Keep 7 significant numbers.
        var width = "".concat(Math.round(size / columnValue * 10e7) / 10e5, "%");
        var more = {};
        if (ownerState.container && ownerState.item && ownerState.columnSpacing !== 0) {
          var themeSpacing = theme.spacing(ownerState.columnSpacing);
          if (themeSpacing !== '0px') {
            var fullWidth = "calc(".concat(width, " + ").concat(getOffset(themeSpacing), ")");
            more = {
              flexBasis: fullWidth,
              maxWidth: fullWidth
            };
          }
        }

        // Close to the bootstrap implementation:
        // https://github.com/twbs/bootstrap/blob/8fccaa2439e97ec72a4b7dc42ccc1f649790adb0/scss/mixins/_grid.scss#L41
        styles = _extends({
          flexBasis: width,
          flexGrow: 0,
          maxWidth: width
        }, more);
      }

      // No need for a media query for the first size.
      if (theme.breakpoints.values[breakpoint] === 0) {
        Object.assign(globalStyles, styles);
      } else {
        globalStyles[theme.breakpoints.up(breakpoint)] = styles;
      }
      return globalStyles;
    }, {});
  }
  function generateDirection(_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    var directionValues = resolveBreakpointValues({
      values: ownerState.direction,
      breakpoints: theme.breakpoints.values
    });
    return handleBreakpoints({
      theme: theme
    }, directionValues, function (propValue) {
      var output = {
        flexDirection: propValue
      };
      if (propValue.indexOf('column') === 0) {
        output["& > .".concat(gridClasses$1.item)] = {
          maxWidth: 'none'
        };
      }
      return output;
    });
  }

  /**
   * Extracts zero value breakpoint keys before a non-zero value breakpoint key.
   * @example { xs: 0, sm: 0, md: 2, lg: 0, xl: 0 } or [0, 0, 2, 0, 0]
   * @returns [xs, sm]
   */
  function extractZeroValueBreakpointKeys(_ref3) {
    var breakpoints = _ref3.breakpoints,
      values = _ref3.values;
    var nonZeroKey = '';
    Object.keys(values).forEach(function (key) {
      if (nonZeroKey !== '') {
        return;
      }
      if (values[key] !== 0) {
        nonZeroKey = key;
      }
    });
    var sortedBreakpointKeysByValue = Object.keys(breakpoints).sort(function (a, b) {
      return breakpoints[a] - breakpoints[b];
    });
    return sortedBreakpointKeysByValue.slice(0, sortedBreakpointKeysByValue.indexOf(nonZeroKey));
  }
  function generateRowGap(_ref4) {
    var theme = _ref4.theme,
      ownerState = _ref4.ownerState;
    var container = ownerState.container,
      rowSpacing = ownerState.rowSpacing;
    var styles = {};
    if (container && rowSpacing !== 0) {
      var rowSpacingValues = resolveBreakpointValues({
        values: rowSpacing,
        breakpoints: theme.breakpoints.values
      });
      var zeroValueBreakpointKeys;
      if (_typeof(rowSpacingValues) === 'object') {
        zeroValueBreakpointKeys = extractZeroValueBreakpointKeys({
          breakpoints: theme.breakpoints.values,
          values: rowSpacingValues
        });
      }
      styles = handleBreakpoints({
        theme: theme
      }, rowSpacingValues, function (propValue, breakpoint) {
        var _zeroValueBreakpointK;
        var themeSpacing = theme.spacing(propValue);
        if (themeSpacing !== '0px') {
          return _defineProperty({
            marginTop: "-".concat(getOffset(themeSpacing))
          }, "& > .".concat(gridClasses$1.item), {
            paddingTop: getOffset(themeSpacing)
          });
        }
        if ((_zeroValueBreakpointK = zeroValueBreakpointKeys) != null && _zeroValueBreakpointK.includes(breakpoint)) {
          return {};
        }
        return _defineProperty({
          marginTop: 0
        }, "& > .".concat(gridClasses$1.item), {
          paddingTop: 0
        });
      });
    }
    return styles;
  }
  function generateColumnGap(_ref7) {
    var theme = _ref7.theme,
      ownerState = _ref7.ownerState;
    var container = ownerState.container,
      columnSpacing = ownerState.columnSpacing;
    var styles = {};
    if (container && columnSpacing !== 0) {
      var columnSpacingValues = resolveBreakpointValues({
        values: columnSpacing,
        breakpoints: theme.breakpoints.values
      });
      var zeroValueBreakpointKeys;
      if (_typeof(columnSpacingValues) === 'object') {
        zeroValueBreakpointKeys = extractZeroValueBreakpointKeys({
          breakpoints: theme.breakpoints.values,
          values: columnSpacingValues
        });
      }
      styles = handleBreakpoints({
        theme: theme
      }, columnSpacingValues, function (propValue, breakpoint) {
        var _zeroValueBreakpointK2;
        var themeSpacing = theme.spacing(propValue);
        if (themeSpacing !== '0px') {
          return _defineProperty({
            width: "calc(100% + ".concat(getOffset(themeSpacing), ")"),
            marginLeft: "-".concat(getOffset(themeSpacing))
          }, "& > .".concat(gridClasses$1.item), {
            paddingLeft: getOffset(themeSpacing)
          });
        }
        if ((_zeroValueBreakpointK2 = zeroValueBreakpointKeys) != null && _zeroValueBreakpointK2.includes(breakpoint)) {
          return {};
        }
        return _defineProperty({
          width: '100%',
          marginLeft: 0
        }, "& > .".concat(gridClasses$1.item), {
          paddingLeft: 0
        });
      });
    }
    return styles;
  }
  function resolveSpacingStyles(spacing, breakpoints) {
    var styles = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
    // undefined/null or `spacing` <= 0
    if (!spacing || spacing <= 0) {
      return [];
    }
    // in case of string/number `spacing`
    if (typeof spacing === 'string' && !Number.isNaN(Number(spacing)) || typeof spacing === 'number') {
      return [styles["spacing-xs-".concat(String(spacing))]];
    }
    // in case of object `spacing`
    var spacingStyles = [];
    breakpoints.forEach(function (breakpoint) {
      var value = spacing[breakpoint];
      if (Number(value) > 0) {
        spacingStyles.push(styles["spacing-".concat(breakpoint, "-").concat(String(value))]);
      }
    });
    return spacingStyles;
  }

  // Default CSS values
  // flex: '0 1 auto',
  // flexDirection: 'row',
  // alignItems: 'flex-start',
  // flexWrap: 'nowrap',
  // justifyContent: 'flex-start',
  var GridRoot = styled$1('div', {
    name: 'MuiGrid',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      var container = ownerState.container,
        direction = ownerState.direction,
        item = ownerState.item,
        spacing = ownerState.spacing,
        wrap = ownerState.wrap,
        zeroMinWidth = ownerState.zeroMinWidth,
        breakpoints = ownerState.breakpoints;
      var spacingStyles = [];

      // in case of grid item
      if (container) {
        spacingStyles = resolveSpacingStyles(spacing, breakpoints, styles);
      }
      var breakpointsStyles = [];
      breakpoints.forEach(function (breakpoint) {
        var value = ownerState[breakpoint];
        if (value) {
          breakpointsStyles.push(styles["grid-".concat(breakpoint, "-").concat(String(value))]);
        }
      });
      return [styles.root, container && styles.container, item && styles.item, zeroMinWidth && styles.zeroMinWidth].concat(_toConsumableArray(spacingStyles), [direction !== 'row' && styles["direction-xs-".concat(String(direction))], wrap !== 'wrap' && styles["wrap-xs-".concat(String(wrap))]], breakpointsStyles);
    }
  })(function (_ref10) {
    var ownerState = _ref10.ownerState;
    return _extends({
      boxSizing: 'border-box'
    }, ownerState.container && {
      display: 'flex',
      flexWrap: 'wrap',
      width: '100%'
    }, ownerState.item && {
      margin: 0 // For instance, it's useful when used with a `figure` element.
    }, ownerState.zeroMinWidth && {
      minWidth: 0
    }, ownerState.wrap !== 'wrap' && {
      flexWrap: ownerState.wrap
    });
  }, generateDirection, generateRowGap, generateColumnGap, generateGrid);
  function resolveSpacingClasses(spacing, breakpoints) {
    // undefined/null or `spacing` <= 0
    if (!spacing || spacing <= 0) {
      return [];
    }
    // in case of string/number `spacing`
    if (typeof spacing === 'string' && !Number.isNaN(Number(spacing)) || typeof spacing === 'number') {
      return ["spacing-xs-".concat(String(spacing))];
    }
    // in case of object `spacing`
    var classes = [];
    breakpoints.forEach(function (breakpoint) {
      var value = spacing[breakpoint];
      if (Number(value) > 0) {
        var className = "spacing-".concat(breakpoint, "-").concat(String(value));
        classes.push(className);
      }
    });
    return classes;
  }
  var useUtilityClasses$10 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      container = ownerState.container,
      direction = ownerState.direction,
      item = ownerState.item,
      spacing = ownerState.spacing,
      wrap = ownerState.wrap,
      zeroMinWidth = ownerState.zeroMinWidth,
      breakpoints = ownerState.breakpoints;
    var spacingClasses = [];

    // in case of grid item
    if (container) {
      spacingClasses = resolveSpacingClasses(spacing, breakpoints);
    }
    var breakpointsClasses = [];
    breakpoints.forEach(function (breakpoint) {
      var value = ownerState[breakpoint];
      if (value) {
        breakpointsClasses.push("grid-".concat(breakpoint, "-").concat(String(value)));
      }
    });
    var slots = {
      root: ['root', container && 'container', item && 'item', zeroMinWidth && 'zeroMinWidth'].concat(_toConsumableArray(spacingClasses), [direction !== 'row' && "direction-xs-".concat(String(direction)), wrap !== 'wrap' && "wrap-xs-".concat(String(wrap))], breakpointsClasses)
    };
    return composeClasses(slots, getGridUtilityClass, classes);
  };
  var Grid = /*#__PURE__*/React__namespace.forwardRef(function Grid(inProps, ref) {
    var themeProps = useDefaultProps({
      props: inProps,
      name: 'MuiGrid'
    });
    var _useTheme = useTheme(),
      breakpoints = _useTheme.breakpoints;
    var props = extendSxProp(themeProps);
    var className = props.className,
      columnsProp = props.columns,
      columnSpacingProp = props.columnSpacing,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      _props$container = props.container,
      container = _props$container === void 0 ? false : _props$container,
      _props$direction = props.direction,
      direction = _props$direction === void 0 ? 'row' : _props$direction,
      _props$item = props.item,
      item = _props$item === void 0 ? false : _props$item,
      rowSpacingProp = props.rowSpacing,
      _props$spacing = props.spacing,
      spacing = _props$spacing === void 0 ? 0 : _props$spacing,
      _props$wrap = props.wrap,
      wrap = _props$wrap === void 0 ? 'wrap' : _props$wrap,
      _props$zeroMinWidth = props.zeroMinWidth,
      zeroMinWidth = _props$zeroMinWidth === void 0 ? false : _props$zeroMinWidth,
      other = _objectWithoutProperties(props, ["className", "columns", "columnSpacing", "component", "container", "direction", "item", "rowSpacing", "spacing", "wrap", "zeroMinWidth"]);
    var rowSpacing = rowSpacingProp || spacing;
    var columnSpacing = columnSpacingProp || spacing;
    var columnsContext = React__namespace.useContext(GridContext$1);

    // columns set with default breakpoint unit of 12
    var columns = container ? columnsProp || 12 : columnsContext;
    var breakpointsValues = {};
    var otherFiltered = _extends({}, other);
    breakpoints.keys.forEach(function (breakpoint) {
      if (other[breakpoint] != null) {
        breakpointsValues[breakpoint] = other[breakpoint];
        delete otherFiltered[breakpoint];
      }
    });
    var ownerState = _extends({}, props, {
      columns: columns,
      container: container,
      direction: direction,
      item: item,
      rowSpacing: rowSpacing,
      columnSpacing: columnSpacing,
      wrap: wrap,
      zeroMinWidth: zeroMinWidth,
      spacing: spacing
    }, breakpointsValues, {
      breakpoints: breakpoints.keys
    });
    var classes = useUtilityClasses$10(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(GridContext$1.Provider, {
      value: columns,
      children: /*#__PURE__*/jsxRuntimeExports.jsx(GridRoot, _extends({
        ownerState: ownerState,
        className: clsx(classes.root, className),
        as: component,
        ref: ref
      }, otherFiltered))
    });
  });
  Grid.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The number of columns.
     * @default 12
     */
    columns: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.number), PropTypes.number, PropTypes.object]),
    /**
     * Defines the horizontal space between the type `item` components.
     * It overrides the value of the `spacing` prop.
     */
    columnSpacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, the component will have the flex *container* behavior.
     * You should be wrapping *items* with a *container*.
     * @default false
     */
    container: PropTypes.bool,
    /**
     * Defines the `flex-direction` style property.
     * It is applied for all screen sizes.
     * @default 'row'
     */
    direction: PropTypes.oneOfType([PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row']), PropTypes.arrayOf(PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row'])), PropTypes.object]),
    /**
     * If `true`, the component will have the flex *item* behavior.
     * You should be wrapping *items* with a *container*.
     * @default false
     */
    item: PropTypes.bool,
    /**
     * If a number, it sets the number of columns the grid item uses.
     * It can't be greater than the total number of columns of the container (12 by default).
     * If 'auto', the grid item's width matches its content.
     * If false, the prop is ignored.
     * If true, the grid item's width grows to use the space available in the grid container.
     * The value is applied for the `lg` breakpoint and wider screens if not overridden.
     * @default false
     */
    lg: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
    /**
     * If a number, it sets the number of columns the grid item uses.
     * It can't be greater than the total number of columns of the container (12 by default).
     * If 'auto', the grid item's width matches its content.
     * If false, the prop is ignored.
     * If true, the grid item's width grows to use the space available in the grid container.
     * The value is applied for the `md` breakpoint and wider screens if not overridden.
     * @default false
     */
    md: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
    /**
     * Defines the vertical space between the type `item` components.
     * It overrides the value of the `spacing` prop.
     */
    rowSpacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),
    /**
     * If a number, it sets the number of columns the grid item uses.
     * It can't be greater than the total number of columns of the container (12 by default).
     * If 'auto', the grid item's width matches its content.
     * If false, the prop is ignored.
     * If true, the grid item's width grows to use the space available in the grid container.
     * The value is applied for the `sm` breakpoint and wider screens if not overridden.
     * @default false
     */
    sm: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
    /**
     * Defines the space between the type `item` components.
     * It can only be used on a type `container` component.
     * @default 0
     */
    spacing: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * Defines the `flex-wrap` style property.
     * It's applied for all screen sizes.
     * @default 'wrap'
     */
    wrap: PropTypes.oneOf(['nowrap', 'wrap-reverse', 'wrap']),
    /**
     * If a number, it sets the number of columns the grid item uses.
     * It can't be greater than the total number of columns of the container (12 by default).
     * If 'auto', the grid item's width matches its content.
     * If false, the prop is ignored.
     * If true, the grid item's width grows to use the space available in the grid container.
     * The value is applied for the `xl` breakpoint and wider screens if not overridden.
     * @default false
     */
    xl: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
    /**
     * If a number, it sets the number of columns the grid item uses.
     * It can't be greater than the total number of columns of the container (12 by default).
     * If 'auto', the grid item's width matches its content.
     * If false, the prop is ignored.
     * If true, the grid item's width grows to use the space available in the grid container.
     * The value is applied for all the screen sizes with the lowest priority.
     * @default false
     */
    xs: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.bool]),
    /**
     * If `true`, it sets `min-width: 0` on the item.
     * Refer to the limitations section of the documentation to better understand the use case.
     * @default false
     */
    zeroMinWidth: PropTypes.bool
  } ;
  {
    var requireProp = requirePropFactory('Grid', Grid);
    // eslint-disable-next-line no-useless-concat
    Grid['propTypes' + ''] = _extends({}, Grid.propTypes, {
      direction: requireProp('container'),
      lg: requireProp('item'),
      md: requireProp('item'),
      sm: requireProp('item'),
      spacing: requireProp('container'),
      wrap: requireProp('container'),
      xs: requireProp('item'),
      zeroMinWidth: requireProp('item')
    });
  }
  var Grid$1 = Grid;

  var Grid2 = createGrid({
    createStyledComponent: styled$1('div', {
      name: 'MuiGrid2',
      slot: 'Root',
      overridesResolver: function overridesResolver(props, styles) {
        return styles.root;
      }
    }),
    componentName: 'MuiGrid2',
    useThemeProps: function useThemeProps(inProps) {
      return useDefaultProps({
        props: inProps,
        name: 'MuiGrid2'
      });
    }
  });
  Grid2.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * @ignore
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var Grid2$1 = Grid2;

  function getGrid2UtilityClass(slot) {
    return generateUtilityClass('MuiGrid2', slot);
  }
  var SPACINGS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  var DIRECTIONS = ['column-reverse', 'column', 'row-reverse', 'row'];
  var WRAPS = ['nowrap', 'wrap-reverse', 'wrap'];
  var GRID_SIZES = ['auto', true, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
  var grid2Classes = generateUtilityClasses('MuiGrid2', ['root', 'container', 'item', 'zeroMinWidth'].concat(_toConsumableArray(SPACINGS.map(function (spacing) {
    return "spacing-xs-".concat(spacing);
  })), _toConsumableArray(DIRECTIONS.map(function (direction) {
    return "direction-xs-".concat(direction);
  })), _toConsumableArray(WRAPS.map(function (wrap) {
    return "wrap-xs-".concat(wrap);
  })), _toConsumableArray(GRID_SIZES.map(function (size) {
    return "grid-xs-".concat(size);
  })), _toConsumableArray(GRID_SIZES.map(function (size) {
    return "grid-sm-".concat(size);
  })), _toConsumableArray(GRID_SIZES.map(function (size) {
    return "grid-md-".concat(size);
  })), _toConsumableArray(GRID_SIZES.map(function (size) {
    return "grid-lg-".concat(size);
  })), _toConsumableArray(GRID_SIZES.map(function (size) {
    return "grid-xl-".concat(size);
  }))));
  var grid2Classes$1 = grid2Classes;

  function getScale(value) {
    return "scale(".concat(value, ", ").concat(Math.pow(value, 2), ")");
  }
  var styles$2 = {
    entering: {
      opacity: 1,
      transform: getScale(1)
    },
    entered: {
      opacity: 1,
      transform: 'none'
    }
  };

  /*
   TODO v6: remove
   Conditionally apply a workaround for the CSS transition bug in Safari 15.4 / WebKit browsers.
   */
  var isWebKit154 = typeof navigator !== 'undefined' && /^((?!chrome|android).)*(safari|mobile)/i.test(navigator.userAgent) && /(os |version\/)15(.|_)4/i.test(navigator.userAgent);

  /**
   * The Grow transition is used by the [Tooltip](/material-ui/react-tooltip/) and
   * [Popover](/material-ui/react-popover/) components.
   * It uses [react-transition-group](https://github.com/reactjs/react-transition-group) internally.
   */
  var Grow = /*#__PURE__*/React__namespace.forwardRef(function Grow(props, ref) {
    var addEndListener = props.addEndListener,
      _props$appear = props.appear,
      appear = _props$appear === void 0 ? true : _props$appear,
      _children = props.children,
      easing = props.easing,
      inProp = props["in"],
      onEnter = props.onEnter,
      onEntered = props.onEntered,
      onEntering = props.onEntering,
      onExit = props.onExit,
      onExited = props.onExited,
      onExiting = props.onExiting,
      style = props.style,
      _props$timeout = props.timeout,
      timeout = _props$timeout === void 0 ? 'auto' : _props$timeout,
      _props$TransitionComp = props.TransitionComponent,
      TransitionComponent = _props$TransitionComp === void 0 ? Transition$1 : _props$TransitionComp,
      other = _objectWithoutProperties(props, ["addEndListener", "appear", "children", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "style", "timeout", "TransitionComponent"]);
    var timer = useTimeout();
    var autoTimeout = React__namespace.useRef();
    var theme = useTheme();
    var nodeRef = React__namespace.useRef(null);
    var handleRef = useForkRef(nodeRef, getReactElementRef(_children), ref);
    var normalizedTransitionCallback = function normalizedTransitionCallback(callback) {
      return function (maybeIsAppearing) {
        if (callback) {
          var node = nodeRef.current;

          // onEnterXxx and onExitXxx callbacks have a different arguments.length value.
          if (maybeIsAppearing === undefined) {
            callback(node);
          } else {
            callback(node, maybeIsAppearing);
          }
        }
      };
    };
    var handleEntering = normalizedTransitionCallback(onEntering);
    var handleEnter = normalizedTransitionCallback(function (node, isAppearing) {
      reflow(node); // So the animation always start from the start.
      var _getTransitionProps = getTransitionProps({
          style: style,
          timeout: timeout,
          easing: easing
        }, {
          mode: 'enter'
        }),
        transitionDuration = _getTransitionProps.duration,
        delay = _getTransitionProps.delay,
        transitionTimingFunction = _getTransitionProps.easing;
      var duration;
      if (timeout === 'auto') {
        duration = theme.transitions.getAutoHeightDuration(node.clientHeight);
        autoTimeout.current = duration;
      } else {
        duration = transitionDuration;
      }
      node.style.transition = [theme.transitions.create('opacity', {
        duration: duration,
        delay: delay
      }), theme.transitions.create('transform', {
        duration: isWebKit154 ? duration : duration * 0.666,
        delay: delay,
        easing: transitionTimingFunction
      })].join(',');
      if (onEnter) {
        onEnter(node, isAppearing);
      }
    });
    var handleEntered = normalizedTransitionCallback(onEntered);
    var handleExiting = normalizedTransitionCallback(onExiting);
    var handleExit = normalizedTransitionCallback(function (node) {
      var _getTransitionProps2 = getTransitionProps({
          style: style,
          timeout: timeout,
          easing: easing
        }, {
          mode: 'exit'
        }),
        transitionDuration = _getTransitionProps2.duration,
        delay = _getTransitionProps2.delay,
        transitionTimingFunction = _getTransitionProps2.easing;
      var duration;
      if (timeout === 'auto') {
        duration = theme.transitions.getAutoHeightDuration(node.clientHeight);
        autoTimeout.current = duration;
      } else {
        duration = transitionDuration;
      }
      node.style.transition = [theme.transitions.create('opacity', {
        duration: duration,
        delay: delay
      }), theme.transitions.create('transform', {
        duration: isWebKit154 ? duration : duration * 0.666,
        delay: isWebKit154 ? delay : delay || duration * 0.333,
        easing: transitionTimingFunction
      })].join(',');
      node.style.opacity = 0;
      node.style.transform = getScale(0.75);
      if (onExit) {
        onExit(node);
      }
    });
    var handleExited = normalizedTransitionCallback(onExited);
    var handleAddEndListener = function handleAddEndListener(next) {
      if (timeout === 'auto') {
        timer.start(autoTimeout.current || 0, next);
      }
      if (addEndListener) {
        // Old call signature before `react-transition-group` implemented `nodeRef`
        addEndListener(nodeRef.current, next);
      }
    };
    return /*#__PURE__*/jsxRuntimeExports.jsx(TransitionComponent, _extends({
      appear: appear,
      "in": inProp,
      nodeRef: nodeRef,
      onEnter: handleEnter,
      onEntered: handleEntered,
      onEntering: handleEntering,
      onExit: handleExit,
      onExited: handleExited,
      onExiting: handleExiting,
      addEndListener: handleAddEndListener,
      timeout: timeout === 'auto' ? null : timeout
    }, other, {
      children: function children(state, childProps) {
        return /*#__PURE__*/React__namespace.cloneElement(_children, _extends({
          style: _extends({
            opacity: 0,
            transform: getScale(0.75),
            visibility: state === 'exited' && !inProp ? 'hidden' : undefined
          }, styles$2[state], style, _children.props.style),
          ref: handleRef
        }, childProps));
      }
    }));
  });
  Grow.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Add a custom transition end trigger. Called with the transitioning DOM
     * node and a done callback. Allows for more fine grained transition end
     * logic. Note: Timeouts are still used as a fallback if provided.
     */
    addEndListener: PropTypes.func,
    /**
     * Perform the enter transition when it first mounts if `in` is also `true`.
     * Set this to `false` to disable this behavior.
     * @default true
     */
    appear: PropTypes.bool,
    /**
     * A single child content element.
     */
    children: elementAcceptingRef$1.isRequired,
    /**
     * The transition timing function.
     * You may specify a single easing or a object containing enter and exit values.
     */
    easing: PropTypes.oneOfType([PropTypes.shape({
      enter: PropTypes.string,
      exit: PropTypes.string
    }), PropTypes.string]),
    /**
     * If `true`, the component will transition in.
     */
    "in": PropTypes.bool,
    /**
     * @ignore
     */
    onEnter: PropTypes.func,
    /**
     * @ignore
     */
    onEntered: PropTypes.func,
    /**
     * @ignore
     */
    onEntering: PropTypes.func,
    /**
     * @ignore
     */
    onExit: PropTypes.func,
    /**
     * @ignore
     */
    onExited: PropTypes.func,
    /**
     * @ignore
     */
    onExiting: PropTypes.func,
    /**
     * @ignore
     */
    style: PropTypes.object,
    /**
     * The duration for the transition, in milliseconds.
     * You may specify a single timeout for all transitions, or individually with an object.
     *
     * Set to 'auto' to automatically calculate transition time based on height.
     * @default 'auto'
     */
    timeout: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.shape({
      appear: PropTypes.number,
      enter: PropTypes.number,
      exit: PropTypes.number
    })])
  } ;
  Grow.muiSupportAuto = true;
  var Grow$1 = Grow;

  var breakpointKeys = ['xs', 'sm', 'md', 'lg', 'xl'];

  // By default, returns true if screen width is the same or greater than the given breakpoint.
  var isWidthUp = function isWidthUp(breakpoint, width) {
    var inclusive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
    if (inclusive) {
      return breakpointKeys.indexOf(breakpoint) <= breakpointKeys.indexOf(width);
    }
    return breakpointKeys.indexOf(breakpoint) < breakpointKeys.indexOf(width);
  };

  // By default, returns true if screen width is less than the given breakpoint.
  var isWidthDown = function isWidthDown(breakpoint, width) {
    var inclusive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
    if (inclusive) {
      return breakpointKeys.indexOf(width) <= breakpointKeys.indexOf(breakpoint);
    }
    return breakpointKeys.indexOf(width) < breakpointKeys.indexOf(breakpoint);
  };
  var withWidth = function withWidth() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    return function (Component) {
      var _options$withTheme = options.withTheme,
        withThemeOption = _options$withTheme === void 0 ? false : _options$withTheme,
        _options$noSSR = options.noSSR,
        noSSR = _options$noSSR === void 0 ? false : _options$noSSR,
        initialWidthOption = options.initialWidth;
      function WithWidth(props) {
        var contextTheme = useTheme();
        var theme = props.theme || contextTheme;
        var _getThemeProps = getThemeProps$1({
            theme: theme,
            name: 'MuiWithWidth',
            props: props
          }),
          initialWidth = _getThemeProps.initialWidth,
          width = _getThemeProps.width,
          other = _objectWithoutProperties(_getThemeProps, ["initialWidth", "width"]);
        var _React$useState = React__namespace.useState(false),
          mountedState = _React$useState[0],
          setMountedState = _React$useState[1];
        useEnhancedEffect$1(function () {
          setMountedState(true);
        }, []);

        /**
         * innerWidth |xs      sm      md      lg      xl
         *            |-------|-------|-------|-------|------>
         * width      |  xs   |  sm   |  md   |  lg   |  xl
         */
        var keys = theme.breakpoints.keys.slice().reverse();
        var widthComputed = keys.reduce(function (output, key) {
          // eslint-disable-next-line react-hooks/rules-of-hooks
          var matches = useMediaQuery(theme.breakpoints.up(key));
          return !output && matches ? key : output;
        }, null);
        var more = _extends({
          width: width || (mountedState || noSSR ? widthComputed : undefined) || initialWidth || initialWidthOption
        }, withThemeOption ? {
          theme: theme
        } : {}, other);

        // When rendering the component on the server,
        // we have no idea about the client browser screen width.
        // In order to prevent blinks and help the reconciliation of the React tree
        // we are not rendering the child component.
        //
        // An alternative is to use the `initialWidth` property.
        if (more.width === undefined) {
          return null;
        }
        return /*#__PURE__*/jsxRuntimeExports.jsx(Component, _extends({}, more));
      }
      WithWidth.propTypes = {
        /**
         * As `window.innerWidth` is unavailable on the server,
         * we default to rendering an empty component during the first mount.
         * You might want to use a heuristic to approximate
         * the screen width of the client browser screen width.
         *
         * For instance, you could be using the user-agent or the client-hints.
         * https://caniuse.com/#search=client%20hint
         */
        initialWidth: PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl']),
        /**
         * @ignore
         */
        theme: PropTypes.object,
        /**
         * Bypass the width calculation logic.
         */
        width: PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl'])
      } ;
      {
        WithWidth.displayName = "WithWidth(".concat(getDisplayName(Component), ")");
      }
      return WithWidth;
    };
  };
  var withWidth$1 = withWidth;

  function HiddenJs(props) {
    var children = props.children,
      only = props.only,
      width = props.width;
    var theme = useTheme();
    var visible = true;

    // `only` check is faster to get out sooner if used.
    if (only) {
      if (Array.isArray(only)) {
        for (var i = 0; i < only.length; i += 1) {
          var breakpoint = only[i];
          if (width === breakpoint) {
            visible = false;
            break;
          }
        }
      } else if (only && width === only) {
        visible = false;
      }
    }

    // Allow `only` to be combined with other props. If already hidden, no need to check others.
    if (visible) {
      // determine visibility based on the smallest size up
      for (var _i = 0; _i < theme.breakpoints.keys.length; _i += 1) {
        var _breakpoint = theme.breakpoints.keys[_i];
        var breakpointUp = props["".concat(_breakpoint, "Up")];
        var breakpointDown = props["".concat(_breakpoint, "Down")];
        if (breakpointUp && isWidthUp(_breakpoint, width) || breakpointDown && isWidthDown(_breakpoint, width)) {
          visible = false;
          break;
        }
      }
    }
    if (!visible) {
      return null;
    }
    return /*#__PURE__*/jsxRuntimeExports.jsx(React__namespace.Fragment, {
      children: children
    });
  }
  HiddenJs.propTypes = {
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * If `true`, screens this size and down are hidden.
     */
    // eslint-disable-next-line react/no-unused-prop-types
    lgDown: PropTypes.bool,
    /**
     * If `true`, screens this size and up are hidden.
     */
    // eslint-disable-next-line react/no-unused-prop-types
    lgUp: PropTypes.bool,
    /**
     * If `true`, screens this size and down are hidden.
     */
    // eslint-disable-next-line react/no-unused-prop-types
    mdDown: PropTypes.bool,
    /**
     * If `true`, screens this size and up are hidden.
     */
    // eslint-disable-next-line react/no-unused-prop-types
    mdUp: PropTypes.bool,
    /**
     * Hide the given breakpoint(s).
     */
    only: PropTypes.oneOfType([PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl']), PropTypes.arrayOf(PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl']))]),
    /**
     * If `true`, screens this size and down are hidden.
     */
    // eslint-disable-next-line react/no-unused-prop-types
    smDown: PropTypes.bool,
    /**
     * If `true`, screens this size and up are hidden.
     */
    // eslint-disable-next-line react/no-unused-prop-types
    smUp: PropTypes.bool,
    /**
     * @ignore
     * width prop provided by withWidth decorator.
     */
    width: PropTypes.string.isRequired,
    /**
     * If `true`, screens this size and down are hidden.
     */
    // eslint-disable-next-line react/no-unused-prop-types
    xlDown: PropTypes.bool,
    /**
     * If `true`, screens this size and up are hidden.
     */
    // eslint-disable-next-line react/no-unused-prop-types
    xlUp: PropTypes.bool,
    /**
     * If `true`, screens this size and down are hidden.
     */
    // eslint-disable-next-line react/no-unused-prop-types
    xsDown: PropTypes.bool,
    /**
     * If `true`, screens this size and up are hidden.
     */
    // eslint-disable-next-line react/no-unused-prop-types
    xsUp: PropTypes.bool
  } ;
  {
    HiddenJs.propTypes = exactProp(HiddenJs.propTypes) ;
  }
  var HiddenJs$1 = withWidth$1()(HiddenJs);

  function getHiddenCssUtilityClass(slot) {
    return generateUtilityClass('PrivateHiddenCss', slot);
  }
  generateUtilityClasses('PrivateHiddenCss', ['root', 'xlDown', 'xlUp', 'onlyXl', 'lgDown', 'lgUp', 'onlyLg', 'mdDown', 'mdUp', 'onlyMd', 'smDown', 'smUp', 'onlySm', 'xsDown', 'xsUp', 'onlyXs']);

  var useUtilityClasses$$ = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      breakpoints = ownerState.breakpoints;
    var slots = {
      root: ['root'].concat(_toConsumableArray(breakpoints.map(function (_ref) {
        var breakpoint = _ref.breakpoint,
          dir = _ref.dir;
        return dir === 'only' ? "".concat(dir).concat(capitalize(breakpoint)) : "".concat(breakpoint).concat(capitalize(dir));
      })))
    };
    return composeClasses(slots, getHiddenCssUtilityClass, classes);
  };
  var HiddenCssRoot = styled$1('div', {
    name: 'PrivateHiddenCss',
    slot: 'Root'
  })(function (_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    var hidden = {
      display: 'none'
    };
    return _extends({}, ownerState.breakpoints.map(function (_ref3) {
      var breakpoint = _ref3.breakpoint,
        dir = _ref3.dir;
      if (dir === 'only') {
        return _defineProperty({}, theme.breakpoints.only(breakpoint), hidden);
      }
      return dir === 'up' ? _defineProperty({}, theme.breakpoints.up(breakpoint), hidden) : _defineProperty({}, theme.breakpoints.down(breakpoint), hidden);
    }).reduce(function (r, o) {
      Object.keys(o).forEach(function (k) {
        r[k] = o[k];
      });
      return r;
    }, {}));
  });

  /**
   * @ignore - internal component.
   */
  function HiddenCss(props) {
    var children = props.children,
      className = props.className,
      only = props.only,
      other = _objectWithoutProperties(props, ["children", "className", "only"]);
    var theme = useTheme();
    {
      var unknownProps = Object.keys(other).filter(function (propName) {
        var isUndeclaredBreakpoint = !theme.breakpoints.keys.some(function (breakpoint) {
          return "".concat(breakpoint, "Up") === propName || "".concat(breakpoint, "Down") === propName;
        });
        return !['classes', 'theme', 'isRtl', 'sx'].includes(propName) && isUndeclaredBreakpoint;
      });
      if (unknownProps.length > 0) {
        console.error("MUI: Unsupported props received by `<Hidden implementation=\"css\" />`: ".concat(unknownProps.join(', '), ". Did you forget to wrap this component in a ThemeProvider declaring these breakpoints?"));
      }
    }
    var breakpoints = [];
    for (var i = 0; i < theme.breakpoints.keys.length; i += 1) {
      var breakpoint = theme.breakpoints.keys[i];
      var breakpointUp = other["".concat(breakpoint, "Up")];
      var breakpointDown = other["".concat(breakpoint, "Down")];
      if (breakpointUp) {
        breakpoints.push({
          breakpoint: breakpoint,
          dir: 'up'
        });
      }
      if (breakpointDown) {
        breakpoints.push({
          breakpoint: breakpoint,
          dir: 'down'
        });
      }
    }
    if (only) {
      var onlyBreakpoints = Array.isArray(only) ? only : [only];
      onlyBreakpoints.forEach(function (breakpoint) {
        breakpoints.push({
          breakpoint: breakpoint,
          dir: 'only'
        });
      });
    }
    var ownerState = _extends({}, props, {
      breakpoints: breakpoints
    });
    var classes = useUtilityClasses$$(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(HiddenCssRoot, {
      className: clsx(classes.root, className),
      ownerState: ownerState,
      children: children
    });
  }
  HiddenCss.propTypes = {
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * Specify which implementation to use.  'js' is the default, 'css' works better for
     * server-side rendering.
     */
    implementation: PropTypes.oneOf(['js', 'css']),
    /**
     * If `true`, screens this size and down are hidden.
     */
    lgDown: PropTypes.bool,
    /**
     * If `true`, screens this size and up are hidden.
     */
    lgUp: PropTypes.bool,
    /**
     * If `true`, screens this size and down are hidden.
     */
    mdDown: PropTypes.bool,
    /**
     * If `true`, screens this size and up are hidden.
     */
    mdUp: PropTypes.bool,
    /**
     * Hide the given breakpoint(s).
     */
    only: PropTypes.oneOfType([PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl']), PropTypes.arrayOf(PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl']))]),
    /**
     * If `true`, screens this size and down are hidden.
     */
    smDown: PropTypes.bool,
    /**
     * If `true`, screens this size and up are hidden.
     */
    smUp: PropTypes.bool,
    /**
     * If `true`, screens this size and down are hidden.
     */
    xlDown: PropTypes.bool,
    /**
     * If `true`, screens this size and up are hidden.
     */
    xlUp: PropTypes.bool,
    /**
     * If `true`, screens this size and down are hidden.
     */
    xsDown: PropTypes.bool,
    /**
     * If `true`, screens this size and up are hidden.
     */
    xsUp: PropTypes.bool
  } ;

  function Hidden(props) {
    var _props$implementation = props.implementation,
      implementation = _props$implementation === void 0 ? 'js' : _props$implementation,
      _props$lgDown = props.lgDown,
      lgDown = _props$lgDown === void 0 ? false : _props$lgDown,
      _props$lgUp = props.lgUp,
      lgUp = _props$lgUp === void 0 ? false : _props$lgUp,
      _props$mdDown = props.mdDown,
      mdDown = _props$mdDown === void 0 ? false : _props$mdDown,
      _props$mdUp = props.mdUp,
      mdUp = _props$mdUp === void 0 ? false : _props$mdUp,
      _props$smDown = props.smDown,
      smDown = _props$smDown === void 0 ? false : _props$smDown,
      _props$smUp = props.smUp,
      smUp = _props$smUp === void 0 ? false : _props$smUp,
      _props$xlDown = props.xlDown,
      xlDown = _props$xlDown === void 0 ? false : _props$xlDown,
      _props$xlUp = props.xlUp,
      xlUp = _props$xlUp === void 0 ? false : _props$xlUp,
      _props$xsDown = props.xsDown,
      xsDown = _props$xsDown === void 0 ? false : _props$xsDown,
      _props$xsUp = props.xsUp,
      xsUp = _props$xsUp === void 0 ? false : _props$xsUp,
      other = _objectWithoutProperties(props, ["implementation", "lgDown", "lgUp", "mdDown", "mdUp", "smDown", "smUp", "xlDown", "xlUp", "xsDown", "xsUp"]);
    if (implementation === 'js') {
      return /*#__PURE__*/jsxRuntimeExports.jsx(HiddenJs$1, _extends({
        lgDown: lgDown,
        lgUp: lgUp,
        mdDown: mdDown,
        mdUp: mdUp,
        smDown: smDown,
        smUp: smUp,
        xlDown: xlDown,
        xlUp: xlUp,
        xsDown: xsDown,
        xsUp: xsUp
      }, other));
    }
    return /*#__PURE__*/jsxRuntimeExports.jsx(HiddenCss, _extends({
      lgDown: lgDown,
      lgUp: lgUp,
      mdDown: mdDown,
      mdUp: mdUp,
      smDown: smDown,
      smUp: smUp,
      xlDown: xlDown,
      xlUp: xlUp,
      xsDown: xsDown,
      xsUp: xsUp
    }, other));
  }
  Hidden.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Specify which implementation to use.  'js' is the default, 'css' works better for
     * server-side rendering.
     * @default 'js'
     */
    implementation: PropTypes.oneOf(['css', 'js']),
    /**
     * You can use this prop when choosing the `js` implementation with server-side rendering.
     *
     * As `window.innerWidth` is unavailable on the server,
     * we default to rendering an empty component during the first mount.
     * You might want to use a heuristic to approximate
     * the screen width of the client browser screen width.
     *
     * For instance, you could be using the user-agent or the client-hints.
     * https://caniuse.com/#search=client%20hint
     */
    initialWidth: PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl']),
    /**
     * If `true`, component is hidden on screens below (but not including) this size.
     * @default false
     */
    lgDown: PropTypes.bool,
    /**
     * If `true`, component is hidden on screens this size and above.
     * @default false
     */
    lgUp: PropTypes.bool,
    /**
     * If `true`, component is hidden on screens below (but not including) this size.
     * @default false
     */
    mdDown: PropTypes.bool,
    /**
     * If `true`, component is hidden on screens this size and above.
     * @default false
     */
    mdUp: PropTypes.bool,
    /**
     * Hide the given breakpoint(s).
     */
    only: PropTypes.oneOfType([PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl']), PropTypes.arrayOf(PropTypes.oneOf(['xs', 'sm', 'md', 'lg', 'xl']).isRequired)]),
    /**
     * If `true`, component is hidden on screens below (but not including) this size.
     * @default false
     */
    smDown: PropTypes.bool,
    /**
     * If `true`, component is hidden on screens this size and above.
     * @default false
     */
    smUp: PropTypes.bool,
    /**
     * If `true`, component is hidden on screens below (but not including) this size.
     * @default false
     */
    xlDown: PropTypes.bool,
    /**
     * If `true`, component is hidden on screens this size and above.
     * @default false
     */
    xlUp: PropTypes.bool,
    /**
     * If `true`, component is hidden on screens below (but not including) this size.
     * @default false
     */
    xsDown: PropTypes.bool,
    /**
     * If `true`, component is hidden on screens this size and above.
     * @default false
     */
    xsUp: PropTypes.bool
  } ;

  function getIconUtilityClass(slot) {
    return generateUtilityClass('MuiIcon', slot);
  }
  var iconClasses = generateUtilityClasses('MuiIcon', ['root', 'colorPrimary', 'colorSecondary', 'colorAction', 'colorError', 'colorDisabled', 'fontSizeInherit', 'fontSizeSmall', 'fontSizeMedium', 'fontSizeLarge']);
  var iconClasses$1 = iconClasses;

  var useUtilityClasses$_ = function useUtilityClasses(ownerState) {
    var color = ownerState.color,
      fontSize = ownerState.fontSize,
      classes = ownerState.classes;
    var slots = {
      root: ['root', color !== 'inherit' && "color".concat(capitalize(color)), "fontSize".concat(capitalize(fontSize))]
    };
    return composeClasses(slots, getIconUtilityClass, classes);
  };
  var IconRoot = styled$1('span', {
    name: 'MuiIcon',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.color !== 'inherit' && styles["color".concat(capitalize(ownerState.color))], styles["fontSize".concat(capitalize(ownerState.fontSize))]];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return {
      userSelect: 'none',
      width: '1em',
      height: '1em',
      // Chrome fix for https://bugs.chromium.org/p/chromium/issues/detail?id=820541
      // To remove at some point.
      overflow: 'hidden',
      display: 'inline-block',
      // allow overflow hidden to take action
      textAlign: 'center',
      // support non-square icon
      flexShrink: 0,
      fontSize: {
        inherit: 'inherit',
        small: theme.typography.pxToRem(20),
        medium: theme.typography.pxToRem(24),
        large: theme.typography.pxToRem(36)
      }[ownerState.fontSize],
      // TODO v5 deprecate, v6 remove for sx
      color: {
        primary: (theme.vars || theme).palette.primary.main,
        secondary: (theme.vars || theme).palette.secondary.main,
        info: (theme.vars || theme).palette.info.main,
        success: (theme.vars || theme).palette.success.main,
        warning: (theme.vars || theme).palette.warning.main,
        action: (theme.vars || theme).palette.action.active,
        error: (theme.vars || theme).palette.error.main,
        disabled: (theme.vars || theme).palette.action.disabled,
        inherit: undefined
      }[ownerState.color]
    };
  });
  var Icon = /*#__PURE__*/React__namespace.forwardRef(function Icon(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiIcon'
    });
    var _props$baseClassName = props.baseClassName,
      baseClassName = _props$baseClassName === void 0 ? 'material-icons' : _props$baseClassName,
      className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'inherit' : _props$color,
      _props$component = props.component,
      Component = _props$component === void 0 ? 'span' : _props$component,
      _props$fontSize = props.fontSize,
      fontSize = _props$fontSize === void 0 ? 'medium' : _props$fontSize,
      other = _objectWithoutProperties(props, ["baseClassName", "className", "color", "component", "fontSize"]);
    var ownerState = _extends({}, props, {
      baseClassName: baseClassName,
      color: color,
      component: Component,
      fontSize: fontSize
    });
    var classes = useUtilityClasses$_(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(IconRoot, _extends({
      as: Component,
      className: clsx(baseClassName,
      // Prevent the translation of the text content.
      // The font relies on the exact text content to render the icon.
      'notranslate', classes.root, className),
      ownerState: ownerState,
      "aria-hidden": true,
      ref: ref
    }, other));
  });
  Icon.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The base class applied to the icon. Defaults to 'material-icons', but can be changed to any
     * other base class that suits the icon font you're using (for example material-icons-rounded, fas, etc).
     * @default 'material-icons'
     */
    baseClassName: PropTypes.string,
    /**
     * The name of the icon font ligature.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'inherit'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['inherit', 'action', 'disabled', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The fontSize applied to the icon. Defaults to 24px, but can be configure to inherit font size.
     * @default 'medium'
     */
    fontSize: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['inherit', 'large', 'medium', 'small']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  Icon.muiName = 'Icon';
  var Icon$1 = Icon;

  function getImageListUtilityClass(slot) {
    return generateUtilityClass('MuiImageList', slot);
  }
  var imageListClasses = generateUtilityClasses('MuiImageList', ['root', 'masonry', 'quilted', 'standard', 'woven']);
  var imageListClasses$1 = imageListClasses;

  /**
   * @ignore - internal component.
   * @type {React.Context<{} | {expanded: boolean, disabled: boolean, toggle: () => void}>}
   */
  var ImageListContext = /*#__PURE__*/React__namespace.createContext({});
  {
    ImageListContext.displayName = 'ImageListContext';
  }
  var ImageListContext$1 = ImageListContext;

  var useUtilityClasses$Z = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      variant = ownerState.variant;
    var slots = {
      root: ['root', variant]
    };
    return composeClasses(slots, getImageListUtilityClass, classes);
  };
  var ImageListRoot = styled$1('ul', {
    name: 'MuiImageList',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.variant]];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends({
      display: 'grid',
      overflowY: 'auto',
      listStyle: 'none',
      padding: 0,
      // Add iOS momentum scrolling for iOS < 13.0
      WebkitOverflowScrolling: 'touch'
    }, ownerState.variant === 'masonry' && {
      display: 'block'
    });
  });
  var ImageList = /*#__PURE__*/React__namespace.forwardRef(function ImageList(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiImageList'
    });
    var children = props.children,
      className = props.className,
      _props$cols = props.cols,
      cols = _props$cols === void 0 ? 2 : _props$cols,
      _props$component = props.component,
      component = _props$component === void 0 ? 'ul' : _props$component,
      _props$rowHeight = props.rowHeight,
      rowHeight = _props$rowHeight === void 0 ? 'auto' : _props$rowHeight,
      _props$gap = props.gap,
      gap = _props$gap === void 0 ? 4 : _props$gap,
      styleProp = props.style,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'standard' : _props$variant,
      other = _objectWithoutProperties(props, ["children", "className", "cols", "component", "rowHeight", "gap", "style", "variant"]);
    var contextValue = React__namespace.useMemo(function () {
      return {
        rowHeight: rowHeight,
        gap: gap,
        variant: variant
      };
    }, [rowHeight, gap, variant]);
    React__namespace.useEffect(function () {
      {
        // Detect Internet Explorer 8+
        if (document !== undefined && 'objectFit' in document.documentElement.style === false) {
          console.error(['MUI: ImageList v5+ no longer natively supports Internet Explorer.', 'Use v4 of this component instead, or polyfill CSS object-fit.'].join('\n'));
        }
      }
    }, []);
    var style = variant === 'masonry' ? _extends({
      columnCount: cols,
      columnGap: gap
    }, styleProp) : _extends({
      gridTemplateColumns: "repeat(".concat(cols, ", 1fr)"),
      gap: gap
    }, styleProp);
    var ownerState = _extends({}, props, {
      component: component,
      gap: gap,
      rowHeight: rowHeight,
      variant: variant
    });
    var classes = useUtilityClasses$Z(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(ImageListRoot, _extends({
      as: component,
      className: clsx(classes.root, classes[variant], className),
      ref: ref,
      style: style,
      ownerState: ownerState
    }, other, {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(ImageListContext$1.Provider, {
        value: contextValue,
        children: children
      })
    }));
  });
  ImageList.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component, normally `ImageListItem`s.
     */
    children: PropTypes /* @typescript-to-proptypes-ignore */.node.isRequired,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * Number of columns.
     * @default 2
     */
    cols: integerPropType,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The gap between items in px.
     * @default 4
     */
    gap: PropTypes.number,
    /**
     * The height of one row in px.
     * @default 'auto'
     */
    rowHeight: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]),
    /**
     * @ignore
     */
    style: PropTypes.object,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The variant to use.
     * @default 'standard'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['masonry', 'quilted', 'standard', 'woven']), PropTypes.string])
  } ;
  var ImageList$1 = ImageList;

  function getImageListItemUtilityClass(slot) {
    return generateUtilityClass('MuiImageListItem', slot);
  }
  var imageListItemClasses = generateUtilityClasses('MuiImageListItem', ['root', 'img', 'standard', 'woven', 'masonry', 'quilted']);
  var imageListItemClasses$1 = imageListItemClasses;

  var useUtilityClasses$Y = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      variant = ownerState.variant;
    var slots = {
      root: ['root', variant],
      img: ['img']
    };
    return composeClasses(slots, getImageListItemUtilityClass, classes);
  };
  var ImageListItemRoot = styled$1('li', {
    name: 'MuiImageListItem',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [_defineProperty({}, "& .".concat(imageListItemClasses$1.img), styles.img), styles.root, styles[ownerState.variant]];
    }
  })(function (_ref2) {
    var ownerState = _ref2.ownerState;
    return _extends({
      display: 'block',
      position: 'relative'
    }, ownerState.variant === 'standard' && {
      // For titlebar under list item
      display: 'flex',
      flexDirection: 'column'
    }, ownerState.variant === 'woven' && {
      height: '100%',
      alignSelf: 'center',
      '&:nth-of-type(even)': {
        height: '70%'
      }
    }, _defineProperty({}, "& .".concat(imageListItemClasses$1.img), _extends({
      objectFit: 'cover',
      width: '100%',
      height: '100%',
      display: 'block'
    }, ownerState.variant === 'standard' && {
      height: 'auto',
      flexGrow: 1
    })));
  });
  var ImageListItem = /*#__PURE__*/React__namespace.forwardRef(function ImageListItem(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiImageListItem'
    });

    // TODO: - Use jsdoc @default?: "cols rows default values are for docs only"
    var children = props.children,
      className = props.className,
      _props$cols = props.cols,
      cols = _props$cols === void 0 ? 1 : _props$cols,
      _props$component = props.component,
      component = _props$component === void 0 ? 'li' : _props$component,
      _props$rows = props.rows,
      rows = _props$rows === void 0 ? 1 : _props$rows,
      style = props.style,
      other = _objectWithoutProperties(props, ["children", "className", "cols", "component", "rows", "style"]);
    var _React$useContext = React__namespace.useContext(ImageListContext$1),
      _React$useContext$row = _React$useContext.rowHeight,
      rowHeight = _React$useContext$row === void 0 ? 'auto' : _React$useContext$row,
      gap = _React$useContext.gap,
      variant = _React$useContext.variant;
    var height = 'auto';
    if (variant === 'woven') {
      height = undefined;
    } else if (rowHeight !== 'auto') {
      height = rowHeight * rows + gap * (rows - 1);
    }
    var ownerState = _extends({}, props, {
      cols: cols,
      component: component,
      gap: gap,
      rowHeight: rowHeight,
      rows: rows,
      variant: variant
    });
    var classes = useUtilityClasses$Y(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(ImageListItemRoot, _extends({
      as: component,
      className: clsx(classes.root, classes[variant], className),
      ref: ref,
      style: _extends({
        height: height,
        gridColumnEnd: variant !== 'masonry' ? "span ".concat(cols) : undefined,
        gridRowEnd: variant !== 'masonry' ? "span ".concat(rows) : undefined,
        marginBottom: variant === 'masonry' ? gap : undefined,
        breakInside: variant === 'masonry' ? 'avoid' : undefined
      }, style),
      ownerState: ownerState
    }, other, {
      children: React__namespace.Children.map(children, function (child) {
        if (! /*#__PURE__*/React__namespace.isValidElement(child)) {
          return null;
        }
        {
          if (reactIsExports.isFragment(child)) {
            console.error(["MUI: The ImageListItem component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n'));
          }
        }
        if (child.type === 'img' || isMuiElement(child, ['Image'])) {
          return /*#__PURE__*/React__namespace.cloneElement(child, {
            className: clsx(classes.img, child.props.className)
          });
        }
        return child;
      })
    }));
  });
  ImageListItem.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component, normally an `<img>`.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * Width of the item in number of grid columns.
     * @default 1
     */
    cols: integerPropType,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * Height of the item in number of grid rows.
     * @default 1
     */
    rows: integerPropType,
    /**
     * @ignore
     */
    style: PropTypes.object,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var ImageListItem$1 = ImageListItem;

  function getImageListItemBarUtilityClass(slot) {
    return generateUtilityClass('MuiImageListItemBar', slot);
  }
  var imageListItemBarClasses = generateUtilityClasses('MuiImageListItemBar', ['root', 'positionBottom', 'positionTop', 'positionBelow', 'titleWrap', 'titleWrapBottom', 'titleWrapTop', 'titleWrapBelow', 'titleWrapActionPosLeft', 'titleWrapActionPosRight', 'title', 'subtitle', 'actionIcon', 'actionIconActionPosLeft', 'actionIconActionPosRight']);
  var imageListItemBarClasses$1 = imageListItemBarClasses;

  var useUtilityClasses$X = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      position = ownerState.position,
      actionIcon = ownerState.actionIcon,
      actionPosition = ownerState.actionPosition;
    var slots = {
      root: ['root', "position".concat(capitalize(position))],
      titleWrap: ['titleWrap', "titleWrap".concat(capitalize(position)), actionIcon && "titleWrapActionPos".concat(capitalize(actionPosition))],
      title: ['title'],
      subtitle: ['subtitle'],
      actionIcon: ['actionIcon', "actionIconActionPos".concat(capitalize(actionPosition))]
    };
    return composeClasses(slots, getImageListItemBarUtilityClass, classes);
  };
  var ImageListItemBarRoot = styled$1('div', {
    name: 'MuiImageListItemBar',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles["position".concat(capitalize(ownerState.position))]];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      position: 'absolute',
      left: 0,
      right: 0,
      background: 'rgba(0, 0, 0, 0.5)',
      display: 'flex',
      alignItems: 'center',
      fontFamily: theme.typography.fontFamily
    }, ownerState.position === 'bottom' && {
      bottom: 0
    }, ownerState.position === 'top' && {
      top: 0
    }, ownerState.position === 'below' && {
      position: 'relative',
      background: 'transparent',
      alignItems: 'normal'
    });
  });
  var ImageListItemBarTitleWrap = styled$1('div', {
    name: 'MuiImageListItemBar',
    slot: 'TitleWrap',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.titleWrap, styles["titleWrap".concat(capitalize(ownerState.position))], ownerState.actionIcon && styles["titleWrapActionPos".concat(capitalize(ownerState.actionPosition))]];
    }
  })(function (_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    return _extends({
      flexGrow: 1,
      padding: '12px 16px',
      color: (theme.vars || theme).palette.common.white,
      overflow: 'hidden'
    }, ownerState.position === 'below' && {
      padding: '6px 0 12px',
      color: 'inherit'
    }, ownerState.actionIcon && ownerState.actionPosition === 'left' && {
      paddingLeft: 0
    }, ownerState.actionIcon && ownerState.actionPosition === 'right' && {
      paddingRight: 0
    });
  });
  var ImageListItemBarTitle = styled$1('div', {
    name: 'MuiImageListItemBar',
    slot: 'Title',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.title;
    }
  })(function (_ref3) {
    var theme = _ref3.theme;
    return {
      fontSize: theme.typography.pxToRem(16),
      lineHeight: '24px',
      textOverflow: 'ellipsis',
      overflow: 'hidden',
      whiteSpace: 'nowrap'
    };
  });
  var ImageListItemBarSubtitle = styled$1('div', {
    name: 'MuiImageListItemBar',
    slot: 'Subtitle',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.subtitle;
    }
  })(function (_ref4) {
    var theme = _ref4.theme;
    return {
      fontSize: theme.typography.pxToRem(12),
      lineHeight: 1,
      textOverflow: 'ellipsis',
      overflow: 'hidden',
      whiteSpace: 'nowrap'
    };
  });
  var ImageListItemBarActionIcon = styled$1('div', {
    name: 'MuiImageListItemBar',
    slot: 'ActionIcon',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.actionIcon, styles["actionIconActionPos".concat(capitalize(ownerState.actionPosition))]];
    }
  })(function (_ref5) {
    var ownerState = _ref5.ownerState;
    return _extends({}, ownerState.actionPosition === 'left' && {
      order: -1
    });
  });
  var ImageListItemBar = /*#__PURE__*/React__namespace.forwardRef(function ImageListItemBar(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiImageListItemBar'
    });
    var actionIcon = props.actionIcon,
      _props$actionPosition = props.actionPosition,
      actionPosition = _props$actionPosition === void 0 ? 'right' : _props$actionPosition,
      className = props.className,
      subtitle = props.subtitle,
      title = props.title,
      _props$position = props.position,
      position = _props$position === void 0 ? 'bottom' : _props$position,
      other = _objectWithoutProperties(props, ["actionIcon", "actionPosition", "className", "subtitle", "title", "position"]);
    var ownerState = _extends({}, props, {
      position: position,
      actionPosition: actionPosition
    });
    var classes = useUtilityClasses$X(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(ImageListItemBarRoot, _extends({
      ownerState: ownerState,
      className: clsx(classes.root, className),
      ref: ref
    }, other, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsxs(ImageListItemBarTitleWrap, {
        ownerState: ownerState,
        className: classes.titleWrap,
        children: [/*#__PURE__*/jsxRuntimeExports.jsx(ImageListItemBarTitle, {
          className: classes.title,
          children: title
        }), subtitle ? /*#__PURE__*/jsxRuntimeExports.jsx(ImageListItemBarSubtitle, {
          className: classes.subtitle,
          children: subtitle
        }) : null]
      }), actionIcon ? /*#__PURE__*/jsxRuntimeExports.jsx(ImageListItemBarActionIcon, {
        ownerState: ownerState,
        className: classes.actionIcon,
        children: actionIcon
      }) : null]
    }));
  });
  ImageListItemBar.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * An IconButton element to be used as secondary action target
     * (primary action target is the item itself).
     */
    actionIcon: PropTypes.node,
    /**
     * Position of secondary action IconButton.
     * @default 'right'
     */
    actionPosition: PropTypes.oneOf(['left', 'right']),
    /**
     * @ignore
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * Position of the title bar.
     * @default 'bottom'
     */
    position: PropTypes.oneOf(['below', 'bottom', 'top']),
    /**
     * String or element serving as subtitle (support text).
     */
    subtitle: PropTypes.node,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * Title to be displayed.
     */
    title: PropTypes.node
  } ;
  var ImageListItemBar$1 = ImageListItemBar;

  var useUtilityClasses$W = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      disableUnderline = ownerState.disableUnderline;
    var slots = {
      root: ['root', !disableUnderline && 'underline'],
      input: ['input']
    };
    var composedClasses = composeClasses(slots, getInputUtilityClass, classes);
    return _extends({}, classes, composedClasses);
  };
  var InputRoot = styled$1(InputBaseRoot, {
    shouldForwardProp: function shouldForwardProp(prop) {
      return rootShouldForwardProp$1(prop) || prop === 'classes';
    },
    name: 'MuiInput',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [].concat(_toConsumableArray(rootOverridesResolver(props, styles)), [!ownerState.disableUnderline && styles.underline]);
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    var light = theme.palette.mode === 'light';
    var bottomLineColor = light ? 'rgba(0, 0, 0, 0.42)' : 'rgba(255, 255, 255, 0.7)';
    if (theme.vars) {
      bottomLineColor = "rgba(".concat(theme.vars.palette.common.onBackgroundChannel, " / ").concat(theme.vars.opacity.inputUnderline, ")");
    }
    return _extends({
      position: 'relative'
    }, ownerState.formControl && {
      'label + &': {
        marginTop: 16
      }
    }, !ownerState.disableUnderline && _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
      '&::after': {
        borderBottom: "2px solid ".concat((theme.vars || theme).palette[ownerState.color].main),
        left: 0,
        bottom: 0,
        // Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
        content: '""',
        position: 'absolute',
        right: 0,
        transform: 'scaleX(0)',
        transition: theme.transitions.create('transform', {
          duration: theme.transitions.duration.shorter,
          easing: theme.transitions.easing.easeOut
        }),
        pointerEvents: 'none' // Transparent to the hover style.
      }
    }, "&.".concat(inputClasses$1.focused, ":after"), {
      // translateX(0) is a workaround for Safari transform scale bug
      // See https://github.com/mui/material-ui/issues/31766
      transform: 'scaleX(1) translateX(0)'
    }), "&.".concat(inputClasses$1.error), {
      '&::before, &::after': {
        borderBottomColor: (theme.vars || theme).palette.error.main
      }
    }), '&::before', {
      borderBottom: "1px solid ".concat(bottomLineColor),
      left: 0,
      bottom: 0,
      // Doing the other way around crash on IE11 "''" https://github.com/cssinjs/jss/issues/242
      content: '"\\00a0"',
      position: 'absolute',
      right: 0,
      transition: theme.transitions.create('border-bottom-color', {
        duration: theme.transitions.duration.shorter
      }),
      pointerEvents: 'none' // Transparent to the hover style.
    }), "&:hover:not(.".concat(inputClasses$1.disabled, ", .").concat(inputClasses$1.error, "):before"), {
      borderBottom: "2px solid ".concat((theme.vars || theme).palette.text.primary),
      // Reset on touch devices, it doesn't add specificity
      '@media (hover: none)': {
        borderBottom: "1px solid ".concat(bottomLineColor)
      }
    }), "&.".concat(inputClasses$1.disabled, ":before"), {
      borderBottomStyle: 'dotted'
    }));
  });
  var InputInput = styled$1(InputBaseComponent, {
    name: 'MuiInput',
    slot: 'Input',
    overridesResolver: inputOverridesResolver
  })({});
  var Input = /*#__PURE__*/React__namespace.forwardRef(function Input(inProps, ref) {
    var _ref3, _slots$root, _ref4, _slots$input;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiInput'
    });
    var disableUnderline = props.disableUnderline,
      _props$components = props.components,
      components = _props$components === void 0 ? {} : _props$components,
      componentsPropsProp = props.componentsProps,
      _props$fullWidth = props.fullWidth,
      fullWidth = _props$fullWidth === void 0 ? false : _props$fullWidth,
      _props$inputComponent = props.inputComponent,
      inputComponent = _props$inputComponent === void 0 ? 'input' : _props$inputComponent,
      _props$multiline = props.multiline,
      multiline = _props$multiline === void 0 ? false : _props$multiline,
      slotProps = props.slotProps,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      _props$type = props.type,
      type = _props$type === void 0 ? 'text' : _props$type,
      other = _objectWithoutProperties(props, ["disableUnderline", "components", "componentsProps", "fullWidth", "inputComponent", "multiline", "slotProps", "slots", "type"]);
    var classes = useUtilityClasses$W(props);
    var ownerState = {
      disableUnderline: disableUnderline
    };
    var inputComponentsProps = {
      root: {
        ownerState: ownerState
      }
    };
    var componentsProps = (slotProps != null ? slotProps : componentsPropsProp) ? deepmerge(slotProps != null ? slotProps : componentsPropsProp, inputComponentsProps) : inputComponentsProps;
    var RootSlot = (_ref3 = (_slots$root = slots.root) != null ? _slots$root : components.Root) != null ? _ref3 : InputRoot;
    var InputSlot = (_ref4 = (_slots$input = slots.input) != null ? _slots$input : components.Input) != null ? _ref4 : InputInput;
    return /*#__PURE__*/jsxRuntimeExports.jsx(InputBase$1, _extends({
      slots: {
        root: RootSlot,
        input: InputSlot
      },
      slotProps: componentsProps,
      fullWidth: fullWidth,
      inputComponent: inputComponent,
      multiline: multiline,
      ref: ref,
      type: type
    }, other, {
      classes: classes
    }));
  });
  Input.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * This prop helps users to fill forms faster, especially on mobile devices.
     * The name can be confusing, as it's more like an autofill.
     * You can learn more about it [following the specification](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill).
     */
    autoComplete: PropTypes.string,
    /**
     * If `true`, the `input` element is focused during the first mount.
     */
    autoFocus: PropTypes.bool,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * The prop defaults to the value (`'primary'`) inherited from the parent FormControl component.
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['primary', 'secondary']), PropTypes.string]),
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `slots` prop.
     * It's recommended to use the `slots` prop instead.
     *
     * @default {}
     */
    components: PropTypes.shape({
      Input: PropTypes.elementType,
      Root: PropTypes.elementType
    }),
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `slotProps` prop.
     * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.
     *
     * @default {}
     */
    componentsProps: PropTypes.shape({
      input: PropTypes.object,
      root: PropTypes.object
    }),
    /**
     * The default value. Use when the component is not controlled.
     */
    defaultValue: PropTypes.any,
    /**
     * If `true`, the component is disabled.
     * The prop defaults to the value (`false`) inherited from the parent FormControl component.
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the `input` will not have an underline.
     */
    disableUnderline: PropTypes.bool,
    /**
     * End `InputAdornment` for this component.
     */
    endAdornment: PropTypes.node,
    /**
     * If `true`, the `input` will indicate an error.
     * The prop defaults to the value (`false`) inherited from the parent FormControl component.
     */
    error: PropTypes.bool,
    /**
     * If `true`, the `input` will take up the full width of its container.
     * @default false
     */
    fullWidth: PropTypes.bool,
    /**
     * The id of the `input` element.
     */
    id: PropTypes.string,
    /**
     * The component used for the `input` element.
     * Either a string to use a HTML element or a component.
     * @default 'input'
     */
    inputComponent: PropTypes.elementType,
    /**
     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
     * @default {}
     */
    inputProps: PropTypes.object,
    /**
     * Pass a ref to the `input` element.
     */
    inputRef: refType$1,
    /**
     * If `dense`, will adjust vertical spacing. This is normally obtained via context from
     * FormControl.
     * The prop defaults to the value (`'none'`) inherited from the parent FormControl component.
     */
    margin: PropTypes.oneOf(['dense', 'none']),
    /**
     * Maximum number of rows to display when multiline option is set to true.
     */
    maxRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * Minimum number of rows to display when multiline option is set to true.
     */
    minRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * If `true`, a [TextareaAutosize](/material-ui/react-textarea-autosize/) element is rendered.
     * @default false
     */
    multiline: PropTypes.bool,
    /**
     * Name attribute of the `input` element.
     */
    name: PropTypes.string,
    /**
     * Callback fired when the value is changed.
     *
     * @param {React.ChangeEvent<HTMLTextAreaElement | HTMLInputElement>} event The event source of the callback.
     * You can pull out the new value by accessing `event.target.value` (string).
     */
    onChange: PropTypes.func,
    /**
     * The short hint displayed in the `input` before the user enters a value.
     */
    placeholder: PropTypes.string,
    /**
     * It prevents the user from changing the value of the field
     * (not from interacting with the field).
     */
    readOnly: PropTypes.bool,
    /**
     * If `true`, the `input` element is required.
     * The prop defaults to the value (`false`) inherited from the parent FormControl component.
     */
    required: PropTypes.bool,
    /**
     * Number of rows to display when multiline option is set to true.
     */
    rows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `componentsProps` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slotProps: PropTypes.shape({
      input: PropTypes.object,
      root: PropTypes.object
    }),
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `components` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slots: PropTypes.shape({
      input: PropTypes.elementType,
      root: PropTypes.elementType
    }),
    /**
     * Start `InputAdornment` for this component.
     */
    startAdornment: PropTypes.node,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * Type of the `input` element. It should be [a valid HTML5 input type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Form_%3Cinput%3E_types).
     * @default 'text'
     */
    type: PropTypes.string,
    /**
     * The value of the `input` element, required for a controlled component.
     */
    value: PropTypes.any
  } ;
  Input.muiName = 'Input';
  var Input$1 = Input;

  function getInputAdornmentUtilityClass(slot) {
    return generateUtilityClass('MuiInputAdornment', slot);
  }
  var inputAdornmentClasses = generateUtilityClasses('MuiInputAdornment', ['root', 'filled', 'standard', 'outlined', 'positionStart', 'positionEnd', 'disablePointerEvents', 'hiddenLabel', 'sizeSmall']);
  var inputAdornmentClasses$1 = inputAdornmentClasses;

  var _span$2;
  var overridesResolver$4 = function overridesResolver(props, styles) {
    var ownerState = props.ownerState;
    return [styles.root, styles["position".concat(capitalize(ownerState.position))], ownerState.disablePointerEvents === true && styles.disablePointerEvents, styles[ownerState.variant]];
  };
  var useUtilityClasses$V = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      disablePointerEvents = ownerState.disablePointerEvents,
      hiddenLabel = ownerState.hiddenLabel,
      position = ownerState.position,
      size = ownerState.size,
      variant = ownerState.variant;
    var slots = {
      root: ['root', disablePointerEvents && 'disablePointerEvents', position && "position".concat(capitalize(position)), variant, hiddenLabel && 'hiddenLabel', size && "size".concat(capitalize(size))]
    };
    return composeClasses(slots, getInputAdornmentUtilityClass, classes);
  };
  var InputAdornmentRoot = styled$1('div', {
    name: 'MuiInputAdornment',
    slot: 'Root',
    overridesResolver: overridesResolver$4
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      display: 'flex',
      height: '0.01em',
      // Fix IE11 flexbox alignment. To remove at some point.
      maxHeight: '2em',
      alignItems: 'center',
      whiteSpace: 'nowrap',
      color: (theme.vars || theme).palette.action.active
    }, ownerState.variant === 'filled' && _defineProperty({}, "&.".concat(inputAdornmentClasses$1.positionStart, "&:not(.").concat(inputAdornmentClasses$1.hiddenLabel, ")"), {
      marginTop: 16
    }), ownerState.position === 'start' && {
      // Styles applied to the root element if `position="start"`.
      marginRight: 8
    }, ownerState.position === 'end' && {
      // Styles applied to the root element if `position="end"`.
      marginLeft: 8
    }, ownerState.disablePointerEvents === true && {
      // Styles applied to the root element if `disablePointerEvents={true}`.
      pointerEvents: 'none'
    });
  });
  var InputAdornment = /*#__PURE__*/React__namespace.forwardRef(function InputAdornment(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiInputAdornment'
    });
    var children = props.children,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      _props$disablePointer = props.disablePointerEvents,
      disablePointerEvents = _props$disablePointer === void 0 ? false : _props$disablePointer,
      _props$disableTypogra = props.disableTypography,
      disableTypography = _props$disableTypogra === void 0 ? false : _props$disableTypogra,
      position = props.position,
      variantProp = props.variant,
      other = _objectWithoutProperties(props, ["children", "className", "component", "disablePointerEvents", "disableTypography", "position", "variant"]);
    var muiFormControl = useFormControl() || {};
    var variant = variantProp;
    if (variantProp && muiFormControl.variant) {
      {
        if (variantProp === muiFormControl.variant) {
          console.error('MUI: The `InputAdornment` variant infers the variant prop ' + 'you do not have to provide one.');
        }
      }
    }
    if (muiFormControl && !variant) {
      variant = muiFormControl.variant;
    }
    var ownerState = _extends({}, props, {
      hiddenLabel: muiFormControl.hiddenLabel,
      size: muiFormControl.size,
      disablePointerEvents: disablePointerEvents,
      position: position,
      variant: variant
    });
    var classes = useUtilityClasses$V(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(FormControlContext$1.Provider, {
      value: null,
      children: /*#__PURE__*/jsxRuntimeExports.jsx(InputAdornmentRoot, _extends({
        as: component,
        ownerState: ownerState,
        className: clsx(classes.root, className),
        ref: ref
      }, other, {
        children: typeof children === 'string' && !disableTypography ? /*#__PURE__*/jsxRuntimeExports.jsx(Typography$1, {
          color: "text.secondary",
          children: children
        }) : /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
          children: [position === 'start' ? ( /* notranslate needed while Google Translate will not fix zero-width space issue */_span$2 || (_span$2 = /*#__PURE__*/jsxRuntimeExports.jsx("span", {
            className: "notranslate",
            children: "\u200B"
          }))) : null, children]
        })
      }))
    });
  });
  InputAdornment.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component, normally an `IconButton` or string.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * Disable pointer events on the root.
     * This allows for the content of the adornment to focus the `input` on click.
     * @default false
     */
    disablePointerEvents: PropTypes.bool,
    /**
     * If children is a string then disable wrapping in a Typography component.
     * @default false
     */
    disableTypography: PropTypes.bool,
    /**
     * The position this adornment should appear relative to the `Input`.
     */
    position: PropTypes.oneOf(['end', 'start']).isRequired,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The variant to use.
     * Note: If you are using the `TextField` component or the `FormControl` component
     * you do not have to set this manually.
     */
    variant: PropTypes.oneOf(['filled', 'outlined', 'standard'])
  } ;
  var InputAdornment$1 = InputAdornment;

  function getInputLabelUtilityClasses(slot) {
    return generateUtilityClass('MuiInputLabel', slot);
  }
  var inputLabelClasses = generateUtilityClasses('MuiInputLabel', ['root', 'focused', 'disabled', 'error', 'required', 'asterisk', 'formControl', 'sizeSmall', 'shrink', 'animated', 'standard', 'filled', 'outlined']);
  var inputLabelClasses$1 = inputLabelClasses;

  var useUtilityClasses$U = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      formControl = ownerState.formControl,
      size = ownerState.size,
      shrink = ownerState.shrink,
      disableAnimation = ownerState.disableAnimation,
      variant = ownerState.variant,
      required = ownerState.required;
    var slots = {
      root: ['root', formControl && 'formControl', !disableAnimation && 'animated', shrink && 'shrink', size && size !== 'normal' && "size".concat(capitalize(size)), variant],
      asterisk: [required && 'asterisk']
    };
    var composedClasses = composeClasses(slots, getInputLabelUtilityClasses, classes);
    return _extends({}, classes, composedClasses);
  };
  var InputLabelRoot = styled$1(FormLabel$1, {
    shouldForwardProp: function shouldForwardProp(prop) {
      return rootShouldForwardProp$1(prop) || prop === 'classes';
    },
    name: 'MuiInputLabel',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [_defineProperty({}, "& .".concat(formLabelClasses$1.asterisk), styles.asterisk), styles.root, ownerState.formControl && styles.formControl, ownerState.size === 'small' && styles.sizeSmall, ownerState.shrink && styles.shrink, !ownerState.disableAnimation && styles.animated, ownerState.focused && styles.focused, styles[ownerState.variant]];
    }
  })(function (_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    return _extends({
      display: 'block',
      transformOrigin: 'top left',
      whiteSpace: 'nowrap',
      overflow: 'hidden',
      textOverflow: 'ellipsis',
      maxWidth: '100%'
    }, ownerState.formControl && {
      position: 'absolute',
      left: 0,
      top: 0,
      // slight alteration to spec spacing to match visual spec result
      transform: 'translate(0, 20px) scale(1)'
    }, ownerState.size === 'small' && {
      // Compensation for the `Input.inputSizeSmall` style.
      transform: 'translate(0, 17px) scale(1)'
    }, ownerState.shrink && {
      transform: 'translate(0, -1.5px) scale(0.75)',
      transformOrigin: 'top left',
      maxWidth: '133%'
    }, !ownerState.disableAnimation && {
      transition: theme.transitions.create(['color', 'transform', 'max-width'], {
        duration: theme.transitions.duration.shorter,
        easing: theme.transitions.easing.easeOut
      })
    }, ownerState.variant === 'filled' && _extends({
      // Chrome's autofill feature gives the input field a yellow background.
      // Since the input field is behind the label in the HTML tree,
      // the input field is drawn last and hides the label with an opaque background color.
      // zIndex: 1 will raise the label above opaque background-colors of input.
      zIndex: 1,
      pointerEvents: 'none',
      transform: 'translate(12px, 16px) scale(1)',
      maxWidth: 'calc(100% - 24px)'
    }, ownerState.size === 'small' && {
      transform: 'translate(12px, 13px) scale(1)'
    }, ownerState.shrink && _extends({
      userSelect: 'none',
      pointerEvents: 'auto',
      transform: 'translate(12px, 7px) scale(0.75)',
      maxWidth: 'calc(133% - 24px)'
    }, ownerState.size === 'small' && {
      transform: 'translate(12px, 4px) scale(0.75)'
    })), ownerState.variant === 'outlined' && _extends({
      // see comment above on filled.zIndex
      zIndex: 1,
      pointerEvents: 'none',
      transform: 'translate(14px, 16px) scale(1)',
      maxWidth: 'calc(100% - 24px)'
    }, ownerState.size === 'small' && {
      transform: 'translate(14px, 9px) scale(1)'
    }, ownerState.shrink && {
      userSelect: 'none',
      pointerEvents: 'auto',
      // Theoretically, we should have (8+5)*2/0.75 = 34px
      // but it feels a better when it bleeds a bit on the left, so 32px.
      maxWidth: 'calc(133% - 32px)',
      transform: 'translate(14px, -9px) scale(0.75)'
    }));
  });
  var InputLabel = /*#__PURE__*/React__namespace.forwardRef(function InputLabel(inProps, ref) {
    var props = useDefaultProps({
      name: 'MuiInputLabel',
      props: inProps
    });
    var _props$disableAnimati = props.disableAnimation,
      disableAnimation = _props$disableAnimati === void 0 ? false : _props$disableAnimati;
      props.margin;
      var shrinkProp = props.shrink;
      props.variant;
      var className = props.className,
      other = _objectWithoutProperties(props, ["disableAnimation", "margin", "shrink", "variant", "className"]);
    var muiFormControl = useFormControl();
    var shrink = shrinkProp;
    if (typeof shrink === 'undefined' && muiFormControl) {
      shrink = muiFormControl.filled || muiFormControl.focused || muiFormControl.adornedStart;
    }
    var fcs = formControlState({
      props: props,
      muiFormControl: muiFormControl,
      states: ['size', 'variant', 'required', 'focused']
    });
    var ownerState = _extends({}, props, {
      disableAnimation: disableAnimation,
      formControl: muiFormControl,
      shrink: shrink,
      size: fcs.size,
      variant: fcs.variant,
      required: fcs.required,
      focused: fcs.focused
    });
    var classes = useUtilityClasses$U(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(InputLabelRoot, _extends({
      "data-shrink": shrink,
      ownerState: ownerState,
      ref: ref,
      className: clsx(classes.root, className)
    }, other, {
      classes: classes
    }));
  });
  InputLabel.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['error', 'info', 'primary', 'secondary', 'success', 'warning']), PropTypes.string]),
    /**
     * If `true`, the transition animation is disabled.
     * @default false
     */
    disableAnimation: PropTypes.bool,
    /**
     * If `true`, the component is disabled.
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the label is displayed in an error state.
     */
    error: PropTypes.bool,
    /**
     * If `true`, the `input` of this label is focused.
     */
    focused: PropTypes.bool,
    /**
     * If `dense`, will adjust vertical spacing. This is normally obtained via context from
     * FormControl.
     */
    margin: PropTypes.oneOf(['dense']),
    /**
     * if `true`, the label will indicate that the `input` is required.
     */
    required: PropTypes.bool,
    /**
     * If `true`, the label is shrunk.
     */
    shrink: PropTypes.bool,
    /**
     * The size of the component.
     * @default 'normal'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['normal', 'small']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The variant to use.
     */
    variant: PropTypes.oneOf(['filled', 'outlined', 'standard'])
  } ;
  var InputLabel$1 = InputLabel;

  function getLinearProgressUtilityClass(slot) {
    return generateUtilityClass('MuiLinearProgress', slot);
  }
  var linearProgressClasses = generateUtilityClasses('MuiLinearProgress', ['root', 'colorPrimary', 'colorSecondary', 'determinate', 'indeterminate', 'buffer', 'query', 'dashed', 'dashedColorPrimary', 'dashedColorSecondary', 'bar', 'barColorPrimary', 'barColorSecondary', 'bar1Indeterminate', 'bar1Determinate', 'bar1Buffer', 'bar2Indeterminate', 'bar2Buffer']);
  var linearProgressClasses$1 = linearProgressClasses;

  var _templateObject$1, _templateObject2$1, _templateObject3$1, _templateObject4$1, _templateObject5, _templateObject6;
  var TRANSITION_DURATION = 4; // seconds
  var indeterminate1Keyframe = keyframes(_templateObject$1 || (_templateObject$1 = _taggedTemplateLiteral(["\n  0% {\n    left: -35%;\n    right: 100%;\n  }\n\n  60% {\n    left: 100%;\n    right: -90%;\n  }\n\n  100% {\n    left: 100%;\n    right: -90%;\n  }\n"])));
  var indeterminate2Keyframe = keyframes(_templateObject2$1 || (_templateObject2$1 = _taggedTemplateLiteral(["\n  0% {\n    left: -200%;\n    right: 100%;\n  }\n\n  60% {\n    left: 107%;\n    right: -8%;\n  }\n\n  100% {\n    left: 107%;\n    right: -8%;\n  }\n"])));
  var bufferKeyframe = keyframes(_templateObject3$1 || (_templateObject3$1 = _taggedTemplateLiteral(["\n  0% {\n    opacity: 1;\n    background-position: 0 -23px;\n  }\n\n  60% {\n    opacity: 0;\n    background-position: 0 -23px;\n  }\n\n  100% {\n    opacity: 1;\n    background-position: -200px -23px;\n  }\n"])));
  var useUtilityClasses$T = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      variant = ownerState.variant,
      color = ownerState.color;
    var slots = {
      root: ['root', "color".concat(capitalize(color)), variant],
      dashed: ['dashed', "dashedColor".concat(capitalize(color))],
      bar1: ['bar', "barColor".concat(capitalize(color)), (variant === 'indeterminate' || variant === 'query') && 'bar1Indeterminate', variant === 'determinate' && 'bar1Determinate', variant === 'buffer' && 'bar1Buffer'],
      bar2: ['bar', variant !== 'buffer' && "barColor".concat(capitalize(color)), variant === 'buffer' && "color".concat(capitalize(color)), (variant === 'indeterminate' || variant === 'query') && 'bar2Indeterminate', variant === 'buffer' && 'bar2Buffer']
    };
    return composeClasses(slots, getLinearProgressUtilityClass, classes);
  };
  var getColorShade = function getColorShade(theme, color) {
    if (color === 'inherit') {
      return 'currentColor';
    }
    if (theme.vars) {
      return theme.vars.palette.LinearProgress["".concat(color, "Bg")];
    }
    return theme.palette.mode === 'light' ? lighten(theme.palette[color].main, 0.62) : darken(theme.palette[color].main, 0.5);
  };
  var LinearProgressRoot = styled$1('span', {
    name: 'MuiLinearProgress',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles["color".concat(capitalize(ownerState.color))], styles[ownerState.variant]];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState,
      theme = _ref.theme;
    return _extends({
      position: 'relative',
      overflow: 'hidden',
      display: 'block',
      height: 4,
      zIndex: 0,
      // Fix Safari's bug during composition of different paint.
      '@media print': {
        colorAdjust: 'exact'
      },
      backgroundColor: getColorShade(theme, ownerState.color)
    }, ownerState.color === 'inherit' && ownerState.variant !== 'buffer' && {
      backgroundColor: 'none',
      '&::before': {
        content: '""',
        position: 'absolute',
        left: 0,
        top: 0,
        right: 0,
        bottom: 0,
        backgroundColor: 'currentColor',
        opacity: 0.3
      }
    }, ownerState.variant === 'buffer' && {
      backgroundColor: 'transparent'
    }, ownerState.variant === 'query' && {
      transform: 'rotate(180deg)'
    });
  });
  var LinearProgressDashed = styled$1('span', {
    name: 'MuiLinearProgress',
    slot: 'Dashed',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.dashed, styles["dashedColor".concat(capitalize(ownerState.color))]];
    }
  })(function (_ref2) {
    var ownerState = _ref2.ownerState,
      theme = _ref2.theme;
    var backgroundColor = getColorShade(theme, ownerState.color);
    return _extends({
      position: 'absolute',
      marginTop: 0,
      height: '100%',
      width: '100%'
    }, ownerState.color === 'inherit' && {
      opacity: 0.3
    }, {
      backgroundImage: "radial-gradient(".concat(backgroundColor, " 0%, ").concat(backgroundColor, " 16%, transparent 42%)"),
      backgroundSize: '10px 10px',
      backgroundPosition: '0 -23px'
    });
  }, css(_templateObject4$1 || (_templateObject4$1 = _taggedTemplateLiteral(["\n    animation: ", " 3s infinite linear;\n  "])), bufferKeyframe));
  var LinearProgressBar1 = styled$1('span', {
    name: 'MuiLinearProgress',
    slot: 'Bar1',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.bar, styles["barColor".concat(capitalize(ownerState.color))], (ownerState.variant === 'indeterminate' || ownerState.variant === 'query') && styles.bar1Indeterminate, ownerState.variant === 'determinate' && styles.bar1Determinate, ownerState.variant === 'buffer' && styles.bar1Buffer];
    }
  })(function (_ref3) {
    var ownerState = _ref3.ownerState,
      theme = _ref3.theme;
    return _extends({
      width: '100%',
      position: 'absolute',
      left: 0,
      bottom: 0,
      top: 0,
      transition: 'transform 0.2s linear',
      transformOrigin: 'left',
      backgroundColor: ownerState.color === 'inherit' ? 'currentColor' : (theme.vars || theme).palette[ownerState.color].main
    }, ownerState.variant === 'determinate' && {
      transition: "transform .".concat(TRANSITION_DURATION, "s linear")
    }, ownerState.variant === 'buffer' && {
      zIndex: 1,
      transition: "transform .".concat(TRANSITION_DURATION, "s linear")
    });
  }, function (_ref4) {
    var ownerState = _ref4.ownerState;
    return (ownerState.variant === 'indeterminate' || ownerState.variant === 'query') && css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n      width: auto;\n      animation: ", " 2.1s cubic-bezier(0.65, 0.815, 0.735, 0.395) infinite;\n    "])), indeterminate1Keyframe);
  });
  var LinearProgressBar2 = styled$1('span', {
    name: 'MuiLinearProgress',
    slot: 'Bar2',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.bar, styles["barColor".concat(capitalize(ownerState.color))], (ownerState.variant === 'indeterminate' || ownerState.variant === 'query') && styles.bar2Indeterminate, ownerState.variant === 'buffer' && styles.bar2Buffer];
    }
  })(function (_ref5) {
    var ownerState = _ref5.ownerState,
      theme = _ref5.theme;
    return _extends({
      width: '100%',
      position: 'absolute',
      left: 0,
      bottom: 0,
      top: 0,
      transition: 'transform 0.2s linear',
      transformOrigin: 'left'
    }, ownerState.variant !== 'buffer' && {
      backgroundColor: ownerState.color === 'inherit' ? 'currentColor' : (theme.vars || theme).palette[ownerState.color].main
    }, ownerState.color === 'inherit' && {
      opacity: 0.3
    }, ownerState.variant === 'buffer' && {
      backgroundColor: getColorShade(theme, ownerState.color),
      transition: "transform .".concat(TRANSITION_DURATION, "s linear")
    });
  }, function (_ref6) {
    var ownerState = _ref6.ownerState;
    return (ownerState.variant === 'indeterminate' || ownerState.variant === 'query') && css(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n      width: auto;\n      animation: ", " 2.1s cubic-bezier(0.165, 0.84, 0.44, 1) 1.15s infinite;\n    "])), indeterminate2Keyframe);
  });

  /**
   * ## ARIA
   *
   * If the progress bar is describing the loading progress of a particular region of a page,
   * you should use `aria-describedby` to point to the progress bar, and set the `aria-busy`
   * attribute to `true` on that region until it has finished loading.
   */
  var LinearProgress = /*#__PURE__*/React__namespace.forwardRef(function LinearProgress(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiLinearProgress'
    });
    var className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'primary' : _props$color,
      value = props.value,
      valueBuffer = props.valueBuffer,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'indeterminate' : _props$variant,
      other = _objectWithoutProperties(props, ["className", "color", "value", "valueBuffer", "variant"]);
    var ownerState = _extends({}, props, {
      color: color,
      variant: variant
    });
    var classes = useUtilityClasses$T(ownerState);
    var isRtl = useRtl();
    var rootProps = {};
    var inlineStyles = {
      bar1: {},
      bar2: {}
    };
    if (variant === 'determinate' || variant === 'buffer') {
      if (value !== undefined) {
        rootProps['aria-valuenow'] = Math.round(value);
        rootProps['aria-valuemin'] = 0;
        rootProps['aria-valuemax'] = 100;
        var transform = value - 100;
        if (isRtl) {
          transform = -transform;
        }
        inlineStyles.bar1.transform = "translateX(".concat(transform, "%)");
      } else {
        console.error('MUI: You need to provide a value prop ' + 'when using the determinate or buffer variant of LinearProgress .');
      }
    }
    if (variant === 'buffer') {
      if (valueBuffer !== undefined) {
        var _transform = (valueBuffer || 0) - 100;
        if (isRtl) {
          _transform = -_transform;
        }
        inlineStyles.bar2.transform = "translateX(".concat(_transform, "%)");
      } else {
        console.error('MUI: You need to provide a valueBuffer prop ' + 'when using the buffer variant of LinearProgress.');
      }
    }
    return /*#__PURE__*/jsxRuntimeExports.jsxs(LinearProgressRoot, _extends({
      className: clsx(classes.root, className),
      ownerState: ownerState,
      role: "progressbar"
    }, rootProps, {
      ref: ref
    }, other, {
      children: [variant === 'buffer' ? /*#__PURE__*/jsxRuntimeExports.jsx(LinearProgressDashed, {
        className: classes.dashed,
        ownerState: ownerState
      }) : null, /*#__PURE__*/jsxRuntimeExports.jsx(LinearProgressBar1, {
        className: classes.bar1,
        ownerState: ownerState,
        style: inlineStyles.bar1
      }), variant === 'determinate' ? null : /*#__PURE__*/jsxRuntimeExports.jsx(LinearProgressBar2, {
        className: classes.bar2,
        ownerState: ownerState,
        style: inlineStyles.bar2
      })]
    }));
  });
  LinearProgress.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'primary'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['inherit', 'primary', 'secondary']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The value of the progress indicator for the determinate and buffer variants.
     * Value between 0 and 100.
     */
    value: PropTypes.number,
    /**
     * The value for the buffer variant.
     * Value between 0 and 100.
     */
    valueBuffer: PropTypes.number,
    /**
     * The variant to use.
     * Use indeterminate or query when there is no progress value.
     * @default 'indeterminate'
     */
    variant: PropTypes.oneOf(['buffer', 'determinate', 'indeterminate', 'query'])
  } ;
  var LinearProgress$1 = LinearProgress;

  function getLinkUtilityClass(slot) {
    return generateUtilityClass('MuiLink', slot);
  }
  var linkClasses = generateUtilityClasses('MuiLink', ['root', 'underlineNone', 'underlineHover', 'underlineAlways', 'button', 'focusVisible']);
  var linkClasses$1 = linkClasses;

  var colorTransformations = {
    primary: 'primary.main',
    textPrimary: 'text.primary',
    secondary: 'secondary.main',
    textSecondary: 'text.secondary',
    error: 'error.main'
  };
  var transformDeprecatedColors = function transformDeprecatedColors(color) {
    return colorTransformations[color] || color;
  };
  var getTextDecoration = function getTextDecoration(_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    var transformedColor = transformDeprecatedColors(ownerState.color);
    var color = getPath(theme, "palette.".concat(transformedColor), false) || ownerState.color;
    var channelColor = getPath(theme, "palette.".concat(transformedColor, "Channel"));
    if ('vars' in theme && channelColor) {
      return "rgba(".concat(channelColor, " / 0.4)");
    }
    return alpha(color, 0.4);
  };
  var getTextDecoration$1 = getTextDecoration;

  var useUtilityClasses$S = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      component = ownerState.component,
      focusVisible = ownerState.focusVisible,
      underline = ownerState.underline;
    var slots = {
      root: ['root', "underline".concat(capitalize(underline)), component === 'button' && 'button', focusVisible && 'focusVisible']
    };
    return composeClasses(slots, getLinkUtilityClass, classes);
  };
  var LinkRoot = styled$1(Typography$1, {
    name: 'MuiLink',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles["underline".concat(capitalize(ownerState.underline))], ownerState.component === 'button' && styles.button];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({}, ownerState.underline === 'none' && {
      textDecoration: 'none'
    }, ownerState.underline === 'hover' && {
      textDecoration: 'none',
      '&:hover': {
        textDecoration: 'underline'
      }
    }, ownerState.underline === 'always' && _extends({
      textDecoration: 'underline'
    }, ownerState.color !== 'inherit' && {
      textDecorationColor: getTextDecoration$1({
        theme: theme,
        ownerState: ownerState
      })
    }, {
      '&:hover': {
        textDecorationColor: 'inherit'
      }
    }), ownerState.component === 'button' && _defineProperty({
      position: 'relative',
      WebkitTapHighlightColor: 'transparent',
      backgroundColor: 'transparent',
      // Reset default value
      // We disable the focus ring for mouse, touch and keyboard users.
      outline: 0,
      border: 0,
      margin: 0,
      // Remove the margin in Safari
      borderRadius: 0,
      padding: 0,
      // Remove the padding in Firefox
      cursor: 'pointer',
      userSelect: 'none',
      verticalAlign: 'middle',
      MozAppearance: 'none',
      // Reset
      WebkitAppearance: 'none',
      // Reset
      '&::-moz-focus-inner': {
        borderStyle: 'none' // Remove Firefox dotted outline.
      }
    }, "&.".concat(linkClasses$1.focusVisible), {
      outline: 'auto'
    }));
  });
  var Link = /*#__PURE__*/React__namespace.forwardRef(function Link(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiLink'
    });
    var className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'primary' : _props$color,
      _props$component = props.component,
      component = _props$component === void 0 ? 'a' : _props$component,
      onBlur = props.onBlur,
      onFocus = props.onFocus,
      TypographyClasses = props.TypographyClasses,
      _props$underline = props.underline,
      underline = _props$underline === void 0 ? 'always' : _props$underline,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'inherit' : _props$variant,
      sx = props.sx,
      other = _objectWithoutProperties(props, ["className", "color", "component", "onBlur", "onFocus", "TypographyClasses", "underline", "variant", "sx"]);
    var _useIsFocusVisible = useIsFocusVisible(),
      isFocusVisibleRef = _useIsFocusVisible.isFocusVisibleRef,
      handleBlurVisible = _useIsFocusVisible.onBlur,
      handleFocusVisible = _useIsFocusVisible.onFocus,
      focusVisibleRef = _useIsFocusVisible.ref;
    var _React$useState = React__namespace.useState(false),
      focusVisible = _React$useState[0],
      setFocusVisible = _React$useState[1];
    var handlerRef = useForkRef(ref, focusVisibleRef);
    var handleBlur = function handleBlur(event) {
      handleBlurVisible(event);
      if (isFocusVisibleRef.current === false) {
        setFocusVisible(false);
      }
      if (onBlur) {
        onBlur(event);
      }
    };
    var handleFocus = function handleFocus(event) {
      handleFocusVisible(event);
      if (isFocusVisibleRef.current === true) {
        setFocusVisible(true);
      }
      if (onFocus) {
        onFocus(event);
      }
    };
    var ownerState = _extends({}, props, {
      color: color,
      component: component,
      focusVisible: focusVisible,
      underline: underline,
      variant: variant
    });
    var classes = useUtilityClasses$S(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(LinkRoot, _extends({
      color: color,
      className: clsx(classes.root, className),
      classes: TypographyClasses,
      component: component,
      onBlur: handleBlur,
      onFocus: handleFocus,
      ref: handlerRef,
      ownerState: ownerState,
      variant: variant,
      sx: [].concat(_toConsumableArray(!Object.keys(colorTransformations).includes(color) ? [{
        color: color
      }] : []), _toConsumableArray(Array.isArray(sx) ? sx : [sx]))
    }, other));
  });
  Link.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the link.
     * @default 'primary'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.any,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: elementTypeAcceptingRef$1,
    /**
     * @ignore
     */
    onBlur: PropTypes.func,
    /**
     * @ignore
     */
    onFocus: PropTypes.func,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * `classes` prop applied to the [`Typography`](/material-ui/api/typography/) element.
     */
    TypographyClasses: PropTypes.object,
    /**
     * Controls when the link should have an underline.
     * @default 'always'
     */
    underline: PropTypes.oneOf(['always', 'hover', 'none']),
    /**
     * Applies the theme typography styles.
     * @default 'inherit'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['body1', 'body2', 'button', 'caption', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'inherit', 'overline', 'subtitle1', 'subtitle2']), PropTypes.string])
  } ;
  var Link$1 = Link;

  /**
   * @ignore - internal component.
   */
  var ListContext = /*#__PURE__*/React__namespace.createContext({});
  {
    ListContext.displayName = 'ListContext';
  }
  var ListContext$1 = ListContext;

  function getListUtilityClass(slot) {
    return generateUtilityClass('MuiList', slot);
  }
  var listClasses = generateUtilityClasses('MuiList', ['root', 'padding', 'dense', 'subheader']);
  var listClasses$1 = listClasses;

  var useUtilityClasses$R = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      disablePadding = ownerState.disablePadding,
      dense = ownerState.dense,
      subheader = ownerState.subheader;
    var slots = {
      root: ['root', !disablePadding && 'padding', dense && 'dense', subheader && 'subheader']
    };
    return composeClasses(slots, getListUtilityClass, classes);
  };
  var ListRoot = styled$1('ul', {
    name: 'MuiList',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, !ownerState.disablePadding && styles.padding, ownerState.dense && styles.dense, ownerState.subheader && styles.subheader];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends({
      listStyle: 'none',
      margin: 0,
      padding: 0,
      position: 'relative'
    }, !ownerState.disablePadding && {
      paddingTop: 8,
      paddingBottom: 8
    }, ownerState.subheader && {
      paddingTop: 0
    });
  });
  var List = /*#__PURE__*/React__namespace.forwardRef(function List(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiList'
    });
    var children = props.children,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'ul' : _props$component,
      _props$dense = props.dense,
      dense = _props$dense === void 0 ? false : _props$dense,
      _props$disablePadding = props.disablePadding,
      disablePadding = _props$disablePadding === void 0 ? false : _props$disablePadding,
      subheader = props.subheader,
      other = _objectWithoutProperties(props, ["children", "className", "component", "dense", "disablePadding", "subheader"]);
    var context = React__namespace.useMemo(function () {
      return {
        dense: dense
      };
    }, [dense]);
    var ownerState = _extends({}, props, {
      component: component,
      dense: dense,
      disablePadding: disablePadding
    });
    var classes = useUtilityClasses$R(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(ListContext$1.Provider, {
      value: context,
      children: /*#__PURE__*/jsxRuntimeExports.jsxs(ListRoot, _extends({
        as: component,
        className: clsx(classes.root, className),
        ref: ref,
        ownerState: ownerState
      }, other, {
        children: [subheader, children]
      }))
    });
  });
  List.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, compact vertical padding designed for keyboard and mouse input is used for
     * the list and list items.
     * The prop is available to descendant components as the `dense` context.
     * @default false
     */
    dense: PropTypes.bool,
    /**
     * If `true`, vertical padding is removed from the list.
     * @default false
     */
    disablePadding: PropTypes.bool,
    /**
     * The content of the subheader, normally `ListSubheader`.
     */
    subheader: PropTypes.node,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var List$1 = List;

  function getListItemUtilityClass(slot) {
    return generateUtilityClass('MuiListItem', slot);
  }
  var listItemClasses = generateUtilityClasses('MuiListItem', ['root', 'container', 'focusVisible', 'dense', 'alignItemsFlexStart', 'disabled', 'divider', 'gutters', 'padding', 'button', 'secondaryAction', 'selected']);
  var listItemClasses$1 = listItemClasses;

  function getListItemButtonUtilityClass(slot) {
    return generateUtilityClass('MuiListItemButton', slot);
  }
  var listItemButtonClasses = generateUtilityClasses('MuiListItemButton', ['root', 'focusVisible', 'dense', 'alignItemsFlexStart', 'disabled', 'divider', 'gutters', 'selected']);
  var listItemButtonClasses$1 = listItemButtonClasses;

  var overridesResolver$3 = function overridesResolver(props, styles) {
    var ownerState = props.ownerState;
    return [styles.root, ownerState.dense && styles.dense, ownerState.alignItems === 'flex-start' && styles.alignItemsFlexStart, ownerState.divider && styles.divider, !ownerState.disableGutters && styles.gutters];
  };
  var useUtilityClasses$Q = function useUtilityClasses(ownerState) {
    var alignItems = ownerState.alignItems,
      classes = ownerState.classes,
      dense = ownerState.dense,
      disabled = ownerState.disabled,
      disableGutters = ownerState.disableGutters,
      divider = ownerState.divider,
      selected = ownerState.selected;
    var slots = {
      root: ['root', dense && 'dense', !disableGutters && 'gutters', divider && 'divider', disabled && 'disabled', alignItems === 'flex-start' && 'alignItemsFlexStart', selected && 'selected']
    };
    var composedClasses = composeClasses(slots, getListItemButtonUtilityClass, classes);
    return _extends({}, classes, composedClasses);
  };
  var ListItemButtonRoot = styled$1(ButtonBase$1, {
    shouldForwardProp: function shouldForwardProp(prop) {
      return rootShouldForwardProp$1(prop) || prop === 'classes';
    },
    name: 'MuiListItemButton',
    slot: 'Root',
    overridesResolver: overridesResolver$3
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
      display: 'flex',
      flexGrow: 1,
      justifyContent: 'flex-start',
      alignItems: 'center',
      position: 'relative',
      textDecoration: 'none',
      minWidth: 0,
      boxSizing: 'border-box',
      textAlign: 'left',
      paddingTop: 8,
      paddingBottom: 8,
      transition: theme.transitions.create('background-color', {
        duration: theme.transitions.duration.shortest
      }),
      '&:hover': {
        textDecoration: 'none',
        backgroundColor: (theme.vars || theme).palette.action.hover,
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: 'transparent'
        }
      }
    }, "&.".concat(listItemButtonClasses$1.selected), _defineProperty({
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / ").concat(theme.vars.palette.action.selectedOpacity, ")") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity)
    }, "&.".concat(listItemButtonClasses$1.focusVisible), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.focusOpacity, "))") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)
    })), "&.".concat(listItemButtonClasses$1.selected, ":hover"), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.hoverOpacity, "))") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity),
      // Reset on touch devices, it doesn't add specificity
      '@media (hover: none)': {
        backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / ").concat(theme.vars.palette.action.selectedOpacity, ")") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity)
      }
    }), "&.".concat(listItemButtonClasses$1.focusVisible), {
      backgroundColor: (theme.vars || theme).palette.action.focus
    }), "&.".concat(listItemButtonClasses$1.disabled), {
      opacity: (theme.vars || theme).palette.action.disabledOpacity
    }), ownerState.divider && {
      borderBottom: "1px solid ".concat((theme.vars || theme).palette.divider),
      backgroundClip: 'padding-box'
    }, ownerState.alignItems === 'flex-start' && {
      alignItems: 'flex-start'
    }, !ownerState.disableGutters && {
      paddingLeft: 16,
      paddingRight: 16
    }, ownerState.dense && {
      paddingTop: 4,
      paddingBottom: 4
    });
  });
  var ListItemButton = /*#__PURE__*/React__namespace.forwardRef(function ListItemButton(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiListItemButton'
    });
    var _props$alignItems = props.alignItems,
      alignItems = _props$alignItems === void 0 ? 'center' : _props$alignItems,
      _props$autoFocus = props.autoFocus,
      autoFocus = _props$autoFocus === void 0 ? false : _props$autoFocus,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      children = props.children,
      _props$dense = props.dense,
      dense = _props$dense === void 0 ? false : _props$dense,
      _props$disableGutters = props.disableGutters,
      disableGutters = _props$disableGutters === void 0 ? false : _props$disableGutters,
      _props$divider = props.divider,
      divider = _props$divider === void 0 ? false : _props$divider,
      focusVisibleClassName = props.focusVisibleClassName,
      _props$selected = props.selected,
      selected = _props$selected === void 0 ? false : _props$selected,
      className = props.className,
      other = _objectWithoutProperties(props, ["alignItems", "autoFocus", "component", "children", "dense", "disableGutters", "divider", "focusVisibleClassName", "selected", "className"]);
    var context = React__namespace.useContext(ListContext$1);
    var childContext = React__namespace.useMemo(function () {
      return {
        dense: dense || context.dense || false,
        alignItems: alignItems,
        disableGutters: disableGutters
      };
    }, [alignItems, context.dense, dense, disableGutters]);
    var listItemRef = React__namespace.useRef(null);
    useEnhancedEffect$1(function () {
      if (autoFocus) {
        if (listItemRef.current) {
          listItemRef.current.focus();
        } else {
          console.error('MUI: Unable to set focus to a ListItemButton whose component has not been rendered.');
        }
      }
    }, [autoFocus]);
    var ownerState = _extends({}, props, {
      alignItems: alignItems,
      dense: childContext.dense,
      disableGutters: disableGutters,
      divider: divider,
      selected: selected
    });
    var classes = useUtilityClasses$Q(ownerState);
    var handleRef = useForkRef(listItemRef, ref);
    return /*#__PURE__*/jsxRuntimeExports.jsx(ListContext$1.Provider, {
      value: childContext,
      children: /*#__PURE__*/jsxRuntimeExports.jsx(ListItemButtonRoot, _extends({
        ref: handleRef,
        href: other.href || other.to
        // `ButtonBase` processes `href` or `to` if `component` is set to 'button'
        ,
        component: (other.href || other.to) && component === 'div' ? 'button' : component,
        focusVisibleClassName: clsx(classes.focusVisible, focusVisibleClassName),
        ownerState: ownerState,
        className: clsx(classes.root, className)
      }, other, {
        classes: classes,
        children: children
      }))
    });
  });
  ListItemButton.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Defines the `align-items` style property.
     * @default 'center'
     */
    alignItems: PropTypes.oneOf(['center', 'flex-start']),
    /**
     * If `true`, the list item is focused during the first mount.
     * Focus will also be triggered if the value changes from false to true.
     * @default false
     */
    autoFocus: PropTypes.bool,
    /**
     * The content of the component if a `ListItemSecondaryAction` is used it must
     * be the last child.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, compact vertical padding designed for keyboard and mouse input is used.
     * The prop defaults to the value inherited from the parent List component.
     * @default false
     */
    dense: PropTypes.bool,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the left and right padding is removed.
     * @default false
     */
    disableGutters: PropTypes.bool,
    /**
     * If `true`, a 1px light border is added to the bottom of the list item.
     * @default false
     */
    divider: PropTypes.bool,
    /**
     * This prop can help identify which element has keyboard focus.
     * The class name will be applied when the element gains the focus through keyboard interaction.
     * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
     * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
     * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
     * if needed.
     */
    focusVisibleClassName: PropTypes.string,
    /**
     * @ignore
     */
    href: PropTypes.string,
    /**
     * Use to apply selected styling.
     * @default false
     */
    selected: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var ListItemButton$1 = ListItemButton;

  function getListItemSecondaryActionClassesUtilityClass(slot) {
    return generateUtilityClass('MuiListItemSecondaryAction', slot);
  }
  var listItemSecondaryActionClasses = generateUtilityClasses('MuiListItemSecondaryAction', ['root', 'disableGutters']);
  var listItemSecondaryActionClasses$1 = listItemSecondaryActionClasses;

  var useUtilityClasses$P = function useUtilityClasses(ownerState) {
    var disableGutters = ownerState.disableGutters,
      classes = ownerState.classes;
    var slots = {
      root: ['root', disableGutters && 'disableGutters']
    };
    return composeClasses(slots, getListItemSecondaryActionClassesUtilityClass, classes);
  };
  var ListItemSecondaryActionRoot = styled$1('div', {
    name: 'MuiListItemSecondaryAction',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.disableGutters && styles.disableGutters];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends({
      position: 'absolute',
      right: 16,
      top: '50%',
      transform: 'translateY(-50%)'
    }, ownerState.disableGutters && {
      right: 0
    });
  });

  /**
   * Must be used as the last child of ListItem to function properly.
   */
  var ListItemSecondaryAction = /*#__PURE__*/React__namespace.forwardRef(function ListItemSecondaryAction(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiListItemSecondaryAction'
    });
    var className = props.className,
      other = _objectWithoutProperties(props, ["className"]);
    var context = React__namespace.useContext(ListContext$1);
    var ownerState = _extends({}, props, {
      disableGutters: context.disableGutters
    });
    var classes = useUtilityClasses$P(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(ListItemSecondaryActionRoot, _extends({
      className: clsx(classes.root, className),
      ownerState: ownerState,
      ref: ref
    }, other));
  });
  ListItemSecondaryAction.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component, normally an `IconButton` or selection control.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  ListItemSecondaryAction.muiName = 'ListItemSecondaryAction';
  var ListItemSecondaryAction$1 = ListItemSecondaryAction;

  var overridesResolver$2 = function overridesResolver(props, styles) {
    var ownerState = props.ownerState;
    return [styles.root, ownerState.dense && styles.dense, ownerState.alignItems === 'flex-start' && styles.alignItemsFlexStart, ownerState.divider && styles.divider, !ownerState.disableGutters && styles.gutters, !ownerState.disablePadding && styles.padding, ownerState.button && styles.button, ownerState.hasSecondaryAction && styles.secondaryAction];
  };
  var useUtilityClasses$O = function useUtilityClasses(ownerState) {
    var alignItems = ownerState.alignItems,
      button = ownerState.button,
      classes = ownerState.classes,
      dense = ownerState.dense,
      disabled = ownerState.disabled,
      disableGutters = ownerState.disableGutters,
      disablePadding = ownerState.disablePadding,
      divider = ownerState.divider,
      hasSecondaryAction = ownerState.hasSecondaryAction,
      selected = ownerState.selected;
    var slots = {
      root: ['root', dense && 'dense', !disableGutters && 'gutters', !disablePadding && 'padding', divider && 'divider', disabled && 'disabled', button && 'button', alignItems === 'flex-start' && 'alignItemsFlexStart', hasSecondaryAction && 'secondaryAction', selected && 'selected'],
      container: ['container']
    };
    return composeClasses(slots, getListItemUtilityClass, classes);
  };
  var ListItemRoot = styled$1('div', {
    name: 'MuiListItem',
    slot: 'Root',
    overridesResolver: overridesResolver$2
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      display: 'flex',
      justifyContent: 'flex-start',
      alignItems: 'center',
      position: 'relative',
      textDecoration: 'none',
      width: '100%',
      boxSizing: 'border-box',
      textAlign: 'left'
    }, !ownerState.disablePadding && _extends({
      paddingTop: 8,
      paddingBottom: 8
    }, ownerState.dense && {
      paddingTop: 4,
      paddingBottom: 4
    }, !ownerState.disableGutters && {
      paddingLeft: 16,
      paddingRight: 16
    }, !!ownerState.secondaryAction && {
      // Add some space to avoid collision as `ListItemSecondaryAction`
      // is absolutely positioned.
      paddingRight: 48
    }), !!ownerState.secondaryAction && _defineProperty({}, "& > .".concat(listItemButtonClasses$1.root), {
      paddingRight: 48
    }), _defineProperty(_defineProperty(_defineProperty({}, "&.".concat(listItemClasses$1.focusVisible), {
      backgroundColor: (theme.vars || theme).palette.action.focus
    }), "&.".concat(listItemClasses$1.selected), _defineProperty({
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / ").concat(theme.vars.palette.action.selectedOpacity, ")") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity)
    }, "&.".concat(listItemClasses$1.focusVisible), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.focusOpacity, "))") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)
    })), "&.".concat(listItemClasses$1.disabled), {
      opacity: (theme.vars || theme).palette.action.disabledOpacity
    }), ownerState.alignItems === 'flex-start' && {
      alignItems: 'flex-start'
    }, ownerState.divider && {
      borderBottom: "1px solid ".concat((theme.vars || theme).palette.divider),
      backgroundClip: 'padding-box'
    }, ownerState.button && _defineProperty({
      transition: theme.transitions.create('background-color', {
        duration: theme.transitions.duration.shortest
      }),
      '&:hover': {
        textDecoration: 'none',
        backgroundColor: (theme.vars || theme).palette.action.hover,
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: 'transparent'
        }
      }
    }, "&.".concat(listItemClasses$1.selected, ":hover"), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.hoverOpacity, "))") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity),
      // Reset on touch devices, it doesn't add specificity
      '@media (hover: none)': {
        backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / ").concat(theme.vars.palette.action.selectedOpacity, ")") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity)
      }
    }), ownerState.hasSecondaryAction && {
      // Add some space to avoid collision as `ListItemSecondaryAction`
      // is absolutely positioned.
      paddingRight: 48
    });
  });
  var ListItemContainer = styled$1('li', {
    name: 'MuiListItem',
    slot: 'Container',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.container;
    }
  })({
    position: 'relative'
  });

  /**
   * Uses an additional container component if `ListItemSecondaryAction` is the last child.
   */
  var ListItem = /*#__PURE__*/React__namespace.forwardRef(function ListItem(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiListItem'
    });
    var _props$alignItems = props.alignItems,
      alignItems = _props$alignItems === void 0 ? 'center' : _props$alignItems,
      _props$autoFocus = props.autoFocus,
      autoFocus = _props$autoFocus === void 0 ? false : _props$autoFocus,
      _props$button = props.button,
      button = _props$button === void 0 ? false : _props$button,
      childrenProp = props.children,
      className = props.className,
      componentProp = props.component,
      _props$components = props.components,
      components = _props$components === void 0 ? {} : _props$components,
      _props$componentsProp = props.componentsProps,
      componentsProps = _props$componentsProp === void 0 ? {} : _props$componentsProp,
      _props$ContainerCompo = props.ContainerComponent,
      ContainerComponent = _props$ContainerCompo === void 0 ? 'li' : _props$ContainerCompo,
      _props$ContainerProps = props.ContainerProps,
      _props$ContainerProps2 = _props$ContainerProps === void 0 ? {} : _props$ContainerProps,
      ContainerClassName = _props$ContainerProps2.className,
      ContainerProps = _objectWithoutProperties(_props$ContainerProps2, ["className"]),
      _props$dense = props.dense,
      dense = _props$dense === void 0 ? false : _props$dense,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$disableGutters = props.disableGutters,
      disableGutters = _props$disableGutters === void 0 ? false : _props$disableGutters,
      _props$disablePadding = props.disablePadding,
      disablePadding = _props$disablePadding === void 0 ? false : _props$disablePadding,
      _props$divider = props.divider,
      divider = _props$divider === void 0 ? false : _props$divider,
      focusVisibleClassName = props.focusVisibleClassName,
      secondaryAction = props.secondaryAction,
      _props$selected = props.selected,
      selected = _props$selected === void 0 ? false : _props$selected,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      other = _objectWithoutProperties(props, ["alignItems", "autoFocus", "button", "children", "className", "component", "components", "componentsProps", "ContainerComponent", "ContainerProps", "dense", "disabled", "disableGutters", "disablePadding", "divider", "focusVisibleClassName", "secondaryAction", "selected", "slotProps", "slots"]);
    var context = React__namespace.useContext(ListContext$1);
    var childContext = React__namespace.useMemo(function () {
      return {
        dense: dense || context.dense || false,
        alignItems: alignItems,
        disableGutters: disableGutters
      };
    }, [alignItems, context.dense, dense, disableGutters]);
    var listItemRef = React__namespace.useRef(null);
    useEnhancedEffect$1(function () {
      if (autoFocus) {
        if (listItemRef.current) {
          listItemRef.current.focus();
        } else {
          console.error('MUI: Unable to set focus to a ListItem whose component has not been rendered.');
        }
      }
    }, [autoFocus]);
    var children = React__namespace.Children.toArray(childrenProp);

    // v4 implementation, deprecated in v5, will be removed in v6
    var hasSecondaryAction = children.length && isMuiElement(children[children.length - 1], ['ListItemSecondaryAction']);
    var ownerState = _extends({}, props, {
      alignItems: alignItems,
      autoFocus: autoFocus,
      button: button,
      dense: childContext.dense,
      disabled: disabled,
      disableGutters: disableGutters,
      disablePadding: disablePadding,
      divider: divider,
      hasSecondaryAction: hasSecondaryAction,
      selected: selected
    });
    var classes = useUtilityClasses$O(ownerState);
    var handleRef = useForkRef(listItemRef, ref);
    var Root = slots.root || components.Root || ListItemRoot;
    var rootProps = slotProps.root || componentsProps.root || {};
    var componentProps = _extends({
      className: clsx(classes.root, rootProps.className, className),
      disabled: disabled
    }, other);
    var Component = componentProp || 'li';
    if (button) {
      componentProps.component = componentProp || 'div';
      componentProps.focusVisibleClassName = clsx(listItemClasses$1.focusVisible, focusVisibleClassName);
      Component = ButtonBase$1;
    }

    // v4 implementation, deprecated in v5, will be removed in v6
    if (hasSecondaryAction) {
      // Use div by default.
      Component = !componentProps.component && !componentProp ? 'div' : Component;

      // Avoid nesting of li > li.
      if (ContainerComponent === 'li') {
        if (Component === 'li') {
          Component = 'div';
        } else if (componentProps.component === 'li') {
          componentProps.component = 'div';
        }
      }
      return /*#__PURE__*/jsxRuntimeExports.jsx(ListContext$1.Provider, {
        value: childContext,
        children: /*#__PURE__*/jsxRuntimeExports.jsxs(ListItemContainer, _extends({
          as: ContainerComponent,
          className: clsx(classes.container, ContainerClassName),
          ref: handleRef,
          ownerState: ownerState
        }, ContainerProps, {
          children: [/*#__PURE__*/jsxRuntimeExports.jsx(Root, _extends({}, rootProps, !isHostComponent(Root) && {
            as: Component,
            ownerState: _extends({}, ownerState, rootProps.ownerState)
          }, componentProps, {
            children: children
          })), children.pop()]
        }))
      });
    }
    return /*#__PURE__*/jsxRuntimeExports.jsx(ListContext$1.Provider, {
      value: childContext,
      children: /*#__PURE__*/jsxRuntimeExports.jsxs(Root, _extends({}, rootProps, {
        as: Component,
        ref: handleRef
      }, !isHostComponent(Root) && {
        ownerState: _extends({}, ownerState, rootProps.ownerState)
      }, componentProps, {
        children: [children, secondaryAction && /*#__PURE__*/jsxRuntimeExports.jsx(ListItemSecondaryAction$1, {
          children: secondaryAction
        })]
      }))
    });
  });
  ListItem.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Defines the `align-items` style property.
     * @default 'center'
     */
    alignItems: PropTypes.oneOf(['center', 'flex-start']),
    /**
     * If `true`, the list item is focused during the first mount.
     * Focus will also be triggered if the value changes from false to true.
     * @default false
     * @deprecated checkout [ListItemButton](/material-ui/api/list-item-button/) instead
     */
    autoFocus: PropTypes.bool,
    /**
     * If `true`, the list item is a button (using `ButtonBase`). Props intended
     * for `ButtonBase` can then be applied to `ListItem`.
     * @default false
     * @deprecated checkout [ListItemButton](/material-ui/api/list-item-button/) instead
     */
    button: PropTypes.bool,
    /**
     * The content of the component if a `ListItemSecondaryAction` is used it must
     * be the last child.
     */
    children: chainPropTypes(PropTypes.node, function (props) {
      var children = React__namespace.Children.toArray(props.children);

      // React.Children.toArray(props.children).findLastIndex(isListItemSecondaryAction)
      var secondaryActionIndex = -1;
      for (var i = children.length - 1; i >= 0; i -= 1) {
        var child = children[i];
        if (isMuiElement(child, ['ListItemSecondaryAction'])) {
          secondaryActionIndex = i;
          break;
        }
      }

      //  is ListItemSecondaryAction the last child of ListItem
      if (secondaryActionIndex !== -1 && secondaryActionIndex !== children.length - 1) {
        return new Error('MUI: You used an element after ListItemSecondaryAction. ' + 'For ListItem to detect that it has a secondary action ' + 'you must pass it as the last child to ListItem.');
      }
      return null;
    }),
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `slots` prop.
     * It's recommended to use the `slots` prop instead.
     *
     * @default {}
     */
    components: PropTypes.shape({
      Root: PropTypes.elementType
    }),
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `slotProps` prop.
     * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.
     *
     * @default {}
     */
    componentsProps: PropTypes.shape({
      root: PropTypes.object
    }),
    /**
     * The container component used when a `ListItemSecondaryAction` is the last child.
     * @default 'li'
     * @deprecated
     */
    ContainerComponent: elementTypeAcceptingRef$1,
    /**
     * Props applied to the container component if used.
     * @default {}
     * @deprecated
     */
    ContainerProps: PropTypes.object,
    /**
     * If `true`, compact vertical padding designed for keyboard and mouse input is used.
     * The prop defaults to the value inherited from the parent List component.
     * @default false
     */
    dense: PropTypes.bool,
    /**
     * If `true`, the component is disabled.
     * @default false
     * @deprecated checkout [ListItemButton](/material-ui/api/list-item-button/) instead
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the left and right padding is removed.
     * @default false
     */
    disableGutters: PropTypes.bool,
    /**
     * If `true`, all padding is removed.
     * @default false
     */
    disablePadding: PropTypes.bool,
    /**
     * If `true`, a 1px light border is added to the bottom of the list item.
     * @default false
     */
    divider: PropTypes.bool,
    /**
     * @ignore
     */
    focusVisibleClassName: PropTypes.string,
    /**
     * The element to display at the end of ListItem.
     */
    secondaryAction: PropTypes.node,
    /**
     * Use to apply selected styling.
     * @default false
     * @deprecated checkout [ListItemButton](/material-ui/api/list-item-button/) instead
     */
    selected: PropTypes.bool,
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `componentsProps` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slotProps: PropTypes.shape({
      root: PropTypes.object
    }),
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `components` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slots: PropTypes.shape({
      root: PropTypes.elementType
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var ListItem$1 = ListItem;

  function getListItemAvatarUtilityClass(slot) {
    return generateUtilityClass('MuiListItemAvatar', slot);
  }
  var listItemAvatarClasses = generateUtilityClasses('MuiListItemAvatar', ['root', 'alignItemsFlexStart']);
  var listItemAvatarClasses$1 = listItemAvatarClasses;

  var useUtilityClasses$N = function useUtilityClasses(ownerState) {
    var alignItems = ownerState.alignItems,
      classes = ownerState.classes;
    var slots = {
      root: ['root', alignItems === 'flex-start' && 'alignItemsFlexStart']
    };
    return composeClasses(slots, getListItemAvatarUtilityClass, classes);
  };
  var ListItemAvatarRoot = styled$1('div', {
    name: 'MuiListItemAvatar',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.alignItems === 'flex-start' && styles.alignItemsFlexStart];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends({
      minWidth: 56,
      flexShrink: 0
    }, ownerState.alignItems === 'flex-start' && {
      marginTop: 8
    });
  });

  /**
   * A simple wrapper to apply `List` styles to an `Avatar`.
   */
  var ListItemAvatar = /*#__PURE__*/React__namespace.forwardRef(function ListItemAvatar(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiListItemAvatar'
    });
    var className = props.className,
      other = _objectWithoutProperties(props, ["className"]);
    var context = React__namespace.useContext(ListContext$1);
    var ownerState = _extends({}, props, {
      alignItems: context.alignItems
    });
    var classes = useUtilityClasses$N(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(ListItemAvatarRoot, _extends({
      className: clsx(classes.root, className),
      ownerState: ownerState,
      ref: ref
    }, other));
  });
  ListItemAvatar.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component, normally an `Avatar`.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var ListItemAvatar$1 = ListItemAvatar;

  function getListItemIconUtilityClass(slot) {
    return generateUtilityClass('MuiListItemIcon', slot);
  }
  var listItemIconClasses = generateUtilityClasses('MuiListItemIcon', ['root', 'alignItemsFlexStart']);
  var listItemIconClasses$1 = listItemIconClasses;

  var useUtilityClasses$M = function useUtilityClasses(ownerState) {
    var alignItems = ownerState.alignItems,
      classes = ownerState.classes;
    var slots = {
      root: ['root', alignItems === 'flex-start' && 'alignItemsFlexStart']
    };
    return composeClasses(slots, getListItemIconUtilityClass, classes);
  };
  var ListItemIconRoot = styled$1('div', {
    name: 'MuiListItemIcon',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.alignItems === 'flex-start' && styles.alignItemsFlexStart];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      minWidth: 56,
      color: (theme.vars || theme).palette.action.active,
      flexShrink: 0,
      display: 'inline-flex'
    }, ownerState.alignItems === 'flex-start' && {
      marginTop: 8
    });
  });

  /**
   * A simple wrapper to apply `List` styles to an `Icon` or `SvgIcon`.
   */
  var ListItemIcon = /*#__PURE__*/React__namespace.forwardRef(function ListItemIcon(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiListItemIcon'
    });
    var className = props.className,
      other = _objectWithoutProperties(props, ["className"]);
    var context = React__namespace.useContext(ListContext$1);
    var ownerState = _extends({}, props, {
      alignItems: context.alignItems
    });
    var classes = useUtilityClasses$M(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(ListItemIconRoot, _extends({
      className: clsx(classes.root, className),
      ownerState: ownerState,
      ref: ref
    }, other));
  });
  ListItemIcon.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component, normally `Icon`, `SvgIcon`,
     * or a `@mui/icons-material` SVG icon element.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var ListItemIcon$1 = ListItemIcon;

  function getListItemTextUtilityClass(slot) {
    return generateUtilityClass('MuiListItemText', slot);
  }
  var listItemTextClasses = generateUtilityClasses('MuiListItemText', ['root', 'multiline', 'dense', 'inset', 'primary', 'secondary']);
  var listItemTextClasses$1 = listItemTextClasses;

  var useUtilityClasses$L = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      inset = ownerState.inset,
      primary = ownerState.primary,
      secondary = ownerState.secondary,
      dense = ownerState.dense;
    var slots = {
      root: ['root', inset && 'inset', dense && 'dense', primary && secondary && 'multiline'],
      primary: ['primary'],
      secondary: ['secondary']
    };
    return composeClasses(slots, getListItemTextUtilityClass, classes);
  };
  var ListItemTextRoot = styled$1('div', {
    name: 'MuiListItemText',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [_defineProperty({}, "& .".concat(listItemTextClasses$1.primary), styles.primary), _defineProperty({}, "& .".concat(listItemTextClasses$1.secondary), styles.secondary), styles.root, ownerState.inset && styles.inset, ownerState.primary && ownerState.secondary && styles.multiline, ownerState.dense && styles.dense];
    }
  })(function (_ref3) {
    var ownerState = _ref3.ownerState;
    return _extends({
      flex: '1 1 auto',
      minWidth: 0,
      marginTop: 4,
      marginBottom: 4
    }, ownerState.primary && ownerState.secondary && {
      marginTop: 6,
      marginBottom: 6
    }, ownerState.inset && {
      paddingLeft: 56
    });
  });
  var ListItemText = /*#__PURE__*/React__namespace.forwardRef(function ListItemText(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiListItemText'
    });
    var children = props.children,
      className = props.className,
      _props$disableTypogra = props.disableTypography,
      disableTypography = _props$disableTypogra === void 0 ? false : _props$disableTypogra,
      _props$inset = props.inset,
      inset = _props$inset === void 0 ? false : _props$inset,
      primaryProp = props.primary,
      primaryTypographyProps = props.primaryTypographyProps,
      secondaryProp = props.secondary,
      secondaryTypographyProps = props.secondaryTypographyProps,
      other = _objectWithoutProperties(props, ["children", "className", "disableTypography", "inset", "primary", "primaryTypographyProps", "secondary", "secondaryTypographyProps"]);
    var _React$useContext = React__namespace.useContext(ListContext$1),
      dense = _React$useContext.dense;
    var primary = primaryProp != null ? primaryProp : children;
    var secondary = secondaryProp;
    var ownerState = _extends({}, props, {
      disableTypography: disableTypography,
      inset: inset,
      primary: !!primary,
      secondary: !!secondary,
      dense: dense
    });
    var classes = useUtilityClasses$L(ownerState);
    if (primary != null && primary.type !== Typography$1 && !disableTypography) {
      primary = /*#__PURE__*/jsxRuntimeExports.jsx(Typography$1, _extends({
        variant: dense ? 'body2' : 'body1',
        className: classes.primary,
        component: primaryTypographyProps != null && primaryTypographyProps.variant ? undefined : 'span',
        display: "block"
      }, primaryTypographyProps, {
        children: primary
      }));
    }
    if (secondary != null && secondary.type !== Typography$1 && !disableTypography) {
      secondary = /*#__PURE__*/jsxRuntimeExports.jsx(Typography$1, _extends({
        variant: "body2",
        className: classes.secondary,
        color: "text.secondary",
        display: "block"
      }, secondaryTypographyProps, {
        children: secondary
      }));
    }
    return /*#__PURE__*/jsxRuntimeExports.jsxs(ListItemTextRoot, _extends({
      className: clsx(classes.root, className),
      ownerState: ownerState,
      ref: ref
    }, other, {
      children: [primary, secondary]
    }));
  });
  ListItemText.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Alias for the `primary` prop.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * If `true`, the children won't be wrapped by a Typography component.
     * This can be useful to render an alternative Typography variant by wrapping
     * the `children` (or `primary`) text, and optional `secondary` text
     * with the Typography component.
     * @default false
     */
    disableTypography: PropTypes.bool,
    /**
     * If `true`, the children are indented.
     * This should be used if there is no left avatar or left icon.
     * @default false
     */
    inset: PropTypes.bool,
    /**
     * The main content element.
     */
    primary: PropTypes.node,
    /**
     * These props will be forwarded to the primary typography component
     * (as long as disableTypography is not `true`).
     */
    primaryTypographyProps: PropTypes.object,
    /**
     * The secondary content element.
     */
    secondary: PropTypes.node,
    /**
     * These props will be forwarded to the secondary typography component
     * (as long as disableTypography is not `true`).
     */
    secondaryTypographyProps: PropTypes.object,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var ListItemText$1 = ListItemText;

  function nextItem$1(list, item, disableListWrap) {
    if (list === item) {
      return list.firstChild;
    }
    if (item && item.nextElementSibling) {
      return item.nextElementSibling;
    }
    return disableListWrap ? null : list.firstChild;
  }
  function previousItem$1(list, item, disableListWrap) {
    if (list === item) {
      return disableListWrap ? list.firstChild : list.lastChild;
    }
    if (item && item.previousElementSibling) {
      return item.previousElementSibling;
    }
    return disableListWrap ? null : list.lastChild;
  }
  function textCriteriaMatches(nextFocus, textCriteria) {
    if (textCriteria === undefined) {
      return true;
    }
    var text = nextFocus.innerText;
    if (text === undefined) {
      // jsdom doesn't support innerText
      text = nextFocus.textContent;
    }
    text = text.trim().toLowerCase();
    if (text.length === 0) {
      return false;
    }
    if (textCriteria.repeating) {
      return text[0] === textCriteria.keys[0];
    }
    return text.indexOf(textCriteria.keys.join('')) === 0;
  }
  function moveFocus$1(list, currentFocus, disableListWrap, disabledItemsFocusable, traversalFunction, textCriteria) {
    var wrappedOnce = false;
    var nextFocus = traversalFunction(list, currentFocus, currentFocus ? disableListWrap : false);
    while (nextFocus) {
      // Prevent infinite loop.
      if (nextFocus === list.firstChild) {
        if (wrappedOnce) {
          return false;
        }
        wrappedOnce = true;
      }

      // Same logic as useAutocomplete.js
      var nextFocusDisabled = disabledItemsFocusable ? false : nextFocus.disabled || nextFocus.getAttribute('aria-disabled') === 'true';
      if (!nextFocus.hasAttribute('tabindex') || !textCriteriaMatches(nextFocus, textCriteria) || nextFocusDisabled) {
        // Move to the next element.
        nextFocus = traversalFunction(list, nextFocus, disableListWrap);
      } else {
        nextFocus.focus();
        return true;
      }
    }
    return false;
  }

  /**
   * A permanently displayed menu following https://www.w3.org/WAI/ARIA/apg/patterns/menu-button/.
   * It's exposed to help customization of the [`Menu`](/material-ui/api/menu/) component if you
   * use it separately you need to move focus into the component manually. Once
   * the focus is placed inside the component it is fully keyboard accessible.
   */
  var MenuList = /*#__PURE__*/React__namespace.forwardRef(function MenuList(props, ref) {
    var actions = props.actions,
      _props$autoFocus = props.autoFocus,
      autoFocus = _props$autoFocus === void 0 ? false : _props$autoFocus,
      _props$autoFocusItem = props.autoFocusItem,
      autoFocusItem = _props$autoFocusItem === void 0 ? false : _props$autoFocusItem,
      children = props.children,
      className = props.className,
      _props$disabledItemsF = props.disabledItemsFocusable,
      disabledItemsFocusable = _props$disabledItemsF === void 0 ? false : _props$disabledItemsF,
      _props$disableListWra = props.disableListWrap,
      disableListWrap = _props$disableListWra === void 0 ? false : _props$disableListWra,
      onKeyDown = props.onKeyDown,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'selectedMenu' : _props$variant,
      other = _objectWithoutProperties(props, ["actions", "autoFocus", "autoFocusItem", "children", "className", "disabledItemsFocusable", "disableListWrap", "onKeyDown", "variant"]);
    var listRef = React__namespace.useRef(null);
    var textCriteriaRef = React__namespace.useRef({
      keys: [],
      repeating: true,
      previousKeyMatched: true,
      lastTime: null
    });
    useEnhancedEffect$1(function () {
      if (autoFocus) {
        listRef.current.focus();
      }
    }, [autoFocus]);
    React__namespace.useImperativeHandle(actions, function () {
      return {
        adjustStyleForScrollbar: function adjustStyleForScrollbar(containerElement, _ref) {
          var direction = _ref.direction;
          // Let's ignore that piece of logic if users are already overriding the width
          // of the menu.
          var noExplicitWidth = !listRef.current.style.width;
          if (containerElement.clientHeight < listRef.current.clientHeight && noExplicitWidth) {
            var scrollbarSize = "".concat(getScrollbarSize(ownerDocument(containerElement)), "px");
            listRef.current.style[direction === 'rtl' ? 'paddingLeft' : 'paddingRight'] = scrollbarSize;
            listRef.current.style.width = "calc(100% + ".concat(scrollbarSize, ")");
          }
          return listRef.current;
        }
      };
    }, []);
    var handleKeyDown = function handleKeyDown(event) {
      var list = listRef.current;
      var key = event.key;
      /**
       * @type {Element} - will always be defined since we are in a keydown handler
       * attached to an element. A keydown event is either dispatched to the activeElement
       * or document.body or document.documentElement. Only the first case will
       * trigger this specific handler.
       */
      var currentFocus = ownerDocument(list).activeElement;
      if (key === 'ArrowDown') {
        // Prevent scroll of the page
        event.preventDefault();
        moveFocus$1(list, currentFocus, disableListWrap, disabledItemsFocusable, nextItem$1);
      } else if (key === 'ArrowUp') {
        event.preventDefault();
        moveFocus$1(list, currentFocus, disableListWrap, disabledItemsFocusable, previousItem$1);
      } else if (key === 'Home') {
        event.preventDefault();
        moveFocus$1(list, null, disableListWrap, disabledItemsFocusable, nextItem$1);
      } else if (key === 'End') {
        event.preventDefault();
        moveFocus$1(list, null, disableListWrap, disabledItemsFocusable, previousItem$1);
      } else if (key.length === 1) {
        var criteria = textCriteriaRef.current;
        var lowerKey = key.toLowerCase();
        var currTime = performance.now();
        if (criteria.keys.length > 0) {
          // Reset
          if (currTime - criteria.lastTime > 500) {
            criteria.keys = [];
            criteria.repeating = true;
            criteria.previousKeyMatched = true;
          } else if (criteria.repeating && lowerKey !== criteria.keys[0]) {
            criteria.repeating = false;
          }
        }
        criteria.lastTime = currTime;
        criteria.keys.push(lowerKey);
        var keepFocusOnCurrent = currentFocus && !criteria.repeating && textCriteriaMatches(currentFocus, criteria);
        if (criteria.previousKeyMatched && (keepFocusOnCurrent || moveFocus$1(list, currentFocus, false, disabledItemsFocusable, nextItem$1, criteria))) {
          event.preventDefault();
        } else {
          criteria.previousKeyMatched = false;
        }
      }
      if (onKeyDown) {
        onKeyDown(event);
      }
    };
    var handleRef = useForkRef(listRef, ref);

    /**
     * the index of the item should receive focus
     * in a `variant="selectedMenu"` it's the first `selected` item
     * otherwise it's the very first item.
     */
    var activeItemIndex = -1;
    // since we inject focus related props into children we have to do a lookahead
    // to check if there is a `selected` item. We're looking for the last `selected`
    // item and use the first valid item as a fallback
    React__namespace.Children.forEach(children, function (child, index) {
      if (! /*#__PURE__*/React__namespace.isValidElement(child)) {
        if (activeItemIndex === index) {
          activeItemIndex += 1;
          if (activeItemIndex >= children.length) {
            // there are no focusable items within the list.
            activeItemIndex = -1;
          }
        }
        return;
      }
      {
        if (reactIsExports.isFragment(child)) {
          console.error(["MUI: The Menu component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n'));
        }
      }
      if (!child.props.disabled) {
        if (variant === 'selectedMenu' && child.props.selected) {
          activeItemIndex = index;
        } else if (activeItemIndex === -1) {
          activeItemIndex = index;
        }
      }
      if (activeItemIndex === index && (child.props.disabled || child.props.muiSkipListHighlight || child.type.muiSkipListHighlight)) {
        activeItemIndex += 1;
        if (activeItemIndex >= children.length) {
          // there are no focusable items within the list.
          activeItemIndex = -1;
        }
      }
    });
    var items = React__namespace.Children.map(children, function (child, index) {
      if (index === activeItemIndex) {
        var newChildProps = {};
        if (autoFocusItem) {
          newChildProps.autoFocus = true;
        }
        if (child.props.tabIndex === undefined && variant === 'selectedMenu') {
          newChildProps.tabIndex = 0;
        }
        return /*#__PURE__*/React__namespace.cloneElement(child, newChildProps);
      }
      return child;
    });
    return /*#__PURE__*/jsxRuntimeExports.jsx(List$1, _extends({
      role: "menu",
      ref: handleRef,
      className: className,
      onKeyDown: handleKeyDown,
      tabIndex: autoFocus ? 0 : -1
    }, other, {
      children: items
    }));
  });
  MenuList.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * If `true`, will focus the `[role="menu"]` container and move into tab order.
     * @default false
     */
    autoFocus: PropTypes.bool,
    /**
     * If `true`, will focus the first menuitem if `variant="menu"` or selected item
     * if `variant="selectedMenu"`.
     * @default false
     */
    autoFocusItem: PropTypes.bool,
    /**
     * MenuList contents, normally `MenuItem`s.
     */
    children: PropTypes.node,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * If `true`, will allow focus on disabled items.
     * @default false
     */
    disabledItemsFocusable: PropTypes.bool,
    /**
     * If `true`, the menu items will not wrap focus.
     * @default false
     */
    disableListWrap: PropTypes.bool,
    /**
     * @ignore
     */
    onKeyDown: PropTypes.func,
    /**
     * The variant to use. Use `menu` to prevent selected items from impacting the initial focus
     * and the vertical alignment relative to the anchor element.
     * @default 'selectedMenu'
     */
    variant: PropTypes.oneOf(['menu', 'selectedMenu'])
  } ;
  var MenuList$1 = MenuList;

  function getPopoverUtilityClass(slot) {
    return generateUtilityClass('MuiPopover', slot);
  }
  var popoverClasses = generateUtilityClasses('MuiPopover', ['root', 'paper']);
  var popoverClasses$1 = popoverClasses;

  function getOffsetTop(rect, vertical) {
    var offset = 0;
    if (typeof vertical === 'number') {
      offset = vertical;
    } else if (vertical === 'center') {
      offset = rect.height / 2;
    } else if (vertical === 'bottom') {
      offset = rect.height;
    }
    return offset;
  }
  function getOffsetLeft(rect, horizontal) {
    var offset = 0;
    if (typeof horizontal === 'number') {
      offset = horizontal;
    } else if (horizontal === 'center') {
      offset = rect.width / 2;
    } else if (horizontal === 'right') {
      offset = rect.width;
    }
    return offset;
  }
  function getTransformOriginValue(transformOrigin) {
    return [transformOrigin.horizontal, transformOrigin.vertical].map(function (n) {
      return typeof n === 'number' ? "".concat(n, "px") : n;
    }).join(' ');
  }
  function resolveAnchorEl(anchorEl) {
    return typeof anchorEl === 'function' ? anchorEl() : anchorEl;
  }
  var useUtilityClasses$K = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root'],
      paper: ['paper']
    };
    return composeClasses(slots, getPopoverUtilityClass, classes);
  };
  var PopoverRoot = styled$1(Modal$1, {
    name: 'MuiPopover',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })({});
  var PopoverPaper = styled$1(Paper$1, {
    name: 'MuiPopover',
    slot: 'Paper',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.paper;
    }
  })({
    position: 'absolute',
    overflowY: 'auto',
    overflowX: 'hidden',
    // So we see the popover when it's empty.
    // It's most likely on issue on userland.
    minWidth: 16,
    minHeight: 16,
    maxWidth: 'calc(100% - 32px)',
    maxHeight: 'calc(100% - 32px)',
    // We disable the focus ring for mouse, touch and keyboard users.
    outline: 0
  });
  var Popover = /*#__PURE__*/React__namespace.forwardRef(function Popover(inProps, ref) {
    var _slotProps$paper, _slots$root, _slots$paper;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiPopover'
    });
    var action = props.action,
      anchorEl = props.anchorEl,
      _props$anchorOrigin = props.anchorOrigin,
      anchorOrigin = _props$anchorOrigin === void 0 ? {
        vertical: 'top',
        horizontal: 'left'
      } : _props$anchorOrigin,
      anchorPosition = props.anchorPosition,
      _props$anchorReferenc = props.anchorReference,
      anchorReference = _props$anchorReferenc === void 0 ? 'anchorEl' : _props$anchorReferenc,
      children = props.children,
      className = props.className,
      containerProp = props.container,
      _props$elevation = props.elevation,
      elevation = _props$elevation === void 0 ? 8 : _props$elevation,
      _props$marginThreshol = props.marginThreshold,
      marginThreshold = _props$marginThreshol === void 0 ? 16 : _props$marginThreshol,
      open = props.open,
      _props$PaperProps = props.PaperProps,
      PaperPropsProp = _props$PaperProps === void 0 ? {} : _props$PaperProps,
      slots = props.slots,
      slotProps = props.slotProps,
      _props$transformOrigi = props.transformOrigin,
      transformOrigin = _props$transformOrigi === void 0 ? {
        vertical: 'top',
        horizontal: 'left'
      } : _props$transformOrigi,
      _props$TransitionComp = props.TransitionComponent,
      TransitionComponent = _props$TransitionComp === void 0 ? Grow$1 : _props$TransitionComp,
      _props$transitionDura = props.transitionDuration,
      transitionDurationProp = _props$transitionDura === void 0 ? 'auto' : _props$transitionDura,
      _props$TransitionProp = props.TransitionProps,
      _props$TransitionProp2 = _props$TransitionProp === void 0 ? {} : _props$TransitionProp,
      onEntering = _props$TransitionProp2.onEntering,
      TransitionProps = _objectWithoutProperties(_props$TransitionProp2, ["onEntering"]),
      _props$disableScrollL = props.disableScrollLock,
      disableScrollLock = _props$disableScrollL === void 0 ? false : _props$disableScrollL,
      other = _objectWithoutProperties(props, ["action", "anchorEl", "anchorOrigin", "anchorPosition", "anchorReference", "children", "className", "container", "elevation", "marginThreshold", "open", "PaperProps", "slots", "slotProps", "transformOrigin", "TransitionComponent", "transitionDuration", "TransitionProps", "disableScrollLock"]);
    var externalPaperSlotProps = (_slotProps$paper = slotProps == null ? void 0 : slotProps.paper) != null ? _slotProps$paper : PaperPropsProp;
    var paperRef = React__namespace.useRef();
    var handlePaperRef = useForkRef(paperRef, externalPaperSlotProps.ref);
    var ownerState = _extends({}, props, {
      anchorOrigin: anchorOrigin,
      anchorReference: anchorReference,
      elevation: elevation,
      marginThreshold: marginThreshold,
      externalPaperSlotProps: externalPaperSlotProps,
      transformOrigin: transformOrigin,
      TransitionComponent: TransitionComponent,
      transitionDuration: transitionDurationProp,
      TransitionProps: TransitionProps
    });
    var classes = useUtilityClasses$K(ownerState);

    // Returns the top/left offset of the position
    // to attach to on the anchor element (or body if none is provided)
    var getAnchorOffset = React__namespace.useCallback(function () {
      if (anchorReference === 'anchorPosition') {
        {
          if (!anchorPosition) {
            console.error('MUI: You need to provide a `anchorPosition` prop when using ' + '<Popover anchorReference="anchorPosition" />.');
          }
        }
        return anchorPosition;
      }
      var resolvedAnchorEl = resolveAnchorEl(anchorEl);

      // If an anchor element wasn't provided, just use the parent body element of this Popover
      var anchorElement = resolvedAnchorEl && resolvedAnchorEl.nodeType === 1 ? resolvedAnchorEl : ownerDocument(paperRef.current).body;
      var anchorRect = anchorElement.getBoundingClientRect();
      {
        var box = anchorElement.getBoundingClientRect();
        if (box.top === 0 && box.left === 0 && box.right === 0 && box.bottom === 0) {
          console.warn(['MUI: The `anchorEl` prop provided to the component is invalid.', 'The anchor element should be part of the document layout.', "Make sure the element is present in the document or that it's not display none."].join('\n'));
        }
      }
      return {
        top: anchorRect.top + getOffsetTop(anchorRect, anchorOrigin.vertical),
        left: anchorRect.left + getOffsetLeft(anchorRect, anchorOrigin.horizontal)
      };
    }, [anchorEl, anchorOrigin.horizontal, anchorOrigin.vertical, anchorPosition, anchorReference]);

    // Returns the base transform origin using the element
    var getTransformOrigin = React__namespace.useCallback(function (elemRect) {
      return {
        vertical: getOffsetTop(elemRect, transformOrigin.vertical),
        horizontal: getOffsetLeft(elemRect, transformOrigin.horizontal)
      };
    }, [transformOrigin.horizontal, transformOrigin.vertical]);
    var getPositioningStyle = React__namespace.useCallback(function (element) {
      var elemRect = {
        width: element.offsetWidth,
        height: element.offsetHeight
      };

      // Get the transform origin point on the element itself
      var elemTransformOrigin = getTransformOrigin(elemRect);
      if (anchorReference === 'none') {
        return {
          top: null,
          left: null,
          transformOrigin: getTransformOriginValue(elemTransformOrigin)
        };
      }

      // Get the offset of the anchoring element
      var anchorOffset = getAnchorOffset();

      // Calculate element positioning
      var top = anchorOffset.top - elemTransformOrigin.vertical;
      var left = anchorOffset.left - elemTransformOrigin.horizontal;
      var bottom = top + elemRect.height;
      var right = left + elemRect.width;

      // Use the parent window of the anchorEl if provided
      var containerWindow = ownerWindow(resolveAnchorEl(anchorEl));

      // Window thresholds taking required margin into account
      var heightThreshold = containerWindow.innerHeight - marginThreshold;
      var widthThreshold = containerWindow.innerWidth - marginThreshold;

      // Check if the vertical axis needs shifting
      if (marginThreshold !== null && top < marginThreshold) {
        var diff = top - marginThreshold;
        top -= diff;
        elemTransformOrigin.vertical += diff;
      } else if (marginThreshold !== null && bottom > heightThreshold) {
        var _diff = bottom - heightThreshold;
        top -= _diff;
        elemTransformOrigin.vertical += _diff;
      }
      {
        if (elemRect.height > heightThreshold && elemRect.height && heightThreshold) {
          console.error(['MUI: The popover component is too tall.', "Some part of it can not be seen on the screen (".concat(elemRect.height - heightThreshold, "px)."), 'Please consider adding a `max-height` to improve the user-experience.'].join('\n'));
        }
      }

      // Check if the horizontal axis needs shifting
      if (marginThreshold !== null && left < marginThreshold) {
        var _diff2 = left - marginThreshold;
        left -= _diff2;
        elemTransformOrigin.horizontal += _diff2;
      } else if (right > widthThreshold) {
        var _diff3 = right - widthThreshold;
        left -= _diff3;
        elemTransformOrigin.horizontal += _diff3;
      }
      return {
        top: "".concat(Math.round(top), "px"),
        left: "".concat(Math.round(left), "px"),
        transformOrigin: getTransformOriginValue(elemTransformOrigin)
      };
    }, [anchorEl, anchorReference, getAnchorOffset, getTransformOrigin, marginThreshold]);
    var _React$useState = React__namespace.useState(open),
      isPositioned = _React$useState[0],
      setIsPositioned = _React$useState[1];
    var setPositioningStyles = React__namespace.useCallback(function () {
      var element = paperRef.current;
      if (!element) {
        return;
      }
      var positioning = getPositioningStyle(element);
      if (positioning.top !== null) {
        element.style.top = positioning.top;
      }
      if (positioning.left !== null) {
        element.style.left = positioning.left;
      }
      element.style.transformOrigin = positioning.transformOrigin;
      setIsPositioned(true);
    }, [getPositioningStyle]);
    React__namespace.useEffect(function () {
      if (disableScrollLock) {
        window.addEventListener('scroll', setPositioningStyles);
      }
      return function () {
        return window.removeEventListener('scroll', setPositioningStyles);
      };
    }, [anchorEl, disableScrollLock, setPositioningStyles]);
    var handleEntering = function handleEntering(element, isAppearing) {
      if (onEntering) {
        onEntering(element, isAppearing);
      }
      setPositioningStyles();
    };
    var handleExited = function handleExited() {
      setIsPositioned(false);
    };
    React__namespace.useEffect(function () {
      if (open) {
        setPositioningStyles();
      }
    });
    React__namespace.useImperativeHandle(action, function () {
      return open ? {
        updatePosition: function updatePosition() {
          setPositioningStyles();
        }
      } : null;
    }, [open, setPositioningStyles]);
    React__namespace.useEffect(function () {
      if (!open) {
        return undefined;
      }
      var handleResize = debounce$1(function () {
        setPositioningStyles();
      });
      var containerWindow = ownerWindow(anchorEl);
      containerWindow.addEventListener('resize', handleResize);
      return function () {
        handleResize.clear();
        containerWindow.removeEventListener('resize', handleResize);
      };
    }, [anchorEl, open, setPositioningStyles]);
    var transitionDuration = transitionDurationProp;
    if (transitionDurationProp === 'auto' && !TransitionComponent.muiSupportAuto) {
      transitionDuration = undefined;
    }

    // If the container prop is provided, use that
    // If the anchorEl prop is provided, use its parent body element as the container
    // If neither are provided let the Modal take care of choosing the container
    var container = containerProp || (anchorEl ? ownerDocument(resolveAnchorEl(anchorEl)).body : undefined);
    var RootSlot = (_slots$root = slots == null ? void 0 : slots.root) != null ? _slots$root : PopoverRoot;
    var PaperSlot = (_slots$paper = slots == null ? void 0 : slots.paper) != null ? _slots$paper : PopoverPaper;
    var paperProps = useSlotProps({
      elementType: PaperSlot,
      externalSlotProps: _extends({}, externalPaperSlotProps, {
        style: isPositioned ? externalPaperSlotProps.style : _extends({}, externalPaperSlotProps.style, {
          opacity: 0
        })
      }),
      additionalProps: {
        elevation: elevation,
        ref: handlePaperRef
      },
      ownerState: ownerState,
      className: clsx(classes.paper, externalPaperSlotProps == null ? void 0 : externalPaperSlotProps.className)
    });
    var _useSlotProps = useSlotProps({
        elementType: RootSlot,
        externalSlotProps: (slotProps == null ? void 0 : slotProps.root) || {},
        externalForwardedProps: other,
        additionalProps: {
          ref: ref,
          slotProps: {
            backdrop: {
              invisible: true
            }
          },
          container: container,
          open: open
        },
        ownerState: ownerState,
        className: clsx(classes.root, className)
      }),
      rootSlotPropsProp = _useSlotProps.slotProps,
      rootProps = _objectWithoutProperties(_useSlotProps, ["slotProps"]);
    return /*#__PURE__*/jsxRuntimeExports.jsx(RootSlot, _extends({}, rootProps, !isHostComponent(RootSlot) && {
      slotProps: rootSlotPropsProp,
      disableScrollLock: disableScrollLock
    }, {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(TransitionComponent, _extends({
        appear: true,
        "in": open,
        onEntering: handleEntering,
        onExited: handleExited,
        timeout: transitionDuration
      }, TransitionProps, {
        children: /*#__PURE__*/jsxRuntimeExports.jsx(PaperSlot, _extends({}, paperProps, {
          children: children
        }))
      }))
    }));
  });
  Popover.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * A ref for imperative actions.
     * It currently only supports updatePosition() action.
     */
    action: refType$1,
    /**
     * An HTML element, [PopoverVirtualElement](/material-ui/react-popover/#virtual-element),
     * or a function that returns either.
     * It's used to set the position of the popover.
     */
    anchorEl: chainPropTypes(PropTypes.oneOfType([HTMLElementType, PropTypes.func]), function (props) {
      if (props.open && (!props.anchorReference || props.anchorReference === 'anchorEl')) {
        var resolvedAnchorEl = resolveAnchorEl(props.anchorEl);
        if (resolvedAnchorEl && resolvedAnchorEl.nodeType === 1) {
          var box = resolvedAnchorEl.getBoundingClientRect();
          if (box.top === 0 && box.left === 0 && box.right === 0 && box.bottom === 0) {
            return new Error(['MUI: The `anchorEl` prop provided to the component is invalid.', 'The anchor element should be part of the document layout.', "Make sure the element is present in the document or that it's not display none."].join('\n'));
          }
        } else {
          return new Error(['MUI: The `anchorEl` prop provided to the component is invalid.', "It should be an Element or PopoverVirtualElement instance but it's `".concat(resolvedAnchorEl, "` instead.")].join('\n'));
        }
      }
      return null;
    }),
    /**
     * This is the point on the anchor where the popover's
     * `anchorEl` will attach to. This is not used when the
     * anchorReference is 'anchorPosition'.
     *
     * Options:
     * vertical: [top, center, bottom];
     * horizontal: [left, center, right].
     * @default {
     *   vertical: 'top',
     *   horizontal: 'left',
     * }
     */
    anchorOrigin: PropTypes.shape({
      horizontal: PropTypes.oneOfType([PropTypes.oneOf(['center', 'left', 'right']), PropTypes.number]).isRequired,
      vertical: PropTypes.oneOfType([PropTypes.oneOf(['bottom', 'center', 'top']), PropTypes.number]).isRequired
    }),
    /**
     * This is the position that may be used to set the position of the popover.
     * The coordinates are relative to the application's client area.
     */
    anchorPosition: PropTypes.shape({
      left: PropTypes.number.isRequired,
      top: PropTypes.number.isRequired
    }),
    /**
     * This determines which anchor prop to refer to when setting
     * the position of the popover.
     * @default 'anchorEl'
     */
    anchorReference: PropTypes.oneOf(['anchorEl', 'anchorPosition', 'none']),
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * An HTML element, component instance, or function that returns either.
     * The `container` will passed to the Modal component.
     *
     * By default, it uses the body of the anchorEl's top-level document object,
     * so it's simply `document.body` most of the time.
     */
    container: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.func]),
    /**
     * Disable the scroll lock behavior.
     * @default false
     */
    disableScrollLock: PropTypes.bool,
    /**
     * The elevation of the popover.
     * @default 8
     */
    elevation: integerPropType,
    /**
     * Specifies how close to the edge of the window the popover can appear.
     * If null, the popover will not be constrained by the window.
     * @default 16
     */
    marginThreshold: PropTypes.number,
    /**
     * Callback fired when the component requests to be closed.
     * The `reason` parameter can optionally be used to control the response to `onClose`.
     */
    onClose: PropTypes.func,
    /**
     * If `true`, the component is shown.
     */
    open: PropTypes.bool.isRequired,
    /**
     * Props applied to the [`Paper`](/material-ui/api/paper/) element.
     *
     * This prop is an alias for `slotProps.paper` and will be overriden by it if both are used.
     * @deprecated Use `slotProps.paper` instead.
     *
     * @default {}
     */
    PaperProps: PropTypes /* @typescript-to-proptypes-ignore */.shape({
      component: elementTypeAcceptingRef$1
    }),
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * @default {}
     */
    slotProps: PropTypes.shape({
      paper: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * The components used for each slot inside.
     *
     * @default {}
     */
    slots: PropTypes.shape({
      paper: PropTypes.elementType,
      root: PropTypes.elementType
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * This is the point on the popover which
     * will attach to the anchor's origin.
     *
     * Options:
     * vertical: [top, center, bottom, x(px)];
     * horizontal: [left, center, right, x(px)].
     * @default {
     *   vertical: 'top',
     *   horizontal: 'left',
     * }
     */
    transformOrigin: PropTypes.shape({
      horizontal: PropTypes.oneOfType([PropTypes.oneOf(['center', 'left', 'right']), PropTypes.number]).isRequired,
      vertical: PropTypes.oneOfType([PropTypes.oneOf(['bottom', 'center', 'top']), PropTypes.number]).isRequired
    }),
    /**
     * The component used for the transition.
     * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
     * @default Grow
     */
    TransitionComponent: PropTypes.elementType,
    /**
     * Set to 'auto' to automatically calculate transition time based on height.
     * @default 'auto'
     */
    transitionDuration: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.shape({
      appear: PropTypes.number,
      enter: PropTypes.number,
      exit: PropTypes.number
    })]),
    /**
     * Props applied to the transition element.
     * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
     * @default {}
     */
    TransitionProps: PropTypes.object
  } ;
  var Popover$1 = Popover;

  function getMenuUtilityClass(slot) {
    return generateUtilityClass('MuiMenu', slot);
  }
  var menuClasses = generateUtilityClasses('MuiMenu', ['root', 'paper', 'list']);
  var menuClasses$1 = menuClasses;

  var RTL_ORIGIN = {
    vertical: 'top',
    horizontal: 'right'
  };
  var LTR_ORIGIN = {
    vertical: 'top',
    horizontal: 'left'
  };
  var useUtilityClasses$J = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root'],
      paper: ['paper'],
      list: ['list']
    };
    return composeClasses(slots, getMenuUtilityClass, classes);
  };
  var MenuRoot = styled$1(Popover$1, {
    shouldForwardProp: function shouldForwardProp(prop) {
      return rootShouldForwardProp$1(prop) || prop === 'classes';
    },
    name: 'MuiMenu',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })({});
  var MenuPaper = styled$1(PopoverPaper, {
    name: 'MuiMenu',
    slot: 'Paper',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.paper;
    }
  })({
    // specZ: The maximum height of a simple menu should be one or more rows less than the view
    // height. This ensures a tappable area outside of the simple menu with which to dismiss
    // the menu.
    maxHeight: 'calc(100% - 96px)',
    // Add iOS momentum scrolling for iOS < 13.0
    WebkitOverflowScrolling: 'touch'
  });
  var MenuMenuList = styled$1(MenuList$1, {
    name: 'MuiMenu',
    slot: 'List',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.list;
    }
  })({
    // We disable the focus ring for mouse, touch and keyboard users.
    outline: 0
  });
  var Menu = /*#__PURE__*/React__namespace.forwardRef(function Menu(inProps, ref) {
    var _slots$paper, _slotProps$paper;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiMenu'
    });
    var _props$autoFocus = props.autoFocus,
      autoFocus = _props$autoFocus === void 0 ? true : _props$autoFocus,
      children = props.children,
      className = props.className,
      _props$disableAutoFoc = props.disableAutoFocusItem,
      disableAutoFocusItem = _props$disableAutoFoc === void 0 ? false : _props$disableAutoFoc,
      _props$MenuListProps = props.MenuListProps,
      MenuListProps = _props$MenuListProps === void 0 ? {} : _props$MenuListProps,
      onClose = props.onClose,
      open = props.open,
      _props$PaperProps = props.PaperProps,
      PaperProps = _props$PaperProps === void 0 ? {} : _props$PaperProps,
      PopoverClasses = props.PopoverClasses,
      _props$transitionDura = props.transitionDuration,
      transitionDuration = _props$transitionDura === void 0 ? 'auto' : _props$transitionDura,
      _props$TransitionProp = props.TransitionProps,
      _props$TransitionProp2 = _props$TransitionProp === void 0 ? {} : _props$TransitionProp,
      onEntering = _props$TransitionProp2.onEntering,
      TransitionProps = _objectWithoutProperties(_props$TransitionProp2, ["onEntering"]),
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'selectedMenu' : _props$variant,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      other = _objectWithoutProperties(props, ["autoFocus", "children", "className", "disableAutoFocusItem", "MenuListProps", "onClose", "open", "PaperProps", "PopoverClasses", "transitionDuration", "TransitionProps", "variant", "slots", "slotProps"]);
    var isRtl = useRtl();
    var ownerState = _extends({}, props, {
      autoFocus: autoFocus,
      disableAutoFocusItem: disableAutoFocusItem,
      MenuListProps: MenuListProps,
      onEntering: onEntering,
      PaperProps: PaperProps,
      transitionDuration: transitionDuration,
      TransitionProps: TransitionProps,
      variant: variant
    });
    var classes = useUtilityClasses$J(ownerState);
    var autoFocusItem = autoFocus && !disableAutoFocusItem && open;
    var menuListActionsRef = React__namespace.useRef(null);
    var handleEntering = function handleEntering(element, isAppearing) {
      if (menuListActionsRef.current) {
        menuListActionsRef.current.adjustStyleForScrollbar(element, {
          direction: isRtl ? 'rtl' : 'ltr'
        });
      }
      if (onEntering) {
        onEntering(element, isAppearing);
      }
    };
    var handleListKeyDown = function handleListKeyDown(event) {
      if (event.key === 'Tab') {
        event.preventDefault();
        if (onClose) {
          onClose(event, 'tabKeyDown');
        }
      }
    };

    /**
     * the index of the item should receive focus
     * in a `variant="selectedMenu"` it's the first `selected` item
     * otherwise it's the very first item.
     */
    var activeItemIndex = -1;
    // since we inject focus related props into children we have to do a lookahead
    // to check if there is a `selected` item. We're looking for the last `selected`
    // item and use the first valid item as a fallback
    React__namespace.Children.map(children, function (child, index) {
      if (! /*#__PURE__*/React__namespace.isValidElement(child)) {
        return;
      }
      {
        if (reactIsExports.isFragment(child)) {
          console.error(["MUI: The Menu component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n'));
        }
      }
      if (!child.props.disabled) {
        if (variant === 'selectedMenu' && child.props.selected) {
          activeItemIndex = index;
        } else if (activeItemIndex === -1) {
          activeItemIndex = index;
        }
      }
    });
    var PaperSlot = (_slots$paper = slots.paper) != null ? _slots$paper : MenuPaper;
    var paperExternalSlotProps = (_slotProps$paper = slotProps.paper) != null ? _slotProps$paper : PaperProps;
    var rootSlotProps = useSlotProps({
      elementType: slots.root,
      externalSlotProps: slotProps.root,
      ownerState: ownerState,
      className: [classes.root, className]
    });
    var paperSlotProps = useSlotProps({
      elementType: PaperSlot,
      externalSlotProps: paperExternalSlotProps,
      ownerState: ownerState,
      className: classes.paper
    });
    return /*#__PURE__*/jsxRuntimeExports.jsx(MenuRoot, _extends({
      onClose: onClose,
      anchorOrigin: {
        vertical: 'bottom',
        horizontal: isRtl ? 'right' : 'left'
      },
      transformOrigin: isRtl ? RTL_ORIGIN : LTR_ORIGIN,
      slots: {
        paper: PaperSlot,
        root: slots.root
      },
      slotProps: {
        root: rootSlotProps,
        paper: paperSlotProps
      },
      open: open,
      ref: ref,
      transitionDuration: transitionDuration,
      TransitionProps: _extends({
        onEntering: handleEntering
      }, TransitionProps),
      ownerState: ownerState
    }, other, {
      classes: PopoverClasses,
      children: /*#__PURE__*/jsxRuntimeExports.jsx(MenuMenuList, _extends({
        onKeyDown: handleListKeyDown,
        actions: menuListActionsRef,
        autoFocus: autoFocus && (activeItemIndex === -1 || disableAutoFocusItem),
        autoFocusItem: autoFocusItem,
        variant: variant
      }, MenuListProps, {
        className: clsx(classes.list, MenuListProps.className),
        children: children
      }))
    }));
  });
  Menu.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * An HTML element, or a function that returns one.
     * It's used to set the position of the menu.
     */
    anchorEl: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.func]),
    /**
     * If `true` (Default) will focus the `[role="menu"]` if no focusable child is found. Disabled
     * children are not focusable. If you set this prop to `false` focus will be placed
     * on the parent modal container. This has severe accessibility implications
     * and should only be considered if you manage focus otherwise.
     * @default true
     */
    autoFocus: PropTypes.bool,
    /**
     * Menu contents, normally `MenuItem`s.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * When opening the menu will not focus the active item but the `[role="menu"]`
     * unless `autoFocus` is also set to `false`. Not using the default means not
     * following WAI-ARIA authoring practices. Please be considerate about possible
     * accessibility implications.
     * @default false
     */
    disableAutoFocusItem: PropTypes.bool,
    /**
     * Props applied to the [`MenuList`](/material-ui/api/menu-list/) element.
     * @default {}
     */
    MenuListProps: PropTypes.object,
    /**
     * Callback fired when the component requests to be closed.
     *
     * @param {object} event The event source of the callback.
     * @param {string} reason Can be: `"escapeKeyDown"`, `"backdropClick"`, `"tabKeyDown"`.
     */
    onClose: PropTypes.func,
    /**
     * If `true`, the component is shown.
     */
    open: PropTypes.bool.isRequired,
    /**
     * @ignore
     */
    PaperProps: PropTypes.object,
    /**
     * `classes` prop applied to the [`Popover`](/material-ui/api/popover/) element.
     */
    PopoverClasses: PropTypes.object,
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * @default {}
     */
    slotProps: PropTypes.shape({
      paper: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * The components used for each slot inside.
     *
     * @default {}
     */
    slots: PropTypes.shape({
      paper: PropTypes.elementType,
      root: PropTypes.elementType
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The length of the transition in `ms`, or 'auto'
     * @default 'auto'
     */
    transitionDuration: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.shape({
      appear: PropTypes.number,
      enter: PropTypes.number,
      exit: PropTypes.number
    })]),
    /**
     * Props applied to the transition element.
     * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
     * @default {}
     */
    TransitionProps: PropTypes.object,
    /**
     * The variant to use. Use `menu` to prevent selected items from impacting the initial focus.
     * @default 'selectedMenu'
     */
    variant: PropTypes.oneOf(['menu', 'selectedMenu'])
  } ;
  var Menu$1 = Menu;

  function getMenuItemUtilityClass(slot) {
    return generateUtilityClass('MuiMenuItem', slot);
  }
  var menuItemClasses = generateUtilityClasses('MuiMenuItem', ['root', 'focusVisible', 'dense', 'disabled', 'divider', 'gutters', 'selected']);
  var menuItemClasses$1 = menuItemClasses;

  var overridesResolver$1 = function overridesResolver(props, styles) {
    var ownerState = props.ownerState;
    return [styles.root, ownerState.dense && styles.dense, ownerState.divider && styles.divider, !ownerState.disableGutters && styles.gutters];
  };
  var useUtilityClasses$I = function useUtilityClasses(ownerState) {
    var disabled = ownerState.disabled,
      dense = ownerState.dense,
      divider = ownerState.divider,
      disableGutters = ownerState.disableGutters,
      selected = ownerState.selected,
      classes = ownerState.classes;
    var slots = {
      root: ['root', dense && 'dense', disabled && 'disabled', !disableGutters && 'gutters', divider && 'divider', selected && 'selected']
    };
    var composedClasses = composeClasses(slots, getMenuItemUtilityClass, classes);
    return _extends({}, classes, composedClasses);
  };
  var MenuItemRoot = styled$1(ButtonBase$1, {
    shouldForwardProp: function shouldForwardProp(prop) {
      return rootShouldForwardProp$1(prop) || prop === 'classes';
    },
    name: 'MuiMenuItem',
    slot: 'Root',
    overridesResolver: overridesResolver$1
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({}, theme.typography.body1, {
      display: 'flex',
      justifyContent: 'flex-start',
      alignItems: 'center',
      position: 'relative',
      textDecoration: 'none',
      minHeight: 48,
      paddingTop: 6,
      paddingBottom: 6,
      boxSizing: 'border-box',
      whiteSpace: 'nowrap'
    }, !ownerState.disableGutters && {
      paddingLeft: 16,
      paddingRight: 16
    }, ownerState.divider && {
      borderBottom: "1px solid ".concat((theme.vars || theme).palette.divider),
      backgroundClip: 'padding-box'
    }, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
      '&:hover': {
        textDecoration: 'none',
        backgroundColor: (theme.vars || theme).palette.action.hover,
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: 'transparent'
        }
      }
    }, "&.".concat(menuItemClasses$1.selected), _defineProperty({
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / ").concat(theme.vars.palette.action.selectedOpacity, ")") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity)
    }, "&.".concat(menuItemClasses$1.focusVisible), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.focusOpacity, "))") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)
    })), "&.".concat(menuItemClasses$1.selected, ":hover"), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.hoverOpacity, "))") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity),
      // Reset on touch devices, it doesn't add specificity
      '@media (hover: none)': {
        backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / ").concat(theme.vars.palette.action.selectedOpacity, ")") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity)
      }
    }), "&.".concat(menuItemClasses$1.focusVisible), {
      backgroundColor: (theme.vars || theme).palette.action.focus
    }), "&.".concat(menuItemClasses$1.disabled), {
      opacity: (theme.vars || theme).palette.action.disabledOpacity
    }), "& + .".concat(dividerClasses$1.root), {
      marginTop: theme.spacing(1),
      marginBottom: theme.spacing(1)
    }), "& + .".concat(dividerClasses$1.inset), {
      marginLeft: 52
    }), "& .".concat(listItemTextClasses$1.root), {
      marginTop: 0,
      marginBottom: 0
    }), "& .".concat(listItemTextClasses$1.inset), {
      paddingLeft: 36
    }), "& .".concat(listItemIconClasses$1.root), {
      minWidth: 36
    }), !ownerState.dense && _defineProperty({}, theme.breakpoints.up('sm'), {
      minHeight: 'auto'
    }), ownerState.dense && _extends({
      minHeight: 32,
      // https://m2.material.io/components/menus#specs > Dense
      paddingTop: 4,
      paddingBottom: 4
    }, theme.typography.body2, _defineProperty({}, "& .".concat(listItemIconClasses$1.root, " svg"), {
      fontSize: '1.25rem'
    })));
  });
  var MenuItem = /*#__PURE__*/React__namespace.forwardRef(function MenuItem(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiMenuItem'
    });
    var _props$autoFocus = props.autoFocus,
      autoFocus = _props$autoFocus === void 0 ? false : _props$autoFocus,
      _props$component = props.component,
      component = _props$component === void 0 ? 'li' : _props$component,
      _props$dense = props.dense,
      dense = _props$dense === void 0 ? false : _props$dense,
      _props$divider = props.divider,
      divider = _props$divider === void 0 ? false : _props$divider,
      _props$disableGutters = props.disableGutters,
      disableGutters = _props$disableGutters === void 0 ? false : _props$disableGutters,
      focusVisibleClassName = props.focusVisibleClassName,
      _props$role = props.role,
      role = _props$role === void 0 ? 'menuitem' : _props$role,
      tabIndexProp = props.tabIndex,
      className = props.className,
      other = _objectWithoutProperties(props, ["autoFocus", "component", "dense", "divider", "disableGutters", "focusVisibleClassName", "role", "tabIndex", "className"]);
    var context = React__namespace.useContext(ListContext$1);
    var childContext = React__namespace.useMemo(function () {
      return {
        dense: dense || context.dense || false,
        disableGutters: disableGutters
      };
    }, [context.dense, dense, disableGutters]);
    var menuItemRef = React__namespace.useRef(null);
    useEnhancedEffect$1(function () {
      if (autoFocus) {
        if (menuItemRef.current) {
          menuItemRef.current.focus();
        } else {
          console.error('MUI: Unable to set focus to a MenuItem whose component has not been rendered.');
        }
      }
    }, [autoFocus]);
    var ownerState = _extends({}, props, {
      dense: childContext.dense,
      divider: divider,
      disableGutters: disableGutters
    });
    var classes = useUtilityClasses$I(props);
    var handleRef = useForkRef(menuItemRef, ref);
    var tabIndex;
    if (!props.disabled) {
      tabIndex = tabIndexProp !== undefined ? tabIndexProp : -1;
    }
    return /*#__PURE__*/jsxRuntimeExports.jsx(ListContext$1.Provider, {
      value: childContext,
      children: /*#__PURE__*/jsxRuntimeExports.jsx(MenuItemRoot, _extends({
        ref: handleRef,
        role: role,
        tabIndex: tabIndex,
        component: component,
        focusVisibleClassName: clsx(classes.focusVisible, focusVisibleClassName),
        className: clsx(classes.root, className)
      }, other, {
        ownerState: ownerState,
        classes: classes
      }))
    });
  });
  MenuItem.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * If `true`, the list item is focused during the first mount.
     * Focus will also be triggered if the value changes from false to true.
     * @default false
     */
    autoFocus: PropTypes.bool,
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, compact vertical padding designed for keyboard and mouse input is used.
     * The prop defaults to the value inherited from the parent Menu component.
     * @default false
     */
    dense: PropTypes.bool,
    /**
     * @ignore
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the left and right padding is removed.
     * @default false
     */
    disableGutters: PropTypes.bool,
    /**
     * If `true`, a 1px light border is added to the bottom of the menu item.
     * @default false
     */
    divider: PropTypes.bool,
    /**
     * This prop can help identify which element has keyboard focus.
     * The class name will be applied when the element gains the focus through keyboard interaction.
     * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
     * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
     * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
     * if needed.
     */
    focusVisibleClassName: PropTypes.string,
    /**
     * @ignore
     */
    role: PropTypes /* @typescript-to-proptypes-ignore */.string,
    /**
     * If `true`, the component is selected.
     * @default false
     */
    selected: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * @default 0
     */
    tabIndex: PropTypes.number
  } ;
  var MenuItem$1 = MenuItem;

  function getMobileStepperUtilityClass(slot) {
    return generateUtilityClass('MuiMobileStepper', slot);
  }
  var mobileStepperClasses = generateUtilityClasses('MuiMobileStepper', ['root', 'positionBottom', 'positionTop', 'positionStatic', 'dots', 'dot', 'dotActive', 'progress']);
  var mobileStepperClasses$1 = mobileStepperClasses;

  var useUtilityClasses$H = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      position = ownerState.position;
    var slots = {
      root: ['root', "position".concat(capitalize(position))],
      dots: ['dots'],
      dot: ['dot'],
      dotActive: ['dotActive'],
      progress: ['progress']
    };
    return composeClasses(slots, getMobileStepperUtilityClass, classes);
  };
  var MobileStepperRoot = styled$1(Paper$1, {
    name: 'MuiMobileStepper',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles["position".concat(capitalize(ownerState.position))]];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      display: 'flex',
      flexDirection: 'row',
      justifyContent: 'space-between',
      alignItems: 'center',
      background: (theme.vars || theme).palette.background["default"],
      padding: 8
    }, ownerState.position === 'bottom' && {
      position: 'fixed',
      bottom: 0,
      left: 0,
      right: 0,
      zIndex: (theme.vars || theme).zIndex.mobileStepper
    }, ownerState.position === 'top' && {
      position: 'fixed',
      top: 0,
      left: 0,
      right: 0,
      zIndex: (theme.vars || theme).zIndex.mobileStepper
    });
  });
  var MobileStepperDots = styled$1('div', {
    name: 'MuiMobileStepper',
    slot: 'Dots',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.dots;
    }
  })(function (_ref2) {
    var ownerState = _ref2.ownerState;
    return _extends({}, ownerState.variant === 'dots' && {
      display: 'flex',
      flexDirection: 'row'
    });
  });
  var MobileStepperDot = styled$1('div', {
    name: 'MuiMobileStepper',
    slot: 'Dot',
    shouldForwardProp: function shouldForwardProp(prop) {
      return slotShouldForwardProp(prop) && prop !== 'dotActive';
    },
    overridesResolver: function overridesResolver(props, styles) {
      var dotActive = props.dotActive;
      return [styles.dot, dotActive && styles.dotActive];
    }
  })(function (_ref3) {
    var theme = _ref3.theme,
      ownerState = _ref3.ownerState,
      dotActive = _ref3.dotActive;
    return _extends({}, ownerState.variant === 'dots' && _extends({
      transition: theme.transitions.create('background-color', {
        duration: theme.transitions.duration.shortest
      }),
      backgroundColor: (theme.vars || theme).palette.action.disabled,
      borderRadius: '50%',
      width: 8,
      height: 8,
      margin: '0 2px'
    }, dotActive && {
      backgroundColor: (theme.vars || theme).palette.primary.main
    }));
  });
  var MobileStepperProgress = styled$1(LinearProgress$1, {
    name: 'MuiMobileStepper',
    slot: 'Progress',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.progress;
    }
  })(function (_ref4) {
    var ownerState = _ref4.ownerState;
    return _extends({}, ownerState.variant === 'progress' && {
      width: '50%'
    });
  });
  var MobileStepper = /*#__PURE__*/React__namespace.forwardRef(function MobileStepper(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiMobileStepper'
    });
    var _props$activeStep = props.activeStep,
      activeStep = _props$activeStep === void 0 ? 0 : _props$activeStep,
      backButton = props.backButton,
      className = props.className,
      LinearProgressProps = props.LinearProgressProps,
      nextButton = props.nextButton,
      _props$position = props.position,
      position = _props$position === void 0 ? 'bottom' : _props$position,
      steps = props.steps,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'dots' : _props$variant,
      other = _objectWithoutProperties(props, ["activeStep", "backButton", "className", "LinearProgressProps", "nextButton", "position", "steps", "variant"]);
    var ownerState = _extends({}, props, {
      activeStep: activeStep,
      position: position,
      variant: variant
    });
    var value;
    if (variant === 'progress') {
      if (steps === 1) {
        value = 100;
      } else {
        value = Math.ceil(activeStep / (steps - 1) * 100);
      }
    }
    var classes = useUtilityClasses$H(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(MobileStepperRoot, _extends({
      square: true,
      elevation: 0,
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState
    }, other, {
      children: [backButton, variant === 'text' && /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
        children: [activeStep + 1, " / ", steps]
      }), variant === 'dots' && /*#__PURE__*/jsxRuntimeExports.jsx(MobileStepperDots, {
        ownerState: ownerState,
        className: classes.dots,
        children: _toConsumableArray(new Array(steps)).map(function (_, index) {
          return /*#__PURE__*/jsxRuntimeExports.jsx(MobileStepperDot, {
            className: clsx(classes.dot, index === activeStep && classes.dotActive),
            ownerState: ownerState,
            dotActive: index === activeStep
          }, index);
        })
      }), variant === 'progress' && /*#__PURE__*/jsxRuntimeExports.jsx(MobileStepperProgress, _extends({
        ownerState: ownerState,
        className: classes.progress,
        variant: "determinate",
        value: value
      }, LinearProgressProps)), nextButton]
    }));
  });
  MobileStepper.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Set the active step (zero based index).
     * Defines which dot is highlighted when the variant is 'dots'.
     * @default 0
     */
    activeStep: integerPropType,
    /**
     * A back button element. For instance, it can be a `Button` or an `IconButton`.
     */
    backButton: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * Props applied to the `LinearProgress` element.
     */
    LinearProgressProps: PropTypes.object,
    /**
     * A next button element. For instance, it can be a `Button` or an `IconButton`.
     */
    nextButton: PropTypes.node,
    /**
     * Set the positioning type.
     * @default 'bottom'
     */
    position: PropTypes.oneOf(['bottom', 'static', 'top']),
    /**
     * The total steps.
     */
    steps: integerPropType.isRequired,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The variant to use.
     * @default 'dots'
     */
    variant: PropTypes.oneOf(['dots', 'progress', 'text'])
  } ;
  var MobileStepper$1 = MobileStepper;

  function getNativeSelectUtilityClasses(slot) {
    return generateUtilityClass('MuiNativeSelect', slot);
  }
  var nativeSelectClasses = generateUtilityClasses('MuiNativeSelect', ['root', 'select', 'multiple', 'filled', 'outlined', 'standard', 'disabled', 'icon', 'iconOpen', 'iconFilled', 'iconOutlined', 'iconStandard', 'nativeInput', 'error']);
  var nativeSelectClasses$1 = nativeSelectClasses;

  var useUtilityClasses$G = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      variant = ownerState.variant,
      disabled = ownerState.disabled,
      multiple = ownerState.multiple,
      open = ownerState.open,
      error = ownerState.error;
    var slots = {
      select: ['select', variant, disabled && 'disabled', multiple && 'multiple', error && 'error'],
      icon: ['icon', "icon".concat(capitalize(variant)), open && 'iconOpen', disabled && 'disabled']
    };
    return composeClasses(slots, getNativeSelectUtilityClasses, classes);
  };
  var nativeSelectSelectStyles = function nativeSelectSelectStyles(_ref) {
    var ownerState = _ref.ownerState,
      theme = _ref.theme;
    return _extends(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
      MozAppearance: 'none',
      // Reset
      WebkitAppearance: 'none',
      // Reset
      // When interacting quickly, the text can end up selected.
      // Native select can't be selected either.
      userSelect: 'none',
      borderRadius: 0,
      // Reset
      cursor: 'pointer',
      '&:focus': _extends({}, theme.vars ? {
        backgroundColor: "rgba(".concat(theme.vars.palette.common.onBackgroundChannel, " / 0.05)")
      } : {
        backgroundColor: theme.palette.mode === 'light' ? 'rgba(0, 0, 0, 0.05)' : 'rgba(255, 255, 255, 0.05)'
      }, {
        borderRadius: 0 // Reset Chrome style
      }),
      // Remove IE11 arrow
      '&::-ms-expand': {
        display: 'none'
      }
    }, "&.".concat(nativeSelectClasses$1.disabled), {
      cursor: 'default'
    }), '&[multiple]', {
      height: 'auto'
    }), '&:not([multiple]) option, &:not([multiple]) optgroup', {
      backgroundColor: (theme.vars || theme).palette.background.paper
    }), '&&&', {
      paddingRight: 24,
      minWidth: 16 // So it doesn't collapse.
    }), ownerState.variant === 'filled' && {
      '&&&': {
        paddingRight: 32
      }
    }, ownerState.variant === 'outlined' && {
      borderRadius: (theme.vars || theme).shape.borderRadius,
      '&:focus': {
        borderRadius: (theme.vars || theme).shape.borderRadius // Reset the reset for Chrome style
      },
      '&&&': {
        paddingRight: 32
      }
    });
  };
  var NativeSelectSelect = styled$1('select', {
    name: 'MuiNativeSelect',
    slot: 'Select',
    shouldForwardProp: rootShouldForwardProp$1,
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.select, styles[ownerState.variant], ownerState.error && styles.error, _defineProperty({}, "&.".concat(nativeSelectClasses$1.multiple), styles.multiple)];
    }
  })(nativeSelectSelectStyles);
  var nativeSelectIconStyles = function nativeSelectIconStyles(_ref3) {
    var ownerState = _ref3.ownerState,
      theme = _ref3.theme;
    return _extends(_defineProperty({
      // We use a position absolute over a flexbox in order to forward the pointer events
      // to the input and to support wrapping tags..
      position: 'absolute',
      right: 0,
      top: 'calc(50% - .5em)',
      // Center vertically, height is 1em
      pointerEvents: 'none',
      // Don't block pointer events on the select under the icon.
      color: (theme.vars || theme).palette.action.active
    }, "&.".concat(nativeSelectClasses$1.disabled), {
      color: (theme.vars || theme).palette.action.disabled
    }), ownerState.open && {
      transform: 'rotate(180deg)'
    }, ownerState.variant === 'filled' && {
      right: 7
    }, ownerState.variant === 'outlined' && {
      right: 7
    });
  };
  var NativeSelectIcon = styled$1('svg', {
    name: 'MuiNativeSelect',
    slot: 'Icon',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.icon, ownerState.variant && styles["icon".concat(capitalize(ownerState.variant))], ownerState.open && styles.iconOpen];
    }
  })(nativeSelectIconStyles);

  /**
   * @ignore - internal component.
   */
  var NativeSelectInput = /*#__PURE__*/React__namespace.forwardRef(function NativeSelectInput(props, ref) {
    var className = props.className,
      disabled = props.disabled,
      error = props.error,
      IconComponent = props.IconComponent,
      inputRef = props.inputRef,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'standard' : _props$variant,
      other = _objectWithoutProperties(props, ["className", "disabled", "error", "IconComponent", "inputRef", "variant"]);
    var ownerState = _extends({}, props, {
      disabled: disabled,
      variant: variant,
      error: error
    });
    var classes = useUtilityClasses$G(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsx(NativeSelectSelect, _extends({
        ownerState: ownerState,
        className: clsx(classes.select, className),
        disabled: disabled,
        ref: inputRef || ref
      }, other)), props.multiple ? null : /*#__PURE__*/jsxRuntimeExports.jsx(NativeSelectIcon, {
        as: IconComponent,
        ownerState: ownerState,
        className: classes.icon
      })]
    });
  });
  NativeSelectInput.propTypes = {
    /**
     * The option elements to populate the select with.
     * Can be some `<option>` elements.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * The CSS class name of the select element.
     */
    className: PropTypes.string,
    /**
     * If `true`, the select is disabled.
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the `select input` will indicate an error.
     */
    error: PropTypes.bool,
    /**
     * The icon that displays the arrow.
     */
    IconComponent: PropTypes.elementType.isRequired,
    /**
     * Use that prop to pass a ref to the native select element.
     * @deprecated
     */
    inputRef: refType$1,
    /**
     * @ignore
     */
    multiple: PropTypes.bool,
    /**
     * Name attribute of the `select` or hidden `input` element.
     */
    name: PropTypes.string,
    /**
     * Callback fired when a menu item is selected.
     *
     * @param {object} event The event source of the callback.
     * You can pull out the new value by accessing `event.target.value` (string).
     */
    onChange: PropTypes.func,
    /**
     * The input value.
     */
    value: PropTypes.any,
    /**
     * The variant to use.
     */
    variant: PropTypes.oneOf(['standard', 'outlined', 'filled'])
  } ;
  var NativeSelectInput$1 = NativeSelectInput;

  var useUtilityClasses$F = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    return composeClasses(slots, getNativeSelectUtilityClasses, classes);
  };
  var defaultInput = /*#__PURE__*/jsxRuntimeExports.jsx(Input$1, {});
  /**
   * An alternative to `<Select native />` with a much smaller bundle size footprint.
   */
  var NativeSelect = /*#__PURE__*/React__namespace.forwardRef(function NativeSelect(inProps, ref) {
    var props = useDefaultProps({
      name: 'MuiNativeSelect',
      props: inProps
    });
    var className = props.className,
      children = props.children,
      _props$classes = props.classes,
      classesProp = _props$classes === void 0 ? {} : _props$classes,
      _props$IconComponent = props.IconComponent,
      IconComponent = _props$IconComponent === void 0 ? ArrowDropDownIcon : _props$IconComponent,
      _props$input = props.input,
      input = _props$input === void 0 ? defaultInput : _props$input,
      inputProps = props.inputProps;
      props.variant;
      var other = _objectWithoutProperties(props, ["className", "children", "classes", "IconComponent", "input", "inputProps", "variant"]);
    var muiFormControl = useFormControl();
    var fcs = formControlState({
      props: props,
      muiFormControl: muiFormControl,
      states: ['variant']
    });
    var ownerState = _extends({}, props, {
      classes: classesProp
    });
    var classes = useUtilityClasses$F(ownerState);
    classesProp.root;
      var otherClasses = _objectWithoutProperties(classesProp, ["root"]);
    return /*#__PURE__*/jsxRuntimeExports.jsx(React__namespace.Fragment, {
      children: /*#__PURE__*/React__namespace.cloneElement(input, _extends({
        // Most of the logic is implemented in `NativeSelectInput`.
        // The `Select` component is a simple API wrapper to expose something better to play with.
        inputComponent: NativeSelectInput$1,
        inputProps: _extends({
          children: children,
          classes: otherClasses,
          IconComponent: IconComponent,
          variant: fcs.variant,
          type: undefined
        }, inputProps, input ? input.props.inputProps : {}),
        ref: ref
      }, other, {
        className: clsx(classes.root, input.props.className, className)
      }))
    });
  });
  NativeSelect.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The option elements to populate the select with.
     * Can be some `<option>` elements.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     * @default {}
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The icon that displays the arrow.
     * @default ArrowDropDownIcon
     */
    IconComponent: PropTypes.elementType,
    /**
     * An `Input` element; does not have to be a material-ui specific `Input`.
     * @default <Input />
     */
    input: PropTypes.element,
    /**
     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/select#attributes) applied to the `select` element.
     */
    inputProps: PropTypes.object,
    /**
     * Callback fired when a menu item is selected.
     *
     * @param {React.ChangeEvent<HTMLSelectElement>} event The event source of the callback.
     * You can pull out the new value by accessing `event.target.value` (string).
     */
    onChange: PropTypes.func,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The `input` value. The DOM API casts this to a string.
     */
    value: PropTypes.any,
    /**
     * The variant to use.
     */
    variant: PropTypes.oneOf(['filled', 'outlined', 'standard'])
  } ;
  NativeSelect.muiName = 'Select';
  var NativeSelect$1 = NativeSelect;

  /**
   * NoSsr purposely removes components from the subject of Server Side Rendering (SSR).
   *
   * This component can be useful in a variety of situations:
   *
   * *   Escape hatch for broken dependencies not supporting SSR.
   * *   Improve the time-to-first paint on the client by only rendering above the fold.
   * *   Reduce the rendering time on the server.
   * *   Under too heavy server load, you can turn on service degradation.
   *
   * Demos:
   *
   * - [No SSR](https://mui.com/material-ui/react-no-ssr/)
   *
   * API:
   *
   * - [NoSsr API](https://mui.com/material-ui/api/no-ssr/)
   */
  function NoSsr(props) {
    var children = props.children,
      _props$defer = props.defer,
      defer = _props$defer === void 0 ? false : _props$defer,
      _props$fallback = props.fallback,
      fallback = _props$fallback === void 0 ? null : _props$fallback;
    var _React$useState = React__namespace.useState(false),
      mountedState = _React$useState[0],
      setMountedState = _React$useState[1];
    useEnhancedEffect$1(function () {
      if (!defer) {
        setMountedState(true);
      }
    }, [defer]);
    React__namespace.useEffect(function () {
      if (defer) {
        setMountedState(true);
      }
    }, [defer]);

    // We need the Fragment here to force react-docgen to recognise NoSsr as a component.
    return /*#__PURE__*/jsxRuntimeExports.jsx(React__namespace.Fragment, {
      children: mountedState ? children : fallback
    });
  }
  NoSsr.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * You can wrap a node.
     */
    children: PropTypes.node,
    /**
     * If `true`, the component will not only prevent server-side rendering.
     * It will also defer the rendering of the children into a different screen frame.
     * @default false
     */
    defer: PropTypes.bool,
    /**
     * The fallback content to display.
     * @default null
     */
    fallback: PropTypes.node
  } ;
  {
    // eslint-disable-next-line
    NoSsr['propTypes' + ''] = exactProp(NoSsr.propTypes);
  }

  var _span$1;
  var NotchedOutlineRoot$1 = styled$1('fieldset', {
    shouldForwardProp: rootShouldForwardProp$1
  })({
    textAlign: 'left',
    position: 'absolute',
    bottom: 0,
    right: 0,
    top: -5,
    left: 0,
    margin: 0,
    padding: '0 8px',
    pointerEvents: 'none',
    borderRadius: 'inherit',
    borderStyle: 'solid',
    borderWidth: 1,
    overflow: 'hidden',
    minWidth: '0%'
  });
  var NotchedOutlineLegend = styled$1('legend', {
    shouldForwardProp: rootShouldForwardProp$1
  })(function (_ref) {
    var ownerState = _ref.ownerState,
      theme = _ref.theme;
    return _extends({
      "float": 'unset',
      // Fix conflict with bootstrap
      width: 'auto',
      // Fix conflict with bootstrap
      overflow: 'hidden'
    }, !ownerState.withLabel && {
      padding: 0,
      lineHeight: '11px',
      // sync with `height` in `legend` styles
      transition: theme.transitions.create('width', {
        duration: 150,
        easing: theme.transitions.easing.easeOut
      })
    }, ownerState.withLabel && _extends({
      display: 'block',
      // Fix conflict with normalize.css and sanitize.css
      padding: 0,
      height: 11,
      // sync with `lineHeight` in `legend` styles
      fontSize: '0.75em',
      visibility: 'hidden',
      maxWidth: 0.01,
      transition: theme.transitions.create('max-width', {
        duration: 50,
        easing: theme.transitions.easing.easeOut
      }),
      whiteSpace: 'nowrap',
      '& > span': {
        paddingLeft: 5,
        paddingRight: 5,
        display: 'inline-block',
        opacity: 0,
        visibility: 'visible'
      }
    }, ownerState.notched && {
      maxWidth: '100%',
      transition: theme.transitions.create('max-width', {
        duration: 100,
        easing: theme.transitions.easing.easeOut,
        delay: 50
      })
    }));
  });

  /**
   * @ignore - internal component.
   */
  function NotchedOutline(props) {
    props.children;
      props.classes;
      var className = props.className,
      label = props.label,
      notched = props.notched,
      other = _objectWithoutProperties(props, ["children", "classes", "className", "label", "notched"]);
    var withLabel = label != null && label !== '';
    var ownerState = _extends({}, props, {
      notched: notched,
      withLabel: withLabel
    });
    return /*#__PURE__*/jsxRuntimeExports.jsx(NotchedOutlineRoot$1, _extends({
      "aria-hidden": true,
      className: className,
      ownerState: ownerState
    }, other, {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(NotchedOutlineLegend, {
        ownerState: ownerState,
        children: withLabel ? /*#__PURE__*/jsxRuntimeExports.jsx("span", {
          children: label
        }) : // notranslate needed while Google Translate will not fix zero-width space issue
        _span$1 || (_span$1 = /*#__PURE__*/jsxRuntimeExports.jsx("span", {
          className: "notranslate",
          children: "\u200B"
        }))
      })
    }));
  }
  NotchedOutline.propTypes = {
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The label.
     */
    label: PropTypes.node,
    /**
     * If `true`, the outline is notched to accommodate the label.
     */
    notched: PropTypes.bool.isRequired,
    /**
     * @ignore
     */
    style: PropTypes.object
  } ;

  var useUtilityClasses$E = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root'],
      notchedOutline: ['notchedOutline'],
      input: ['input']
    };
    var composedClasses = composeClasses(slots, getOutlinedInputUtilityClass, classes);
    return _extends({}, classes, composedClasses);
  };
  var OutlinedInputRoot = styled$1(InputBaseRoot, {
    shouldForwardProp: function shouldForwardProp(prop) {
      return rootShouldForwardProp$1(prop) || prop === 'classes';
    },
    name: 'MuiOutlinedInput',
    slot: 'Root',
    overridesResolver: rootOverridesResolver
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    var borderColor = theme.palette.mode === 'light' ? 'rgba(0, 0, 0, 0.23)' : 'rgba(255, 255, 255, 0.23)';
    return _extends(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
      position: 'relative',
      borderRadius: (theme.vars || theme).shape.borderRadius
    }, "&:hover .".concat(outlinedInputClasses$1.notchedOutline), {
      borderColor: (theme.vars || theme).palette.text.primary
    }), '@media (hover: none)', _defineProperty({}, "&:hover .".concat(outlinedInputClasses$1.notchedOutline), {
      borderColor: theme.vars ? "rgba(".concat(theme.vars.palette.common.onBackgroundChannel, " / 0.23)") : borderColor
    })), "&.".concat(outlinedInputClasses$1.focused, " .").concat(outlinedInputClasses$1.notchedOutline), {
      borderColor: (theme.vars || theme).palette[ownerState.color].main,
      borderWidth: 2
    }), "&.".concat(outlinedInputClasses$1.error, " .").concat(outlinedInputClasses$1.notchedOutline), {
      borderColor: (theme.vars || theme).palette.error.main
    }), "&.".concat(outlinedInputClasses$1.disabled, " .").concat(outlinedInputClasses$1.notchedOutline), {
      borderColor: (theme.vars || theme).palette.action.disabled
    }), ownerState.startAdornment && {
      paddingLeft: 14
    }, ownerState.endAdornment && {
      paddingRight: 14
    }, ownerState.multiline && _extends({
      padding: '16.5px 14px'
    }, ownerState.size === 'small' && {
      padding: '8.5px 14px'
    }));
  });
  var NotchedOutlineRoot = styled$1(NotchedOutline, {
    name: 'MuiOutlinedInput',
    slot: 'NotchedOutline',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.notchedOutline;
    }
  })(function (_ref2) {
    var theme = _ref2.theme;
    var borderColor = theme.palette.mode === 'light' ? 'rgba(0, 0, 0, 0.23)' : 'rgba(255, 255, 255, 0.23)';
    return {
      borderColor: theme.vars ? "rgba(".concat(theme.vars.palette.common.onBackgroundChannel, " / 0.23)") : borderColor
    };
  });
  var OutlinedInputInput = styled$1(InputBaseComponent, {
    name: 'MuiOutlinedInput',
    slot: 'Input',
    overridesResolver: inputOverridesResolver
  })(function (_ref3) {
    var theme = _ref3.theme,
      ownerState = _ref3.ownerState;
    return _extends({
      padding: '16.5px 14px'
    }, !theme.vars && {
      '&:-webkit-autofill': {
        WebkitBoxShadow: theme.palette.mode === 'light' ? null : '0 0 0 100px #266798 inset',
        WebkitTextFillColor: theme.palette.mode === 'light' ? null : '#fff',
        caretColor: theme.palette.mode === 'light' ? null : '#fff',
        borderRadius: 'inherit'
      }
    }, theme.vars && _defineProperty({
      '&:-webkit-autofill': {
        borderRadius: 'inherit'
      }
    }, theme.getColorSchemeSelector('dark'), {
      '&:-webkit-autofill': {
        WebkitBoxShadow: '0 0 0 100px #266798 inset',
        WebkitTextFillColor: '#fff',
        caretColor: '#fff'
      }
    }), ownerState.size === 'small' && {
      padding: '8.5px 14px'
    }, ownerState.multiline && {
      padding: 0
    }, ownerState.startAdornment && {
      paddingLeft: 0
    }, ownerState.endAdornment && {
      paddingRight: 0
    });
  });
  var OutlinedInput = /*#__PURE__*/React__namespace.forwardRef(function OutlinedInput(inProps, ref) {
    var _ref5, _slots$root, _ref6, _slots$input, _React$Fragment;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiOutlinedInput'
    });
    var _props$components = props.components,
      components = _props$components === void 0 ? {} : _props$components,
      _props$fullWidth = props.fullWidth,
      fullWidth = _props$fullWidth === void 0 ? false : _props$fullWidth,
      _props$inputComponent = props.inputComponent,
      inputComponent = _props$inputComponent === void 0 ? 'input' : _props$inputComponent,
      label = props.label,
      _props$multiline = props.multiline,
      multiline = _props$multiline === void 0 ? false : _props$multiline,
      notched = props.notched,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      _props$type = props.type,
      type = _props$type === void 0 ? 'text' : _props$type,
      other = _objectWithoutProperties(props, ["components", "fullWidth", "inputComponent", "label", "multiline", "notched", "slots", "type"]);
    var classes = useUtilityClasses$E(props);
    var muiFormControl = useFormControl();
    var fcs = formControlState({
      props: props,
      muiFormControl: muiFormControl,
      states: ['color', 'disabled', 'error', 'focused', 'hiddenLabel', 'size', 'required']
    });
    var ownerState = _extends({}, props, {
      color: fcs.color || 'primary',
      disabled: fcs.disabled,
      error: fcs.error,
      focused: fcs.focused,
      formControl: muiFormControl,
      fullWidth: fullWidth,
      hiddenLabel: fcs.hiddenLabel,
      multiline: multiline,
      size: fcs.size,
      type: type
    });
    var RootSlot = (_ref5 = (_slots$root = slots.root) != null ? _slots$root : components.Root) != null ? _ref5 : OutlinedInputRoot;
    var InputSlot = (_ref6 = (_slots$input = slots.input) != null ? _slots$input : components.Input) != null ? _ref6 : OutlinedInputInput;
    return /*#__PURE__*/jsxRuntimeExports.jsx(InputBase$1, _extends({
      slots: {
        root: RootSlot,
        input: InputSlot
      },
      renderSuffix: function renderSuffix(state) {
        return /*#__PURE__*/jsxRuntimeExports.jsx(NotchedOutlineRoot, {
          ownerState: ownerState,
          className: classes.notchedOutline,
          label: label != null && label !== '' && fcs.required ? _React$Fragment || (_React$Fragment = /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
            children: [label, "\u2009", '*']
          })) : label,
          notched: typeof notched !== 'undefined' ? notched : Boolean(state.startAdornment || state.filled || state.focused)
        });
      },
      fullWidth: fullWidth,
      inputComponent: inputComponent,
      multiline: multiline,
      ref: ref,
      type: type
    }, other, {
      classes: _extends({}, classes, {
        notchedOutline: null
      })
    }));
  });
  OutlinedInput.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * This prop helps users to fill forms faster, especially on mobile devices.
     * The name can be confusing, as it's more like an autofill.
     * You can learn more about it [following the specification](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill).
     */
    autoComplete: PropTypes.string,
    /**
     * If `true`, the `input` element is focused during the first mount.
     */
    autoFocus: PropTypes.bool,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * The prop defaults to the value (`'primary'`) inherited from the parent FormControl component.
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['primary', 'secondary']), PropTypes.string]),
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `slots` prop.
     * It's recommended to use the `slots` prop instead.
     *
     * @default {}
     */
    components: PropTypes.shape({
      Input: PropTypes.elementType,
      Root: PropTypes.elementType
    }),
    /**
     * The default value. Use when the component is not controlled.
     */
    defaultValue: PropTypes.any,
    /**
     * If `true`, the component is disabled.
     * The prop defaults to the value (`false`) inherited from the parent FormControl component.
     */
    disabled: PropTypes.bool,
    /**
     * End `InputAdornment` for this component.
     */
    endAdornment: PropTypes.node,
    /**
     * If `true`, the `input` will indicate an error.
     * The prop defaults to the value (`false`) inherited from the parent FormControl component.
     */
    error: PropTypes.bool,
    /**
     * If `true`, the `input` will take up the full width of its container.
     * @default false
     */
    fullWidth: PropTypes.bool,
    /**
     * The id of the `input` element.
     */
    id: PropTypes.string,
    /**
     * The component used for the `input` element.
     * Either a string to use a HTML element or a component.
     * @default 'input'
     */
    inputComponent: PropTypes.elementType,
    /**
     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
     * @default {}
     */
    inputProps: PropTypes.object,
    /**
     * Pass a ref to the `input` element.
     */
    inputRef: refType$1,
    /**
     * The label of the `input`. It is only used for layout. The actual labelling
     * is handled by `InputLabel`.
     */
    label: PropTypes.node,
    /**
     * If `dense`, will adjust vertical spacing. This is normally obtained via context from
     * FormControl.
     * The prop defaults to the value (`'none'`) inherited from the parent FormControl component.
     */
    margin: PropTypes.oneOf(['dense', 'none']),
    /**
     * Maximum number of rows to display when multiline option is set to true.
     */
    maxRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * Minimum number of rows to display when multiline option is set to true.
     */
    minRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * If `true`, a [TextareaAutosize](/material-ui/react-textarea-autosize/) element is rendered.
     * @default false
     */
    multiline: PropTypes.bool,
    /**
     * Name attribute of the `input` element.
     */
    name: PropTypes.string,
    /**
     * If `true`, the outline is notched to accommodate the label.
     */
    notched: PropTypes.bool,
    /**
     * Callback fired when the value is changed.
     *
     * @param {React.ChangeEvent<HTMLTextAreaElement | HTMLInputElement>} event The event source of the callback.
     * You can pull out the new value by accessing `event.target.value` (string).
     */
    onChange: PropTypes.func,
    /**
     * The short hint displayed in the `input` before the user enters a value.
     */
    placeholder: PropTypes.string,
    /**
     * It prevents the user from changing the value of the field
     * (not from interacting with the field).
     */
    readOnly: PropTypes.bool,
    /**
     * If `true`, the `input` element is required.
     * The prop defaults to the value (`false`) inherited from the parent FormControl component.
     */
    required: PropTypes.bool,
    /**
     * Number of rows to display when multiline option is set to true.
     */
    rows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `components` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slots: PropTypes.shape({
      input: PropTypes.elementType,
      root: PropTypes.elementType
    }),
    /**
     * Start `InputAdornment` for this component.
     */
    startAdornment: PropTypes.node,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * Type of the `input` element. It should be [a valid HTML5 input type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Form_%3Cinput%3E_types).
     * @default 'text'
     */
    type: PropTypes.string,
    /**
     * The value of the `input` element, required for a controlled component.
     */
    value: PropTypes.any
  } ;
  OutlinedInput.muiName = 'Input';
  var OutlinedInput$1 = OutlinedInput;

  function getPaginationUtilityClass(slot) {
    return generateUtilityClass('MuiPagination', slot);
  }
  var paginationClasses = generateUtilityClasses('MuiPagination', ['root', 'ul', 'outlined', 'text']);
  var paginationClasses$1 = paginationClasses;

  function usePagination() {
    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    // keep default values in sync with @default tags in Pagination.propTypes
    var _props$boundaryCount = props.boundaryCount,
      boundaryCount = _props$boundaryCount === void 0 ? 1 : _props$boundaryCount,
      _props$componentName = props.componentName,
      componentName = _props$componentName === void 0 ? 'usePagination' : _props$componentName,
      _props$count = props.count,
      count = _props$count === void 0 ? 1 : _props$count,
      _props$defaultPage = props.defaultPage,
      defaultPage = _props$defaultPage === void 0 ? 1 : _props$defaultPage,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$hideNextButton = props.hideNextButton,
      hideNextButton = _props$hideNextButton === void 0 ? false : _props$hideNextButton,
      _props$hidePrevButton = props.hidePrevButton,
      hidePrevButton = _props$hidePrevButton === void 0 ? false : _props$hidePrevButton,
      handleChange = props.onChange,
      pageProp = props.page,
      _props$showFirstButto = props.showFirstButton,
      showFirstButton = _props$showFirstButto === void 0 ? false : _props$showFirstButto,
      _props$showLastButton = props.showLastButton,
      showLastButton = _props$showLastButton === void 0 ? false : _props$showLastButton,
      _props$siblingCount = props.siblingCount,
      siblingCount = _props$siblingCount === void 0 ? 1 : _props$siblingCount,
      other = _objectWithoutProperties(props, ["boundaryCount", "componentName", "count", "defaultPage", "disabled", "hideNextButton", "hidePrevButton", "onChange", "page", "showFirstButton", "showLastButton", "siblingCount"]);
    var _useControlled = useControlled({
        controlled: pageProp,
        "default": defaultPage,
        name: componentName,
        state: 'page'
      }),
      _useControlled2 = _slicedToArray(_useControlled, 2),
      page = _useControlled2[0],
      setPageState = _useControlled2[1];
    var handleClick = function handleClick(event, value) {
      if (!pageProp) {
        setPageState(value);
      }
      if (handleChange) {
        handleChange(event, value);
      }
    };

    // https://dev.to/namirsab/comment/2050
    var range = function range(start, end) {
      var length = end - start + 1;
      return Array.from({
        length: length
      }, function (_, i) {
        return start + i;
      });
    };
    var startPages = range(1, Math.min(boundaryCount, count));
    var endPages = range(Math.max(count - boundaryCount + 1, boundaryCount + 1), count);
    var siblingsStart = Math.max(Math.min(
    // Natural start
    page - siblingCount,
    // Lower boundary when page is high
    count - boundaryCount - siblingCount * 2 - 1),
    // Greater than startPages
    boundaryCount + 2);
    var siblingsEnd = Math.min(Math.max(
    // Natural end
    page + siblingCount,
    // Upper boundary when page is low
    boundaryCount + siblingCount * 2 + 2),
    // Less than endPages
    endPages.length > 0 ? endPages[0] - 2 : count - 1);

    // Basic list of items to render
    // for example itemList = ['first', 'previous', 1, 'ellipsis', 4, 5, 6, 'ellipsis', 10, 'next', 'last']
    var itemList = [].concat(_toConsumableArray(showFirstButton ? ['first'] : []), _toConsumableArray(hidePrevButton ? [] : ['previous']), _toConsumableArray(startPages), _toConsumableArray(siblingsStart > boundaryCount + 2 ? ['start-ellipsis'] : boundaryCount + 1 < count - boundaryCount ? [boundaryCount + 1] : []), _toConsumableArray(range(siblingsStart, siblingsEnd)), _toConsumableArray(siblingsEnd < count - boundaryCount - 1 ? ['end-ellipsis'] : count - boundaryCount > boundaryCount ? [count - boundaryCount] : []), _toConsumableArray(endPages), _toConsumableArray(hideNextButton ? [] : ['next']), _toConsumableArray(showLastButton ? ['last'] : []));

    // Map the button type to its page number
    var buttonPage = function buttonPage(type) {
      switch (type) {
        case 'first':
          return 1;
        case 'previous':
          return page - 1;
        case 'next':
          return page + 1;
        case 'last':
          return count;
        default:
          return null;
      }
    };

    // Convert the basic item list to PaginationItem props objects
    var items = itemList.map(function (item) {
      return typeof item === 'number' ? {
        onClick: function onClick(event) {
          handleClick(event, item);
        },
        type: 'page',
        page: item,
        selected: item === page,
        disabled: disabled,
        'aria-current': item === page ? 'true' : undefined
      } : {
        onClick: function onClick(event) {
          handleClick(event, buttonPage(item));
        },
        type: item,
        page: buttonPage(item),
        selected: false,
        disabled: disabled || item.indexOf('ellipsis') === -1 && (item === 'next' || item === 'last' ? page >= count : page <= 1)
      };
    });
    return _extends({
      items: items
    }, other);
  }

  function getPaginationItemUtilityClass(slot) {
    return generateUtilityClass('MuiPaginationItem', slot);
  }
  var paginationItemClasses = generateUtilityClasses('MuiPaginationItem', ['root', 'page', 'sizeSmall', 'sizeLarge', 'text', 'textPrimary', 'textSecondary', 'outlined', 'outlinedPrimary', 'outlinedSecondary', 'rounded', 'ellipsis', 'firstLast', 'previousNext', 'focusVisible', 'disabled', 'selected', 'icon', 'colorPrimary', 'colorSecondary']);
  var paginationItemClasses$1 = paginationItemClasses;

  var FirstPageIconDefault = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M18.41 16.59L13.82 12l4.59-4.59L17 6l-6 6 6 6zM6 6h2v12H6z"
  }), 'FirstPage');

  var LastPageIconDefault = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M5.59 7.41L10.18 12l-4.59 4.59L7 18l6-6-6-6zM16 6h2v12h-2z"
  }), 'LastPage');

  var NavigateBeforeIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"
  }), 'NavigateBefore');

  var NavigateNextIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"
  }), 'NavigateNext');

  var overridesResolver = function overridesResolver(props, styles) {
    var ownerState = props.ownerState;
    return [styles.root, styles[ownerState.variant], styles["size".concat(capitalize(ownerState.size))], ownerState.variant === 'text' && styles["text".concat(capitalize(ownerState.color))], ownerState.variant === 'outlined' && styles["outlined".concat(capitalize(ownerState.color))], ownerState.shape === 'rounded' && styles.rounded, ownerState.type === 'page' && styles.page, (ownerState.type === 'start-ellipsis' || ownerState.type === 'end-ellipsis') && styles.ellipsis, (ownerState.type === 'previous' || ownerState.type === 'next') && styles.previousNext, (ownerState.type === 'first' || ownerState.type === 'last') && styles.firstLast];
  };
  var useUtilityClasses$D = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      color = ownerState.color,
      disabled = ownerState.disabled,
      selected = ownerState.selected,
      size = ownerState.size,
      shape = ownerState.shape,
      type = ownerState.type,
      variant = ownerState.variant;
    var slots = {
      root: ['root', "size".concat(capitalize(size)), variant, shape, color !== 'standard' && "color".concat(capitalize(color)), color !== 'standard' && "".concat(variant).concat(capitalize(color)), disabled && 'disabled', selected && 'selected', {
        page: 'page',
        first: 'firstLast',
        last: 'firstLast',
        'start-ellipsis': 'ellipsis',
        'end-ellipsis': 'ellipsis',
        previous: 'previousNext',
        next: 'previousNext'
      }[type]],
      icon: ['icon']
    };
    return composeClasses(slots, getPaginationItemUtilityClass, classes);
  };
  var PaginationItemEllipsis = styled$1('div', {
    name: 'MuiPaginationItem',
    slot: 'Root',
    overridesResolver: overridesResolver
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({}, theme.typography.body2, _defineProperty({
      borderRadius: 32 / 2,
      textAlign: 'center',
      boxSizing: 'border-box',
      minWidth: 32,
      padding: '0 6px',
      margin: '0 3px',
      color: (theme.vars || theme).palette.text.primary,
      height: 'auto'
    }, "&.".concat(paginationItemClasses$1.disabled), {
      opacity: (theme.vars || theme).palette.action.disabledOpacity
    }), ownerState.size === 'small' && {
      minWidth: 26,
      borderRadius: 26 / 2,
      margin: '0 1px',
      padding: '0 4px'
    }, ownerState.size === 'large' && {
      minWidth: 40,
      borderRadius: 40 / 2,
      padding: '0 10px',
      fontSize: theme.typography.pxToRem(15)
    });
  });
  var PaginationItemPage = styled$1(ButtonBase$1, {
    name: 'MuiPaginationItem',
    slot: 'Root',
    overridesResolver: overridesResolver
  })(function (_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    return _extends({}, theme.typography.body2, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
      borderRadius: 32 / 2,
      textAlign: 'center',
      boxSizing: 'border-box',
      minWidth: 32,
      height: 32,
      padding: '0 6px',
      margin: '0 3px',
      color: (theme.vars || theme).palette.text.primary
    }, "&.".concat(paginationItemClasses$1.focusVisible), {
      backgroundColor: (theme.vars || theme).palette.action.focus
    }), "&.".concat(paginationItemClasses$1.disabled), {
      opacity: (theme.vars || theme).palette.action.disabledOpacity
    }), "transition", theme.transitions.create(['color', 'background-color'], {
      duration: theme.transitions.duration["short"]
    })), '&:hover', {
      backgroundColor: (theme.vars || theme).palette.action.hover,
      // Reset on touch devices, it doesn't add specificity
      '@media (hover: none)': {
        backgroundColor: 'transparent'
      }
    }), "&.".concat(paginationItemClasses$1.selected), _defineProperty(_defineProperty({
      backgroundColor: (theme.vars || theme).palette.action.selected,
      '&:hover': {
        backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.action.selectedChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.hoverOpacity, "))") : alpha(theme.palette.action.selected, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity),
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: (theme.vars || theme).palette.action.selected
        }
      }
    }, "&.".concat(paginationItemClasses$1.focusVisible), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.action.selectedChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.focusOpacity, "))") : alpha(theme.palette.action.selected, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)
    }), "&.".concat(paginationItemClasses$1.disabled), {
      opacity: 1,
      color: (theme.vars || theme).palette.action.disabled,
      backgroundColor: (theme.vars || theme).palette.action.selected
    })), ownerState.size === 'small' && {
      minWidth: 26,
      height: 26,
      borderRadius: 26 / 2,
      margin: '0 1px',
      padding: '0 4px'
    }, ownerState.size === 'large' && {
      minWidth: 40,
      height: 40,
      borderRadius: 40 / 2,
      padding: '0 10px',
      fontSize: theme.typography.pxToRem(15)
    }, ownerState.shape === 'rounded' && {
      borderRadius: (theme.vars || theme).shape.borderRadius
    });
  }, function (_ref3) {
    var theme = _ref3.theme,
      ownerState = _ref3.ownerState;
    return _extends({}, ownerState.variant === 'text' && _defineProperty({}, "&.".concat(paginationItemClasses$1.selected), _extends({}, ownerState.color !== 'standard' && _defineProperty({
      color: (theme.vars || theme).palette[ownerState.color].contrastText,
      backgroundColor: (theme.vars || theme).palette[ownerState.color].main,
      '&:hover': {
        backgroundColor: (theme.vars || theme).palette[ownerState.color].dark,
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: (theme.vars || theme).palette[ownerState.color].main
        }
      }
    }, "&.".concat(paginationItemClasses$1.focusVisible), {
      backgroundColor: (theme.vars || theme).palette[ownerState.color].dark
    }), _defineProperty({}, "&.".concat(paginationItemClasses$1.disabled), {
      color: (theme.vars || theme).palette.action.disabled
    }))), ownerState.variant === 'outlined' && _defineProperty({
      border: theme.vars ? "1px solid rgba(".concat(theme.vars.palette.common.onBackgroundChannel, " / 0.23)") : "1px solid ".concat(theme.palette.mode === 'light' ? 'rgba(0, 0, 0, 0.23)' : 'rgba(255, 255, 255, 0.23)')
    }, "&.".concat(paginationItemClasses$1.selected), _extends({}, ownerState.color !== 'standard' && _defineProperty({
      color: (theme.vars || theme).palette[ownerState.color].main,
      border: "1px solid ".concat(theme.vars ? "rgba(".concat(theme.vars.palette[ownerState.color].mainChannel, " / 0.5)") : alpha(theme.palette[ownerState.color].main, 0.5)),
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette[ownerState.color].mainChannel, " / ").concat(theme.vars.palette.action.activatedOpacity, ")") : alpha(theme.palette[ownerState.color].main, theme.palette.action.activatedOpacity),
      '&:hover': {
        backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette[ownerState.color].mainChannel, " / calc(").concat(theme.vars.palette.action.activatedOpacity, " + ").concat(theme.vars.palette.action.focusOpacity, "))") : alpha(theme.palette[ownerState.color].main, theme.palette.action.activatedOpacity + theme.palette.action.focusOpacity),
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: 'transparent'
        }
      }
    }, "&.".concat(paginationItemClasses$1.focusVisible), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette[ownerState.color].mainChannel, " / calc(").concat(theme.vars.palette.action.activatedOpacity, " + ").concat(theme.vars.palette.action.focusOpacity, "))") : alpha(theme.palette[ownerState.color].main, theme.palette.action.activatedOpacity + theme.palette.action.focusOpacity)
    }), _defineProperty({}, "&.".concat(paginationItemClasses$1.disabled), {
      borderColor: (theme.vars || theme).palette.action.disabledBackground,
      color: (theme.vars || theme).palette.action.disabled
    }))));
  });
  var PaginationItemPageIcon = styled$1('div', {
    name: 'MuiPaginationItem',
    slot: 'Icon',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.icon;
    }
  })(function (_ref8) {
    var theme = _ref8.theme,
      ownerState = _ref8.ownerState;
    return _extends({
      fontSize: theme.typography.pxToRem(20),
      margin: '0 -8px'
    }, ownerState.size === 'small' && {
      fontSize: theme.typography.pxToRem(18)
    }, ownerState.size === 'large' && {
      fontSize: theme.typography.pxToRem(22)
    });
  });
  var PaginationItem = /*#__PURE__*/React__namespace.forwardRef(function PaginationItem(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiPaginationItem'
    });
    var className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'standard' : _props$color,
      component = props.component,
      _props$components = props.components,
      components = _props$components === void 0 ? {} : _props$components,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      page = props.page,
      _props$selected = props.selected,
      selected = _props$selected === void 0 ? false : _props$selected,
      _props$shape = props.shape,
      shape = _props$shape === void 0 ? 'circular' : _props$shape,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      _props$type = props.type,
      type = _props$type === void 0 ? 'page' : _props$type,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'text' : _props$variant,
      other = _objectWithoutProperties(props, ["className", "color", "component", "components", "disabled", "page", "selected", "shape", "size", "slots", "type", "variant"]);
    var ownerState = _extends({}, props, {
      color: color,
      disabled: disabled,
      selected: selected,
      shape: shape,
      size: size,
      type: type,
      variant: variant
    });
    var isRtl = useRtl();
    var classes = useUtilityClasses$D(ownerState);
    var normalizedIcons = isRtl ? {
      previous: slots.next || components.next || NavigateNextIcon,
      next: slots.previous || components.previous || NavigateBeforeIcon,
      last: slots.first || components.first || FirstPageIconDefault,
      first: slots.last || components.last || LastPageIconDefault
    } : {
      previous: slots.previous || components.previous || NavigateBeforeIcon,
      next: slots.next || components.next || NavigateNextIcon,
      first: slots.first || components.first || FirstPageIconDefault,
      last: slots.last || components.last || LastPageIconDefault
    };
    var Icon = normalizedIcons[type];
    return type === 'start-ellipsis' || type === 'end-ellipsis' ? /*#__PURE__*/jsxRuntimeExports.jsx(PaginationItemEllipsis, {
      ref: ref,
      ownerState: ownerState,
      className: clsx(classes.root, className),
      children: "\u2026"
    }) : /*#__PURE__*/jsxRuntimeExports.jsxs(PaginationItemPage, _extends({
      ref: ref,
      ownerState: ownerState,
      component: component,
      disabled: disabled,
      className: clsx(classes.root, className)
    }, other, {
      children: [type === 'page' && page, Icon ? /*#__PURE__*/jsxRuntimeExports.jsx(PaginationItemPageIcon, {
        as: Icon,
        ownerState: ownerState,
        className: classes.icon
      }) : null]
    }));
  });
  PaginationItem.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * @ignore
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The active color.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'standard'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['primary', 'secondary', 'standard']), PropTypes.string]),
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `slots` prop.
     * It's recommended to use the `slots` prop instead.
     *
     * @default {}
     */
    components: PropTypes.shape({
      first: PropTypes.elementType,
      last: PropTypes.elementType,
      next: PropTypes.elementType,
      previous: PropTypes.elementType
    }),
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * The current page number.
     */
    page: PropTypes.node,
    /**
     * If `true` the pagination item is selected.
     * @default false
     */
    selected: PropTypes.bool,
    /**
     * The shape of the pagination item.
     * @default 'circular'
     */
    shape: PropTypes.oneOf(['circular', 'rounded']),
    /**
     * The size of the component.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['small', 'medium', 'large']), PropTypes.string]),
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `components` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slots: PropTypes.shape({
      first: PropTypes.elementType,
      last: PropTypes.elementType,
      next: PropTypes.elementType,
      previous: PropTypes.elementType
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The type of pagination item.
     * @default 'page'
     */
    type: PropTypes.oneOf(['end-ellipsis', 'first', 'last', 'next', 'page', 'previous', 'start-ellipsis']),
    /**
     * The variant to use.
     * @default 'text'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['outlined', 'text']), PropTypes.string])
  } ;
  var PaginationItem$1 = PaginationItem;

  var useUtilityClasses$C = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      variant = ownerState.variant;
    var slots = {
      root: ['root', variant],
      ul: ['ul']
    };
    return composeClasses(slots, getPaginationUtilityClass, classes);
  };
  var PaginationRoot = styled$1('nav', {
    name: 'MuiPagination',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.variant]];
    }
  })({});
  var PaginationUl = styled$1('ul', {
    name: 'MuiPagination',
    slot: 'Ul',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.ul;
    }
  })({
    display: 'flex',
    flexWrap: 'wrap',
    alignItems: 'center',
    padding: 0,
    margin: 0,
    listStyle: 'none'
  });
  function defaultGetAriaLabel$1(type, page, selected) {
    if (type === 'page') {
      return "".concat(selected ? '' : 'Go to ', "page ").concat(page);
    }
    return "Go to ".concat(type, " page");
  }
  var Pagination = /*#__PURE__*/React__namespace.forwardRef(function Pagination(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiPagination'
    });
    var _props$boundaryCount = props.boundaryCount,
      boundaryCount = _props$boundaryCount === void 0 ? 1 : _props$boundaryCount,
      className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'standard' : _props$color,
      _props$count = props.count,
      count = _props$count === void 0 ? 1 : _props$count,
      _props$defaultPage = props.defaultPage,
      defaultPage = _props$defaultPage === void 0 ? 1 : _props$defaultPage,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$getItemAriaLab = props.getItemAriaLabel,
      getItemAriaLabel = _props$getItemAriaLab === void 0 ? defaultGetAriaLabel$1 : _props$getItemAriaLab,
      _props$hideNextButton = props.hideNextButton,
      hideNextButton = _props$hideNextButton === void 0 ? false : _props$hideNextButton,
      _props$hidePrevButton = props.hidePrevButton,
      hidePrevButton = _props$hidePrevButton === void 0 ? false : _props$hidePrevButton;
      props.onChange;
      props.page;
      var _props$renderItem = props.renderItem,
      renderItem = _props$renderItem === void 0 ? function (item) {
        return /*#__PURE__*/jsxRuntimeExports.jsx(PaginationItem$1, _extends({}, item));
      } : _props$renderItem,
      _props$shape = props.shape,
      shape = _props$shape === void 0 ? 'circular' : _props$shape,
      _props$showFirstButto = props.showFirstButton,
      showFirstButton = _props$showFirstButto === void 0 ? false : _props$showFirstButto,
      _props$showLastButton = props.showLastButton,
      showLastButton = _props$showLastButton === void 0 ? false : _props$showLastButton,
      _props$siblingCount = props.siblingCount,
      siblingCount = _props$siblingCount === void 0 ? 1 : _props$siblingCount,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'text' : _props$variant,
      other = _objectWithoutProperties(props, ["boundaryCount", "className", "color", "count", "defaultPage", "disabled", "getItemAriaLabel", "hideNextButton", "hidePrevButton", "onChange", "page", "renderItem", "shape", "showFirstButton", "showLastButton", "siblingCount", "size", "variant"]);
    var _usePagination = usePagination(_extends({}, props, {
        componentName: 'Pagination'
      })),
      items = _usePagination.items;
    var ownerState = _extends({}, props, {
      boundaryCount: boundaryCount,
      color: color,
      count: count,
      defaultPage: defaultPage,
      disabled: disabled,
      getItemAriaLabel: getItemAriaLabel,
      hideNextButton: hideNextButton,
      hidePrevButton: hidePrevButton,
      renderItem: renderItem,
      shape: shape,
      showFirstButton: showFirstButton,
      showLastButton: showLastButton,
      siblingCount: siblingCount,
      size: size,
      variant: variant
    });
    var classes = useUtilityClasses$C(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(PaginationRoot, _extends({
      "aria-label": "pagination navigation",
      className: clsx(classes.root, className),
      ownerState: ownerState,
      ref: ref
    }, other, {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(PaginationUl, {
        className: classes.ul,
        ownerState: ownerState,
        children: items.map(function (item, index) {
          return /*#__PURE__*/jsxRuntimeExports.jsx("li", {
            children: renderItem(_extends({}, item, {
              color: color,
              'aria-label': getItemAriaLabel(item.type, item.page, item.selected),
              shape: shape,
              size: size,
              variant: variant
            }))
          }, index);
        })
      })
    }));
  });

  // @default tags synced with default values from usePagination

  Pagination.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Number of always visible pages at the beginning and end.
     * @default 1
     */
    boundaryCount: integerPropType,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The active color.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'standard'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['primary', 'secondary', 'standard']), PropTypes.string]),
    /**
     * The total number of pages.
     * @default 1
     */
    count: integerPropType,
    /**
     * The page selected by default when the component is uncontrolled.
     * @default 1
     */
    defaultPage: integerPropType,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * Accepts a function which returns a string value that provides a user-friendly name for the current page.
     * This is important for screen reader users.
     *
     * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
     * @param {string} type The link or button type to format ('page' | 'first' | 'last' | 'next' | 'previous' | 'start-ellipsis' | 'end-ellipsis'). Defaults to 'page'.
     * @param {number} page The page number to format.
     * @param {bool} selected If true, the current page is selected.
     * @returns {string}
     */
    getItemAriaLabel: PropTypes.func,
    /**
     * If `true`, hide the next-page button.
     * @default false
     */
    hideNextButton: PropTypes.bool,
    /**
     * If `true`, hide the previous-page button.
     * @default false
     */
    hidePrevButton: PropTypes.bool,
    /**
     * Callback fired when the page is changed.
     *
     * @param {React.ChangeEvent<unknown>} event The event source of the callback.
     * @param {number} page The page selected.
     */
    onChange: PropTypes.func,
    /**
     * The current page. Unlike `TablePagination`, which starts numbering from `0`, this pagination starts from `1`.
     */
    page: integerPropType,
    /**
     * Render the item.
     * @param {PaginationRenderItemParams} params The props to spread on a PaginationItem.
     * @returns {ReactNode}
     * @default (item) => <PaginationItem {...item} />
     */
    renderItem: PropTypes.func,
    /**
     * The shape of the pagination items.
     * @default 'circular'
     */
    shape: PropTypes.oneOf(['circular', 'rounded']),
    /**
     * If `true`, show the first-page button.
     * @default false
     */
    showFirstButton: PropTypes.bool,
    /**
     * If `true`, show the last-page button.
     * @default false
     */
    showLastButton: PropTypes.bool,
    /**
     * Number of always visible pages before and after the current page.
     * @default 1
     */
    siblingCount: integerPropType,
    /**
     * The size of the component.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['small', 'medium', 'large']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The variant to use.
     * @default 'text'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['outlined', 'text']), PropTypes.string])
  } ;
  var Pagination$1 = Pagination;

  var RadioButtonUncheckedIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"
  }), 'RadioButtonUnchecked');

  var RadioButtonCheckedIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M8.465 8.465C9.37 7.56 10.62 7 12 7C14.76 7 17 9.24 17 12C17 13.38 16.44 14.63 15.535 15.535C14.63 16.44 13.38 17 12 17C9.24 17 7 14.76 7 12C7 10.62 7.56 9.37 8.465 8.465Z"
  }), 'RadioButtonChecked');

  var RadioButtonIconRoot = styled$1('span', {
    shouldForwardProp: rootShouldForwardProp$1
  })({
    position: 'relative',
    display: 'flex'
  });
  var RadioButtonIconBackground = styled$1(RadioButtonUncheckedIcon)({
    // Scale applied to prevent dot misalignment in Safari
    transform: 'scale(1)'
  });
  var RadioButtonIconDot = styled$1(RadioButtonCheckedIcon)(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      left: 0,
      position: 'absolute',
      transform: 'scale(0)',
      transition: theme.transitions.create('transform', {
        easing: theme.transitions.easing.easeIn,
        duration: theme.transitions.duration.shortest
      })
    }, ownerState.checked && {
      transform: 'scale(1)',
      transition: theme.transitions.create('transform', {
        easing: theme.transitions.easing.easeOut,
        duration: theme.transitions.duration.shortest
      })
    });
  });

  /**
   * @ignore - internal component.
   */
  function RadioButtonIcon(props) {
    var _props$checked = props.checked,
      checked = _props$checked === void 0 ? false : _props$checked,
      _props$classes = props.classes,
      classes = _props$classes === void 0 ? {} : _props$classes,
      fontSize = props.fontSize;
    var ownerState = _extends({}, props, {
      checked: checked
    });
    return /*#__PURE__*/jsxRuntimeExports.jsxs(RadioButtonIconRoot, {
      className: classes.root,
      ownerState: ownerState,
      children: [/*#__PURE__*/jsxRuntimeExports.jsx(RadioButtonIconBackground, {
        fontSize: fontSize,
        className: classes.background,
        ownerState: ownerState
      }), /*#__PURE__*/jsxRuntimeExports.jsx(RadioButtonIconDot, {
        fontSize: fontSize,
        className: classes.dot,
        ownerState: ownerState
      })]
    });
  }
  RadioButtonIcon.propTypes = {
    /**
     * If `true`, the component is checked.
     */
    checked: PropTypes.bool,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * The size of the component.
     * `small` is equivalent to the dense radio styling.
     */
    fontSize: PropTypes.oneOf(['small', 'medium'])
  } ;

  /**
   * @ignore - internal component.
   */
  var RadioGroupContext = /*#__PURE__*/React__namespace.createContext(undefined);
  {
    RadioGroupContext.displayName = 'RadioGroupContext';
  }
  var RadioGroupContext$1 = RadioGroupContext;

  function useRadioGroup() {
    return React__namespace.useContext(RadioGroupContext$1);
  }

  function getRadioUtilityClass(slot) {
    return generateUtilityClass('MuiRadio', slot);
  }
  var radioClasses = generateUtilityClasses('MuiRadio', ['root', 'checked', 'disabled', 'colorPrimary', 'colorSecondary', 'sizeSmall']);
  var radioClasses$1 = radioClasses;

  var useUtilityClasses$B = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      color = ownerState.color,
      size = ownerState.size;
    var slots = {
      root: ['root', "color".concat(capitalize(color)), size !== 'medium' && "size".concat(capitalize(size))]
    };
    return _extends({}, classes, composeClasses(slots, getRadioUtilityClass, classes));
  };
  var RadioRoot = styled$1(SwitchBase$1, {
    shouldForwardProp: function shouldForwardProp(prop) {
      return rootShouldForwardProp$1(prop) || prop === 'classes';
    },
    name: 'MuiRadio',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.size !== 'medium' && styles["size".concat(capitalize(ownerState.size))], styles["color".concat(capitalize(ownerState.color))]];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      color: (theme.vars || theme).palette.text.secondary
    }, !ownerState.disableRipple && {
      '&:hover': {
        backgroundColor: theme.vars ? "rgba(".concat(ownerState.color === 'default' ? theme.vars.palette.action.activeChannel : theme.vars.palette[ownerState.color].mainChannel, " / ").concat(theme.vars.palette.action.hoverOpacity, ")") : alpha(ownerState.color === 'default' ? theme.palette.action.active : theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: 'transparent'
        }
      }
    }, ownerState.color !== 'default' && _defineProperty({}, "&.".concat(radioClasses$1.checked), {
      color: (theme.vars || theme).palette[ownerState.color].main
    }), _defineProperty({}, "&.".concat(radioClasses$1.disabled), {
      color: (theme.vars || theme).palette.action.disabled
    }));
  });
  function areEqualValues$1(a, b) {
    if (_typeof(b) === 'object' && b !== null) {
      return a === b;
    }

    // The value could be a number, the DOM will stringify it anyway.
    return String(a) === String(b);
  }
  var defaultCheckedIcon = /*#__PURE__*/jsxRuntimeExports.jsx(RadioButtonIcon, {
    checked: true
  });
  var defaultIcon$1 = /*#__PURE__*/jsxRuntimeExports.jsx(RadioButtonIcon, {});
  var Radio = /*#__PURE__*/React__namespace.forwardRef(function Radio(inProps, ref) {
    var _defaultIcon$props$fo, _defaultCheckedIcon$p;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiRadio'
    });
    var checkedProp = props.checked,
      _props$checkedIcon = props.checkedIcon,
      checkedIcon = _props$checkedIcon === void 0 ? defaultCheckedIcon : _props$checkedIcon,
      _props$color = props.color,
      color = _props$color === void 0 ? 'primary' : _props$color,
      _props$icon = props.icon,
      icon = _props$icon === void 0 ? defaultIcon$1 : _props$icon,
      nameProp = props.name,
      onChangeProp = props.onChange,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      className = props.className,
      other = _objectWithoutProperties(props, ["checked", "checkedIcon", "color", "icon", "name", "onChange", "size", "className"]);
    var ownerState = _extends({}, props, {
      color: color,
      size: size
    });
    var classes = useUtilityClasses$B(ownerState);
    var radioGroup = useRadioGroup();
    var checked = checkedProp;
    var onChange = createChainedFunction(onChangeProp, radioGroup && radioGroup.onChange);
    var name = nameProp;
    if (radioGroup) {
      if (typeof checked === 'undefined') {
        checked = areEqualValues$1(radioGroup.value, props.value);
      }
      if (typeof name === 'undefined') {
        name = radioGroup.name;
      }
    }
    return /*#__PURE__*/jsxRuntimeExports.jsx(RadioRoot, _extends({
      type: "radio",
      icon: /*#__PURE__*/React__namespace.cloneElement(icon, {
        fontSize: (_defaultIcon$props$fo = defaultIcon$1.props.fontSize) != null ? _defaultIcon$props$fo : size
      }),
      checkedIcon: /*#__PURE__*/React__namespace.cloneElement(checkedIcon, {
        fontSize: (_defaultCheckedIcon$p = defaultCheckedIcon.props.fontSize) != null ? _defaultCheckedIcon$p : size
      }),
      ownerState: ownerState,
      classes: classes,
      name: name,
      checked: checked,
      onChange: onChange,
      ref: ref,
      className: clsx(classes.root, className)
    }, other));
  });
  Radio.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * If `true`, the component is checked.
     */
    checked: PropTypes.bool,
    /**
     * The icon to display when the component is checked.
     * @default <RadioButtonIcon checked />
     */
    checkedIcon: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'primary'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['default', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * If `true`, the component is disabled.
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the ripple effect is disabled.
     * @default false
     */
    disableRipple: PropTypes.bool,
    /**
     * The icon to display when the component is unchecked.
     * @default <RadioButtonIcon />
     */
    icon: PropTypes.node,
    /**
     * The id of the `input` element.
     */
    id: PropTypes.string,
    /**
     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
     */
    inputProps: PropTypes.object,
    /**
     * Pass a ref to the `input` element.
     */
    inputRef: refType$1,
    /**
     * Name attribute of the `input` element.
     */
    name: PropTypes.string,
    /**
     * Callback fired when the state is changed.
     *
     * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.
     * You can pull out the new value by accessing `event.target.value` (string).
     * You can pull out the new checked state by accessing `event.target.checked` (boolean).
     */
    onChange: PropTypes.func,
    /**
     * If `true`, the `input` element is required.
     * @default false
     */
    required: PropTypes.bool,
    /**
     * The size of the component.
     * `small` is equivalent to the dense radio styling.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['medium', 'small']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The value of the component. The DOM API casts this to a string.
     */
    value: PropTypes.any
  } ;
  var Radio$1 = Radio;

  function getRadioGroupUtilityClass(slot) {
    return generateUtilityClass('MuiRadioGroup', slot);
  }
  var radioGroupClasses = generateUtilityClasses('MuiRadioGroup', ['root', 'row', 'error']);
  var radioGroupClasses$1 = radioGroupClasses;

  var useUtilityClasses$A = function useUtilityClasses(props) {
    var classes = props.classes,
      row = props.row,
      error = props.error;
    var slots = {
      root: ['root', row && 'row', error && 'error']
    };
    return composeClasses(slots, getRadioGroupUtilityClass, classes);
  };
  var RadioGroup = /*#__PURE__*/React__namespace.forwardRef(function RadioGroup(props, ref) {
    var actions = props.actions,
      children = props.children,
      className = props.className,
      defaultValue = props.defaultValue,
      nameProp = props.name,
      _onChange = props.onChange,
      valueProp = props.value,
      other = _objectWithoutProperties(props, ["actions", "children", "className", "defaultValue", "name", "onChange", "value"]);
    var rootRef = React__namespace.useRef(null);
    var classes = useUtilityClasses$A(props);
    var _useControlled = useControlled({
        controlled: valueProp,
        "default": defaultValue,
        name: 'RadioGroup'
      }),
      _useControlled2 = _slicedToArray(_useControlled, 2),
      value = _useControlled2[0],
      setValueState = _useControlled2[1];
    React__namespace.useImperativeHandle(actions, function () {
      return {
        focus: function focus() {
          var input = rootRef.current.querySelector('input:not(:disabled):checked');
          if (!input) {
            input = rootRef.current.querySelector('input:not(:disabled)');
          }
          if (input) {
            input.focus();
          }
        }
      };
    }, []);
    var handleRef = useForkRef(ref, rootRef);
    var name = useId(nameProp);
    var contextValue = React__namespace.useMemo(function () {
      return {
        name: name,
        onChange: function onChange(event) {
          setValueState(event.target.value);
          if (_onChange) {
            _onChange(event, event.target.value);
          }
        },
        value: value
      };
    }, [name, _onChange, setValueState, value]);
    return /*#__PURE__*/jsxRuntimeExports.jsx(RadioGroupContext$1.Provider, {
      value: contextValue,
      children: /*#__PURE__*/jsxRuntimeExports.jsx(FormGroup$1, _extends({
        role: "radiogroup",
        ref: handleRef,
        className: clsx(classes.root, className)
      }, other, {
        children: children
      }))
    });
  });
  RadioGroup.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The default value. Use when the component is not controlled.
     */
    defaultValue: PropTypes.any,
    /**
     * The name used to reference the value of the control.
     * If you don't provide this prop, it falls back to a randomly generated name.
     */
    name: PropTypes.string,
    /**
     * Callback fired when a radio button is selected.
     *
     * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.
     * @param {string} value The value of the selected radio button.
     * You can pull out the new value by accessing `event.target.value` (string).
     */
    onChange: PropTypes.func,
    /**
     * Value of the selected radio button. The DOM API casts this to a string.
     */
    value: PropTypes.any
  } ;
  var RadioGroup$1 = RadioGroup;

  var Star = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M12 17.27L18.18 21l-1.64-7.03L22 9.24l-7.19-.61L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21z"
  }), 'Star');

  var StarBorder = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M22 9.24l-7.19-.62L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21 12 17.27 18.18 21l-1.63-7.03L22 9.24zM12 15.4l-3.76 2.27 1-4.28-3.32-2.88 4.38-.38L12 6.1l1.71 4.04 4.38.38-3.32 2.88 1 4.28L12 15.4z"
  }), 'StarBorder');

  function getRatingUtilityClass(slot) {
    return generateUtilityClass('MuiRating', slot);
  }
  var ratingClasses = generateUtilityClasses('MuiRating', ['root', 'sizeSmall', 'sizeMedium', 'sizeLarge', 'readOnly', 'disabled', 'focusVisible', 'visuallyHidden', 'pristine', 'label', 'labelEmptyValueActive', 'icon', 'iconEmpty', 'iconFilled', 'iconHover', 'iconFocus', 'iconActive', 'decimal']);
  var ratingClasses$1 = ratingClasses;

  function getDecimalPrecision$1(num) {
    var decimalPart = num.toString().split('.')[1];
    return decimalPart ? decimalPart.length : 0;
  }
  function roundValueToPrecision(value, precision) {
    if (value == null) {
      return value;
    }
    var nearest = Math.round(value / precision) * precision;
    return Number(nearest.toFixed(getDecimalPrecision$1(precision)));
  }
  var useUtilityClasses$z = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      size = ownerState.size,
      readOnly = ownerState.readOnly,
      disabled = ownerState.disabled,
      emptyValueFocused = ownerState.emptyValueFocused,
      focusVisible = ownerState.focusVisible;
    var slots = {
      root: ['root', "size".concat(capitalize(size)), disabled && 'disabled', focusVisible && 'focusVisible', readOnly && 'readOnly'],
      label: ['label', 'pristine'],
      labelEmptyValue: [emptyValueFocused && 'labelEmptyValueActive'],
      icon: ['icon'],
      iconEmpty: ['iconEmpty'],
      iconFilled: ['iconFilled'],
      iconHover: ['iconHover'],
      iconFocus: ['iconFocus'],
      iconActive: ['iconActive'],
      decimal: ['decimal'],
      visuallyHidden: ['visuallyHidden']
    };
    return composeClasses(slots, getRatingUtilityClass, classes);
  };
  var RatingRoot = styled$1('span', {
    name: 'MuiRating',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [_defineProperty({}, "& .".concat(ratingClasses$1.visuallyHidden), styles.visuallyHidden), styles.root, styles["size".concat(capitalize(ownerState.size))], ownerState.readOnly && styles.readOnly];
    }
  })(function (_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    return _extends(_defineProperty(_defineProperty(_defineProperty({
      display: 'inline-flex',
      // Required to position the pristine input absolutely
      position: 'relative',
      fontSize: theme.typography.pxToRem(24),
      color: '#faaf00',
      cursor: 'pointer',
      textAlign: 'left',
      width: 'min-content',
      WebkitTapHighlightColor: 'transparent'
    }, "&.".concat(ratingClasses$1.disabled), {
      opacity: (theme.vars || theme).palette.action.disabledOpacity,
      pointerEvents: 'none'
    }), "&.".concat(ratingClasses$1.focusVisible, " .").concat(ratingClasses$1.iconActive), {
      outline: '1px solid #999'
    }), "& .".concat(ratingClasses$1.visuallyHidden), visuallyHidden$1), ownerState.size === 'small' && {
      fontSize: theme.typography.pxToRem(18)
    }, ownerState.size === 'large' && {
      fontSize: theme.typography.pxToRem(30)
    }, ownerState.readOnly && {
      pointerEvents: 'none'
    });
  });
  var RatingLabel = styled$1('label', {
    name: 'MuiRating',
    slot: 'Label',
    overridesResolver: function overridesResolver(_ref3, styles) {
      var ownerState = _ref3.ownerState;
      return [styles.label, ownerState.emptyValueFocused && styles.labelEmptyValueActive];
    }
  })(function (_ref4) {
    var ownerState = _ref4.ownerState;
    return _extends({
      cursor: 'inherit'
    }, ownerState.emptyValueFocused && {
      top: 0,
      bottom: 0,
      position: 'absolute',
      outline: '1px solid #999',
      width: '100%'
    });
  });
  var RatingIcon = styled$1('span', {
    name: 'MuiRating',
    slot: 'Icon',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.icon, ownerState.iconEmpty && styles.iconEmpty, ownerState.iconFilled && styles.iconFilled, ownerState.iconHover && styles.iconHover, ownerState.iconFocus && styles.iconFocus, ownerState.iconActive && styles.iconActive];
    }
  })(function (_ref5) {
    var theme = _ref5.theme,
      ownerState = _ref5.ownerState;
    return _extends({
      // Fit wrapper to actual icon size.
      display: 'flex',
      transition: theme.transitions.create('transform', {
        duration: theme.transitions.duration.shortest
      }),
      // Fix mouseLeave issue.
      // https://github.com/facebook/react/issues/4492
      pointerEvents: 'none'
    }, ownerState.iconActive && {
      transform: 'scale(1.2)'
    }, ownerState.iconEmpty && {
      color: (theme.vars || theme).palette.action.disabled
    });
  });
  var RatingDecimal = styled$1('span', {
    name: 'MuiRating',
    slot: 'Decimal',
    shouldForwardProp: function shouldForwardProp(prop) {
      return slotShouldForwardProp(prop) && prop !== 'iconActive';
    },
    overridesResolver: function overridesResolver(props, styles) {
      var iconActive = props.iconActive;
      return [styles.decimal, iconActive && styles.iconActive];
    }
  })(function (_ref6) {
    var iconActive = _ref6.iconActive;
    return _extends({
      position: 'relative'
    }, iconActive && {
      transform: 'scale(1.2)'
    });
  });
  function IconContainer(props) {
    props.value;
      var other = _objectWithoutProperties(props, ["value"]);
    return /*#__PURE__*/jsxRuntimeExports.jsx("span", _extends({}, other));
  }
  IconContainer.propTypes = {
    value: PropTypes.number.isRequired
  } ;
  function RatingItem(props) {
    var classes = props.classes,
      disabled = props.disabled,
      emptyIcon = props.emptyIcon,
      focus = props.focus,
      getLabelText = props.getLabelText,
      highlightSelectedOnly = props.highlightSelectedOnly,
      hover = props.hover,
      icon = props.icon,
      IconContainerComponent = props.IconContainerComponent,
      isActive = props.isActive,
      itemValue = props.itemValue,
      labelProps = props.labelProps,
      name = props.name,
      onBlur = props.onBlur,
      onChange = props.onChange,
      onClick = props.onClick,
      onFocus = props.onFocus,
      readOnly = props.readOnly,
      ownerState = props.ownerState,
      ratingValue = props.ratingValue,
      ratingValueRounded = props.ratingValueRounded;
    var isFilled = highlightSelectedOnly ? itemValue === ratingValue : itemValue <= ratingValue;
    var isHovered = itemValue <= hover;
    var isFocused = itemValue <= focus;
    var isChecked = itemValue === ratingValueRounded;
    var id = useId();
    var container = /*#__PURE__*/jsxRuntimeExports.jsx(RatingIcon, {
      as: IconContainerComponent,
      value: itemValue,
      className: clsx(classes.icon, isFilled ? classes.iconFilled : classes.iconEmpty, isHovered && classes.iconHover, isFocused && classes.iconFocus, isActive && classes.iconActive),
      ownerState: _extends({}, ownerState, {
        iconEmpty: !isFilled,
        iconFilled: isFilled,
        iconHover: isHovered,
        iconFocus: isFocused,
        iconActive: isActive
      }),
      children: emptyIcon && !isFilled ? emptyIcon : icon
    });
    if (readOnly) {
      return /*#__PURE__*/jsxRuntimeExports.jsx("span", _extends({}, labelProps, {
        children: container
      }));
    }
    return /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsxs(RatingLabel, _extends({
        ownerState: _extends({}, ownerState, {
          emptyValueFocused: undefined
        }),
        htmlFor: id
      }, labelProps, {
        children: [container, /*#__PURE__*/jsxRuntimeExports.jsx("span", {
          className: classes.visuallyHidden,
          children: getLabelText(itemValue)
        })]
      })), /*#__PURE__*/jsxRuntimeExports.jsx("input", {
        className: classes.visuallyHidden,
        onFocus: onFocus,
        onBlur: onBlur,
        onChange: onChange,
        onClick: onClick,
        disabled: disabled,
        value: itemValue,
        id: id,
        type: "radio",
        name: name,
        checked: isChecked
      })]
    });
  }
  RatingItem.propTypes = {
    classes: PropTypes.object.isRequired,
    disabled: PropTypes.bool.isRequired,
    emptyIcon: PropTypes.node,
    focus: PropTypes.number.isRequired,
    getLabelText: PropTypes.func.isRequired,
    highlightSelectedOnly: PropTypes.bool.isRequired,
    hover: PropTypes.number.isRequired,
    icon: PropTypes.node,
    IconContainerComponent: PropTypes.elementType.isRequired,
    isActive: PropTypes.bool.isRequired,
    itemValue: PropTypes.number.isRequired,
    labelProps: PropTypes.object,
    name: PropTypes.string,
    onBlur: PropTypes.func.isRequired,
    onChange: PropTypes.func.isRequired,
    onClick: PropTypes.func.isRequired,
    onFocus: PropTypes.func.isRequired,
    ownerState: PropTypes.object.isRequired,
    ratingValue: PropTypes.number,
    ratingValueRounded: PropTypes.number,
    readOnly: PropTypes.bool.isRequired
  } ;
  var defaultIcon = /*#__PURE__*/jsxRuntimeExports.jsx(Star, {
    fontSize: "inherit"
  });
  var defaultEmptyIcon = /*#__PURE__*/jsxRuntimeExports.jsx(StarBorder, {
    fontSize: "inherit"
  });
  function defaultLabelText(value) {
    return "".concat(value, " Star").concat(value !== 1 ? 's' : '');
  }
  var Rating = /*#__PURE__*/React__namespace.forwardRef(function Rating(inProps, ref) {
    var props = useDefaultProps({
      name: 'MuiRating',
      props: inProps
    });
    var className = props.className,
      _props$defaultValue = props.defaultValue,
      defaultValue = _props$defaultValue === void 0 ? null : _props$defaultValue,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$emptyIcon = props.emptyIcon,
      emptyIcon = _props$emptyIcon === void 0 ? defaultEmptyIcon : _props$emptyIcon,
      _props$emptyLabelText = props.emptyLabelText,
      emptyLabelText = _props$emptyLabelText === void 0 ? 'Empty' : _props$emptyLabelText,
      _props$getLabelText = props.getLabelText,
      getLabelText = _props$getLabelText === void 0 ? defaultLabelText : _props$getLabelText,
      _props$highlightSelec = props.highlightSelectedOnly,
      highlightSelectedOnly = _props$highlightSelec === void 0 ? false : _props$highlightSelec,
      _props$icon = props.icon,
      icon = _props$icon === void 0 ? defaultIcon : _props$icon,
      _props$IconContainerC = props.IconContainerComponent,
      IconContainerComponent = _props$IconContainerC === void 0 ? IconContainer : _props$IconContainerC,
      _props$max = props.max,
      max = _props$max === void 0 ? 5 : _props$max,
      nameProp = props.name,
      onChange = props.onChange,
      onChangeActive = props.onChangeActive,
      onMouseLeave = props.onMouseLeave,
      onMouseMove = props.onMouseMove,
      _props$precision = props.precision,
      precision = _props$precision === void 0 ? 1 : _props$precision,
      _props$readOnly = props.readOnly,
      readOnly = _props$readOnly === void 0 ? false : _props$readOnly,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      valueProp = props.value,
      other = _objectWithoutProperties(props, ["className", "defaultValue", "disabled", "emptyIcon", "emptyLabelText", "getLabelText", "highlightSelectedOnly", "icon", "IconContainerComponent", "max", "name", "onChange", "onChangeActive", "onMouseLeave", "onMouseMove", "precision", "readOnly", "size", "value"]);
    var name = useId(nameProp);
    var _useControlled = useControlled({
        controlled: valueProp,
        "default": defaultValue,
        name: 'Rating'
      }),
      _useControlled2 = _slicedToArray(_useControlled, 2),
      valueDerived = _useControlled2[0],
      setValueState = _useControlled2[1];
    var valueRounded = roundValueToPrecision(valueDerived, precision);
    var isRtl = useRtl();
    var _React$useState = React__namespace.useState({
        hover: -1,
        focus: -1
      }),
      _React$useState$ = _React$useState[0],
      hover = _React$useState$.hover,
      focus = _React$useState$.focus,
      setState = _React$useState[1];
    var value = valueRounded;
    if (hover !== -1) {
      value = hover;
    }
    if (focus !== -1) {
      value = focus;
    }
    var _useIsFocusVisible = useIsFocusVisible(),
      isFocusVisibleRef = _useIsFocusVisible.isFocusVisibleRef,
      handleBlurVisible = _useIsFocusVisible.onBlur,
      handleFocusVisible = _useIsFocusVisible.onFocus,
      focusVisibleRef = _useIsFocusVisible.ref;
    var _React$useState2 = React__namespace.useState(false),
      focusVisible = _React$useState2[0],
      setFocusVisible = _React$useState2[1];
    var rootRef = React__namespace.useRef();
    var handleRef = useForkRef(focusVisibleRef, rootRef, ref);
    var handleMouseMove = function handleMouseMove(event) {
      if (onMouseMove) {
        onMouseMove(event);
      }
      var rootNode = rootRef.current;
      var _rootNode$getBounding = rootNode.getBoundingClientRect(),
        right = _rootNode$getBounding.right,
        left = _rootNode$getBounding.left,
        containerWidth = _rootNode$getBounding.width;
      var percent;
      if (isRtl) {
        percent = (right - event.clientX) / containerWidth;
      } else {
        percent = (event.clientX - left) / containerWidth;
      }
      var newHover = roundValueToPrecision(max * percent + precision / 2, precision);
      newHover = clamp(newHover, precision, max);
      setState(function (prev) {
        return prev.hover === newHover && prev.focus === newHover ? prev : {
          hover: newHover,
          focus: newHover
        };
      });
      setFocusVisible(false);
      if (onChangeActive && hover !== newHover) {
        onChangeActive(event, newHover);
      }
    };
    var handleMouseLeave = function handleMouseLeave(event) {
      if (onMouseLeave) {
        onMouseLeave(event);
      }
      var newHover = -1;
      setState({
        hover: newHover,
        focus: newHover
      });
      if (onChangeActive && hover !== newHover) {
        onChangeActive(event, newHover);
      }
    };
    var handleChange = function handleChange(event) {
      var newValue = event.target.value === '' ? null : parseFloat(event.target.value);

      // Give mouse priority over keyboard
      // Fix https://github.com/mui/material-ui/issues/22827
      if (hover !== -1) {
        newValue = hover;
      }
      setValueState(newValue);
      if (onChange) {
        onChange(event, newValue);
      }
    };
    var handleClear = function handleClear(event) {
      // Ignore keyboard events
      // https://github.com/facebook/react/issues/7407
      if (event.clientX === 0 && event.clientY === 0) {
        return;
      }
      setState({
        hover: -1,
        focus: -1
      });
      setValueState(null);
      if (onChange && parseFloat(event.target.value) === valueRounded) {
        onChange(event, null);
      }
    };
    var handleFocus = function handleFocus(event) {
      handleFocusVisible(event);
      if (isFocusVisibleRef.current === true) {
        setFocusVisible(true);
      }
      var newFocus = parseFloat(event.target.value);
      setState(function (prev) {
        return {
          hover: prev.hover,
          focus: newFocus
        };
      });
    };
    var handleBlur = function handleBlur(event) {
      if (hover !== -1) {
        return;
      }
      handleBlurVisible(event);
      if (isFocusVisibleRef.current === false) {
        setFocusVisible(false);
      }
      var newFocus = -1;
      setState(function (prev) {
        return {
          hover: prev.hover,
          focus: newFocus
        };
      });
    };
    var _React$useState3 = React__namespace.useState(false),
      emptyValueFocused = _React$useState3[0],
      setEmptyValueFocused = _React$useState3[1];
    var ownerState = _extends({}, props, {
      defaultValue: defaultValue,
      disabled: disabled,
      emptyIcon: emptyIcon,
      emptyLabelText: emptyLabelText,
      emptyValueFocused: emptyValueFocused,
      focusVisible: focusVisible,
      getLabelText: getLabelText,
      icon: icon,
      IconContainerComponent: IconContainerComponent,
      max: max,
      precision: precision,
      readOnly: readOnly,
      size: size
    });
    var classes = useUtilityClasses$z(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(RatingRoot, _extends({
      ref: handleRef,
      onMouseMove: handleMouseMove,
      onMouseLeave: handleMouseLeave,
      className: clsx(classes.root, className, readOnly && 'MuiRating-readOnly'),
      ownerState: ownerState,
      role: readOnly ? 'img' : null,
      "aria-label": readOnly ? getLabelText(value) : null
    }, other, {
      children: [Array.from(new Array(max)).map(function (_, index) {
        var itemValue = index + 1;
        var ratingItemProps = {
          classes: classes,
          disabled: disabled,
          emptyIcon: emptyIcon,
          focus: focus,
          getLabelText: getLabelText,
          highlightSelectedOnly: highlightSelectedOnly,
          hover: hover,
          icon: icon,
          IconContainerComponent: IconContainerComponent,
          name: name,
          onBlur: handleBlur,
          onChange: handleChange,
          onClick: handleClear,
          onFocus: handleFocus,
          ratingValue: value,
          ratingValueRounded: valueRounded,
          readOnly: readOnly,
          ownerState: ownerState
        };
        var isActive = itemValue === Math.ceil(value) && (hover !== -1 || focus !== -1);
        if (precision < 1) {
          var items = Array.from(new Array(1 / precision));
          return /*#__PURE__*/jsxRuntimeExports.jsx(RatingDecimal, {
            className: clsx(classes.decimal, isActive && classes.iconActive),
            ownerState: ownerState,
            iconActive: isActive,
            children: items.map(function ($, indexDecimal) {
              var itemDecimalValue = roundValueToPrecision(itemValue - 1 + (indexDecimal + 1) * precision, precision);
              return /*#__PURE__*/jsxRuntimeExports.jsx(RatingItem, _extends({}, ratingItemProps, {
                // The icon is already displayed as active
                isActive: false,
                itemValue: itemDecimalValue,
                labelProps: {
                  style: items.length - 1 === indexDecimal ? {} : {
                    width: itemDecimalValue === value ? "".concat((indexDecimal + 1) * precision * 100, "%") : '0%',
                    overflow: 'hidden',
                    position: 'absolute'
                  }
                }
              }), itemDecimalValue);
            })
          }, itemValue);
        }
        return /*#__PURE__*/jsxRuntimeExports.jsx(RatingItem, _extends({}, ratingItemProps, {
          isActive: isActive,
          itemValue: itemValue
        }), itemValue);
      }), !readOnly && !disabled && /*#__PURE__*/jsxRuntimeExports.jsxs(RatingLabel, {
        className: clsx(classes.label, classes.labelEmptyValue),
        ownerState: ownerState,
        children: [/*#__PURE__*/jsxRuntimeExports.jsx("input", {
          className: classes.visuallyHidden,
          value: "",
          id: "".concat(name, "-empty"),
          type: "radio",
          name: name,
          checked: valueRounded == null,
          onFocus: function onFocus() {
            return setEmptyValueFocused(true);
          },
          onBlur: function onBlur() {
            return setEmptyValueFocused(false);
          },
          onChange: handleChange
        }), /*#__PURE__*/jsxRuntimeExports.jsx("span", {
          className: classes.visuallyHidden,
          children: emptyLabelText
        })]
      })]
    }));
  });
  Rating.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The default value. Use when the component is not controlled.
     * @default null
     */
    defaultValue: PropTypes.number,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * The icon to display when empty.
     * @default <StarBorder fontSize="inherit" />
     */
    emptyIcon: PropTypes.node,
    /**
     * The label read when the rating input is empty.
     * @default 'Empty'
     */
    emptyLabelText: PropTypes.node,
    /**
     * Accepts a function which returns a string value that provides a user-friendly name for the current value of the rating.
     * This is important for screen reader users.
     *
     * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
     * @param {number} value The rating label's value to format.
     * @returns {string}
     * @default function defaultLabelText(value) {
     *   return `${value} Star${value !== 1 ? 's' : ''}`;
     * }
     */
    getLabelText: PropTypes.func,
    /**
     * If `true`, only the selected icon will be highlighted.
     * @default false
     */
    highlightSelectedOnly: PropTypes.bool,
    /**
     * The icon to display.
     * @default <Star fontSize="inherit" />
     */
    icon: PropTypes.node,
    /**
     * The component containing the icon.
     * @default function IconContainer(props) {
     *   const { value, ...other } = props;
     *   return <span {...other} />;
     * }
     */
    IconContainerComponent: PropTypes.elementType,
    /**
     * Maximum rating.
     * @default 5
     */
    max: PropTypes.number,
    /**
     * The name attribute of the radio `input` elements.
     * This input `name` should be unique within the page.
     * Being unique within a form is insufficient since the `name` is used to generated IDs.
     */
    name: PropTypes.string,
    /**
     * Callback fired when the value changes.
     * @param {React.SyntheticEvent} event The event source of the callback.
     * @param {number|null} value The new value.
     */
    onChange: PropTypes.func,
    /**
     * Callback function that is fired when the hover state changes.
     * @param {React.SyntheticEvent} event The event source of the callback.
     * @param {number} value The new value.
     */
    onChangeActive: PropTypes.func,
    /**
     * @ignore
     */
    onMouseLeave: PropTypes.func,
    /**
     * @ignore
     */
    onMouseMove: PropTypes.func,
    /**
     * The minimum increment value change allowed.
     * @default 1
     */
    precision: chainPropTypes(PropTypes.number, function (props) {
      if (props.precision < 0.1) {
        return new Error(['MUI: The prop `precision` should be above 0.1.', 'A value below this limit has an imperceptible impact.'].join('\n'));
      }
      return null;
    }),
    /**
     * Removes all hover effects and pointer events.
     * @default false
     */
    readOnly: PropTypes.bool,
    /**
     * The size of the component.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['small', 'medium', 'large']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The rating value.
     */
    value: PropTypes.number
  } ;
  var Rating$1 = Rating;

  function getScopedCssBaselineUtilityClass(slot) {
    return generateUtilityClass('MuiScopedCssBaseline', slot);
  }
  var scopedCssBaselineClasses = generateUtilityClasses('MuiScopedCssBaseline', ['root']);
  var scopedCssBaselineClasses$1 = scopedCssBaselineClasses;

  var useUtilityClasses$y = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    return composeClasses(slots, getScopedCssBaselineUtilityClass, classes);
  };
  var ScopedCssBaselineRoot = styled$1('div', {
    name: 'MuiScopedCssBaseline',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    var colorSchemeStyles = {};
    if (ownerState.enableColorScheme && theme.colorSchemes) {
      Object.entries(theme.colorSchemes).forEach(function (_ref2) {
        var _scheme$palette;
        var _ref3 = _slicedToArray(_ref2, 2),
          key = _ref3[0],
          scheme = _ref3[1];
        colorSchemeStyles["&".concat(theme.getColorSchemeSelector(key).replace(/\s*&/, ''))] = {
          colorScheme: (_scheme$palette = scheme.palette) == null ? void 0 : _scheme$palette.mode
        };
      });
    }
    return _extends({}, html(theme, ownerState.enableColorScheme), body(theme), {
      '& *, & *::before, & *::after': {
        boxSizing: 'inherit'
      },
      '& strong, & b': {
        fontWeight: theme.typography.fontWeightBold
      }
    }, colorSchemeStyles);
  });
  var ScopedCssBaseline = /*#__PURE__*/React__namespace.forwardRef(function ScopedCssBaseline(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiScopedCssBaseline'
    });
    var className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component;
      props.enableColorScheme;
      var other = _objectWithoutProperties(props, ["className", "component", "enableColorScheme"]);
    var ownerState = _extends({}, props, {
      component: component
    });
    var classes = useUtilityClasses$y(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(ScopedCssBaselineRoot, _extends({
      as: component,
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState
    }, other));
  });
  ScopedCssBaseline.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * Enable `color-scheme` CSS property to use `theme.palette.mode`.
     * For more details, check out https://developer.mozilla.org/en-US/docs/Web/CSS/color-scheme
     * For browser support, check out https://caniuse.com/?search=color-scheme
     */
    enableColorScheme: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var ScopedCssBaseline$1 = ScopedCssBaseline;

  function getSelectUtilityClasses(slot) {
    return generateUtilityClass('MuiSelect', slot);
  }
  var selectClasses = generateUtilityClasses('MuiSelect', ['root', 'select', 'multiple', 'filled', 'outlined', 'standard', 'disabled', 'focused', 'icon', 'iconOpen', 'iconFilled', 'iconOutlined', 'iconStandard', 'nativeInput', 'error']);
  var selectClasses$1 = selectClasses;

  var _span;
  var SelectSelect = styled$1('div', {
    name: 'MuiSelect',
    slot: 'Select',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [// Win specificity over the input base
      _defineProperty({}, "&.".concat(selectClasses$1.select), styles.select), _defineProperty({}, "&.".concat(selectClasses$1.select), styles[ownerState.variant]), _defineProperty({}, "&.".concat(selectClasses$1.error), styles.error), _defineProperty({}, "&.".concat(selectClasses$1.multiple), styles.multiple)];
    }
  })(nativeSelectSelectStyles, _defineProperty({}, "&.".concat(selectClasses$1.select), {
    height: 'auto',
    // Resets for multiple select with chips
    minHeight: '1.4375em',
    // Required for select\text-field height consistency
    textOverflow: 'ellipsis',
    whiteSpace: 'nowrap',
    overflow: 'hidden'
  }));
  var SelectIcon = styled$1('svg', {
    name: 'MuiSelect',
    slot: 'Icon',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.icon, ownerState.variant && styles["icon".concat(capitalize(ownerState.variant))], ownerState.open && styles.iconOpen];
    }
  })(nativeSelectIconStyles);
  var SelectNativeInput = styled$1('input', {
    shouldForwardProp: function shouldForwardProp(prop) {
      return slotShouldForwardProp(prop) && prop !== 'classes';
    },
    name: 'MuiSelect',
    slot: 'NativeInput',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.nativeInput;
    }
  })({
    bottom: 0,
    left: 0,
    position: 'absolute',
    opacity: 0,
    pointerEvents: 'none',
    width: '100%',
    boxSizing: 'border-box'
  });
  function areEqualValues(a, b) {
    if (_typeof(b) === 'object' && b !== null) {
      return a === b;
    }

    // The value could be a number, the DOM will stringify it anyway.
    return String(a) === String(b);
  }
  function isEmpty(display) {
    return display == null || typeof display === 'string' && !display.trim();
  }
  var useUtilityClasses$x = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      variant = ownerState.variant,
      disabled = ownerState.disabled,
      multiple = ownerState.multiple,
      open = ownerState.open,
      error = ownerState.error;
    var slots = {
      select: ['select', variant, disabled && 'disabled', multiple && 'multiple', error && 'error'],
      icon: ['icon', "icon".concat(capitalize(variant)), open && 'iconOpen', disabled && 'disabled'],
      nativeInput: ['nativeInput']
    };
    return composeClasses(slots, getSelectUtilityClasses, classes);
  };

  /**
   * @ignore - internal component.
   */
  var SelectInput = /*#__PURE__*/React__namespace.forwardRef(function SelectInput(props, ref) {
    var _MenuProps$slotProps;
    var ariaDescribedby = props['aria-describedby'],
      ariaLabel = props['aria-label'],
      autoFocus = props.autoFocus,
      autoWidth = props.autoWidth,
      children = props.children,
      className = props.className,
      defaultOpen = props.defaultOpen,
      defaultValue = props.defaultValue,
      disabled = props.disabled,
      displayEmpty = props.displayEmpty,
      _props$error = props.error,
      error = _props$error === void 0 ? false : _props$error,
      IconComponent = props.IconComponent,
      inputRefProp = props.inputRef,
      labelId = props.labelId,
      _props$MenuProps = props.MenuProps,
      MenuProps = _props$MenuProps === void 0 ? {} : _props$MenuProps,
      multiple = props.multiple,
      name = props.name,
      onBlur = props.onBlur,
      onChange = props.onChange,
      onClose = props.onClose,
      onFocus = props.onFocus,
      onOpen = props.onOpen,
      openProp = props.open,
      readOnly = props.readOnly,
      renderValue = props.renderValue,
      _props$SelectDisplayP = props.SelectDisplayProps,
      SelectDisplayProps = _props$SelectDisplayP === void 0 ? {} : _props$SelectDisplayP,
      tabIndexProp = props.tabIndex;
      props.type;
      var valueProp = props.value,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'standard' : _props$variant,
      other = _objectWithoutProperties(props, ["aria-describedby", "aria-label", "autoFocus", "autoWidth", "children", "className", "defaultOpen", "defaultValue", "disabled", "displayEmpty", "error", "IconComponent", "inputRef", "labelId", "MenuProps", "multiple", "name", "onBlur", "onChange", "onClose", "onFocus", "onOpen", "open", "readOnly", "renderValue", "SelectDisplayProps", "tabIndex", "type", "value", "variant"]);
    var _useControlled = useControlled({
        controlled: valueProp,
        "default": defaultValue,
        name: 'Select'
      }),
      _useControlled2 = _slicedToArray(_useControlled, 2),
      value = _useControlled2[0],
      setValueState = _useControlled2[1];
    var _useControlled3 = useControlled({
        controlled: openProp,
        "default": defaultOpen,
        name: 'Select'
      }),
      _useControlled4 = _slicedToArray(_useControlled3, 2),
      openState = _useControlled4[0],
      setOpenState = _useControlled4[1];
    var inputRef = React__namespace.useRef(null);
    var displayRef = React__namespace.useRef(null);
    var _React$useState = React__namespace.useState(null),
      displayNode = _React$useState[0],
      setDisplayNode = _React$useState[1];
    var _React$useRef = React__namespace.useRef(openProp != null),
      isOpenControlled = _React$useRef.current;
    var _React$useState2 = React__namespace.useState(),
      menuMinWidthState = _React$useState2[0],
      setMenuMinWidthState = _React$useState2[1];
    var handleRef = useForkRef(ref, inputRefProp);
    var handleDisplayRef = React__namespace.useCallback(function (node) {
      displayRef.current = node;
      if (node) {
        setDisplayNode(node);
      }
    }, []);
    var anchorElement = displayNode == null ? void 0 : displayNode.parentNode;
    React__namespace.useImperativeHandle(handleRef, function () {
      return {
        focus: function focus() {
          displayRef.current.focus();
        },
        node: inputRef.current,
        value: value
      };
    }, [value]);

    // Resize menu on `defaultOpen` automatic toggle.
    React__namespace.useEffect(function () {
      if (defaultOpen && openState && displayNode && !isOpenControlled) {
        setMenuMinWidthState(autoWidth ? null : anchorElement.clientWidth);
        displayRef.current.focus();
      }
      // eslint-disable-next-line react-hooks/exhaustive-deps
    }, [displayNode, autoWidth]);
    // `isOpenControlled` is ignored because the component should never switch between controlled and uncontrolled modes.
    // `defaultOpen` and `openState` are ignored to avoid unnecessary callbacks.
    React__namespace.useEffect(function () {
      if (autoFocus) {
        displayRef.current.focus();
      }
    }, [autoFocus]);
    React__namespace.useEffect(function () {
      if (!labelId) {
        return undefined;
      }
      var label = ownerDocument(displayRef.current).getElementById(labelId);
      if (label) {
        var handler = function handler() {
          if (getSelection().isCollapsed) {
            displayRef.current.focus();
          }
        };
        label.addEventListener('click', handler);
        return function () {
          label.removeEventListener('click', handler);
        };
      }
      return undefined;
    }, [labelId]);
    var update = function update(open, event) {
      if (open) {
        if (onOpen) {
          onOpen(event);
        }
      } else if (onClose) {
        onClose(event);
      }
      if (!isOpenControlled) {
        setMenuMinWidthState(autoWidth ? null : anchorElement.clientWidth);
        setOpenState(open);
      }
    };
    var handleMouseDown = function handleMouseDown(event) {
      // Ignore everything but left-click
      if (event.button !== 0) {
        return;
      }
      // Hijack the default focus behavior.
      event.preventDefault();
      displayRef.current.focus();
      update(true, event);
    };
    var handleClose = function handleClose(event) {
      update(false, event);
    };
    var childrenArray = React__namespace.Children.toArray(children);

    // Support autofill.
    var handleChange = function handleChange(event) {
      var child = childrenArray.find(function (childItem) {
        return childItem.props.value === event.target.value;
      });
      if (child === undefined) {
        return;
      }
      setValueState(child.props.value);
      if (onChange) {
        onChange(event, child);
      }
    };
    var handleItemClick = function handleItemClick(child) {
      return function (event) {
        var newValue;

        // We use the tabindex attribute to signal the available options.
        if (!event.currentTarget.hasAttribute('tabindex')) {
          return;
        }
        if (multiple) {
          newValue = Array.isArray(value) ? value.slice() : [];
          var itemIndex = value.indexOf(child.props.value);
          if (itemIndex === -1) {
            newValue.push(child.props.value);
          } else {
            newValue.splice(itemIndex, 1);
          }
        } else {
          newValue = child.props.value;
        }
        if (child.props.onClick) {
          child.props.onClick(event);
        }
        if (value !== newValue) {
          setValueState(newValue);
          if (onChange) {
            // Redefine target to allow name and value to be read.
            // This allows seamless integration with the most popular form libraries.
            // https://github.com/mui/material-ui/issues/13485#issuecomment-676048492
            // Clone the event to not override `target` of the original event.
            var nativeEvent = event.nativeEvent || event;
            var clonedEvent = new nativeEvent.constructor(nativeEvent.type, nativeEvent);
            Object.defineProperty(clonedEvent, 'target', {
              writable: true,
              value: {
                value: newValue,
                name: name
              }
            });
            onChange(clonedEvent, child);
          }
        }
        if (!multiple) {
          update(false, event);
        }
      };
    };
    var handleKeyDown = function handleKeyDown(event) {
      if (!readOnly) {
        var validKeys = [' ', 'ArrowUp', 'ArrowDown',
        // The native select doesn't respond to enter on macOS, but it's recommended by
        // https://www.w3.org/WAI/ARIA/apg/patterns/combobox/examples/combobox-select-only/
        'Enter'];
        if (validKeys.indexOf(event.key) !== -1) {
          event.preventDefault();
          update(true, event);
        }
      }
    };
    var open = displayNode !== null && openState;
    var handleBlur = function handleBlur(event) {
      // if open event.stopImmediatePropagation
      if (!open && onBlur) {
        // Preact support, target is read only property on a native event.
        Object.defineProperty(event, 'target', {
          writable: true,
          value: {
            value: value,
            name: name
          }
        });
        onBlur(event);
      }
    };
    delete other['aria-invalid'];
    var display;
    var displaySingle;
    var displayMultiple = [];
    var computeDisplay = false;
    var foundMatch = false;

    // No need to display any value if the field is empty.
    if (isFilled({
      value: value
    }) || displayEmpty) {
      if (renderValue) {
        display = renderValue(value);
      } else {
        computeDisplay = true;
      }
    }
    var items = childrenArray.map(function (child) {
      if (! /*#__PURE__*/React__namespace.isValidElement(child)) {
        return null;
      }
      {
        if (reactIsExports.isFragment(child)) {
          console.error(["MUI: The Select component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n'));
        }
      }
      var selected;
      if (multiple) {
        if (!Array.isArray(value)) {
          throw new Error("MUI: The `value` prop must be an array when using the `Select` component with `multiple`." );
        }
        selected = value.some(function (v) {
          return areEqualValues(v, child.props.value);
        });
        if (selected && computeDisplay) {
          displayMultiple.push(child.props.children);
        }
      } else {
        selected = areEqualValues(value, child.props.value);
        if (selected && computeDisplay) {
          displaySingle = child.props.children;
        }
      }
      if (selected) {
        foundMatch = true;
      }
      return /*#__PURE__*/React__namespace.cloneElement(child, {
        'aria-selected': selected ? 'true' : 'false',
        onClick: handleItemClick(child),
        onKeyUp: function onKeyUp(event) {
          if (event.key === ' ') {
            // otherwise our MenuItems dispatches a click event
            // it's not behavior of the native <option> and causes
            // the select to close immediately since we open on space keydown
            event.preventDefault();
          }
          if (child.props.onKeyUp) {
            child.props.onKeyUp(event);
          }
        },
        role: 'option',
        selected: selected,
        value: undefined,
        // The value is most likely not a valid HTML attribute.
        'data-value': child.props.value // Instead, we provide it as a data attribute.
      });
    });
    {
      // eslint-disable-next-line react-hooks/rules-of-hooks
      React__namespace.useEffect(function () {
        if (!foundMatch && !multiple && value !== '') {
          var values = childrenArray.map(function (child) {
            return child.props.value;
          });
          console.warn(["MUI: You have provided an out-of-range value `".concat(value, "` for the select ").concat(name ? "(name=\"".concat(name, "\") ") : '', "component."), "Consider providing a value that matches one of the available options or ''.", "The available values are ".concat(values.filter(function (x) {
            return x != null;
          }).map(function (x) {
            return "`".concat(x, "`");
          }).join(', ') || '""', ".")].join('\n'));
        }
      }, [foundMatch, childrenArray, multiple, name, value]);
    }
    if (computeDisplay) {
      if (multiple) {
        if (displayMultiple.length === 0) {
          display = null;
        } else {
          display = displayMultiple.reduce(function (output, child, index) {
            output.push(child);
            if (index < displayMultiple.length - 1) {
              output.push(', ');
            }
            return output;
          }, []);
        }
      } else {
        display = displaySingle;
      }
    }

    // Avoid performing a layout computation in the render method.
    var menuMinWidth = menuMinWidthState;
    if (!autoWidth && isOpenControlled && displayNode) {
      menuMinWidth = anchorElement.clientWidth;
    }
    var tabIndex;
    if (typeof tabIndexProp !== 'undefined') {
      tabIndex = tabIndexProp;
    } else {
      tabIndex = disabled ? null : 0;
    }
    var buttonId = SelectDisplayProps.id || (name ? "mui-component-select-".concat(name) : undefined);
    var ownerState = _extends({}, props, {
      variant: variant,
      value: value,
      open: open,
      error: error
    });
    var classes = useUtilityClasses$x(ownerState);
    var paperProps = _extends({}, MenuProps.PaperProps, (_MenuProps$slotProps = MenuProps.slotProps) == null ? void 0 : _MenuProps$slotProps.paper);
    var listboxId = useId();
    return /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsx(SelectSelect, _extends({
        ref: handleDisplayRef,
        tabIndex: tabIndex,
        role: "combobox",
        "aria-controls": listboxId,
        "aria-disabled": disabled ? 'true' : undefined,
        "aria-expanded": open ? 'true' : 'false',
        "aria-haspopup": "listbox",
        "aria-label": ariaLabel,
        "aria-labelledby": [labelId, buttonId].filter(Boolean).join(' ') || undefined,
        "aria-describedby": ariaDescribedby,
        onKeyDown: handleKeyDown,
        onMouseDown: disabled || readOnly ? null : handleMouseDown,
        onBlur: handleBlur,
        onFocus: onFocus
      }, SelectDisplayProps, {
        ownerState: ownerState,
        className: clsx(SelectDisplayProps.className, classes.select, className)
        // The id is required for proper a11y
        ,
        id: buttonId,
        children: isEmpty(display) ? // notranslate needed while Google Translate will not fix zero-width space issue
        _span || (_span = /*#__PURE__*/jsxRuntimeExports.jsx("span", {
          className: "notranslate",
          children: "\u200B"
        })) : display
      })), /*#__PURE__*/jsxRuntimeExports.jsx(SelectNativeInput, _extends({
        "aria-invalid": error,
        value: Array.isArray(value) ? value.join(',') : value,
        name: name,
        ref: inputRef,
        "aria-hidden": true,
        onChange: handleChange,
        tabIndex: -1,
        disabled: disabled,
        className: classes.nativeInput,
        autoFocus: autoFocus,
        ownerState: ownerState
      }, other)), /*#__PURE__*/jsxRuntimeExports.jsx(SelectIcon, {
        as: IconComponent,
        className: classes.icon,
        ownerState: ownerState
      }), /*#__PURE__*/jsxRuntimeExports.jsx(Menu$1, _extends({
        id: "menu-".concat(name || ''),
        anchorEl: anchorElement,
        open: open,
        onClose: handleClose,
        anchorOrigin: {
          vertical: 'bottom',
          horizontal: 'center'
        },
        transformOrigin: {
          vertical: 'top',
          horizontal: 'center'
        }
      }, MenuProps, {
        MenuListProps: _extends({
          'aria-labelledby': labelId,
          role: 'listbox',
          'aria-multiselectable': multiple ? 'true' : undefined,
          disableListWrap: true,
          id: listboxId
        }, MenuProps.MenuListProps),
        slotProps: _extends({}, MenuProps.slotProps, {
          paper: _extends({}, paperProps, {
            style: _extends({
              minWidth: menuMinWidth
            }, paperProps != null ? paperProps.style : null)
          })
        }),
        children: items
      }))]
    });
  });
  SelectInput.propTypes = {
    /**
     * @ignore
     */
    'aria-describedby': PropTypes.string,
    /**
     * @ignore
     */
    'aria-label': PropTypes.string,
    /**
     * @ignore
     */
    autoFocus: PropTypes.bool,
    /**
     * If `true`, the width of the popover will automatically be set according to the items inside the
     * menu, otherwise it will be at least the width of the select input.
     */
    autoWidth: PropTypes.bool,
    /**
     * The option elements to populate the select with.
     * Can be some `<MenuItem>` elements.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * The CSS class name of the select element.
     */
    className: PropTypes.string,
    /**
     * If `true`, the component is toggled on mount. Use when the component open state is not controlled.
     * You can only use it when the `native` prop is `false` (default).
     */
    defaultOpen: PropTypes.bool,
    /**
     * The default value. Use when the component is not controlled.
     */
    defaultValue: PropTypes.any,
    /**
     * If `true`, the select is disabled.
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the selected item is displayed even if its value is empty.
     */
    displayEmpty: PropTypes.bool,
    /**
     * If `true`, the `select input` will indicate an error.
     */
    error: PropTypes.bool,
    /**
     * The icon that displays the arrow.
     */
    IconComponent: PropTypes.elementType.isRequired,
    /**
     * Imperative handle implementing `{ value: T, node: HTMLElement, focus(): void }`
     * Equivalent to `ref`
     */
    inputRef: refType$1,
    /**
     * The ID of an element that acts as an additional label. The Select will
     * be labelled by the additional label and the selected value.
     */
    labelId: PropTypes.string,
    /**
     * Props applied to the [`Menu`](/material-ui/api/menu/) element.
     */
    MenuProps: PropTypes.object,
    /**
     * If `true`, `value` must be an array and the menu will support multiple selections.
     */
    multiple: PropTypes.bool,
    /**
     * Name attribute of the `select` or hidden `input` element.
     */
    name: PropTypes.string,
    /**
     * @ignore
     */
    onBlur: PropTypes.func,
    /**
     * Callback fired when a menu item is selected.
     *
     * @param {object} event The event source of the callback.
     * You can pull out the new value by accessing `event.target.value` (any).
     * @param {object} [child] The react element that was selected.
     */
    onChange: PropTypes.func,
    /**
     * Callback fired when the component requests to be closed.
     * Use in controlled mode (see open).
     *
     * @param {object} event The event source of the callback.
     */
    onClose: PropTypes.func,
    /**
     * @ignore
     */
    onFocus: PropTypes.func,
    /**
     * Callback fired when the component requests to be opened.
     * Use in controlled mode (see open).
     *
     * @param {object} event The event source of the callback.
     */
    onOpen: PropTypes.func,
    /**
     * If `true`, the component is shown.
     */
    open: PropTypes.bool,
    /**
     * @ignore
     */
    readOnly: PropTypes.bool,
    /**
     * Render the selected value.
     *
     * @param {any} value The `value` provided to the component.
     * @returns {ReactNode}
     */
    renderValue: PropTypes.func,
    /**
     * Props applied to the clickable div element.
     */
    SelectDisplayProps: PropTypes.object,
    /**
     * @ignore
     */
    tabIndex: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * @ignore
     */
    type: PropTypes.any,
    /**
     * The input value.
     */
    value: PropTypes.any,
    /**
     * The variant to use.
     */
    variant: PropTypes.oneOf(['standard', 'outlined', 'filled'])
  } ;
  var SelectInput$1 = SelectInput;

  var useUtilityClasses$w = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    return classes;
  };
  var styledRootConfig = {
    name: 'MuiSelect',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    },
    shouldForwardProp: function shouldForwardProp(prop) {
      return rootShouldForwardProp$1(prop) && prop !== 'variant';
    },
    slot: 'Root'
  };
  var StyledInput = styled$1(Input$1, styledRootConfig)('');
  var StyledOutlinedInput = styled$1(OutlinedInput$1, styledRootConfig)('');
  var StyledFilledInput = styled$1(FilledInput$1, styledRootConfig)('');
  var Select = /*#__PURE__*/React__namespace.forwardRef(function Select(inProps, ref) {
    var props = useDefaultProps({
      name: 'MuiSelect',
      props: inProps
    });
    var _props$autoWidth = props.autoWidth,
      autoWidth = _props$autoWidth === void 0 ? false : _props$autoWidth,
      children = props.children,
      _props$classes = props.classes,
      classesProp = _props$classes === void 0 ? {} : _props$classes,
      className = props.className,
      _props$defaultOpen = props.defaultOpen,
      defaultOpen = _props$defaultOpen === void 0 ? false : _props$defaultOpen,
      _props$displayEmpty = props.displayEmpty,
      displayEmpty = _props$displayEmpty === void 0 ? false : _props$displayEmpty,
      _props$IconComponent = props.IconComponent,
      IconComponent = _props$IconComponent === void 0 ? ArrowDropDownIcon : _props$IconComponent,
      id = props.id,
      input = props.input,
      inputProps = props.inputProps,
      label = props.label,
      labelId = props.labelId,
      MenuProps = props.MenuProps,
      _props$multiple = props.multiple,
      multiple = _props$multiple === void 0 ? false : _props$multiple,
      _props$native = props["native"],
      _native = _props$native === void 0 ? false : _props$native,
      onClose = props.onClose,
      onOpen = props.onOpen,
      open = props.open,
      renderValue = props.renderValue,
      SelectDisplayProps = props.SelectDisplayProps,
      _props$variant = props.variant,
      variantProp = _props$variant === void 0 ? 'outlined' : _props$variant,
      other = _objectWithoutProperties(props, ["autoWidth", "children", "classes", "className", "defaultOpen", "displayEmpty", "IconComponent", "id", "input", "inputProps", "label", "labelId", "MenuProps", "multiple", "native", "onClose", "onOpen", "open", "renderValue", "SelectDisplayProps", "variant"]);
    var inputComponent = _native ? NativeSelectInput$1 : SelectInput$1;
    var muiFormControl = useFormControl();
    var fcs = formControlState({
      props: props,
      muiFormControl: muiFormControl,
      states: ['variant', 'error']
    });
    var variant = fcs.variant || variantProp;
    var ownerState = _extends({}, props, {
      variant: variant,
      classes: classesProp
    });
    var classes = useUtilityClasses$w(ownerState);
    classes.root;
      var restOfClasses = _objectWithoutProperties(classes, ["root"]);
    var InputComponent = input || {
      standard: /*#__PURE__*/jsxRuntimeExports.jsx(StyledInput, {
        ownerState: ownerState
      }),
      outlined: /*#__PURE__*/jsxRuntimeExports.jsx(StyledOutlinedInput, {
        label: label,
        ownerState: ownerState
      }),
      filled: /*#__PURE__*/jsxRuntimeExports.jsx(StyledFilledInput, {
        ownerState: ownerState
      })
    }[variant];
    var inputComponentRef = useForkRef(ref, getReactElementRef(InputComponent));
    return /*#__PURE__*/jsxRuntimeExports.jsx(React__namespace.Fragment, {
      children: /*#__PURE__*/React__namespace.cloneElement(InputComponent, _extends({
        // Most of the logic is implemented in `SelectInput`.
        // The `Select` component is a simple API wrapper to expose something better to play with.
        inputComponent: inputComponent,
        inputProps: _extends({
          children: children,
          error: fcs.error,
          IconComponent: IconComponent,
          variant: variant,
          type: undefined,
          // We render a select. We can ignore the type provided by the `Input`.
          multiple: multiple
        }, _native ? {
          id: id
        } : {
          autoWidth: autoWidth,
          defaultOpen: defaultOpen,
          displayEmpty: displayEmpty,
          labelId: labelId,
          MenuProps: MenuProps,
          onClose: onClose,
          onOpen: onOpen,
          open: open,
          renderValue: renderValue,
          SelectDisplayProps: _extends({
            id: id
          }, SelectDisplayProps)
        }, inputProps, {
          classes: inputProps ? deepmerge(restOfClasses, inputProps.classes) : restOfClasses
        }, input ? input.props.inputProps : {})
      }, (multiple && _native || displayEmpty) && variant === 'outlined' ? {
        notched: true
      } : {}, {
        ref: inputComponentRef,
        className: clsx(InputComponent.props.className, className, classes.root)
      }, !input && {
        variant: variant
      }, other))
    });
  });
  Select.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * If `true`, the width of the popover will automatically be set according to the items inside the
     * menu, otherwise it will be at least the width of the select input.
     * @default false
     */
    autoWidth: PropTypes.bool,
    /**
     * The option elements to populate the select with.
     * Can be some `MenuItem` when `native` is false and `option` when `native` is true.
     *
     * ⚠️The `MenuItem` elements **must** be direct descendants when `native` is false.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     * @default {}
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * If `true`, the component is initially open. Use when the component open state is not controlled (i.e. the `open` prop is not defined).
     * You can only use it when the `native` prop is `false` (default).
     * @default false
     */
    defaultOpen: PropTypes.bool,
    /**
     * The default value. Use when the component is not controlled.
     */
    defaultValue: PropTypes.any,
    /**
     * If `true`, a value is displayed even if no items are selected.
     *
     * In order to display a meaningful value, a function can be passed to the `renderValue` prop which
     * returns the value to be displayed when no items are selected.
     *
     * ⚠️ When using this prop, make sure the label doesn't overlap with the empty displayed value.
     * The label should either be hidden or forced to a shrunk state.
     * @default false
     */
    displayEmpty: PropTypes.bool,
    /**
     * The icon that displays the arrow.
     * @default ArrowDropDownIcon
     */
    IconComponent: PropTypes.elementType,
    /**
     * The `id` of the wrapper element or the `select` element when `native`.
     */
    id: PropTypes.string,
    /**
     * An `Input` element; does not have to be a material-ui specific `Input`.
     */
    input: PropTypes.element,
    /**
     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
     * When `native` is `true`, the attributes are applied on the `select` element.
     */
    inputProps: PropTypes.object,
    /**
     * See [OutlinedInput#label](/material-ui/api/outlined-input/#props)
     */
    label: PropTypes.node,
    /**
     * The ID of an element that acts as an additional label. The Select will
     * be labelled by the additional label and the selected value.
     */
    labelId: PropTypes.string,
    /**
     * Props applied to the [`Menu`](/material-ui/api/menu/) element.
     */
    MenuProps: PropTypes.object,
    /**
     * If `true`, `value` must be an array and the menu will support multiple selections.
     * @default false
     */
    multiple: PropTypes.bool,
    /**
     * If `true`, the component uses a native `select` element.
     * @default false
     */
    "native": PropTypes.bool,
    /**
     * Callback fired when a menu item is selected.
     *
     * @param {SelectChangeEvent<Value>} event The event source of the callback.
     * You can pull out the new value by accessing `event.target.value` (any).
     * **Warning**: This is a generic event, not a change event, unless the change event is caused by browser autofill.
     * @param {object} [child] The react element that was selected when `native` is `false` (default).
     */
    onChange: PropTypes.func,
    /**
     * Callback fired when the component requests to be closed.
     * Use it in either controlled (see the `open` prop), or uncontrolled mode (to detect when the Select collapses).
     *
     * @param {object} event The event source of the callback.
     */
    onClose: PropTypes.func,
    /**
     * Callback fired when the component requests to be opened.
     * Use it in either controlled (see the `open` prop), or uncontrolled mode (to detect when the Select expands).
     *
     * @param {object} event The event source of the callback.
     */
    onOpen: PropTypes.func,
    /**
     * If `true`, the component is shown.
     * You can only use it when the `native` prop is `false` (default).
     */
    open: PropTypes.bool,
    /**
     * Render the selected value.
     * You can only use it when the `native` prop is `false` (default).
     *
     * @param {any} value The `value` provided to the component.
     * @returns {ReactNode}
     */
    renderValue: PropTypes.func,
    /**
     * Props applied to the clickable div element.
     */
    SelectDisplayProps: PropTypes.object,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The `input` value. Providing an empty string will select no options.
     * Set to an empty string `''` if you don't want any of the available options to be selected.
     *
     * If the value is an object it must have reference equality with the option in order to be selected.
     * If the value is not an object, the string representation must match with the string representation of the option in order to be selected.
     */
    value: PropTypes.oneOfType([PropTypes.oneOf(['']), PropTypes.any]),
    /**
     * The variant to use.
     * @default 'outlined'
     */
    variant: PropTypes.oneOf(['filled', 'outlined', 'standard'])
  } ;
  Select.muiName = 'Select';
  var Select$1 = Select;

  function getSkeletonUtilityClass(slot) {
    return generateUtilityClass('MuiSkeleton', slot);
  }
  var skeletonClasses = generateUtilityClasses('MuiSkeleton', ['root', 'text', 'rectangular', 'rounded', 'circular', 'pulse', 'wave', 'withChildren', 'fitContent', 'heightAuto']);
  var skeletonClasses$1 = skeletonClasses;

  var _templateObject, _templateObject2, _templateObject3, _templateObject4;
  var useUtilityClasses$v = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      variant = ownerState.variant,
      animation = ownerState.animation,
      hasChildren = ownerState.hasChildren,
      width = ownerState.width,
      height = ownerState.height;
    var slots = {
      root: ['root', variant, animation, hasChildren && 'withChildren', hasChildren && !width && 'fitContent', hasChildren && !height && 'heightAuto']
    };
    return composeClasses(slots, getSkeletonUtilityClass, classes);
  };
  var pulseKeyframe = keyframes(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  0% {\n    opacity: 1;\n  }\n\n  50% {\n    opacity: 0.4;\n  }\n\n  100% {\n    opacity: 1;\n  }\n"])));
  var waveKeyframe = keyframes(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  0% {\n    transform: translateX(-100%);\n  }\n\n  50% {\n    /* +0.5s of delay between each loop */\n    transform: translateX(100%);\n  }\n\n  100% {\n    transform: translateX(100%);\n  }\n"])));
  var SkeletonRoot = styled$1('span', {
    name: 'MuiSkeleton',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.variant], ownerState.animation !== false && styles[ownerState.animation], ownerState.hasChildren && styles.withChildren, ownerState.hasChildren && !ownerState.width && styles.fitContent, ownerState.hasChildren && !ownerState.height && styles.heightAuto];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    var radiusUnit = getUnit(theme.shape.borderRadius) || 'px';
    var radiusValue = toUnitless(theme.shape.borderRadius);
    return _extends({
      display: 'block',
      // Create a "on paper" color with sufficient contrast retaining the color
      backgroundColor: theme.vars ? theme.vars.palette.Skeleton.bg : alpha(theme.palette.text.primary, theme.palette.mode === 'light' ? 0.11 : 0.13),
      height: '1.2em'
    }, ownerState.variant === 'text' && {
      marginTop: 0,
      marginBottom: 0,
      height: 'auto',
      transformOrigin: '0 55%',
      transform: 'scale(1, 0.60)',
      borderRadius: "".concat(radiusValue).concat(radiusUnit, "/").concat(Math.round(radiusValue / 0.6 * 10) / 10).concat(radiusUnit),
      '&:empty:before': {
        content: '"\\00a0"'
      }
    }, ownerState.variant === 'circular' && {
      borderRadius: '50%'
    }, ownerState.variant === 'rounded' && {
      borderRadius: (theme.vars || theme).shape.borderRadius
    }, ownerState.hasChildren && {
      '& > *': {
        visibility: 'hidden'
      }
    }, ownerState.hasChildren && !ownerState.width && {
      maxWidth: 'fit-content'
    }, ownerState.hasChildren && !ownerState.height && {
      height: 'auto'
    });
  }, function (_ref2) {
    var ownerState = _ref2.ownerState;
    return ownerState.animation === 'pulse' && css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n      animation: ", " 2s ease-in-out 0.5s infinite;\n    "])), pulseKeyframe);
  }, function (_ref3) {
    var ownerState = _ref3.ownerState,
      theme = _ref3.theme;
    return ownerState.animation === 'wave' && css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n      position: relative;\n      overflow: hidden;\n\n      /* Fix bug in Safari https://bugs.webkit.org/show_bug.cgi?id=68196 */\n      -webkit-mask-image: -webkit-radial-gradient(white, black);\n\n      &::after {\n        animation: ", " 2s linear 0.5s infinite;\n        background: linear-gradient(\n          90deg,\n          transparent,\n          ", ",\n          transparent\n        );\n        content: '';\n        position: absolute;\n        transform: translateX(-100%); /* Avoid flash during server-side hydration */\n        bottom: 0;\n        left: 0;\n        right: 0;\n        top: 0;\n      }\n    "])), waveKeyframe, (theme.vars || theme).palette.action.hover);
  });
  var Skeleton = /*#__PURE__*/React__namespace.forwardRef(function Skeleton(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiSkeleton'
    });
    var _props$animation = props.animation,
      animation = _props$animation === void 0 ? 'pulse' : _props$animation,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'span' : _props$component,
      height = props.height,
      style = props.style,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'text' : _props$variant,
      width = props.width,
      other = _objectWithoutProperties(props, ["animation", "className", "component", "height", "style", "variant", "width"]);
    var ownerState = _extends({}, props, {
      animation: animation,
      component: component,
      variant: variant,
      hasChildren: Boolean(other.children)
    });
    var classes = useUtilityClasses$v(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(SkeletonRoot, _extends({
      as: component,
      ref: ref,
      className: clsx(classes.root, className),
      ownerState: ownerState
    }, other, {
      style: _extends({
        width: width,
        height: height
      }, style)
    }));
  });
  Skeleton.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The animation.
     * If `false` the animation effect is disabled.
     * @default 'pulse'
     */
    animation: PropTypes.oneOf(['pulse', 'wave', false]),
    /**
     * Optional children to infer width and height from.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * Height of the skeleton.
     * Useful when you don't want to adapt the skeleton to a text element but for instance a card.
     */
    height: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * @ignore
     */
    style: PropTypes.object,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The type of content that will be rendered.
     * @default 'text'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['circular', 'rectangular', 'rounded', 'text']), PropTypes.string]),
    /**
     * Width of the skeleton.
     * Useful when the skeleton is inside an inline element with no width of its own.
     */
    width: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
  } ;
  var Skeleton$1 = Skeleton;

  function areArraysEqual(array1, array2) {
    var itemComparer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (a, b) {
      return a === b;
    };
    return array1.length === array2.length && array1.every(function (value, index) {
      return itemComparer(value, array2[index]);
    });
  }

  var INTENTIONAL_DRAG_COUNT_THRESHOLD = 2;
  function asc(a, b) {
    return a - b;
  }
  function findClosest(values, currentValue) {
    var _values$reduce;
    var _ref = (_values$reduce = values.reduce(function (acc, value, index) {
        var distance = Math.abs(currentValue - value);
        if (acc === null || distance < acc.distance || distance === acc.distance) {
          return {
            distance: distance,
            index: index
          };
        }
        return acc;
      }, null)) != null ? _values$reduce : {},
      closestIndex = _ref.index;
    return closestIndex;
  }
  function trackFinger(event, touchId) {
    // The event is TouchEvent
    if (touchId.current !== undefined && event.changedTouches) {
      var touchEvent = event;
      for (var i = 0; i < touchEvent.changedTouches.length; i += 1) {
        var touch = touchEvent.changedTouches[i];
        if (touch.identifier === touchId.current) {
          return {
            x: touch.clientX,
            y: touch.clientY
          };
        }
      }
      return false;
    }

    // The event is MouseEvent
    return {
      x: event.clientX,
      y: event.clientY
    };
  }
  function valueToPercent(value, min, max) {
    return (value - min) * 100 / (max - min);
  }
  function percentToValue(percent, min, max) {
    return (max - min) * percent + min;
  }
  function getDecimalPrecision(num) {
    // This handles the case when num is very small (0.00000001), js will turn this into 1e-8.
    // When num is bigger than 1 or less than -1 it won't get converted to this notation so it's fine.
    if (Math.abs(num) < 1) {
      var parts = num.toExponential().split('e-');
      var matissaDecimalPart = parts[0].split('.')[1];
      return (matissaDecimalPart ? matissaDecimalPart.length : 0) + parseInt(parts[1], 10);
    }
    var decimalPart = num.toString().split('.')[1];
    return decimalPart ? decimalPart.length : 0;
  }
  function roundValueToStep(value, step, min) {
    var nearest = Math.round((value - min) / step) * step + min;
    return Number(nearest.toFixed(getDecimalPrecision(step)));
  }
  function setValueIndex(_ref2) {
    var values = _ref2.values,
      newValue = _ref2.newValue,
      index = _ref2.index;
    var output = values.slice();
    output[index] = newValue;
    return output.sort(asc);
  }
  function focusThumb(_ref3) {
    var _sliderRef$current, _doc$activeElement;
    var sliderRef = _ref3.sliderRef,
      activeIndex = _ref3.activeIndex,
      setActive = _ref3.setActive;
    var doc = ownerDocument(sliderRef.current);
    if (!((_sliderRef$current = sliderRef.current) != null && _sliderRef$current.contains(doc.activeElement)) || Number(doc == null || (_doc$activeElement = doc.activeElement) == null ? void 0 : _doc$activeElement.getAttribute('data-index')) !== activeIndex) {
      var _sliderRef$current2;
      (_sliderRef$current2 = sliderRef.current) == null || _sliderRef$current2.querySelector("[type=\"range\"][data-index=\"".concat(activeIndex, "\"]")).focus();
    }
    if (setActive) {
      setActive(activeIndex);
    }
  }
  function areValuesEqual(newValue, oldValue) {
    if (typeof newValue === 'number' && typeof oldValue === 'number') {
      return newValue === oldValue;
    }
    if (_typeof(newValue) === 'object' && _typeof(oldValue) === 'object') {
      return areArraysEqual(newValue, oldValue);
    }
    return false;
  }
  var axisProps = {
    horizontal: {
      offset: function offset(percent) {
        return {
          left: "".concat(percent, "%")
        };
      },
      leap: function leap(percent) {
        return {
          width: "".concat(percent, "%")
        };
      }
    },
    'horizontal-reverse': {
      offset: function offset(percent) {
        return {
          right: "".concat(percent, "%")
        };
      },
      leap: function leap(percent) {
        return {
          width: "".concat(percent, "%")
        };
      }
    },
    vertical: {
      offset: function offset(percent) {
        return {
          bottom: "".concat(percent, "%")
        };
      },
      leap: function leap(percent) {
        return {
          height: "".concat(percent, "%")
        };
      }
    }
  };
  var Identity$1 = function Identity(x) {
    return x;
  };

  // TODO: remove support for Safari < 13.
  // https://caniuse.com/#search=touch-action
  //
  // Safari, on iOS, supports touch action since v13.
  // Over 80% of the iOS phones are compatible
  // in August 2020.
  // Utilizing the CSS.supports method to check if touch-action is supported.
  // Since CSS.supports is supported on all but Edge@12 and IE and touch-action
  // is supported on both Edge@12 and IE if CSS.supports is not available that means that
  // touch-action will be supported
  var cachedSupportsTouchActionNone;
  function doesSupportTouchActionNone() {
    if (cachedSupportsTouchActionNone === undefined) {
      if (typeof CSS !== 'undefined' && typeof CSS.supports === 'function') {
        cachedSupportsTouchActionNone = CSS.supports('touch-action', 'none');
      } else {
        cachedSupportsTouchActionNone = true;
      }
    }
    return cachedSupportsTouchActionNone;
  }
  /**
   *
   * Demos:
   *
   * - [Slider](https://mui.com/base-ui/react-slider/#hook)
   *
   * API:
   *
   * - [useSlider API](https://mui.com/base-ui/react-slider/hooks-api/#use-slider)
   */
  function useSlider(parameters) {
    var ariaLabelledby = parameters['aria-labelledby'],
      defaultValue = parameters.defaultValue,
      _parameters$disabled = parameters.disabled,
      disabled = _parameters$disabled === void 0 ? false : _parameters$disabled,
      _parameters$disableSw = parameters.disableSwap,
      disableSwap = _parameters$disableSw === void 0 ? false : _parameters$disableSw,
      _parameters$isRtl = parameters.isRtl,
      isRtl = _parameters$isRtl === void 0 ? false : _parameters$isRtl,
      _parameters$marks = parameters.marks,
      marksProp = _parameters$marks === void 0 ? false : _parameters$marks,
      _parameters$max = parameters.max,
      max = _parameters$max === void 0 ? 100 : _parameters$max,
      _parameters$min = parameters.min,
      min = _parameters$min === void 0 ? 0 : _parameters$min,
      name = parameters.name,
      onChange = parameters.onChange,
      onChangeCommitted = parameters.onChangeCommitted,
      _parameters$orientati = parameters.orientation,
      orientation = _parameters$orientati === void 0 ? 'horizontal' : _parameters$orientati,
      ref = parameters.rootRef,
      _parameters$scale = parameters.scale,
      scale = _parameters$scale === void 0 ? Identity$1 : _parameters$scale,
      _parameters$step = parameters.step,
      step = _parameters$step === void 0 ? 1 : _parameters$step,
      _parameters$shiftStep = parameters.shiftStep,
      shiftStep = _parameters$shiftStep === void 0 ? 10 : _parameters$shiftStep,
      tabIndex = parameters.tabIndex,
      valueProp = parameters.value;
    var touchId = React__namespace.useRef(undefined);
    // We can't use the :active browser pseudo-classes.
    // - The active state isn't triggered when clicking on the rail.
    // - The active state isn't transferred when inversing a range slider.
    var _React$useState = React__namespace.useState(-1),
      active = _React$useState[0],
      setActive = _React$useState[1];
    var _React$useState2 = React__namespace.useState(-1),
      open = _React$useState2[0],
      setOpen = _React$useState2[1];
    var _React$useState3 = React__namespace.useState(false),
      dragging = _React$useState3[0],
      setDragging = _React$useState3[1];
    var moveCount = React__namespace.useRef(0);
    var _useControlled = useControlled({
        controlled: valueProp,
        "default": defaultValue != null ? defaultValue : min,
        name: 'Slider'
      }),
      _useControlled2 = _slicedToArray(_useControlled, 2),
      valueDerived = _useControlled2[0],
      setValueState = _useControlled2[1];
    var handleChange = onChange && function (event, value, thumbIndex) {
      // Redefine target to allow name and value to be read.
      // This allows seamless integration with the most popular form libraries.
      // https://github.com/mui/material-ui/issues/13485#issuecomment-676048492
      // Clone the event to not override `target` of the original event.
      var nativeEvent = event.nativeEvent || event;
      // @ts-ignore The nativeEvent is function, not object
      var clonedEvent = new nativeEvent.constructor(nativeEvent.type, nativeEvent);
      Object.defineProperty(clonedEvent, 'target', {
        writable: true,
        value: {
          value: value,
          name: name
        }
      });
      onChange(clonedEvent, value, thumbIndex);
    };
    var range = Array.isArray(valueDerived);
    var values = range ? valueDerived.slice().sort(asc) : [valueDerived];
    values = values.map(function (value) {
      return value == null ? min : clamp(value, min, max);
    });
    var marks = marksProp === true && step !== null ? _toConsumableArray(Array(Math.floor((max - min) / step) + 1)).map(function (_, index) {
      return {
        value: min + step * index
      };
    }) : marksProp || [];
    var marksValues = marks.map(function (mark) {
      return mark.value;
    });
    var _useIsFocusVisible = useIsFocusVisible(),
      isFocusVisibleRef = _useIsFocusVisible.isFocusVisibleRef,
      handleBlurVisible = _useIsFocusVisible.onBlur,
      handleFocusVisible = _useIsFocusVisible.onFocus,
      focusVisibleRef = _useIsFocusVisible.ref;
    var _React$useState4 = React__namespace.useState(-1),
      focusedThumbIndex = _React$useState4[0],
      setFocusedThumbIndex = _React$useState4[1];
    var sliderRef = React__namespace.useRef(null);
    var handleFocusRef = useForkRef(focusVisibleRef, sliderRef);
    var handleRef = useForkRef(ref, handleFocusRef);
    var createHandleHiddenInputFocus = function createHandleHiddenInputFocus(otherHandlers) {
      return function (event) {
        var _otherHandlers$onFocu;
        var index = Number(event.currentTarget.getAttribute('data-index'));
        handleFocusVisible(event);
        if (isFocusVisibleRef.current === true) {
          setFocusedThumbIndex(index);
        }
        setOpen(index);
        otherHandlers == null || (_otherHandlers$onFocu = otherHandlers.onFocus) == null || _otherHandlers$onFocu.call(otherHandlers, event);
      };
    };
    var createHandleHiddenInputBlur = function createHandleHiddenInputBlur(otherHandlers) {
      return function (event) {
        var _otherHandlers$onBlur;
        handleBlurVisible(event);
        if (isFocusVisibleRef.current === false) {
          setFocusedThumbIndex(-1);
        }
        setOpen(-1);
        otherHandlers == null || (_otherHandlers$onBlur = otherHandlers.onBlur) == null || _otherHandlers$onBlur.call(otherHandlers, event);
      };
    };
    var changeValue = function changeValue(event, valueInput) {
      var index = Number(event.currentTarget.getAttribute('data-index'));
      var value = values[index];
      var marksIndex = marksValues.indexOf(value);
      var newValue = valueInput;
      if (marks && step == null) {
        var maxMarksValue = marksValues[marksValues.length - 1];
        if (newValue > maxMarksValue) {
          newValue = maxMarksValue;
        } else if (newValue < marksValues[0]) {
          newValue = marksValues[0];
        } else {
          newValue = newValue < value ? marksValues[marksIndex - 1] : marksValues[marksIndex + 1];
        }
      }
      newValue = clamp(newValue, min, max);
      if (range) {
        // Bound the new value to the thumb's neighbours.
        if (disableSwap) {
          newValue = clamp(newValue, values[index - 1] || -Infinity, values[index + 1] || Infinity);
        }
        var previousValue = newValue;
        newValue = setValueIndex({
          values: values,
          newValue: newValue,
          index: index
        });
        var activeIndex = index;

        // Potentially swap the index if needed.
        if (!disableSwap) {
          activeIndex = newValue.indexOf(previousValue);
        }
        focusThumb({
          sliderRef: sliderRef,
          activeIndex: activeIndex
        });
      }
      setValueState(newValue);
      setFocusedThumbIndex(index);
      if (handleChange && !areValuesEqual(newValue, valueDerived)) {
        handleChange(event, newValue, index);
      }
      if (onChangeCommitted) {
        onChangeCommitted(event, newValue);
      }
    };
    var createHandleHiddenInputKeyDown = function createHandleHiddenInputKeyDown(otherHandlers) {
      return function (event) {
        var _otherHandlers$onKeyD;
        // The Shift + Up/Down keyboard shortcuts for moving the slider makes sense to be supported
        // only if the step is defined. If the step is null, this means tha the marks are used for specifying the valid values.
        if (step !== null) {
          var index = Number(event.currentTarget.getAttribute('data-index'));
          var value = values[index];
          var newValue = null;
          if ((event.key === 'ArrowLeft' || event.key === 'ArrowDown') && event.shiftKey || event.key === 'PageDown') {
            newValue = Math.max(value - shiftStep, min);
          } else if ((event.key === 'ArrowRight' || event.key === 'ArrowUp') && event.shiftKey || event.key === 'PageUp') {
            newValue = Math.min(value + shiftStep, max);
          }
          if (newValue !== null) {
            changeValue(event, newValue);
            event.preventDefault();
          }
        }
        otherHandlers == null || (_otherHandlers$onKeyD = otherHandlers.onKeyDown) == null || _otherHandlers$onKeyD.call(otherHandlers, event);
      };
    };
    useEnhancedEffect$1(function () {
      if (disabled && sliderRef.current.contains(document.activeElement)) {
        var _document$activeEleme;
        // This is necessary because Firefox and Safari will keep focus
        // on a disabled element:
        // https://codesandbox.io/p/sandbox/mui-pr-22247-forked-h151h?file=/src/App.js
        // @ts-ignore
        (_document$activeEleme = document.activeElement) == null || _document$activeEleme.blur();
      }
    }, [disabled]);
    if (disabled && active !== -1) {
      setActive(-1);
    }
    if (disabled && focusedThumbIndex !== -1) {
      setFocusedThumbIndex(-1);
    }
    var createHandleHiddenInputChange = function createHandleHiddenInputChange(otherHandlers) {
      return function (event) {
        var _otherHandlers$onChan;
        (_otherHandlers$onChan = otherHandlers.onChange) == null || _otherHandlers$onChan.call(otherHandlers, event);
        // @ts-ignore
        changeValue(event, event.target.valueAsNumber);
      };
    };
    var previousIndex = React__namespace.useRef(undefined);
    var axis = orientation;
    if (isRtl && orientation === 'horizontal') {
      axis += '-reverse';
    }
    var getFingerNewValue = function getFingerNewValue(_ref4) {
      var finger = _ref4.finger,
        _ref4$move = _ref4.move,
        move = _ref4$move === void 0 ? false : _ref4$move;
      var slider = sliderRef.current;
      var _getBoundingClientRec = slider.getBoundingClientRect(),
        width = _getBoundingClientRec.width,
        height = _getBoundingClientRec.height,
        bottom = _getBoundingClientRec.bottom,
        left = _getBoundingClientRec.left;
      var percent;
      if (axis.indexOf('vertical') === 0) {
        percent = (bottom - finger.y) / height;
      } else {
        percent = (finger.x - left) / width;
      }
      if (axis.indexOf('-reverse') !== -1) {
        percent = 1 - percent;
      }
      var newValue;
      newValue = percentToValue(percent, min, max);
      if (step) {
        newValue = roundValueToStep(newValue, step, min);
      } else {
        var closestIndex = findClosest(marksValues, newValue);
        newValue = marksValues[closestIndex];
      }
      newValue = clamp(newValue, min, max);
      var activeIndex = 0;
      if (range) {
        if (!move) {
          activeIndex = findClosest(values, newValue);
        } else {
          activeIndex = previousIndex.current;
        }

        // Bound the new value to the thumb's neighbours.
        if (disableSwap) {
          newValue = clamp(newValue, values[activeIndex - 1] || -Infinity, values[activeIndex + 1] || Infinity);
        }
        var previousValue = newValue;
        newValue = setValueIndex({
          values: values,
          newValue: newValue,
          index: activeIndex
        });

        // Potentially swap the index if needed.
        if (!(disableSwap && move)) {
          activeIndex = newValue.indexOf(previousValue);
          previousIndex.current = activeIndex;
        }
      }
      return {
        newValue: newValue,
        activeIndex: activeIndex
      };
    };
    var handleTouchMove = useEventCallback(function (nativeEvent) {
      var finger = trackFinger(nativeEvent, touchId);
      if (!finger) {
        return;
      }
      moveCount.current += 1;

      // Cancel move in case some other element consumed a mouseup event and it was not fired.
      // @ts-ignore buttons doesn't not exists on touch event
      if (nativeEvent.type === 'mousemove' && nativeEvent.buttons === 0) {
        // eslint-disable-next-line @typescript-eslint/no-use-before-define
        handleTouchEnd(nativeEvent);
        return;
      }
      var _getFingerNewValue = getFingerNewValue({
          finger: finger,
          move: true
        }),
        newValue = _getFingerNewValue.newValue,
        activeIndex = _getFingerNewValue.activeIndex;
      focusThumb({
        sliderRef: sliderRef,
        activeIndex: activeIndex,
        setActive: setActive
      });
      setValueState(newValue);
      if (!dragging && moveCount.current > INTENTIONAL_DRAG_COUNT_THRESHOLD) {
        setDragging(true);
      }
      if (handleChange && !areValuesEqual(newValue, valueDerived)) {
        handleChange(nativeEvent, newValue, activeIndex);
      }
    });
    var handleTouchEnd = useEventCallback(function (nativeEvent) {
      var finger = trackFinger(nativeEvent, touchId);
      setDragging(false);
      if (!finger) {
        return;
      }
      var _getFingerNewValue2 = getFingerNewValue({
          finger: finger,
          move: true
        }),
        newValue = _getFingerNewValue2.newValue;
      setActive(-1);
      if (nativeEvent.type === 'touchend') {
        setOpen(-1);
      }
      if (onChangeCommitted) {
        onChangeCommitted(nativeEvent, newValue);
      }
      touchId.current = undefined;

      // eslint-disable-next-line @typescript-eslint/no-use-before-define
      stopListening();
    });
    var handleTouchStart = useEventCallback(function (nativeEvent) {
      if (disabled) {
        return;
      }
      // If touch-action: none; is not supported we need to prevent the scroll manually.
      if (!doesSupportTouchActionNone()) {
        nativeEvent.preventDefault();
      }
      var touch = nativeEvent.changedTouches[0];
      if (touch != null) {
        // A number that uniquely identifies the current finger in the touch session.
        touchId.current = touch.identifier;
      }
      var finger = trackFinger(nativeEvent, touchId);
      if (finger !== false) {
        var _getFingerNewValue3 = getFingerNewValue({
            finger: finger
          }),
          newValue = _getFingerNewValue3.newValue,
          activeIndex = _getFingerNewValue3.activeIndex;
        focusThumb({
          sliderRef: sliderRef,
          activeIndex: activeIndex,
          setActive: setActive
        });
        setValueState(newValue);
        if (handleChange && !areValuesEqual(newValue, valueDerived)) {
          handleChange(nativeEvent, newValue, activeIndex);
        }
      }
      moveCount.current = 0;
      var doc = ownerDocument(sliderRef.current);
      doc.addEventListener('touchmove', handleTouchMove, {
        passive: true
      });
      doc.addEventListener('touchend', handleTouchEnd, {
        passive: true
      });
    });
    var stopListening = React__namespace.useCallback(function () {
      var doc = ownerDocument(sliderRef.current);
      doc.removeEventListener('mousemove', handleTouchMove);
      doc.removeEventListener('mouseup', handleTouchEnd);
      doc.removeEventListener('touchmove', handleTouchMove);
      doc.removeEventListener('touchend', handleTouchEnd);
    }, [handleTouchEnd, handleTouchMove]);
    React__namespace.useEffect(function () {
      var slider = sliderRef.current;
      slider.addEventListener('touchstart', handleTouchStart, {
        passive: doesSupportTouchActionNone()
      });
      return function () {
        slider.removeEventListener('touchstart', handleTouchStart);
        stopListening();
      };
    }, [stopListening, handleTouchStart]);
    React__namespace.useEffect(function () {
      if (disabled) {
        stopListening();
      }
    }, [disabled, stopListening]);
    var createHandleMouseDown = function createHandleMouseDown(otherHandlers) {
      return function (event) {
        var _otherHandlers$onMous;
        (_otherHandlers$onMous = otherHandlers.onMouseDown) == null || _otherHandlers$onMous.call(otherHandlers, event);
        if (disabled) {
          return;
        }
        if (event.defaultPrevented) {
          return;
        }

        // Only handle left clicks
        if (event.button !== 0) {
          return;
        }

        // Avoid text selection
        event.preventDefault();
        var finger = trackFinger(event, touchId);
        if (finger !== false) {
          var _getFingerNewValue4 = getFingerNewValue({
              finger: finger
            }),
            newValue = _getFingerNewValue4.newValue,
            activeIndex = _getFingerNewValue4.activeIndex;
          focusThumb({
            sliderRef: sliderRef,
            activeIndex: activeIndex,
            setActive: setActive
          });
          setValueState(newValue);
          if (handleChange && !areValuesEqual(newValue, valueDerived)) {
            handleChange(event, newValue, activeIndex);
          }
        }
        moveCount.current = 0;
        var doc = ownerDocument(sliderRef.current);
        doc.addEventListener('mousemove', handleTouchMove, {
          passive: true
        });
        doc.addEventListener('mouseup', handleTouchEnd);
      };
    };
    var trackOffset = valueToPercent(range ? values[0] : min, min, max);
    var trackLeap = valueToPercent(values[values.length - 1], min, max) - trackOffset;
    var getRootProps = function getRootProps() {
      var externalProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var externalHandlers = extractEventHandlers(externalProps);
      var ownEventHandlers = {
        onMouseDown: createHandleMouseDown(externalHandlers || {})
      };
      var mergedEventHandlers = _extends({}, externalHandlers, ownEventHandlers);
      return _extends({}, externalProps, {
        ref: handleRef
      }, mergedEventHandlers);
    };
    var createHandleMouseOver = function createHandleMouseOver(otherHandlers) {
      return function (event) {
        var _otherHandlers$onMous2;
        (_otherHandlers$onMous2 = otherHandlers.onMouseOver) == null || _otherHandlers$onMous2.call(otherHandlers, event);
        var index = Number(event.currentTarget.getAttribute('data-index'));
        setOpen(index);
      };
    };
    var createHandleMouseLeave = function createHandleMouseLeave(otherHandlers) {
      return function (event) {
        var _otherHandlers$onMous3;
        (_otherHandlers$onMous3 = otherHandlers.onMouseLeave) == null || _otherHandlers$onMous3.call(otherHandlers, event);
        setOpen(-1);
      };
    };
    var getThumbProps = function getThumbProps() {
      var externalProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var externalHandlers = extractEventHandlers(externalProps);
      var ownEventHandlers = {
        onMouseOver: createHandleMouseOver(externalHandlers || {}),
        onMouseLeave: createHandleMouseLeave(externalHandlers || {})
      };
      return _extends({}, externalProps, externalHandlers, ownEventHandlers);
    };
    var getThumbStyle = function getThumbStyle(index) {
      return {
        // So the non active thumb doesn't show its label on hover.
        pointerEvents: active !== -1 && active !== index ? 'none' : undefined
      };
    };
    var getHiddenInputProps = function getHiddenInputProps() {
      var _parameters$step2;
      var externalProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var externalHandlers = extractEventHandlers(externalProps);
      var ownEventHandlers = {
        onChange: createHandleHiddenInputChange(externalHandlers || {}),
        onFocus: createHandleHiddenInputFocus(externalHandlers || {}),
        onBlur: createHandleHiddenInputBlur(externalHandlers || {}),
        onKeyDown: createHandleHiddenInputKeyDown(externalHandlers || {})
      };
      var mergedEventHandlers = _extends({}, externalHandlers, ownEventHandlers);
      return _extends({
        tabIndex: tabIndex,
        'aria-labelledby': ariaLabelledby,
        'aria-orientation': orientation,
        'aria-valuemax': scale(max),
        'aria-valuemin': scale(min),
        name: name,
        type: 'range',
        min: parameters.min,
        max: parameters.max,
        step: parameters.step === null && parameters.marks ? 'any' : (_parameters$step2 = parameters.step) != null ? _parameters$step2 : undefined,
        disabled: disabled
      }, externalProps, mergedEventHandlers, {
        style: _extends({}, visuallyHidden$1, {
          direction: isRtl ? 'rtl' : 'ltr',
          // So that VoiceOver's focus indicator matches the thumb's dimensions
          width: '100%',
          height: '100%'
        })
      });
    };
    return {
      active: active,
      axis: axis,
      axisProps: axisProps,
      dragging: dragging,
      focusedThumbIndex: focusedThumbIndex,
      getHiddenInputProps: getHiddenInputProps,
      getRootProps: getRootProps,
      getThumbProps: getThumbProps,
      marks: marks,
      open: open,
      range: range,
      rootRef: handleRef,
      trackLeap: trackLeap,
      trackOffset: trackOffset,
      values: values,
      getThumbStyle: getThumbStyle
    };
  }

  var shouldSpreadAdditionalProps = function shouldSpreadAdditionalProps(Slot) {
    return !Slot || !isHostComponent(Slot);
  };
  var shouldSpreadAdditionalProps$1 = shouldSpreadAdditionalProps;

  function getSliderUtilityClass(slot) {
    return generateUtilityClass('MuiSlider', slot);
  }
  var sliderClasses = generateUtilityClasses('MuiSlider', ['root', 'active', 'colorPrimary', 'colorSecondary', 'colorError', 'colorInfo', 'colorSuccess', 'colorWarning', 'disabled', 'dragging', 'focusVisible', 'mark', 'markActive', 'marked', 'markLabel', 'markLabelActive', 'rail', 'sizeSmall', 'thumb', 'thumbColorPrimary', 'thumbColorSecondary', 'thumbColorError', 'thumbColorSuccess', 'thumbColorInfo', 'thumbColorWarning', 'track', 'trackInverted', 'trackFalse', 'thumbSizeSmall', 'valueLabel', 'valueLabelOpen', 'valueLabelCircle', 'valueLabelLabel', 'vertical']);
  var sliderClasses$1 = sliderClasses;

  var useValueLabelClasses = function useValueLabelClasses(props) {
    var open = props.open;
    var utilityClasses = {
      offset: clsx(open && sliderClasses$1.valueLabelOpen),
      circle: sliderClasses$1.valueLabelCircle,
      label: sliderClasses$1.valueLabelLabel
    };
    return utilityClasses;
  };

  /**
   * @ignore - internal component.
   */
  function SliderValueLabel$1(props) {
    var children = props.children,
      className = props.className,
      value = props.value;
    var classes = useValueLabelClasses(props);
    if (!children) {
      return null;
    }
    return /*#__PURE__*/React__namespace.cloneElement(children, {
      className: clsx(children.props.className)
    }, /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
      children: [children.props.children, /*#__PURE__*/jsxRuntimeExports.jsx("span", {
        className: clsx(classes.offset, className),
        "aria-hidden": true,
        children: /*#__PURE__*/jsxRuntimeExports.jsx("span", {
          className: classes.circle,
          children: /*#__PURE__*/jsxRuntimeExports.jsx("span", {
            className: classes.label,
            children: value
          })
        })
      })]
    }));
  }
  SliderValueLabel$1.propTypes = {
    children: PropTypes.element.isRequired,
    className: PropTypes.string,
    value: PropTypes.node
  } ;

  function Identity(x) {
    return x;
  }
  var SliderRoot = styled$1('span', {
    name: 'MuiSlider',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles["color".concat(capitalize(ownerState.color))], ownerState.size !== 'medium' && styles["size".concat(capitalize(ownerState.size))], ownerState.marked && styles.marked, ownerState.orientation === 'vertical' && styles.vertical, ownerState.track === 'inverted' && styles.trackInverted, ownerState.track === false && styles.trackFalse];
    }
  })(function (_ref) {
    var _theme$vars;
    var theme = _ref.theme;
    return _defineProperty(_defineProperty(_defineProperty({
      borderRadius: 12,
      boxSizing: 'content-box',
      display: 'inline-block',
      position: 'relative',
      cursor: 'pointer',
      touchAction: 'none',
      WebkitTapHighlightColor: 'transparent',
      '@media print': {
        colorAdjust: 'exact'
      }
    }, "&.".concat(sliderClasses$1.disabled), {
      pointerEvents: 'none',
      cursor: 'default',
      color: (theme.vars || theme).palette.grey[400]
    }), "&.".concat(sliderClasses$1.dragging), _defineProperty({}, "& .".concat(sliderClasses$1.thumb, ", & .").concat(sliderClasses$1.track), {
      transition: 'none'
    })), "variants", [].concat(_toConsumableArray(Object.keys(((_theme$vars = theme.vars) != null ? _theme$vars : theme).palette).filter(function (key) {
      var _theme$vars2;
      return ((_theme$vars2 = theme.vars) != null ? _theme$vars2 : theme).palette[key].main;
    }).map(function (color) {
      return {
        props: {
          color: color
        },
        style: {
          color: (theme.vars || theme).palette[color].main
        }
      };
    })), [{
      props: {
        orientation: 'horizontal'
      },
      style: {
        height: 4,
        width: '100%',
        padding: '13px 0',
        // The primary input mechanism of the device includes a pointing device of limited accuracy.
        '@media (pointer: coarse)': {
          // Reach 42px touch target, about ~8mm on screen.
          padding: '20px 0'
        }
      }
    }, {
      props: {
        orientation: 'horizontal',
        size: 'small'
      },
      style: {
        height: 2
      }
    }, {
      props: {
        orientation: 'horizontal',
        marked: true
      },
      style: {
        marginBottom: 20
      }
    }, {
      props: {
        orientation: 'vertical'
      },
      style: {
        height: '100%',
        width: 4,
        padding: '0 13px',
        // The primary input mechanism of the device includes a pointing device of limited accuracy.
        '@media (pointer: coarse)': {
          // Reach 42px touch target, about ~8mm on screen.
          padding: '0 20px'
        }
      }
    }, {
      props: {
        orientation: 'vertical',
        size: 'small'
      },
      style: {
        width: 2
      }
    }, {
      props: {
        orientation: 'vertical',
        marked: true
      },
      style: {
        marginRight: 44
      }
    }]));
  });
  var SliderRail = styled$1('span', {
    name: 'MuiSlider',
    slot: 'Rail',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.rail;
    }
  })({
    display: 'block',
    position: 'absolute',
    borderRadius: 'inherit',
    backgroundColor: 'currentColor',
    opacity: 0.38,
    variants: [{
      props: {
        orientation: 'horizontal'
      },
      style: {
        width: '100%',
        height: 'inherit',
        top: '50%',
        transform: 'translateY(-50%)'
      }
    }, {
      props: {
        orientation: 'vertical'
      },
      style: {
        height: '100%',
        width: 'inherit',
        left: '50%',
        transform: 'translateX(-50%)'
      }
    }, {
      props: {
        track: 'inverted'
      },
      style: {
        opacity: 1
      }
    }]
  });
  var SliderTrack = styled$1('span', {
    name: 'MuiSlider',
    slot: 'Track',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.track;
    }
  })(function (_ref3) {
    var _theme$vars3;
    var theme = _ref3.theme;
    return {
      display: 'block',
      position: 'absolute',
      borderRadius: 'inherit',
      border: '1px solid currentColor',
      backgroundColor: 'currentColor',
      transition: theme.transitions.create(['left', 'width', 'bottom', 'height'], {
        duration: theme.transitions.duration.shortest
      }),
      variants: [{
        props: {
          size: 'small'
        },
        style: {
          border: 'none'
        }
      }, {
        props: {
          orientation: 'horizontal'
        },
        style: {
          height: 'inherit',
          top: '50%',
          transform: 'translateY(-50%)'
        }
      }, {
        props: {
          orientation: 'vertical'
        },
        style: {
          width: 'inherit',
          left: '50%',
          transform: 'translateX(-50%)'
        }
      }, {
        props: {
          track: false
        },
        style: {
          display: 'none'
        }
      }].concat(_toConsumableArray(Object.keys(((_theme$vars3 = theme.vars) != null ? _theme$vars3 : theme).palette).filter(function (key) {
        var _theme$vars4;
        return ((_theme$vars4 = theme.vars) != null ? _theme$vars4 : theme).palette[key].main;
      }).map(function (color) {
        return {
          props: {
            color: color,
            track: 'inverted'
          },
          style: _extends({}, theme.vars ? {
            backgroundColor: theme.vars.palette.Slider["".concat(color, "Track")],
            borderColor: theme.vars.palette.Slider["".concat(color, "Track")]
          } : _extends({
            backgroundColor: lighten(theme.palette[color].main, 0.62),
            borderColor: lighten(theme.palette[color].main, 0.62)
          }, theme.applyStyles('dark', {
            backgroundColor: darken(theme.palette[color].main, 0.5)
          }), theme.applyStyles('dark', {
            borderColor: darken(theme.palette[color].main, 0.5)
          })))
        };
      })))
    };
  });
  var SliderThumb = styled$1('span', {
    name: 'MuiSlider',
    slot: 'Thumb',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.thumb, styles["thumbColor".concat(capitalize(ownerState.color))], ownerState.size !== 'medium' && styles["thumbSize".concat(capitalize(ownerState.size))]];
    }
  })(function (_ref4) {
    var _theme$vars5;
    var theme = _ref4.theme;
    return _defineProperty(_defineProperty({
      position: 'absolute',
      width: 20,
      height: 20,
      boxSizing: 'border-box',
      borderRadius: '50%',
      outline: 0,
      backgroundColor: 'currentColor',
      display: 'flex',
      alignItems: 'center',
      justifyContent: 'center',
      transition: theme.transitions.create(['box-shadow', 'left', 'bottom'], {
        duration: theme.transitions.duration.shortest
      }),
      '&::before': {
        position: 'absolute',
        content: '""',
        borderRadius: 'inherit',
        width: '100%',
        height: '100%',
        boxShadow: (theme.vars || theme).shadows[2]
      },
      '&::after': {
        position: 'absolute',
        content: '""',
        borderRadius: '50%',
        // 42px is the hit target
        width: 42,
        height: 42,
        top: '50%',
        left: '50%',
        transform: 'translate(-50%, -50%)'
      }
    }, "&.".concat(sliderClasses$1.disabled), {
      '&:hover': {
        boxShadow: 'none'
      }
    }), "variants", [{
      props: {
        size: 'small'
      },
      style: {
        width: 12,
        height: 12,
        '&::before': {
          boxShadow: 'none'
        }
      }
    }, {
      props: {
        orientation: 'horizontal'
      },
      style: {
        top: '50%',
        transform: 'translate(-50%, -50%)'
      }
    }, {
      props: {
        orientation: 'vertical'
      },
      style: {
        left: '50%',
        transform: 'translate(-50%, 50%)'
      }
    }].concat(_toConsumableArray(Object.keys(((_theme$vars5 = theme.vars) != null ? _theme$vars5 : theme).palette).filter(function (key) {
      var _theme$vars6;
      return ((_theme$vars6 = theme.vars) != null ? _theme$vars6 : theme).palette[key].main;
    }).map(function (color) {
      return {
        props: {
          color: color
        },
        style: _defineProperty(_defineProperty({}, "&:hover, &.".concat(sliderClasses$1.focusVisible), _extends({}, theme.vars ? {
          boxShadow: "0px 0px 0px 8px rgba(".concat(theme.vars.palette[color].mainChannel, " / 0.16)")
        } : {
          boxShadow: "0px 0px 0px 8px ".concat(alpha(theme.palette[color].main, 0.16))
        }, {
          '@media (hover: none)': {
            boxShadow: 'none'
          }
        })), "&.".concat(sliderClasses$1.active), _extends({}, theme.vars ? {
          boxShadow: "0px 0px 0px 14px rgba(".concat(theme.vars.palette[color].mainChannel, " / 0.16)")
        } : {
          boxShadow: "0px 0px 0px 14px ".concat(alpha(theme.palette[color].main, 0.16))
        }))
      };
    }))));
  });
  var SliderValueLabel = styled$1(SliderValueLabel$1, {
    name: 'MuiSlider',
    slot: 'ValueLabel',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.valueLabel;
    }
  })(function (_ref6) {
    var theme = _ref6.theme;
    return _extends({
      zIndex: 1,
      whiteSpace: 'nowrap'
    }, theme.typography.body2, {
      fontWeight: 500,
      transition: theme.transitions.create(['transform'], {
        duration: theme.transitions.duration.shortest
      }),
      position: 'absolute',
      backgroundColor: (theme.vars || theme).palette.grey[600],
      borderRadius: 2,
      color: (theme.vars || theme).palette.common.white,
      display: 'flex',
      alignItems: 'center',
      justifyContent: 'center',
      padding: '0.25rem 0.75rem',
      variants: [{
        props: {
          orientation: 'horizontal'
        },
        style: _defineProperty({
          transform: 'translateY(-100%) scale(0)',
          top: '-10px',
          transformOrigin: 'bottom center',
          '&::before': {
            position: 'absolute',
            content: '""',
            width: 8,
            height: 8,
            transform: 'translate(-50%, 50%) rotate(45deg)',
            backgroundColor: 'inherit',
            bottom: 0,
            left: '50%'
          }
        }, "&.".concat(sliderClasses$1.valueLabelOpen), {
          transform: 'translateY(-100%) scale(1)'
        })
      }, {
        props: {
          orientation: 'vertical'
        },
        style: _defineProperty({
          transform: 'translateY(-50%) scale(0)',
          right: '30px',
          top: '50%',
          transformOrigin: 'right center',
          '&::before': {
            position: 'absolute',
            content: '""',
            width: 8,
            height: 8,
            transform: 'translate(-50%, -50%) rotate(45deg)',
            backgroundColor: 'inherit',
            right: -8,
            top: '50%'
          }
        }, "&.".concat(sliderClasses$1.valueLabelOpen), {
          transform: 'translateY(-50%) scale(1)'
        })
      }, {
        props: {
          size: 'small'
        },
        style: {
          fontSize: theme.typography.pxToRem(12),
          padding: '0.25rem 0.5rem'
        }
      }, {
        props: {
          orientation: 'vertical',
          size: 'small'
        },
        style: {
          right: '20px'
        }
      }]
    });
  });
  var SliderMark = styled$1('span', {
    name: 'MuiSlider',
    slot: 'Mark',
    shouldForwardProp: function shouldForwardProp(prop) {
      return slotShouldForwardProp(prop) && prop !== 'markActive';
    },
    overridesResolver: function overridesResolver(props, styles) {
      var markActive = props.markActive;
      return [styles.mark, markActive && styles.markActive];
    }
  })(function (_ref7) {
    var theme = _ref7.theme;
    return {
      position: 'absolute',
      width: 2,
      height: 2,
      borderRadius: 1,
      backgroundColor: 'currentColor',
      variants: [{
        props: {
          orientation: 'horizontal'
        },
        style: {
          top: '50%',
          transform: 'translate(-1px, -50%)'
        }
      }, {
        props: {
          orientation: 'vertical'
        },
        style: {
          left: '50%',
          transform: 'translate(-50%, 1px)'
        }
      }, {
        props: {
          markActive: true
        },
        style: {
          backgroundColor: (theme.vars || theme).palette.background.paper,
          opacity: 0.8
        }
      }]
    };
  });
  var SliderMarkLabel = styled$1('span', {
    name: 'MuiSlider',
    slot: 'MarkLabel',
    shouldForwardProp: function shouldForwardProp(prop) {
      return slotShouldForwardProp(prop) && prop !== 'markLabelActive';
    },
    overridesResolver: function overridesResolver(props, styles) {
      return styles.markLabel;
    }
  })(function (_ref8) {
    var theme = _ref8.theme;
    return _extends({}, theme.typography.body2, {
      color: (theme.vars || theme).palette.text.secondary,
      position: 'absolute',
      whiteSpace: 'nowrap',
      variants: [{
        props: {
          orientation: 'horizontal'
        },
        style: {
          top: 30,
          transform: 'translateX(-50%)',
          '@media (pointer: coarse)': {
            top: 40
          }
        }
      }, {
        props: {
          orientation: 'vertical'
        },
        style: {
          left: 36,
          transform: 'translateY(50%)',
          '@media (pointer: coarse)': {
            left: 44
          }
        }
      }, {
        props: {
          markLabelActive: true
        },
        style: {
          color: (theme.vars || theme).palette.text.primary
        }
      }]
    });
  });
  var useUtilityClasses$u = function useUtilityClasses(ownerState) {
    var disabled = ownerState.disabled,
      dragging = ownerState.dragging,
      marked = ownerState.marked,
      orientation = ownerState.orientation,
      track = ownerState.track,
      classes = ownerState.classes,
      color = ownerState.color,
      size = ownerState.size;
    var slots = {
      root: ['root', disabled && 'disabled', dragging && 'dragging', marked && 'marked', orientation === 'vertical' && 'vertical', track === 'inverted' && 'trackInverted', track === false && 'trackFalse', color && "color".concat(capitalize(color)), size && "size".concat(capitalize(size))],
      rail: ['rail'],
      track: ['track'],
      mark: ['mark'],
      markActive: ['markActive'],
      markLabel: ['markLabel'],
      markLabelActive: ['markLabelActive'],
      valueLabel: ['valueLabel'],
      thumb: ['thumb', disabled && 'disabled', size && "thumbSize".concat(capitalize(size)), color && "thumbColor".concat(capitalize(color))],
      active: ['active'],
      disabled: ['disabled'],
      focusVisible: ['focusVisible']
    };
    return composeClasses(slots, getSliderUtilityClass, classes);
  };
  var Forward = function Forward(_ref9) {
    var children = _ref9.children;
    return children;
  };
  var Slider = /*#__PURE__*/React__namespace.forwardRef(function Slider(inputProps, ref) {
    var _ref10, _slots$root, _ref11, _slots$rail, _ref12, _slots$track, _ref13, _slots$thumb, _ref14, _slots$valueLabel, _ref15, _slots$mark, _ref16, _slots$markLabel, _ref17, _slots$input, _slotProps$root, _slotProps$rail, _slotProps$track, _slotProps$thumb, _slotProps$valueLabel, _slotProps$mark, _slotProps$markLabel, _slotProps$input;
    var props = useDefaultProps({
      props: inputProps,
      name: 'MuiSlider'
    });
    var isRtl = useRtl();
    var ariaLabel = props['aria-label'],
      ariaValuetext = props['aria-valuetext'],
      ariaLabelledby = props['aria-labelledby'],
      _props$component = props.component,
      component = _props$component === void 0 ? 'span' : _props$component,
      _props$components = props.components,
      components = _props$components === void 0 ? {} : _props$components,
      _props$componentsProp = props.componentsProps,
      componentsProps = _props$componentsProp === void 0 ? {} : _props$componentsProp,
      _props$color = props.color,
      color = _props$color === void 0 ? 'primary' : _props$color,
      classesProp = props.classes,
      className = props.className,
      _props$disableSwap = props.disableSwap,
      disableSwap = _props$disableSwap === void 0 ? false : _props$disableSwap,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      getAriaLabel = props.getAriaLabel,
      getAriaValueText = props.getAriaValueText,
      _props$marks = props.marks,
      marksProp = _props$marks === void 0 ? false : _props$marks,
      _props$max = props.max,
      max = _props$max === void 0 ? 100 : _props$max,
      _props$min = props.min,
      min = _props$min === void 0 ? 0 : _props$min;
      props.name;
      props.onChange;
      props.onChangeCommitted;
      var _props$orientation = props.orientation,
      orientation = _props$orientation === void 0 ? 'horizontal' : _props$orientation,
      _props$shiftStep = props.shiftStep,
      shiftStep = _props$shiftStep === void 0 ? 10 : _props$shiftStep,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      _props$step = props.step,
      step = _props$step === void 0 ? 1 : _props$step,
      _props$scale = props.scale,
      scale = _props$scale === void 0 ? Identity : _props$scale,
      slotProps = props.slotProps,
      slots = props.slots;
      props.tabIndex;
      var _props$track = props.track,
      track = _props$track === void 0 ? 'normal' : _props$track;
      props.value;
      var _props$valueLabelDisp = props.valueLabelDisplay,
      valueLabelDisplay = _props$valueLabelDisp === void 0 ? 'off' : _props$valueLabelDisp,
      _props$valueLabelForm = props.valueLabelFormat,
      valueLabelFormat = _props$valueLabelForm === void 0 ? Identity : _props$valueLabelForm,
      other = _objectWithoutProperties(props, ["aria-label", "aria-valuetext", "aria-labelledby", "component", "components", "componentsProps", "color", "classes", "className", "disableSwap", "disabled", "getAriaLabel", "getAriaValueText", "marks", "max", "min", "name", "onChange", "onChangeCommitted", "orientation", "shiftStep", "size", "step", "scale", "slotProps", "slots", "tabIndex", "track", "value", "valueLabelDisplay", "valueLabelFormat"]);
    var ownerState = _extends({}, props, {
      isRtl: isRtl,
      max: max,
      min: min,
      classes: classesProp,
      disabled: disabled,
      disableSwap: disableSwap,
      orientation: orientation,
      marks: marksProp,
      color: color,
      size: size,
      step: step,
      shiftStep: shiftStep,
      scale: scale,
      track: track,
      valueLabelDisplay: valueLabelDisplay,
      valueLabelFormat: valueLabelFormat
    });
    var _useSlider = useSlider(_extends({}, ownerState, {
        rootRef: ref
      })),
      axisProps = _useSlider.axisProps,
      getRootProps = _useSlider.getRootProps,
      getHiddenInputProps = _useSlider.getHiddenInputProps,
      getThumbProps = _useSlider.getThumbProps,
      open = _useSlider.open,
      active = _useSlider.active,
      axis = _useSlider.axis,
      focusedThumbIndex = _useSlider.focusedThumbIndex,
      range = _useSlider.range,
      dragging = _useSlider.dragging,
      marks = _useSlider.marks,
      values = _useSlider.values,
      trackOffset = _useSlider.trackOffset,
      trackLeap = _useSlider.trackLeap,
      getThumbStyle = _useSlider.getThumbStyle;
    ownerState.marked = marks.length > 0 && marks.some(function (mark) {
      return mark.label;
    });
    ownerState.dragging = dragging;
    ownerState.focusedThumbIndex = focusedThumbIndex;
    var classes = useUtilityClasses$u(ownerState);

    // support both `slots` and `components` for backward compatibility
    var RootSlot = (_ref10 = (_slots$root = slots == null ? void 0 : slots.root) != null ? _slots$root : components.Root) != null ? _ref10 : SliderRoot;
    var RailSlot = (_ref11 = (_slots$rail = slots == null ? void 0 : slots.rail) != null ? _slots$rail : components.Rail) != null ? _ref11 : SliderRail;
    var TrackSlot = (_ref12 = (_slots$track = slots == null ? void 0 : slots.track) != null ? _slots$track : components.Track) != null ? _ref12 : SliderTrack;
    var ThumbSlot = (_ref13 = (_slots$thumb = slots == null ? void 0 : slots.thumb) != null ? _slots$thumb : components.Thumb) != null ? _ref13 : SliderThumb;
    var ValueLabelSlot = (_ref14 = (_slots$valueLabel = slots == null ? void 0 : slots.valueLabel) != null ? _slots$valueLabel : components.ValueLabel) != null ? _ref14 : SliderValueLabel;
    var MarkSlot = (_ref15 = (_slots$mark = slots == null ? void 0 : slots.mark) != null ? _slots$mark : components.Mark) != null ? _ref15 : SliderMark;
    var MarkLabelSlot = (_ref16 = (_slots$markLabel = slots == null ? void 0 : slots.markLabel) != null ? _slots$markLabel : components.MarkLabel) != null ? _ref16 : SliderMarkLabel;
    var InputSlot = (_ref17 = (_slots$input = slots == null ? void 0 : slots.input) != null ? _slots$input : components.Input) != null ? _ref17 : 'input';
    var rootSlotProps = (_slotProps$root = slotProps == null ? void 0 : slotProps.root) != null ? _slotProps$root : componentsProps.root;
    var railSlotProps = (_slotProps$rail = slotProps == null ? void 0 : slotProps.rail) != null ? _slotProps$rail : componentsProps.rail;
    var trackSlotProps = (_slotProps$track = slotProps == null ? void 0 : slotProps.track) != null ? _slotProps$track : componentsProps.track;
    var thumbSlotProps = (_slotProps$thumb = slotProps == null ? void 0 : slotProps.thumb) != null ? _slotProps$thumb : componentsProps.thumb;
    var valueLabelSlotProps = (_slotProps$valueLabel = slotProps == null ? void 0 : slotProps.valueLabel) != null ? _slotProps$valueLabel : componentsProps.valueLabel;
    var markSlotProps = (_slotProps$mark = slotProps == null ? void 0 : slotProps.mark) != null ? _slotProps$mark : componentsProps.mark;
    var markLabelSlotProps = (_slotProps$markLabel = slotProps == null ? void 0 : slotProps.markLabel) != null ? _slotProps$markLabel : componentsProps.markLabel;
    var inputSlotProps = (_slotProps$input = slotProps == null ? void 0 : slotProps.input) != null ? _slotProps$input : componentsProps.input;
    var rootProps = useSlotProps({
      elementType: RootSlot,
      getSlotProps: getRootProps,
      externalSlotProps: rootSlotProps,
      externalForwardedProps: other,
      additionalProps: _extends({}, shouldSpreadAdditionalProps$1(RootSlot) && {
        as: component
      }),
      ownerState: _extends({}, ownerState, rootSlotProps == null ? void 0 : rootSlotProps.ownerState),
      className: [classes.root, className]
    });
    var railProps = useSlotProps({
      elementType: RailSlot,
      externalSlotProps: railSlotProps,
      ownerState: ownerState,
      className: classes.rail
    });
    var trackProps = useSlotProps({
      elementType: TrackSlot,
      externalSlotProps: trackSlotProps,
      additionalProps: {
        style: _extends({}, axisProps[axis].offset(trackOffset), axisProps[axis].leap(trackLeap))
      },
      ownerState: _extends({}, ownerState, trackSlotProps == null ? void 0 : trackSlotProps.ownerState),
      className: classes.track
    });
    var thumbProps = useSlotProps({
      elementType: ThumbSlot,
      getSlotProps: getThumbProps,
      externalSlotProps: thumbSlotProps,
      ownerState: _extends({}, ownerState, thumbSlotProps == null ? void 0 : thumbSlotProps.ownerState),
      className: classes.thumb
    });
    var valueLabelProps = useSlotProps({
      elementType: ValueLabelSlot,
      externalSlotProps: valueLabelSlotProps,
      ownerState: _extends({}, ownerState, valueLabelSlotProps == null ? void 0 : valueLabelSlotProps.ownerState),
      className: classes.valueLabel
    });
    var markProps = useSlotProps({
      elementType: MarkSlot,
      externalSlotProps: markSlotProps,
      ownerState: ownerState,
      className: classes.mark
    });
    var markLabelProps = useSlotProps({
      elementType: MarkLabelSlot,
      externalSlotProps: markLabelSlotProps,
      ownerState: ownerState,
      className: classes.markLabel
    });
    var inputSliderProps = useSlotProps({
      elementType: InputSlot,
      getSlotProps: getHiddenInputProps,
      externalSlotProps: inputSlotProps,
      ownerState: ownerState
    });
    return /*#__PURE__*/jsxRuntimeExports.jsxs(RootSlot, _extends({}, rootProps, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsx(RailSlot, _extends({}, railProps)), /*#__PURE__*/jsxRuntimeExports.jsx(TrackSlot, _extends({}, trackProps)), marks.filter(function (mark) {
        return mark.value >= min && mark.value <= max;
      }).map(function (mark, index) {
        var percent = valueToPercent(mark.value, min, max);
        var style = axisProps[axis].offset(percent);
        var markActive;
        if (track === false) {
          markActive = values.indexOf(mark.value) !== -1;
        } else {
          markActive = track === 'normal' && (range ? mark.value >= values[0] && mark.value <= values[values.length - 1] : mark.value <= values[0]) || track === 'inverted' && (range ? mark.value <= values[0] || mark.value >= values[values.length - 1] : mark.value >= values[0]);
        }
        return /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
          children: [/*#__PURE__*/jsxRuntimeExports.jsx(MarkSlot, _extends({
            "data-index": index
          }, markProps, !isHostComponent(MarkSlot) && {
            markActive: markActive
          }, {
            style: _extends({}, style, markProps.style),
            className: clsx(markProps.className, markActive && classes.markActive)
          })), mark.label != null ? /*#__PURE__*/jsxRuntimeExports.jsx(MarkLabelSlot, _extends({
            "aria-hidden": true,
            "data-index": index
          }, markLabelProps, !isHostComponent(MarkLabelSlot) && {
            markLabelActive: markActive
          }, {
            style: _extends({}, style, markLabelProps.style),
            className: clsx(classes.markLabel, markLabelProps.className, markActive && classes.markLabelActive),
            children: mark.label
          })) : null]
        }, index);
      }), values.map(function (value, index) {
        var percent = valueToPercent(value, min, max);
        var style = axisProps[axis].offset(percent);
        var ValueLabelComponent = valueLabelDisplay === 'off' ? Forward : ValueLabelSlot;
        return (
          /*#__PURE__*/
          /* TODO v6: Change component structure. It will help in avoiding the complicated React.cloneElement API added in SliderValueLabel component. Should be: Thumb -> Input, ValueLabel. Follow Joy UI's Slider structure. */
          jsxRuntimeExports.jsx(ValueLabelComponent, _extends({}, !isHostComponent(ValueLabelComponent) && {
            valueLabelFormat: valueLabelFormat,
            valueLabelDisplay: valueLabelDisplay,
            value: typeof valueLabelFormat === 'function' ? valueLabelFormat(scale(value), index) : valueLabelFormat,
            index: index,
            open: open === index || active === index || valueLabelDisplay === 'on',
            disabled: disabled
          }, valueLabelProps, {
            children: /*#__PURE__*/jsxRuntimeExports.jsx(ThumbSlot, _extends({
              "data-index": index
            }, thumbProps, {
              className: clsx(classes.thumb, thumbProps.className, active === index && classes.active, focusedThumbIndex === index && classes.focusVisible),
              style: _extends({}, style, getThumbStyle(index), thumbProps.style),
              children: /*#__PURE__*/jsxRuntimeExports.jsx(InputSlot, _extends({
                "data-index": index,
                "aria-label": getAriaLabel ? getAriaLabel(index) : ariaLabel,
                "aria-valuenow": scale(value),
                "aria-labelledby": ariaLabelledby,
                "aria-valuetext": getAriaValueText ? getAriaValueText(scale(value), index) : ariaValuetext,
                value: values[index]
              }, inputSliderProps))
            }))
          }), index)
        );
      })]
    }));
  });
  Slider.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The label of the slider.
     */
    'aria-label': chainPropTypes(PropTypes.string, function (props) {
      var range = Array.isArray(props.value || props.defaultValue);
      if (range && props['aria-label'] != null) {
        return new Error('MUI: You need to use the `getAriaLabel` prop instead of `aria-label` when using a range slider.');
      }
      return null;
    }),
    /**
     * The id of the element containing a label for the slider.
     */
    'aria-labelledby': PropTypes.string,
    /**
     * A string value that provides a user-friendly name for the current value of the slider.
     */
    'aria-valuetext': chainPropTypes(PropTypes.string, function (props) {
      var range = Array.isArray(props.value || props.defaultValue);
      if (range && props['aria-valuetext'] != null) {
        return new Error('MUI: You need to use the `getAriaValueText` prop instead of `aria-valuetext` when using a range slider.');
      }
      return null;
    }),
    /**
     * @ignore
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'primary'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * The components used for each slot inside.
     *
     * @deprecated use the `slots` prop instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
     *
     * @default {}
     */
    components: PropTypes.shape({
      Input: PropTypes.elementType,
      Mark: PropTypes.elementType,
      MarkLabel: PropTypes.elementType,
      Rail: PropTypes.elementType,
      Root: PropTypes.elementType,
      Thumb: PropTypes.elementType,
      Track: PropTypes.elementType,
      ValueLabel: PropTypes.elementType
    }),
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * @deprecated use the `slotProps` prop instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
     *
     * @default {}
     */
    componentsProps: PropTypes.shape({
      input: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      mark: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      markLabel: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      rail: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      root: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      thumb: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      track: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      valueLabel: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
        children: PropTypes.element,
        className: PropTypes.string,
        open: PropTypes.bool,
        style: PropTypes.object,
        value: PropTypes.number,
        valueLabelDisplay: PropTypes.oneOf(['auto', 'off', 'on'])
      })])
    }),
    /**
     * The default value. Use when the component is not controlled.
     */
    defaultValue: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.number), PropTypes.number]),
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the active thumb doesn't swap when moving pointer over a thumb while dragging another thumb.
     * @default false
     */
    disableSwap: PropTypes.bool,
    /**
     * Accepts a function which returns a string value that provides a user-friendly name for the thumb labels of the slider.
     * This is important for screen reader users.
     * @param {number} index The thumb label's index to format.
     * @returns {string}
     */
    getAriaLabel: PropTypes.func,
    /**
     * Accepts a function which returns a string value that provides a user-friendly name for the current value of the slider.
     * This is important for screen reader users.
     * @param {number} value The thumb label's value to format.
     * @param {number} index The thumb label's index to format.
     * @returns {string}
     */
    getAriaValueText: PropTypes.func,
    /**
     * Marks indicate predetermined values to which the user can move the slider.
     * If `true` the marks are spaced according the value of the `step` prop.
     * If an array, it should contain objects with `value` and an optional `label` keys.
     * @default false
     */
    marks: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.shape({
      label: PropTypes.node,
      value: PropTypes.number.isRequired
    })), PropTypes.bool]),
    /**
     * The maximum allowed value of the slider.
     * Should not be equal to min.
     * @default 100
     */
    max: PropTypes.number,
    /**
     * The minimum allowed value of the slider.
     * Should not be equal to max.
     * @default 0
     */
    min: PropTypes.number,
    /**
     * Name attribute of the hidden `input` element.
     */
    name: PropTypes.string,
    /**
     * Callback function that is fired when the slider's value changed.
     *
     * @param {Event} event The event source of the callback.
     * You can pull out the new value by accessing `event.target.value` (any).
     * **Warning**: This is a generic event not a change event.
     * @param {number | number[]} value The new value.
     * @param {number} activeThumb Index of the currently moved thumb.
     */
    onChange: PropTypes.func,
    /**
     * Callback function that is fired when the `mouseup` is triggered.
     *
     * @param {React.SyntheticEvent | Event} event The event source of the callback. **Warning**: This is a generic event not a change event.
     * @param {number | number[]} value The new value.
     */
    onChangeCommitted: PropTypes.func,
    /**
     * The component orientation.
     * @default 'horizontal'
     */
    orientation: PropTypes.oneOf(['horizontal', 'vertical']),
    /**
     * A transformation function, to change the scale of the slider.
     * @param {any} x
     * @returns {any}
     * @default function Identity(x) {
     *   return x;
     * }
     */
    scale: PropTypes.func,
    /**
     * The granularity with which the slider can step through values when using Page Up/Page Down or Shift + Arrow Up/Arrow Down.
     * @default 10
     */
    shiftStep: PropTypes.number,
    /**
     * The size of the slider.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['small', 'medium']), PropTypes.string]),
    /**
     * The props used for each slot inside the Slider.
     * @default {}
     */
    slotProps: PropTypes.shape({
      input: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      mark: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      markLabel: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      rail: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      root: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      thumb: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      track: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      valueLabel: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
        children: PropTypes.element,
        className: PropTypes.string,
        open: PropTypes.bool,
        style: PropTypes.object,
        value: PropTypes.number,
        valueLabelDisplay: PropTypes.oneOf(['auto', 'off', 'on'])
      })])
    }),
    /**
     * The components used for each slot inside the Slider.
     * Either a string to use a HTML element or a component.
     * @default {}
     */
    slots: PropTypes.shape({
      input: PropTypes.elementType,
      mark: PropTypes.elementType,
      markLabel: PropTypes.elementType,
      rail: PropTypes.elementType,
      root: PropTypes.elementType,
      thumb: PropTypes.elementType,
      track: PropTypes.elementType,
      valueLabel: PropTypes.elementType
    }),
    /**
     * The granularity with which the slider can step through values. (A "discrete" slider.)
     * The `min` prop serves as the origin for the valid values.
     * We recommend (max - min) to be evenly divisible by the step.
     *
     * When step is `null`, the thumb can only be slid onto marks provided with the `marks` prop.
     * @default 1
     */
    step: PropTypes.number,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * Tab index attribute of the hidden `input` element.
     */
    tabIndex: PropTypes.number,
    /**
     * The track presentation:
     *
     * - `normal` the track will render a bar representing the slider value.
     * - `inverted` the track will render a bar representing the remaining slider value.
     * - `false` the track will render without a bar.
     * @default 'normal'
     */
    track: PropTypes.oneOf(['inverted', 'normal', false]),
    /**
     * The value of the slider.
     * For ranged sliders, provide an array with two values.
     */
    value: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.number), PropTypes.number]),
    /**
     * Controls when the value label is displayed:
     *
     * - `auto` the value label will display when the thumb is hovered or focused.
     * - `on` will display persistently.
     * - `off` will never display.
     * @default 'off'
     */
    valueLabelDisplay: PropTypes.oneOf(['auto', 'off', 'on']),
    /**
     * The format function the value label's value.
     *
     * When a function is provided, it should have the following signature:
     *
     * - {number} value The value label's value to format
     * - {number} index The value label's index to format
     * @param {any} x
     * @returns {any}
     * @default function Identity(x) {
     *   return x;
     * }
     */
    valueLabelFormat: PropTypes.oneOfType([PropTypes.func, PropTypes.string])
  } ;
  var Slider$1 = Slider;

  /**
   * The basic building block for creating custom snackbar.
   *
   * Demos:
   *
   * - [Snackbar](https://mui.com/base-ui/react-snackbar/#hook)
   *
   * API:
   *
   * - [useSnackbar API](https://mui.com/base-ui/react-snackbar/hooks-api/#use-snackbar)
   */
  function useSnackbar() {
    var parameters = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var _parameters$autoHideD = parameters.autoHideDuration,
      autoHideDuration = _parameters$autoHideD === void 0 ? null : _parameters$autoHideD,
      _parameters$disableWi = parameters.disableWindowBlurListener,
      disableWindowBlurListener = _parameters$disableWi === void 0 ? false : _parameters$disableWi,
      onClose = parameters.onClose,
      open = parameters.open,
      resumeHideDuration = parameters.resumeHideDuration;
    var timerAutoHide = useTimeout();
    React__namespace.useEffect(function () {
      if (!open) {
        return undefined;
      }

      /**
       * @param {KeyboardEvent} nativeEvent
       */
      function handleKeyDown(nativeEvent) {
        if (!nativeEvent.defaultPrevented) {
          // IE11, Edge (prior to using Blink?) use 'Esc'
          if (nativeEvent.key === 'Escape' || nativeEvent.key === 'Esc') {
            // not calling `preventDefault` since we don't know if people may ignore this event e.g. a permanently open snackbar
            onClose == null || onClose(nativeEvent, 'escapeKeyDown');
          }
        }
      }
      document.addEventListener('keydown', handleKeyDown);
      return function () {
        document.removeEventListener('keydown', handleKeyDown);
      };
    }, [open, onClose]);
    var handleClose = useEventCallback(function (event, reason) {
      onClose == null || onClose(event, reason);
    });
    var setAutoHideTimer = useEventCallback(function (autoHideDurationParam) {
      if (!onClose || autoHideDurationParam == null) {
        return;
      }
      timerAutoHide.start(autoHideDurationParam, function () {
        handleClose(null, 'timeout');
      });
    });
    React__namespace.useEffect(function () {
      if (open) {
        setAutoHideTimer(autoHideDuration);
      }
      return timerAutoHide.clear;
    }, [open, autoHideDuration, setAutoHideTimer, timerAutoHide]);
    var handleClickAway = function handleClickAway(event) {
      onClose == null || onClose(event, 'clickaway');
    };

    // Pause the timer when the user is interacting with the Snackbar
    // or when the user hide the window.
    var handlePause = timerAutoHide.clear;

    // Restart the timer when the user is no longer interacting with the Snackbar
    // or when the window is shown back.
    var handleResume = React__namespace.useCallback(function () {
      if (autoHideDuration != null) {
        setAutoHideTimer(resumeHideDuration != null ? resumeHideDuration : autoHideDuration * 0.5);
      }
    }, [autoHideDuration, resumeHideDuration, setAutoHideTimer]);
    var createHandleBlur = function createHandleBlur(otherHandlers) {
      return function (event) {
        var onBlurCallback = otherHandlers.onBlur;
        onBlurCallback == null || onBlurCallback(event);
        handleResume();
      };
    };
    var createHandleFocus = function createHandleFocus(otherHandlers) {
      return function (event) {
        var onFocusCallback = otherHandlers.onFocus;
        onFocusCallback == null || onFocusCallback(event);
        handlePause();
      };
    };
    var createMouseEnter = function createMouseEnter(otherHandlers) {
      return function (event) {
        var onMouseEnterCallback = otherHandlers.onMouseEnter;
        onMouseEnterCallback == null || onMouseEnterCallback(event);
        handlePause();
      };
    };
    var createMouseLeave = function createMouseLeave(otherHandlers) {
      return function (event) {
        var onMouseLeaveCallback = otherHandlers.onMouseLeave;
        onMouseLeaveCallback == null || onMouseLeaveCallback(event);
        handleResume();
      };
    };
    React__namespace.useEffect(function () {
      // TODO: window global should be refactored here
      if (!disableWindowBlurListener && open) {
        window.addEventListener('focus', handleResume);
        window.addEventListener('blur', handlePause);
        return function () {
          window.removeEventListener('focus', handleResume);
          window.removeEventListener('blur', handlePause);
        };
      }
      return undefined;
    }, [disableWindowBlurListener, open, handleResume, handlePause]);
    var getRootProps = function getRootProps() {
      var externalProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var externalEventHandlers = _extends({}, extractEventHandlers(parameters), extractEventHandlers(externalProps));
      return _extends({
        // ClickAwayListener adds an `onClick` prop which results in the alert not being announced.
        // See https://github.com/mui/material-ui/issues/29080
        role: 'presentation'
      }, externalProps, externalEventHandlers, {
        onBlur: createHandleBlur(externalEventHandlers),
        onFocus: createHandleFocus(externalEventHandlers),
        onMouseEnter: createMouseEnter(externalEventHandlers),
        onMouseLeave: createMouseLeave(externalEventHandlers)
      });
    };
    return {
      getRootProps: getRootProps,
      onClickAway: handleClickAway
    };
  }

  function getSnackbarContentUtilityClass(slot) {
    return generateUtilityClass('MuiSnackbarContent', slot);
  }
  var snackbarContentClasses = generateUtilityClasses('MuiSnackbarContent', ['root', 'message', 'action']);
  var snackbarContentClasses$1 = snackbarContentClasses;

  var useUtilityClasses$t = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root'],
      action: ['action'],
      message: ['message']
    };
    return composeClasses(slots, getSnackbarContentUtilityClass, classes);
  };
  var SnackbarContentRoot = styled$1(Paper$1, {
    name: 'MuiSnackbarContent',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })(function (_ref) {
    var theme = _ref.theme;
    var emphasis = theme.palette.mode === 'light' ? 0.8 : 0.98;
    var backgroundColor = emphasize(theme.palette.background["default"], emphasis);
    return _extends({}, theme.typography.body2, _defineProperty({
      color: theme.vars ? theme.vars.palette.SnackbarContent.color : theme.palette.getContrastText(backgroundColor),
      backgroundColor: theme.vars ? theme.vars.palette.SnackbarContent.bg : backgroundColor,
      display: 'flex',
      alignItems: 'center',
      flexWrap: 'wrap',
      padding: '6px 16px',
      borderRadius: (theme.vars || theme).shape.borderRadius,
      flexGrow: 1
    }, theme.breakpoints.up('sm'), {
      flexGrow: 'initial',
      minWidth: 288
    }));
  });
  var SnackbarContentMessage = styled$1('div', {
    name: 'MuiSnackbarContent',
    slot: 'Message',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.message;
    }
  })({
    padding: '8px 0'
  });
  var SnackbarContentAction = styled$1('div', {
    name: 'MuiSnackbarContent',
    slot: 'Action',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.action;
    }
  })({
    display: 'flex',
    alignItems: 'center',
    marginLeft: 'auto',
    paddingLeft: 16,
    marginRight: -8
  });
  var SnackbarContent = /*#__PURE__*/React__namespace.forwardRef(function SnackbarContent(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiSnackbarContent'
    });
    var action = props.action,
      className = props.className,
      message = props.message,
      _props$role = props.role,
      role = _props$role === void 0 ? 'alert' : _props$role,
      other = _objectWithoutProperties(props, ["action", "className", "message", "role"]);
    var ownerState = props;
    var classes = useUtilityClasses$t(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(SnackbarContentRoot, _extends({
      role: role,
      square: true,
      elevation: 6,
      className: clsx(classes.root, className),
      ownerState: ownerState,
      ref: ref
    }, other, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsx(SnackbarContentMessage, {
        className: classes.message,
        ownerState: ownerState,
        children: message
      }), action ? /*#__PURE__*/jsxRuntimeExports.jsx(SnackbarContentAction, {
        className: classes.action,
        ownerState: ownerState,
        children: action
      }) : null]
    }));
  });
  SnackbarContent.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The action to display. It renders after the message, at the end of the snackbar.
     */
    action: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The message to display.
     */
    message: PropTypes.node,
    /**
     * The ARIA role attribute of the element.
     * @default 'alert'
     */
    role: PropTypes /* @typescript-to-proptypes-ignore */.string,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var SnackbarContent$1 = SnackbarContent;

  function getSnackbarUtilityClass(slot) {
    return generateUtilityClass('MuiSnackbar', slot);
  }
  var snackbarClasses = generateUtilityClasses('MuiSnackbar', ['root', 'anchorOriginTopCenter', 'anchorOriginBottomCenter', 'anchorOriginTopRight', 'anchorOriginBottomRight', 'anchorOriginTopLeft', 'anchorOriginBottomLeft']);
  var snackbarClasses$1 = snackbarClasses;

  var useUtilityClasses$s = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      anchorOrigin = ownerState.anchorOrigin;
    var slots = {
      root: ['root', "anchorOrigin".concat(capitalize(anchorOrigin.vertical)).concat(capitalize(anchorOrigin.horizontal))]
    };
    return composeClasses(slots, getSnackbarUtilityClass, classes);
  };
  var SnackbarRoot = styled$1('div', {
    name: 'MuiSnackbar',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles["anchorOrigin".concat(capitalize(ownerState.anchorOrigin.vertical)).concat(capitalize(ownerState.anchorOrigin.horizontal))]];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    var center = {
      left: '50%',
      right: 'auto',
      transform: 'translateX(-50%)'
    };
    return _extends({
      zIndex: (theme.vars || theme).zIndex.snackbar,
      position: 'fixed',
      display: 'flex',
      left: 8,
      right: 8,
      justifyContent: 'center',
      alignItems: 'center'
    }, ownerState.anchorOrigin.vertical === 'top' ? {
      top: 8
    } : {
      bottom: 8
    }, ownerState.anchorOrigin.horizontal === 'left' && {
      justifyContent: 'flex-start'
    }, ownerState.anchorOrigin.horizontal === 'right' && {
      justifyContent: 'flex-end'
    }, _defineProperty({}, theme.breakpoints.up('sm'), _extends({}, ownerState.anchorOrigin.vertical === 'top' ? {
      top: 24
    } : {
      bottom: 24
    }, ownerState.anchorOrigin.horizontal === 'center' && center, ownerState.anchorOrigin.horizontal === 'left' && {
      left: 24,
      right: 'auto'
    }, ownerState.anchorOrigin.horizontal === 'right' && {
      right: 24,
      left: 'auto'
    })));
  });
  var Snackbar = /*#__PURE__*/React__namespace.forwardRef(function Snackbar(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiSnackbar'
    });
    var theme = useTheme();
    var defaultTransitionDuration = {
      enter: theme.transitions.duration.enteringScreen,
      exit: theme.transitions.duration.leavingScreen
    };
    var action = props.action,
      _props$anchorOrigin = props.anchorOrigin,
      _props$anchorOrigin2 = _props$anchorOrigin === void 0 ? {
        vertical: 'bottom',
        horizontal: 'left'
      } : _props$anchorOrigin,
      vertical = _props$anchorOrigin2.vertical,
      horizontal = _props$anchorOrigin2.horizontal,
      _props$autoHideDurati = props.autoHideDuration,
      autoHideDuration = _props$autoHideDurati === void 0 ? null : _props$autoHideDurati,
      children = props.children,
      className = props.className,
      ClickAwayListenerProps = props.ClickAwayListenerProps,
      ContentProps = props.ContentProps,
      _props$disableWindowB = props.disableWindowBlurListener,
      disableWindowBlurListener = _props$disableWindowB === void 0 ? false : _props$disableWindowB,
      message = props.message;
      props.onBlur;
      props.onClose;
      props.onFocus;
      props.onMouseEnter;
      props.onMouseLeave;
      var open = props.open;
      props.resumeHideDuration;
      var _props$TransitionComp = props.TransitionComponent,
      TransitionComponent = _props$TransitionComp === void 0 ? Grow$1 : _props$TransitionComp,
      _props$transitionDura = props.transitionDuration,
      transitionDuration = _props$transitionDura === void 0 ? defaultTransitionDuration : _props$transitionDura,
      _props$TransitionProp = props.TransitionProps,
      _props$TransitionProp2 = _props$TransitionProp === void 0 ? {} : _props$TransitionProp,
      onEnter = _props$TransitionProp2.onEnter,
      onExited = _props$TransitionProp2.onExited,
      TransitionProps = _objectWithoutProperties(_props$TransitionProp2, ["onEnter", "onExited"]),
      other = _objectWithoutProperties(props, ["action", "anchorOrigin", "autoHideDuration", "children", "className", "ClickAwayListenerProps", "ContentProps", "disableWindowBlurListener", "message", "onBlur", "onClose", "onFocus", "onMouseEnter", "onMouseLeave", "open", "resumeHideDuration", "TransitionComponent", "transitionDuration", "TransitionProps"]);
    var ownerState = _extends({}, props, {
      anchorOrigin: {
        vertical: vertical,
        horizontal: horizontal
      },
      autoHideDuration: autoHideDuration,
      disableWindowBlurListener: disableWindowBlurListener,
      TransitionComponent: TransitionComponent,
      transitionDuration: transitionDuration
    });
    var classes = useUtilityClasses$s(ownerState);
    var _useSnackbar = useSnackbar(_extends({}, ownerState)),
      getRootProps = _useSnackbar.getRootProps,
      onClickAway = _useSnackbar.onClickAway;
    var _React$useState = React__namespace.useState(true),
      exited = _React$useState[0],
      setExited = _React$useState[1];
    var rootProps = useSlotProps({
      elementType: SnackbarRoot,
      getSlotProps: getRootProps,
      externalForwardedProps: other,
      ownerState: ownerState,
      additionalProps: {
        ref: ref
      },
      className: [classes.root, className]
    });
    var handleExited = function handleExited(node) {
      setExited(true);
      if (onExited) {
        onExited(node);
      }
    };
    var handleEnter = function handleEnter(node, isAppearing) {
      setExited(false);
      if (onEnter) {
        onEnter(node, isAppearing);
      }
    };

    // So we only render active snackbars.
    if (!open && exited) {
      return null;
    }
    return /*#__PURE__*/jsxRuntimeExports.jsx(ClickAwayListener, _extends({
      onClickAway: onClickAway
    }, ClickAwayListenerProps, {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(SnackbarRoot, _extends({}, rootProps, {
        children: /*#__PURE__*/jsxRuntimeExports.jsx(TransitionComponent, _extends({
          appear: true,
          "in": open,
          timeout: transitionDuration,
          direction: vertical === 'top' ? 'down' : 'up',
          onEnter: handleEnter,
          onExited: handleExited
        }, TransitionProps, {
          children: children || /*#__PURE__*/jsxRuntimeExports.jsx(SnackbarContent$1, _extends({
            message: message,
            action: action
          }, ContentProps))
        }))
      }))
    }));
  });
  Snackbar.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The action to display. It renders after the message, at the end of the snackbar.
     */
    action: PropTypes.node,
    /**
     * The anchor of the `Snackbar`.
     * On smaller screens, the component grows to occupy all the available width,
     * the horizontal alignment is ignored.
     * @default { vertical: 'bottom', horizontal: 'left' }
     */
    anchorOrigin: PropTypes.shape({
      horizontal: PropTypes.oneOf(['center', 'left', 'right']).isRequired,
      vertical: PropTypes.oneOf(['bottom', 'top']).isRequired
    }),
    /**
     * The number of milliseconds to wait before automatically calling the
     * `onClose` function. `onClose` should then set the state of the `open`
     * prop to hide the Snackbar. This behavior is disabled by default with
     * the `null` value.
     * @default null
     */
    autoHideDuration: PropTypes.number,
    /**
     * Replace the `SnackbarContent` component.
     */
    children: PropTypes.element,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * Props applied to the `ClickAwayListener` element.
     */
    ClickAwayListenerProps: PropTypes.object,
    /**
     * Props applied to the [`SnackbarContent`](/material-ui/api/snackbar-content/) element.
     */
    ContentProps: PropTypes.object,
    /**
     * If `true`, the `autoHideDuration` timer will expire even if the window is not focused.
     * @default false
     */
    disableWindowBlurListener: PropTypes.bool,
    /**
     * When displaying multiple consecutive snackbars using a single parent-rendered
     * `<Snackbar/>`, add the `key` prop to ensure independent treatment of each message.
     * For instance, use `<Snackbar key={message} />`. Otherwise, messages might update
     * in place, and features like `autoHideDuration` could be affected.
     */
    key: function key() {
      return null;
    },
    /**
     * The message to display.
     */
    message: PropTypes.node,
    /**
     * @ignore
     */
    onBlur: PropTypes.func,
    /**
     * Callback fired when the component requests to be closed.
     * Typically `onClose` is used to set state in the parent component,
     * which is used to control the `Snackbar` `open` prop.
     * The `reason` parameter can optionally be used to control the response to `onClose`,
     * for example ignoring `clickaway`.
     *
     * @param {React.SyntheticEvent<any> | Event} event The event source of the callback.
     * @param {string} reason Can be: `"timeout"` (`autoHideDuration` expired), `"clickaway"`, or `"escapeKeyDown"`.
     */
    onClose: PropTypes.func,
    /**
     * @ignore
     */
    onFocus: PropTypes.func,
    /**
     * @ignore
     */
    onMouseEnter: PropTypes.func,
    /**
     * @ignore
     */
    onMouseLeave: PropTypes.func,
    /**
     * If `true`, the component is shown.
     */
    open: PropTypes.bool,
    /**
     * The number of milliseconds to wait before dismissing after user interaction.
     * If `autoHideDuration` prop isn't specified, it does nothing.
     * If `autoHideDuration` prop is specified but `resumeHideDuration` isn't,
     * we default to `autoHideDuration / 2` ms.
     */
    resumeHideDuration: PropTypes.number,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The component used for the transition.
     * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
     * @default Grow
     */
    TransitionComponent: PropTypes.elementType,
    /**
     * The duration for the transition, in milliseconds.
     * You may specify a single timeout for all transitions, or individually with an object.
     * @default {
     *   enter: theme.transitions.duration.enteringScreen,
     *   exit: theme.transitions.duration.leavingScreen,
     * }
     */
    transitionDuration: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
      appear: PropTypes.number,
      enter: PropTypes.number,
      exit: PropTypes.number
    })]),
    /**
     * Props applied to the transition element.
     * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
     * @default {}
     */
    TransitionProps: PropTypes.object
  } ;
  var Snackbar$1 = Snackbar;

  var styles$1 = {
    entering: {
      transform: 'none'
    },
    entered: {
      transform: 'none'
    }
  };

  /**
   * The Zoom transition can be used for the floating variant of the
   * [Button](/material-ui/react-button/#floating-action-buttons) component.
   * It uses [react-transition-group](https://github.com/reactjs/react-transition-group) internally.
   */
  var Zoom = /*#__PURE__*/React__namespace.forwardRef(function Zoom(props, ref) {
    var theme = useTheme();
    var defaultTimeout = {
      enter: theme.transitions.duration.enteringScreen,
      exit: theme.transitions.duration.leavingScreen
    };
    var addEndListener = props.addEndListener,
      _props$appear = props.appear,
      appear = _props$appear === void 0 ? true : _props$appear,
      _children = props.children,
      easing = props.easing,
      inProp = props["in"],
      onEnter = props.onEnter,
      onEntered = props.onEntered,
      onEntering = props.onEntering,
      onExit = props.onExit,
      onExited = props.onExited,
      onExiting = props.onExiting,
      style = props.style,
      _props$timeout = props.timeout,
      timeout = _props$timeout === void 0 ? defaultTimeout : _props$timeout,
      _props$TransitionComp = props.TransitionComponent,
      TransitionComponent = _props$TransitionComp === void 0 ? Transition$1 : _props$TransitionComp,
      other = _objectWithoutProperties(props, ["addEndListener", "appear", "children", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "style", "timeout", "TransitionComponent"]);
    var nodeRef = React__namespace.useRef(null);
    var handleRef = useForkRef(nodeRef, getReactElementRef(_children), ref);
    var normalizedTransitionCallback = function normalizedTransitionCallback(callback) {
      return function (maybeIsAppearing) {
        if (callback) {
          var node = nodeRef.current;

          // onEnterXxx and onExitXxx callbacks have a different arguments.length value.
          if (maybeIsAppearing === undefined) {
            callback(node);
          } else {
            callback(node, maybeIsAppearing);
          }
        }
      };
    };
    var handleEntering = normalizedTransitionCallback(onEntering);
    var handleEnter = normalizedTransitionCallback(function (node, isAppearing) {
      reflow(node); // So the animation always start from the start.

      var transitionProps = getTransitionProps({
        style: style,
        timeout: timeout,
        easing: easing
      }, {
        mode: 'enter'
      });
      node.style.webkitTransition = theme.transitions.create('transform', transitionProps);
      node.style.transition = theme.transitions.create('transform', transitionProps);
      if (onEnter) {
        onEnter(node, isAppearing);
      }
    });
    var handleEntered = normalizedTransitionCallback(onEntered);
    var handleExiting = normalizedTransitionCallback(onExiting);
    var handleExit = normalizedTransitionCallback(function (node) {
      var transitionProps = getTransitionProps({
        style: style,
        timeout: timeout,
        easing: easing
      }, {
        mode: 'exit'
      });
      node.style.webkitTransition = theme.transitions.create('transform', transitionProps);
      node.style.transition = theme.transitions.create('transform', transitionProps);
      if (onExit) {
        onExit(node);
      }
    });
    var handleExited = normalizedTransitionCallback(onExited);
    var handleAddEndListener = function handleAddEndListener(next) {
      if (addEndListener) {
        // Old call signature before `react-transition-group` implemented `nodeRef`
        addEndListener(nodeRef.current, next);
      }
    };
    return /*#__PURE__*/jsxRuntimeExports.jsx(TransitionComponent, _extends({
      appear: appear,
      "in": inProp,
      nodeRef: nodeRef,
      onEnter: handleEnter,
      onEntered: handleEntered,
      onEntering: handleEntering,
      onExit: handleExit,
      onExited: handleExited,
      onExiting: handleExiting,
      addEndListener: handleAddEndListener,
      timeout: timeout
    }, other, {
      children: function children(state, childProps) {
        return /*#__PURE__*/React__namespace.cloneElement(_children, _extends({
          style: _extends({
            transform: 'scale(0)',
            visibility: state === 'exited' && !inProp ? 'hidden' : undefined
          }, styles$1[state], style, _children.props.style),
          ref: handleRef
        }, childProps));
      }
    }));
  });
  Zoom.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Add a custom transition end trigger. Called with the transitioning DOM
     * node and a done callback. Allows for more fine grained transition end
     * logic. Note: Timeouts are still used as a fallback if provided.
     */
    addEndListener: PropTypes.func,
    /**
     * Perform the enter transition when it first mounts if `in` is also `true`.
     * Set this to `false` to disable this behavior.
     * @default true
     */
    appear: PropTypes.bool,
    /**
     * A single child content element.
     */
    children: elementAcceptingRef$1.isRequired,
    /**
     * The transition timing function.
     * You may specify a single easing or a object containing enter and exit values.
     */
    easing: PropTypes.oneOfType([PropTypes.shape({
      enter: PropTypes.string,
      exit: PropTypes.string
    }), PropTypes.string]),
    /**
     * If `true`, the component will transition in.
     */
    "in": PropTypes.bool,
    /**
     * @ignore
     */
    onEnter: PropTypes.func,
    /**
     * @ignore
     */
    onEntered: PropTypes.func,
    /**
     * @ignore
     */
    onEntering: PropTypes.func,
    /**
     * @ignore
     */
    onExit: PropTypes.func,
    /**
     * @ignore
     */
    onExited: PropTypes.func,
    /**
     * @ignore
     */
    onExiting: PropTypes.func,
    /**
     * @ignore
     */
    style: PropTypes.object,
    /**
     * The duration for the transition, in milliseconds.
     * You may specify a single timeout for all transitions, or individually with an object.
     * @default {
     *   enter: theme.transitions.duration.enteringScreen,
     *   exit: theme.transitions.duration.leavingScreen,
     * }
     */
    timeout: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
      appear: PropTypes.number,
      enter: PropTypes.number,
      exit: PropTypes.number
    })])
  } ;
  var Zoom$1 = Zoom;

  function getSpeedDialUtilityClass(slot) {
    return generateUtilityClass('MuiSpeedDial', slot);
  }
  var speedDialClasses = generateUtilityClasses('MuiSpeedDial', ['root', 'fab', 'directionUp', 'directionDown', 'directionLeft', 'directionRight', 'actions', 'actionsClosed']);
  var speedDialClasses$1 = speedDialClasses;

  var useUtilityClasses$r = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      open = ownerState.open,
      direction = ownerState.direction;
    var slots = {
      root: ['root', "direction".concat(capitalize(direction))],
      fab: ['fab'],
      actions: ['actions', !open && 'actionsClosed']
    };
    return composeClasses(slots, getSpeedDialUtilityClass, classes);
  };
  function getOrientation(direction) {
    if (direction === 'up' || direction === 'down') {
      return 'vertical';
    }
    if (direction === 'right' || direction === 'left') {
      return 'horizontal';
    }
    return undefined;
  }
  var dialRadius = 32;
  var spacingActions = 16;
  var SpeedDialRoot = styled$1('div', {
    name: 'MuiSpeedDial',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles["direction".concat(capitalize(ownerState.direction))]];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      zIndex: (theme.vars || theme).zIndex.speedDial,
      display: 'flex',
      alignItems: 'center',
      pointerEvents: 'none'
    }, ownerState.direction === 'up' && _defineProperty({
      flexDirection: 'column-reverse'
    }, "& .".concat(speedDialClasses$1.actions), {
      flexDirection: 'column-reverse',
      marginBottom: -dialRadius,
      paddingBottom: spacingActions + dialRadius
    }), ownerState.direction === 'down' && _defineProperty({
      flexDirection: 'column'
    }, "& .".concat(speedDialClasses$1.actions), {
      flexDirection: 'column',
      marginTop: -dialRadius,
      paddingTop: spacingActions + dialRadius
    }), ownerState.direction === 'left' && _defineProperty({
      flexDirection: 'row-reverse'
    }, "& .".concat(speedDialClasses$1.actions), {
      flexDirection: 'row-reverse',
      marginRight: -dialRadius,
      paddingRight: spacingActions + dialRadius
    }), ownerState.direction === 'right' && _defineProperty({
      flexDirection: 'row'
    }, "& .".concat(speedDialClasses$1.actions), {
      flexDirection: 'row',
      marginLeft: -dialRadius,
      paddingLeft: spacingActions + dialRadius
    }));
  });
  var SpeedDialFab = styled$1(Fab$1, {
    name: 'MuiSpeedDial',
    slot: 'Fab',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.fab;
    }
  })(function () {
    return {
      pointerEvents: 'auto'
    };
  });
  var SpeedDialActions = styled$1('div', {
    name: 'MuiSpeedDial',
    slot: 'Actions',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.actions, !ownerState.open && styles.actionsClosed];
    }
  })(function (_ref6) {
    var ownerState = _ref6.ownerState;
    return _extends({
      display: 'flex',
      pointerEvents: 'auto'
    }, !ownerState.open && {
      transition: 'top 0s linear 0.2s',
      pointerEvents: 'none'
    });
  });
  var SpeedDial = /*#__PURE__*/React__namespace.forwardRef(function SpeedDial(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiSpeedDial'
    });
    var theme = useTheme();
    var defaultTransitionDuration = {
      enter: theme.transitions.duration.enteringScreen,
      exit: theme.transitions.duration.leavingScreen
    };
    var ariaLabel = props.ariaLabel,
      _props$FabProps = props.FabProps,
      _props$FabProps2 = _props$FabProps === void 0 ? {} : _props$FabProps,
      origDialButtonRef = _props$FabProps2.ref,
      FabProps = _objectWithoutProperties(_props$FabProps2, ["ref"]),
      childrenProp = props.children,
      className = props.className,
      _props$direction = props.direction,
      direction = _props$direction === void 0 ? 'up' : _props$direction,
      _props$hidden = props.hidden,
      hidden = _props$hidden === void 0 ? false : _props$hidden,
      icon = props.icon,
      onBlur = props.onBlur,
      onClose = props.onClose,
      onFocus = props.onFocus,
      onKeyDown = props.onKeyDown,
      onMouseEnter = props.onMouseEnter,
      onMouseLeave = props.onMouseLeave,
      onOpen = props.onOpen,
      openProp = props.open;
      props.openIcon;
      var _props$TransitionComp = props.TransitionComponent,
      TransitionComponent = _props$TransitionComp === void 0 ? Zoom$1 : _props$TransitionComp,
      _props$transitionDura = props.transitionDuration,
      transitionDuration = _props$transitionDura === void 0 ? defaultTransitionDuration : _props$transitionDura,
      TransitionProps = props.TransitionProps,
      other = _objectWithoutProperties(props, ["ariaLabel", "FabProps", "children", "className", "direction", "hidden", "icon", "onBlur", "onClose", "onFocus", "onKeyDown", "onMouseEnter", "onMouseLeave", "onOpen", "open", "openIcon", "TransitionComponent", "transitionDuration", "TransitionProps"]);
    var _useControlled = useControlled({
        controlled: openProp,
        "default": false,
        name: 'SpeedDial',
        state: 'open'
      }),
      _useControlled2 = _slicedToArray(_useControlled, 2),
      open = _useControlled2[0],
      setOpenState = _useControlled2[1];
    var ownerState = _extends({}, props, {
      open: open,
      direction: direction
    });
    var classes = useUtilityClasses$r(ownerState);
    var eventTimer = useTimeout();

    /**
     * an index in actions.current
     */
    var focusedAction = React__namespace.useRef(0);

    /**
     * pressing this key while the focus is on a child SpeedDialAction focuses
     * the next SpeedDialAction.
     * It is equal to the first arrow key pressed while focus is on the SpeedDial
     * that is not orthogonal to the direction.
     * @type {utils.ArrowKey?}
     */
    var nextItemArrowKey = React__namespace.useRef();

    /**
     * refs to the Button that have an action associated to them in this SpeedDial
     * [Fab, ...(SpeedDialActions > Button)]
     * @type {HTMLButtonElement[]}
     */
    var actions = React__namespace.useRef([]);
    actions.current = [actions.current[0]];
    var handleOwnFabRef = React__namespace.useCallback(function (fabFef) {
      actions.current[0] = fabFef;
    }, []);
    var handleFabRef = useForkRef(origDialButtonRef, handleOwnFabRef);

    /**
     * creates a ref callback for the Button in a SpeedDialAction
     * Is called before the original ref callback for Button that was set in buttonProps
     *
     * @param dialActionIndex {number}
     * @param origButtonRef {React.RefObject?}
     */
    var createHandleSpeedDialActionButtonRef = function createHandleSpeedDialActionButtonRef(dialActionIndex, origButtonRef) {
      return function (buttonRef) {
        actions.current[dialActionIndex + 1] = buttonRef;
        if (origButtonRef) {
          origButtonRef(buttonRef);
        }
      };
    };
    var handleKeyDown = function handleKeyDown(event) {
      if (onKeyDown) {
        onKeyDown(event);
      }
      var key = event.key.replace('Arrow', '').toLowerCase();
      var _nextItemArrowKey$cur = nextItemArrowKey.current,
        nextItemArrowKeyCurrent = _nextItemArrowKey$cur === void 0 ? key : _nextItemArrowKey$cur;
      if (event.key === 'Escape') {
        setOpenState(false);
        actions.current[0].focus();
        if (onClose) {
          onClose(event, 'escapeKeyDown');
        }
        return;
      }
      if (getOrientation(key) === getOrientation(nextItemArrowKeyCurrent) && getOrientation(key) !== undefined) {
        event.preventDefault();
        var actionStep = key === nextItemArrowKeyCurrent ? 1 : -1;

        // stay within array indices
        var nextAction = clamp(focusedAction.current + actionStep, 0, actions.current.length - 1);
        actions.current[nextAction].focus();
        focusedAction.current = nextAction;
        nextItemArrowKey.current = nextItemArrowKeyCurrent;
      }
    };
    React__namespace.useEffect(function () {
      // actions were closed while navigation state was not reset
      if (!open) {
        focusedAction.current = 0;
        nextItemArrowKey.current = undefined;
      }
    }, [open]);
    var handleClose = function handleClose(event) {
      if (event.type === 'mouseleave' && onMouseLeave) {
        onMouseLeave(event);
      }
      if (event.type === 'blur' && onBlur) {
        onBlur(event);
      }
      eventTimer.clear();
      if (event.type === 'blur') {
        eventTimer.start(0, function () {
          setOpenState(false);
          if (onClose) {
            onClose(event, 'blur');
          }
        });
      } else {
        setOpenState(false);
        if (onClose) {
          onClose(event, 'mouseLeave');
        }
      }
    };
    var handleClick = function handleClick(event) {
      if (FabProps.onClick) {
        FabProps.onClick(event);
      }
      eventTimer.clear();
      if (open) {
        setOpenState(false);
        if (onClose) {
          onClose(event, 'toggle');
        }
      } else {
        setOpenState(true);
        if (onOpen) {
          onOpen(event, 'toggle');
        }
      }
    };
    var handleOpen = function handleOpen(event) {
      if (event.type === 'mouseenter' && onMouseEnter) {
        onMouseEnter(event);
      }
      if (event.type === 'focus' && onFocus) {
        onFocus(event);
      }

      // When moving the focus between two items,
      // a chain if blur and focus event is triggered.
      // We only handle the last event.
      eventTimer.clear();
      if (!open) {
        // Wait for a future focus or click event
        eventTimer.start(0, function () {
          setOpenState(true);
          if (onOpen) {
            var eventMap = {
              focus: 'focus',
              mouseenter: 'mouseEnter'
            };
            onOpen(event, eventMap[event.type]);
          }
        });
      }
    };

    // Filter the label for valid id characters.
    var id = ariaLabel.replace(/^[^a-z]+|[^\w:.-]+/gi, '');
    var allItems = React__namespace.Children.toArray(childrenProp).filter(function (child) {
      {
        if (reactIsExports.isFragment(child)) {
          console.error(["MUI: The SpeedDial component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n'));
        }
      }
      return /*#__PURE__*/React__namespace.isValidElement(child);
    });
    var children = allItems.map(function (child, index) {
      var _child$props = child.props,
        _child$props$FabProps = _child$props.FabProps,
        _child$props$FabProps2 = _child$props$FabProps === void 0 ? {} : _child$props$FabProps,
        origButtonRef = _child$props$FabProps2.ref,
        ChildFabProps = _objectWithoutProperties(_child$props$FabProps2, ["ref"]),
        tooltipPlacementProp = _child$props.tooltipPlacement;
      var tooltipPlacement = tooltipPlacementProp || (getOrientation(direction) === 'vertical' ? 'left' : 'top');
      return /*#__PURE__*/React__namespace.cloneElement(child, {
        FabProps: _extends({}, ChildFabProps, {
          ref: createHandleSpeedDialActionButtonRef(index, origButtonRef)
        }),
        delay: 30 * (open ? index : allItems.length - index),
        open: open,
        tooltipPlacement: tooltipPlacement,
        id: "".concat(id, "-action-").concat(index)
      });
    });
    return /*#__PURE__*/jsxRuntimeExports.jsxs(SpeedDialRoot, _extends({
      className: clsx(classes.root, className),
      ref: ref,
      role: "presentation",
      onKeyDown: handleKeyDown,
      onBlur: handleClose,
      onFocus: handleOpen,
      onMouseEnter: handleOpen,
      onMouseLeave: handleClose,
      ownerState: ownerState
    }, other, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsx(TransitionComponent, _extends({
        "in": !hidden,
        timeout: transitionDuration,
        unmountOnExit: true
      }, TransitionProps, {
        children: /*#__PURE__*/jsxRuntimeExports.jsx(SpeedDialFab, _extends({
          color: "primary",
          "aria-label": ariaLabel,
          "aria-haspopup": "true",
          "aria-expanded": open,
          "aria-controls": "".concat(id, "-actions")
        }, FabProps, {
          onClick: handleClick,
          className: clsx(classes.fab, FabProps.className),
          ref: handleFabRef,
          ownerState: ownerState,
          children: /*#__PURE__*/React__namespace.isValidElement(icon) && isMuiElement(icon, ['SpeedDialIcon']) ? /*#__PURE__*/React__namespace.cloneElement(icon, {
            open: open
          }) : icon
        }))
      })), /*#__PURE__*/jsxRuntimeExports.jsx(SpeedDialActions, {
        id: "".concat(id, "-actions"),
        role: "menu",
        "aria-orientation": getOrientation(direction),
        className: clsx(classes.actions, !open && classes.actionsClosed),
        ownerState: ownerState,
        children: children
      })]
    }));
  });
  SpeedDial.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The aria-label of the button element.
     * Also used to provide the `id` for the `SpeedDial` element and its children.
     */
    ariaLabel: PropTypes.string.isRequired,
    /**
     * SpeedDialActions to display when the SpeedDial is `open`.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The direction the actions open relative to the floating action button.
     * @default 'up'
     */
    direction: PropTypes.oneOf(['down', 'left', 'right', 'up']),
    /**
     * Props applied to the [`Fab`](/material-ui/api/fab/) element.
     * @default {}
     */
    FabProps: PropTypes.object,
    /**
     * If `true`, the SpeedDial is hidden.
     * @default false
     */
    hidden: PropTypes.bool,
    /**
     * The icon to display in the SpeedDial Fab. The `SpeedDialIcon` component
     * provides a default Icon with animation.
     */
    icon: PropTypes.node,
    /**
     * @ignore
     */
    onBlur: PropTypes.func,
    /**
     * Callback fired when the component requests to be closed.
     *
     * @param {object} event The event source of the callback.
     * @param {string} reason Can be: `"toggle"`, `"blur"`, `"mouseLeave"`, `"escapeKeyDown"`.
     */
    onClose: PropTypes.func,
    /**
     * @ignore
     */
    onFocus: PropTypes.func,
    /**
     * @ignore
     */
    onKeyDown: PropTypes.func,
    /**
     * @ignore
     */
    onMouseEnter: PropTypes.func,
    /**
     * @ignore
     */
    onMouseLeave: PropTypes.func,
    /**
     * Callback fired when the component requests to be open.
     *
     * @param {object} event The event source of the callback.
     * @param {string} reason Can be: `"toggle"`, `"focus"`, `"mouseEnter"`.
     */
    onOpen: PropTypes.func,
    /**
     * If `true`, the component is shown.
     */
    open: PropTypes.bool,
    /**
     * The icon to display in the SpeedDial Fab when the SpeedDial is open.
     */
    openIcon: PropTypes.node,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The component used for the transition.
     * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
     * @default Zoom
     */
    TransitionComponent: PropTypes.elementType,
    /**
     * The duration for the transition, in milliseconds.
     * You may specify a single timeout for all transitions, or individually with an object.
     * @default {
     *   enter: theme.transitions.duration.enteringScreen,
     *   exit: theme.transitions.duration.leavingScreen,
     * }
     */
    transitionDuration: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
      appear: PropTypes.number,
      enter: PropTypes.number,
      exit: PropTypes.number
    })]),
    /**
     * Props applied to the transition element.
     * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
     */
    TransitionProps: PropTypes.object
  } ;
  var SpeedDial$1 = SpeedDial;

  function getTooltipUtilityClass(slot) {
    return generateUtilityClass('MuiTooltip', slot);
  }
  var tooltipClasses = generateUtilityClasses('MuiTooltip', ['popper', 'popperInteractive', 'popperArrow', 'popperClose', 'tooltip', 'tooltipArrow', 'touch', 'tooltipPlacementLeft', 'tooltipPlacementRight', 'tooltipPlacementTop', 'tooltipPlacementBottom', 'arrow']);
  var tooltipClasses$1 = tooltipClasses;

  function round(value) {
    return Math.round(value * 1e5) / 1e5;
  }
  var useUtilityClasses$q = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      disableInteractive = ownerState.disableInteractive,
      arrow = ownerState.arrow,
      touch = ownerState.touch,
      placement = ownerState.placement;
    var slots = {
      popper: ['popper', !disableInteractive && 'popperInteractive', arrow && 'popperArrow'],
      tooltip: ['tooltip', arrow && 'tooltipArrow', touch && 'touch', "tooltipPlacement".concat(capitalize(placement.split('-')[0]))],
      arrow: ['arrow']
    };
    return composeClasses(slots, getTooltipUtilityClass, classes);
  };
  var TooltipPopper = styled$1(Popper$1, {
    name: 'MuiTooltip',
    slot: 'Popper',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.popper, !ownerState.disableInteractive && styles.popperInteractive, ownerState.arrow && styles.popperArrow, !ownerState.open && styles.popperClose];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState,
      open = _ref.open;
    return _extends({
      zIndex: (theme.vars || theme).zIndex.tooltip,
      pointerEvents: 'none'
    }, !ownerState.disableInteractive && {
      pointerEvents: 'auto'
    }, !open && {
      pointerEvents: 'none'
    }, ownerState.arrow && _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, "&[data-popper-placement*=\"bottom\"] .".concat(tooltipClasses$1.arrow), {
      top: 0,
      marginTop: '-0.71em',
      '&::before': {
        transformOrigin: '0 100%'
      }
    }), "&[data-popper-placement*=\"top\"] .".concat(tooltipClasses$1.arrow), {
      bottom: 0,
      marginBottom: '-0.71em',
      '&::before': {
        transformOrigin: '100% 0'
      }
    }), "&[data-popper-placement*=\"right\"] .".concat(tooltipClasses$1.arrow), _extends({}, !ownerState.isRtl ? {
      left: 0,
      marginLeft: '-0.71em'
    } : {
      right: 0,
      marginRight: '-0.71em'
    }, {
      height: '1em',
      width: '0.71em',
      '&::before': {
        transformOrigin: '100% 100%'
      }
    })), "&[data-popper-placement*=\"left\"] .".concat(tooltipClasses$1.arrow), _extends({}, !ownerState.isRtl ? {
      right: 0,
      marginRight: '-0.71em'
    } : {
      left: 0,
      marginLeft: '-0.71em'
    }, {
      height: '1em',
      width: '0.71em',
      '&::before': {
        transformOrigin: '0 0'
      }
    })));
  });
  var TooltipTooltip = styled$1('div', {
    name: 'MuiTooltip',
    slot: 'Tooltip',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.tooltip, ownerState.touch && styles.touch, ownerState.arrow && styles.tooltipArrow, styles["tooltipPlacement".concat(capitalize(ownerState.placement.split('-')[0]))]];
    }
  })(function (_ref3) {
    var theme = _ref3.theme,
      ownerState = _ref3.ownerState;
    return _extends({
      backgroundColor: theme.vars ? theme.vars.palette.Tooltip.bg : alpha(theme.palette.grey[700], 0.92),
      borderRadius: (theme.vars || theme).shape.borderRadius,
      color: (theme.vars || theme).palette.common.white,
      fontFamily: theme.typography.fontFamily,
      padding: '4px 8px',
      fontSize: theme.typography.pxToRem(11),
      maxWidth: 300,
      margin: 2,
      wordWrap: 'break-word',
      fontWeight: theme.typography.fontWeightMedium
    }, ownerState.arrow && {
      position: 'relative',
      margin: 0
    }, ownerState.touch && {
      padding: '8px 16px',
      fontSize: theme.typography.pxToRem(14),
      lineHeight: "".concat(round(16 / 14), "em"),
      fontWeight: theme.typography.fontWeightRegular
    }, _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, ".".concat(tooltipClasses$1.popper, "[data-popper-placement*=\"left\"] &"), _extends({
      transformOrigin: 'right center'
    }, !ownerState.isRtl ? _extends({
      marginRight: '14px'
    }, ownerState.touch && {
      marginRight: '24px'
    }) : _extends({
      marginLeft: '14px'
    }, ownerState.touch && {
      marginLeft: '24px'
    }))), ".".concat(tooltipClasses$1.popper, "[data-popper-placement*=\"right\"] &"), _extends({
      transformOrigin: 'left center'
    }, !ownerState.isRtl ? _extends({
      marginLeft: '14px'
    }, ownerState.touch && {
      marginLeft: '24px'
    }) : _extends({
      marginRight: '14px'
    }, ownerState.touch && {
      marginRight: '24px'
    }))), ".".concat(tooltipClasses$1.popper, "[data-popper-placement*=\"top\"] &"), _extends({
      transformOrigin: 'center bottom',
      marginBottom: '14px'
    }, ownerState.touch && {
      marginBottom: '24px'
    })), ".".concat(tooltipClasses$1.popper, "[data-popper-placement*=\"bottom\"] &"), _extends({
      transformOrigin: 'center top',
      marginTop: '14px'
    }, ownerState.touch && {
      marginTop: '24px'
    })));
  });
  var TooltipArrow = styled$1('span', {
    name: 'MuiTooltip',
    slot: 'Arrow',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.arrow;
    }
  })(function (_ref4) {
    var theme = _ref4.theme;
    return {
      overflow: 'hidden',
      position: 'absolute',
      width: '1em',
      height: '0.71em' /* = width / sqrt(2) = (length of the hypotenuse) */,
      boxSizing: 'border-box',
      color: theme.vars ? theme.vars.palette.Tooltip.bg : alpha(theme.palette.grey[700], 0.9),
      '&::before': {
        content: '""',
        margin: 'auto',
        display: 'block',
        width: '100%',
        height: '100%',
        backgroundColor: 'currentColor',
        transform: 'rotate(45deg)'
      }
    };
  });
  var hystersisOpen = false;
  var hystersisTimer = new Timeout();
  var cursorPosition = {
    x: 0,
    y: 0
  };
  function composeEventHandler(handler, eventHandler) {
    return function (event) {
      for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        params[_key - 1] = arguments[_key];
      }
      if (eventHandler) {
        eventHandler.apply(void 0, [event].concat(params));
      }
      handler.apply(void 0, [event].concat(params));
    };
  }

  // TODO v6: Remove PopperComponent, PopperProps, TransitionComponent and TransitionProps.
  var Tooltip = /*#__PURE__*/React__namespace.forwardRef(function Tooltip(inProps, ref) {
    var _ref5, _slots$popper, _ref6, _ref7, _slots$transition, _ref8, _slots$tooltip, _ref9, _slots$arrow, _slotProps$popper, _ref10, _slotProps$popper2, _slotProps$transition, _slotProps$tooltip, _ref11, _slotProps$tooltip2, _slotProps$arrow, _ref12, _slotProps$arrow2;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTooltip'
    });
    var _props$arrow = props.arrow,
      arrow = _props$arrow === void 0 ? false : _props$arrow,
      childrenProp = props.children;
      props.classes;
      var _props$components = props.components,
      components = _props$components === void 0 ? {} : _props$components,
      _props$componentsProp = props.componentsProps,
      componentsProps = _props$componentsProp === void 0 ? {} : _props$componentsProp,
      _props$describeChild = props.describeChild,
      describeChild = _props$describeChild === void 0 ? false : _props$describeChild,
      _props$disableFocusLi = props.disableFocusListener,
      disableFocusListener = _props$disableFocusLi === void 0 ? false : _props$disableFocusLi,
      _props$disableHoverLi = props.disableHoverListener,
      disableHoverListener = _props$disableHoverLi === void 0 ? false : _props$disableHoverLi,
      _props$disableInterac = props.disableInteractive,
      disableInteractiveProp = _props$disableInterac === void 0 ? false : _props$disableInterac,
      _props$disableTouchLi = props.disableTouchListener,
      disableTouchListener = _props$disableTouchLi === void 0 ? false : _props$disableTouchLi,
      _props$enterDelay = props.enterDelay,
      enterDelay = _props$enterDelay === void 0 ? 100 : _props$enterDelay,
      _props$enterNextDelay = props.enterNextDelay,
      enterNextDelay = _props$enterNextDelay === void 0 ? 0 : _props$enterNextDelay,
      _props$enterTouchDela = props.enterTouchDelay,
      enterTouchDelay = _props$enterTouchDela === void 0 ? 700 : _props$enterTouchDela,
      _props$followCursor = props.followCursor,
      followCursor = _props$followCursor === void 0 ? false : _props$followCursor,
      idProp = props.id,
      _props$leaveDelay = props.leaveDelay,
      leaveDelay = _props$leaveDelay === void 0 ? 0 : _props$leaveDelay,
      _props$leaveTouchDela = props.leaveTouchDelay,
      leaveTouchDelay = _props$leaveTouchDela === void 0 ? 1500 : _props$leaveTouchDela,
      onClose = props.onClose,
      onOpen = props.onOpen,
      openProp = props.open,
      _props$placement = props.placement,
      placement = _props$placement === void 0 ? 'bottom' : _props$placement,
      PopperComponentProp = props.PopperComponent,
      _props$PopperProps = props.PopperProps,
      PopperProps = _props$PopperProps === void 0 ? {} : _props$PopperProps,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      title = props.title,
      _props$TransitionComp = props.TransitionComponent,
      TransitionComponentProp = _props$TransitionComp === void 0 ? Grow$1 : _props$TransitionComp,
      TransitionProps = props.TransitionProps,
      other = _objectWithoutProperties(props, ["arrow", "children", "classes", "components", "componentsProps", "describeChild", "disableFocusListener", "disableHoverListener", "disableInteractive", "disableTouchListener", "enterDelay", "enterNextDelay", "enterTouchDelay", "followCursor", "id", "leaveDelay", "leaveTouchDelay", "onClose", "onOpen", "open", "placement", "PopperComponent", "PopperProps", "slotProps", "slots", "title", "TransitionComponent", "TransitionProps"]); // to prevent runtime errors, developers will need to provide a child as a React element anyway.
    var children = /*#__PURE__*/React__namespace.isValidElement(childrenProp) ? childrenProp : /*#__PURE__*/jsxRuntimeExports.jsx("span", {
      children: childrenProp
    });
    var theme = useTheme();
    var isRtl = useRtl();
    var _React$useState = React__namespace.useState(),
      childNode = _React$useState[0],
      setChildNode = _React$useState[1];
    var _React$useState2 = React__namespace.useState(null),
      arrowRef = _React$useState2[0],
      setArrowRef = _React$useState2[1];
    var ignoreNonTouchEvents = React__namespace.useRef(false);
    var disableInteractive = disableInteractiveProp || followCursor;
    var closeTimer = useTimeout();
    var enterTimer = useTimeout();
    var leaveTimer = useTimeout();
    var touchTimer = useTimeout();
    var _useControlled = useControlled({
        controlled: openProp,
        "default": false,
        name: 'Tooltip',
        state: 'open'
      }),
      _useControlled2 = _slicedToArray(_useControlled, 2),
      openState = _useControlled2[0],
      setOpenState = _useControlled2[1];
    var open = openState;
    {
      // eslint-disable-next-line react-hooks/rules-of-hooks
      var _React$useRef = React__namespace.useRef(openProp !== undefined),
        isControlled = _React$useRef.current; // eslint-disable-next-line react-hooks/rules-of-hooks
      React__namespace.useEffect(function () {
        if (childNode && childNode.disabled && !isControlled && title !== '' && childNode.tagName.toLowerCase() === 'button') {
          console.error(['MUI: You are providing a disabled `button` child to the Tooltip component.', 'A disabled element does not fire events.', "Tooltip needs to listen to the child element's events to display the title.", '', 'Add a simple wrapper element, such as a `span`.'].join('\n'));
        }
      }, [title, childNode, isControlled]);
    }
    var id = useId(idProp);
    var prevUserSelect = React__namespace.useRef();
    var stopTouchInteraction = useEventCallback(function () {
      if (prevUserSelect.current !== undefined) {
        document.body.style.WebkitUserSelect = prevUserSelect.current;
        prevUserSelect.current = undefined;
      }
      touchTimer.clear();
    });
    React__namespace.useEffect(function () {
      return stopTouchInteraction;
    }, [stopTouchInteraction]);
    var handleOpen = function handleOpen(event) {
      hystersisTimer.clear();
      hystersisOpen = true;

      // The mouseover event will trigger for every nested element in the tooltip.
      // We can skip rerendering when the tooltip is already open.
      // We are using the mouseover event instead of the mouseenter event to fix a hide/show issue.
      setOpenState(true);
      if (onOpen && !open) {
        onOpen(event);
      }
    };
    var handleClose = useEventCallback(
    /**
     * @param {React.SyntheticEvent | Event} event
     */
    function (event) {
      hystersisTimer.start(800 + leaveDelay, function () {
        hystersisOpen = false;
      });
      setOpenState(false);
      if (onClose && open) {
        onClose(event);
      }
      closeTimer.start(theme.transitions.duration.shortest, function () {
        ignoreNonTouchEvents.current = false;
      });
    });
    var handleMouseOver = function handleMouseOver(event) {
      if (ignoreNonTouchEvents.current && event.type !== 'touchstart') {
        return;
      }

      // Remove the title ahead of time.
      // We don't want to wait for the next render commit.
      // We would risk displaying two tooltips at the same time (native + this one).
      if (childNode) {
        childNode.removeAttribute('title');
      }
      enterTimer.clear();
      leaveTimer.clear();
      if (enterDelay || hystersisOpen && enterNextDelay) {
        enterTimer.start(hystersisOpen ? enterNextDelay : enterDelay, function () {
          handleOpen(event);
        });
      } else {
        handleOpen(event);
      }
    };
    var handleMouseLeave = function handleMouseLeave(event) {
      enterTimer.clear();
      leaveTimer.start(leaveDelay, function () {
        handleClose(event);
      });
    };
    var _useIsFocusVisible = useIsFocusVisible(),
      isFocusVisibleRef = _useIsFocusVisible.isFocusVisibleRef,
      handleBlurVisible = _useIsFocusVisible.onBlur,
      handleFocusVisible = _useIsFocusVisible.onFocus,
      focusVisibleRef = _useIsFocusVisible.ref; // We don't necessarily care about the focusVisible state (which is safe to access via ref anyway).
    // We just need to re-render the Tooltip if the focus-visible state changes.
    var _React$useState3 = React__namespace.useState(false),
      setChildIsFocusVisible = _React$useState3[1];
    var handleBlur = function handleBlur(event) {
      handleBlurVisible(event);
      if (isFocusVisibleRef.current === false) {
        setChildIsFocusVisible(false);
        handleMouseLeave(event);
      }
    };
    var handleFocus = function handleFocus(event) {
      // Workaround for https://github.com/facebook/react/issues/7769
      // The autoFocus of React might trigger the event before the componentDidMount.
      // We need to account for this eventuality.
      if (!childNode) {
        setChildNode(event.currentTarget);
      }
      handleFocusVisible(event);
      if (isFocusVisibleRef.current === true) {
        setChildIsFocusVisible(true);
        handleMouseOver(event);
      }
    };
    var detectTouchStart = function detectTouchStart(event) {
      ignoreNonTouchEvents.current = true;
      var childrenProps = children.props;
      if (childrenProps.onTouchStart) {
        childrenProps.onTouchStart(event);
      }
    };
    var handleTouchStart = function handleTouchStart(event) {
      detectTouchStart(event);
      leaveTimer.clear();
      closeTimer.clear();
      stopTouchInteraction();
      prevUserSelect.current = document.body.style.WebkitUserSelect;
      // Prevent iOS text selection on long-tap.
      document.body.style.WebkitUserSelect = 'none';
      touchTimer.start(enterTouchDelay, function () {
        document.body.style.WebkitUserSelect = prevUserSelect.current;
        handleMouseOver(event);
      });
    };
    var handleTouchEnd = function handleTouchEnd(event) {
      if (children.props.onTouchEnd) {
        children.props.onTouchEnd(event);
      }
      stopTouchInteraction();
      leaveTimer.start(leaveTouchDelay, function () {
        handleClose(event);
      });
    };
    React__namespace.useEffect(function () {
      if (!open) {
        return undefined;
      }

      /**
       * @param {KeyboardEvent} nativeEvent
       */
      function handleKeyDown(nativeEvent) {
        // IE11, Edge (prior to using Bink?) use 'Esc'
        if (nativeEvent.key === 'Escape' || nativeEvent.key === 'Esc') {
          handleClose(nativeEvent);
        }
      }
      document.addEventListener('keydown', handleKeyDown);
      return function () {
        document.removeEventListener('keydown', handleKeyDown);
      };
    }, [handleClose, open]);
    var handleRef = useForkRef(getReactElementRef(children), focusVisibleRef, setChildNode, ref);

    // There is no point in displaying an empty tooltip.
    // So we exclude all falsy values, except 0, which is valid.
    if (!title && title !== 0) {
      open = false;
    }
    var popperRef = React__namespace.useRef();
    var handleMouseMove = function handleMouseMove(event) {
      var childrenProps = children.props;
      if (childrenProps.onMouseMove) {
        childrenProps.onMouseMove(event);
      }
      cursorPosition = {
        x: event.clientX,
        y: event.clientY
      };
      if (popperRef.current) {
        popperRef.current.update();
      }
    };
    var nameOrDescProps = {};
    var titleIsString = typeof title === 'string';
    if (describeChild) {
      nameOrDescProps.title = !open && titleIsString && !disableHoverListener ? title : null;
      nameOrDescProps['aria-describedby'] = open ? id : null;
    } else {
      nameOrDescProps['aria-label'] = titleIsString ? title : null;
      nameOrDescProps['aria-labelledby'] = open && !titleIsString ? id : null;
    }
    var childrenProps = _extends({}, nameOrDescProps, other, children.props, {
      className: clsx(other.className, children.props.className),
      onTouchStart: detectTouchStart,
      ref: handleRef
    }, followCursor ? {
      onMouseMove: handleMouseMove
    } : {});
    {
      childrenProps['data-mui-internal-clone-element'] = true;

      // eslint-disable-next-line react-hooks/rules-of-hooks
      React__namespace.useEffect(function () {
        if (childNode && !childNode.getAttribute('data-mui-internal-clone-element')) {
          console.error(['MUI: The `children` component of the Tooltip is not forwarding its props correctly.', 'Please make sure that props are spread on the same element that the ref is applied to.'].join('\n'));
        }
      }, [childNode]);
    }
    var interactiveWrapperListeners = {};
    if (!disableTouchListener) {
      childrenProps.onTouchStart = handleTouchStart;
      childrenProps.onTouchEnd = handleTouchEnd;
    }
    if (!disableHoverListener) {
      childrenProps.onMouseOver = composeEventHandler(handleMouseOver, childrenProps.onMouseOver);
      childrenProps.onMouseLeave = composeEventHandler(handleMouseLeave, childrenProps.onMouseLeave);
      if (!disableInteractive) {
        interactiveWrapperListeners.onMouseOver = handleMouseOver;
        interactiveWrapperListeners.onMouseLeave = handleMouseLeave;
      }
    }
    if (!disableFocusListener) {
      childrenProps.onFocus = composeEventHandler(handleFocus, childrenProps.onFocus);
      childrenProps.onBlur = composeEventHandler(handleBlur, childrenProps.onBlur);
      if (!disableInteractive) {
        interactiveWrapperListeners.onFocus = handleFocus;
        interactiveWrapperListeners.onBlur = handleBlur;
      }
    }
    {
      if (children.props.title) {
        console.error(['MUI: You have provided a `title` prop to the child of <Tooltip />.', "Remove this title prop `".concat(children.props.title, "` or the Tooltip component.")].join('\n'));
      }
    }
    var popperOptions = React__namespace.useMemo(function () {
      var _PopperProps$popperOp;
      var tooltipModifiers = [{
        name: 'arrow',
        enabled: Boolean(arrowRef),
        options: {
          element: arrowRef,
          padding: 4
        }
      }];
      if ((_PopperProps$popperOp = PopperProps.popperOptions) != null && _PopperProps$popperOp.modifiers) {
        tooltipModifiers = tooltipModifiers.concat(PopperProps.popperOptions.modifiers);
      }
      return _extends({}, PopperProps.popperOptions, {
        modifiers: tooltipModifiers
      });
    }, [arrowRef, PopperProps]);
    var ownerState = _extends({}, props, {
      isRtl: isRtl,
      arrow: arrow,
      disableInteractive: disableInteractive,
      placement: placement,
      PopperComponentProp: PopperComponentProp,
      touch: ignoreNonTouchEvents.current
    });
    var classes = useUtilityClasses$q(ownerState);
    var PopperComponent = (_ref5 = (_slots$popper = slots.popper) != null ? _slots$popper : components.Popper) != null ? _ref5 : TooltipPopper;
    var TransitionComponent = (_ref6 = (_ref7 = (_slots$transition = slots.transition) != null ? _slots$transition : components.Transition) != null ? _ref7 : TransitionComponentProp) != null ? _ref6 : Grow$1;
    var TooltipComponent = (_ref8 = (_slots$tooltip = slots.tooltip) != null ? _slots$tooltip : components.Tooltip) != null ? _ref8 : TooltipTooltip;
    var ArrowComponent = (_ref9 = (_slots$arrow = slots.arrow) != null ? _slots$arrow : components.Arrow) != null ? _ref9 : TooltipArrow;
    var popperProps = appendOwnerState(PopperComponent, _extends({}, PopperProps, (_slotProps$popper = slotProps.popper) != null ? _slotProps$popper : componentsProps.popper, {
      className: clsx(classes.popper, PopperProps == null ? void 0 : PopperProps.className, (_ref10 = (_slotProps$popper2 = slotProps.popper) != null ? _slotProps$popper2 : componentsProps.popper) == null ? void 0 : _ref10.className)
    }), ownerState);
    var transitionProps = appendOwnerState(TransitionComponent, _extends({}, TransitionProps, (_slotProps$transition = slotProps.transition) != null ? _slotProps$transition : componentsProps.transition), ownerState);
    var tooltipProps = appendOwnerState(TooltipComponent, _extends({}, (_slotProps$tooltip = slotProps.tooltip) != null ? _slotProps$tooltip : componentsProps.tooltip, {
      className: clsx(classes.tooltip, (_ref11 = (_slotProps$tooltip2 = slotProps.tooltip) != null ? _slotProps$tooltip2 : componentsProps.tooltip) == null ? void 0 : _ref11.className)
    }), ownerState);
    var tooltipArrowProps = appendOwnerState(ArrowComponent, _extends({}, (_slotProps$arrow = slotProps.arrow) != null ? _slotProps$arrow : componentsProps.arrow, {
      className: clsx(classes.arrow, (_ref12 = (_slotProps$arrow2 = slotProps.arrow) != null ? _slotProps$arrow2 : componentsProps.arrow) == null ? void 0 : _ref12.className)
    }), ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
      children: [/*#__PURE__*/React__namespace.cloneElement(children, childrenProps), /*#__PURE__*/jsxRuntimeExports.jsx(PopperComponent, _extends({
        as: PopperComponentProp != null ? PopperComponentProp : Popper$1,
        placement: placement,
        anchorEl: followCursor ? {
          getBoundingClientRect: function getBoundingClientRect() {
            return {
              top: cursorPosition.y,
              left: cursorPosition.x,
              right: cursorPosition.x,
              bottom: cursorPosition.y,
              width: 0,
              height: 0
            };
          }
        } : childNode,
        popperRef: popperRef,
        open: childNode ? open : false,
        id: id,
        transition: true
      }, interactiveWrapperListeners, popperProps, {
        popperOptions: popperOptions,
        children: function children(_ref13) {
          var TransitionPropsInner = _ref13.TransitionProps;
          return /*#__PURE__*/jsxRuntimeExports.jsx(TransitionComponent, _extends({
            timeout: theme.transitions.duration.shorter
          }, TransitionPropsInner, transitionProps, {
            children: /*#__PURE__*/jsxRuntimeExports.jsxs(TooltipComponent, _extends({}, tooltipProps, {
              children: [title, arrow ? /*#__PURE__*/jsxRuntimeExports.jsx(ArrowComponent, _extends({}, tooltipArrowProps, {
                ref: setArrowRef
              })) : null]
            }))
          }));
        }
      }))]
    });
  });
  Tooltip.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * If `true`, adds an arrow to the tooltip.
     * @default false
     */
    arrow: PropTypes.bool,
    /**
     * Tooltip reference element.
     */
    children: elementAcceptingRef$1.isRequired,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `slots` prop.
     * It's recommended to use the `slots` prop instead.
     *
     * @default {}
     */
    components: PropTypes.shape({
      Arrow: PropTypes.elementType,
      Popper: PropTypes.elementType,
      Tooltip: PropTypes.elementType,
      Transition: PropTypes.elementType
    }),
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `slotProps` prop.
     * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.
     *
     * @default {}
     */
    componentsProps: PropTypes.shape({
      arrow: PropTypes.object,
      popper: PropTypes.object,
      tooltip: PropTypes.object,
      transition: PropTypes.object
    }),
    /**
     * Set to `true` if the `title` acts as an accessible description.
     * By default the `title` acts as an accessible label for the child.
     * @default false
     */
    describeChild: PropTypes.bool,
    /**
     * Do not respond to focus-visible events.
     * @default false
     */
    disableFocusListener: PropTypes.bool,
    /**
     * Do not respond to hover events.
     * @default false
     */
    disableHoverListener: PropTypes.bool,
    /**
     * Makes a tooltip not interactive, i.e. it will close when the user
     * hovers over the tooltip before the `leaveDelay` is expired.
     * @default false
     */
    disableInteractive: PropTypes.bool,
    /**
     * Do not respond to long press touch events.
     * @default false
     */
    disableTouchListener: PropTypes.bool,
    /**
     * The number of milliseconds to wait before showing the tooltip.
     * This prop won't impact the enter touch delay (`enterTouchDelay`).
     * @default 100
     */
    enterDelay: PropTypes.number,
    /**
     * The number of milliseconds to wait before showing the tooltip when one was already recently opened.
     * @default 0
     */
    enterNextDelay: PropTypes.number,
    /**
     * The number of milliseconds a user must touch the element before showing the tooltip.
     * @default 700
     */
    enterTouchDelay: PropTypes.number,
    /**
     * If `true`, the tooltip follow the cursor over the wrapped element.
     * @default false
     */
    followCursor: PropTypes.bool,
    /**
     * This prop is used to help implement the accessibility logic.
     * If you don't provide this prop. It falls back to a randomly generated id.
     */
    id: PropTypes.string,
    /**
     * The number of milliseconds to wait before hiding the tooltip.
     * This prop won't impact the leave touch delay (`leaveTouchDelay`).
     * @default 0
     */
    leaveDelay: PropTypes.number,
    /**
     * The number of milliseconds after the user stops touching an element before hiding the tooltip.
     * @default 1500
     */
    leaveTouchDelay: PropTypes.number,
    /**
     * Callback fired when the component requests to be closed.
     *
     * @param {React.SyntheticEvent} event The event source of the callback.
     */
    onClose: PropTypes.func,
    /**
     * Callback fired when the component requests to be open.
     *
     * @param {React.SyntheticEvent} event The event source of the callback.
     */
    onOpen: PropTypes.func,
    /**
     * If `true`, the component is shown.
     */
    open: PropTypes.bool,
    /**
     * Tooltip placement.
     * @default 'bottom'
     */
    placement: PropTypes.oneOf(['bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
    /**
     * The component used for the popper.
     * @default Popper
     */
    PopperComponent: PropTypes.elementType,
    /**
     * Props applied to the [`Popper`](/material-ui/api/popper/) element.
     * @default {}
     */
    PopperProps: PropTypes.object,
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     *
     * This prop is an alias for the `componentsProps` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slotProps: PropTypes.shape({
      arrow: PropTypes.object,
      popper: PropTypes.object,
      tooltip: PropTypes.object,
      transition: PropTypes.object
    }),
    /**
     * The components used for each slot inside.
     *
     * This prop is an alias for the `components` prop, which will be deprecated in the future.
     *
     * @default {}
     */
    slots: PropTypes.shape({
      arrow: PropTypes.elementType,
      popper: PropTypes.elementType,
      tooltip: PropTypes.elementType,
      transition: PropTypes.elementType
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * Tooltip title. Zero-length titles string, undefined, null and false are never displayed.
     */
    title: PropTypes.node,
    /**
     * The component used for the transition.
     * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
     * @default Grow
     */
    TransitionComponent: PropTypes.elementType,
    /**
     * Props applied to the transition element.
     * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
     */
    TransitionProps: PropTypes.object
  } ;
  var Tooltip$1 = Tooltip;

  function getSpeedDialActionUtilityClass(slot) {
    return generateUtilityClass('MuiSpeedDialAction', slot);
  }
  var speedDialActionClasses = generateUtilityClasses('MuiSpeedDialAction', ['fab', 'fabClosed', 'staticTooltip', 'staticTooltipClosed', 'staticTooltipLabel', 'tooltipPlacementLeft', 'tooltipPlacementRight']);
  var speedDialActionClasses$1 = speedDialActionClasses;

  var useUtilityClasses$p = function useUtilityClasses(ownerState) {
    var open = ownerState.open,
      tooltipPlacement = ownerState.tooltipPlacement,
      classes = ownerState.classes;
    var slots = {
      fab: ['fab', !open && 'fabClosed'],
      staticTooltip: ['staticTooltip', "tooltipPlacement".concat(capitalize(tooltipPlacement)), !open && 'staticTooltipClosed'],
      staticTooltipLabel: ['staticTooltipLabel']
    };
    return composeClasses(slots, getSpeedDialActionUtilityClass, classes);
  };
  var SpeedDialActionFab = styled$1(Fab$1, {
    name: 'MuiSpeedDialAction',
    slot: 'Fab',
    skipVariantsResolver: false,
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.fab, !ownerState.open && styles.fabClosed];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      margin: 8,
      color: (theme.vars || theme).palette.text.secondary,
      backgroundColor: (theme.vars || theme).palette.background.paper,
      '&:hover': {
        backgroundColor: theme.vars ? theme.vars.palette.SpeedDialAction.fabHoverBg : emphasize(theme.palette.background.paper, 0.15)
      },
      transition: "".concat(theme.transitions.create('transform', {
        duration: theme.transitions.duration.shorter
      }), ", opacity 0.8s"),
      opacity: 1
    }, !ownerState.open && {
      opacity: 0,
      transform: 'scale(0)'
    });
  });
  var SpeedDialActionStaticTooltip = styled$1('span', {
    name: 'MuiSpeedDialAction',
    slot: 'StaticTooltip',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.staticTooltip, !ownerState.open && styles.staticTooltipClosed, styles["tooltipPlacement".concat(capitalize(ownerState.tooltipPlacement))]];
    }
  })(function (_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    return _defineProperty({
      position: 'relative',
      display: 'flex',
      alignItems: 'center'
    }, "& .".concat(speedDialActionClasses$1.staticTooltipLabel), _extends({
      transition: theme.transitions.create(['transform', 'opacity'], {
        duration: theme.transitions.duration.shorter
      }),
      opacity: 1
    }, !ownerState.open && {
      opacity: 0,
      transform: 'scale(0.5)'
    }, ownerState.tooltipPlacement === 'left' && {
      transformOrigin: '100% 50%',
      right: '100%',
      marginRight: 8
    }, ownerState.tooltipPlacement === 'right' && {
      transformOrigin: '0% 50%',
      left: '100%',
      marginLeft: 8
    }));
  });
  var SpeedDialActionStaticTooltipLabel = styled$1('span', {
    name: 'MuiSpeedDialAction',
    slot: 'StaticTooltipLabel',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.staticTooltipLabel;
    }
  })(function (_ref4) {
    var theme = _ref4.theme;
    return _extends({
      position: 'absolute'
    }, theme.typography.body1, {
      backgroundColor: (theme.vars || theme).palette.background.paper,
      borderRadius: (theme.vars || theme).shape.borderRadius,
      boxShadow: (theme.vars || theme).shadows[1],
      color: (theme.vars || theme).palette.text.secondary,
      padding: '4px 16px',
      wordBreak: 'keep-all'
    });
  });
  var SpeedDialAction = /*#__PURE__*/React__namespace.forwardRef(function SpeedDialAction(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiSpeedDialAction'
    });
    var className = props.className,
      _props$delay = props.delay,
      delay = _props$delay === void 0 ? 0 : _props$delay,
      _props$FabProps = props.FabProps,
      FabProps = _props$FabProps === void 0 ? {} : _props$FabProps,
      icon = props.icon,
      id = props.id,
      open = props.open,
      TooltipClasses = props.TooltipClasses,
      _props$tooltipOpen = props.tooltipOpen,
      tooltipOpenProp = _props$tooltipOpen === void 0 ? false : _props$tooltipOpen,
      _props$tooltipPlaceme = props.tooltipPlacement,
      tooltipPlacement = _props$tooltipPlaceme === void 0 ? 'left' : _props$tooltipPlaceme,
      tooltipTitle = props.tooltipTitle,
      other = _objectWithoutProperties(props, ["className", "delay", "FabProps", "icon", "id", "open", "TooltipClasses", "tooltipOpen", "tooltipPlacement", "tooltipTitle"]);
    var ownerState = _extends({}, props, {
      tooltipPlacement: tooltipPlacement
    });
    var classes = useUtilityClasses$p(ownerState);
    var _React$useState = React__namespace.useState(tooltipOpenProp),
      tooltipOpen = _React$useState[0],
      setTooltipOpen = _React$useState[1];
    var handleTooltipClose = function handleTooltipClose() {
      setTooltipOpen(false);
    };
    var handleTooltipOpen = function handleTooltipOpen() {
      setTooltipOpen(true);
    };
    var transitionStyle = {
      transitionDelay: "".concat(delay, "ms")
    };
    var fab = /*#__PURE__*/jsxRuntimeExports.jsx(SpeedDialActionFab, _extends({
      size: "small",
      className: clsx(classes.fab, className),
      tabIndex: -1,
      role: "menuitem",
      ownerState: ownerState
    }, FabProps, {
      style: _extends({}, transitionStyle, FabProps.style),
      children: icon
    }));
    if (tooltipOpenProp) {
      return /*#__PURE__*/jsxRuntimeExports.jsxs(SpeedDialActionStaticTooltip, _extends({
        id: id,
        ref: ref,
        className: classes.staticTooltip,
        ownerState: ownerState
      }, other, {
        children: [/*#__PURE__*/jsxRuntimeExports.jsx(SpeedDialActionStaticTooltipLabel, {
          style: transitionStyle,
          id: "".concat(id, "-label"),
          className: classes.staticTooltipLabel,
          ownerState: ownerState,
          children: tooltipTitle
        }), /*#__PURE__*/React__namespace.cloneElement(fab, {
          'aria-labelledby': "".concat(id, "-label")
        })]
      }));
    }
    if (!open && tooltipOpen) {
      setTooltipOpen(false);
    }
    return /*#__PURE__*/jsxRuntimeExports.jsx(Tooltip$1, _extends({
      id: id,
      ref: ref,
      title: tooltipTitle,
      placement: tooltipPlacement,
      onClose: handleTooltipClose,
      onOpen: handleTooltipOpen,
      open: open && tooltipOpen,
      classes: TooltipClasses
    }, other, {
      children: fab
    }));
  });
  SpeedDialAction.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * Adds a transition delay, to allow a series of SpeedDialActions to be animated.
     * @default 0
     */
    delay: PropTypes.number,
    /**
     * Props applied to the [`Fab`](/material-ui/api/fab/) component.
     * @default {}
     */
    FabProps: PropTypes.object,
    /**
     * The icon to display in the SpeedDial Fab.
     */
    icon: PropTypes.node,
    /**
     * This prop is used to help implement the accessibility logic.
     * If you don't provide this prop. It falls back to a randomly generated id.
     */
    id: PropTypes.string,
    /**
     * If `true`, the component is shown.
     */
    open: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * `classes` prop applied to the [`Tooltip`](/material-ui/api/tooltip/) element.
     */
    TooltipClasses: PropTypes.object,
    /**
     * Make the tooltip always visible when the SpeedDial is open.
     * @default false
     */
    tooltipOpen: PropTypes.bool,
    /**
     * Placement of the tooltip.
     * @default 'left'
     */
    tooltipPlacement: PropTypes.oneOf(['bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
    /**
     * Label to display in the tooltip.
     */
    tooltipTitle: PropTypes.node
  } ;
  var SpeedDialAction$1 = SpeedDialAction;

  var AddIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"
  }), 'Add');

  function getSpeedDialIconUtilityClass(slot) {
    return generateUtilityClass('MuiSpeedDialIcon', slot);
  }
  var speedDialIconClasses = generateUtilityClasses('MuiSpeedDialIcon', ['root', 'icon', 'iconOpen', 'iconWithOpenIconOpen', 'openIcon', 'openIconOpen']);
  var speedDialIconClasses$1 = speedDialIconClasses;

  var useUtilityClasses$o = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      open = ownerState.open,
      openIcon = ownerState.openIcon;
    var slots = {
      root: ['root'],
      icon: ['icon', open && 'iconOpen', openIcon && open && 'iconWithOpenIconOpen'],
      openIcon: ['openIcon', open && 'openIconOpen']
    };
    return composeClasses(slots, getSpeedDialIconUtilityClass, classes);
  };
  var SpeedDialIconRoot = styled$1('span', {
    name: 'MuiSpeedDialIcon',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [_defineProperty({}, "& .".concat(speedDialIconClasses$1.icon), styles.icon), _defineProperty({}, "& .".concat(speedDialIconClasses$1.icon), ownerState.open && styles.iconOpen), _defineProperty({}, "& .".concat(speedDialIconClasses$1.icon), ownerState.open && ownerState.openIcon && styles.iconWithOpenIconOpen), _defineProperty({}, "& .".concat(speedDialIconClasses$1.openIcon), styles.openIcon), _defineProperty({}, "& .".concat(speedDialIconClasses$1.openIcon), ownerState.open && styles.openIconOpen), styles.root];
    }
  })(function (_ref6) {
    var theme = _ref6.theme,
      ownerState = _ref6.ownerState;
    return _defineProperty(_defineProperty({
      height: 24
    }, "& .".concat(speedDialIconClasses$1.icon), _extends({
      transition: theme.transitions.create(['transform', 'opacity'], {
        duration: theme.transitions.duration["short"]
      })
    }, ownerState.open && _extends({
      transform: 'rotate(45deg)'
    }, ownerState.openIcon && {
      opacity: 0
    }))), "& .".concat(speedDialIconClasses$1.openIcon), _extends({
      position: 'absolute',
      transition: theme.transitions.create(['transform', 'opacity'], {
        duration: theme.transitions.duration["short"]
      }),
      opacity: 0,
      transform: 'rotate(-45deg)'
    }, ownerState.open && {
      transform: 'rotate(0deg)',
      opacity: 1
    }));
  });
  var SpeedDialIcon = /*#__PURE__*/React__namespace.forwardRef(function SpeedDialIcon(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiSpeedDialIcon'
    });
    var className = props.className,
      iconProp = props.icon;
      props.open;
      var openIconProp = props.openIcon,
      other = _objectWithoutProperties(props, ["className", "icon", "open", "openIcon"]);
    var ownerState = props;
    var classes = useUtilityClasses$o(ownerState);
    function formatIcon(icon, newClassName) {
      if ( /*#__PURE__*/React__namespace.isValidElement(icon)) {
        return /*#__PURE__*/React__namespace.cloneElement(icon, {
          className: newClassName
        });
      }
      return icon;
    }
    return /*#__PURE__*/jsxRuntimeExports.jsxs(SpeedDialIconRoot, _extends({
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState
    }, other, {
      children: [openIconProp ? formatIcon(openIconProp, classes.openIcon) : null, iconProp ? formatIcon(iconProp, classes.icon) : /*#__PURE__*/jsxRuntimeExports.jsx(AddIcon, {
        className: classes.icon
      })]
    }));
  });
  SpeedDialIcon.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The icon to display.
     */
    icon: PropTypes.node,
    /**
     * @ignore
     * If `true`, the component is shown.
     */
    open: PropTypes.bool,
    /**
     * The icon to display in the SpeedDial Floating Action Button when the SpeedDial is open.
     */
    openIcon: PropTypes.node,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  SpeedDialIcon.muiName = 'SpeedDialIcon';
  var SpeedDialIcon$1 = SpeedDialIcon;

  /**
   * Provides information about the current step in Stepper.
   */
  var StepperContext = /*#__PURE__*/React__namespace.createContext({});
  {
    StepperContext.displayName = 'StepperContext';
  }

  /**
   * Returns the current StepperContext or an empty object if no StepperContext
   * has been defined in the component tree.
   */
  function useStepperContext() {
    return React__namespace.useContext(StepperContext);
  }
  var StepperContext$1 = StepperContext;

  /**
   * Provides information about the current step in Stepper.
   */
  var StepContext = /*#__PURE__*/React__namespace.createContext({});
  {
    StepContext.displayName = 'StepContext';
  }

  /**
   * Returns the current StepContext or an empty object if no StepContext
   * has been defined in the component tree.
   */
  function useStepContext() {
    return React__namespace.useContext(StepContext);
  }
  var StepContext$1 = StepContext;

  function getStepUtilityClass(slot) {
    return generateUtilityClass('MuiStep', slot);
  }
  var stepClasses = generateUtilityClasses('MuiStep', ['root', 'horizontal', 'vertical', 'alternativeLabel', 'completed']);
  var stepClasses$1 = stepClasses;

  var useUtilityClasses$n = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      orientation = ownerState.orientation,
      alternativeLabel = ownerState.alternativeLabel,
      completed = ownerState.completed;
    var slots = {
      root: ['root', orientation, alternativeLabel && 'alternativeLabel', completed && 'completed']
    };
    return composeClasses(slots, getStepUtilityClass, classes);
  };
  var StepRoot = styled$1('div', {
    name: 'MuiStep',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.orientation], ownerState.alternativeLabel && styles.alternativeLabel, ownerState.completed && styles.completed];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends({}, ownerState.orientation === 'horizontal' && {
      paddingLeft: 8,
      paddingRight: 8
    }, ownerState.alternativeLabel && {
      flex: 1,
      position: 'relative'
    });
  });
  var Step = /*#__PURE__*/React__namespace.forwardRef(function Step(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiStep'
    });
    var activeProp = props.active,
      children = props.children,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      completedProp = props.completed,
      disabledProp = props.disabled,
      _props$expanded = props.expanded,
      expanded = _props$expanded === void 0 ? false : _props$expanded,
      index = props.index,
      last = props.last,
      other = _objectWithoutProperties(props, ["active", "children", "className", "component", "completed", "disabled", "expanded", "index", "last"]);
    var _React$useContext = React__namespace.useContext(StepperContext$1),
      activeStep = _React$useContext.activeStep,
      connector = _React$useContext.connector,
      alternativeLabel = _React$useContext.alternativeLabel,
      orientation = _React$useContext.orientation,
      nonLinear = _React$useContext.nonLinear;
    var _activeProp = activeProp,
      active = _activeProp === void 0 ? false : _activeProp,
      _completedProp = completedProp,
      completed = _completedProp === void 0 ? false : _completedProp,
      _disabledProp = disabledProp,
      disabled = _disabledProp === void 0 ? false : _disabledProp;
    if (activeStep === index) {
      active = activeProp !== undefined ? activeProp : true;
    } else if (!nonLinear && activeStep > index) {
      completed = completedProp !== undefined ? completedProp : true;
    } else if (!nonLinear && activeStep < index) {
      disabled = disabledProp !== undefined ? disabledProp : true;
    }
    var contextValue = React__namespace.useMemo(function () {
      return {
        index: index,
        last: last,
        expanded: expanded,
        icon: index + 1,
        active: active,
        completed: completed,
        disabled: disabled
      };
    }, [index, last, expanded, active, completed, disabled]);
    var ownerState = _extends({}, props, {
      active: active,
      orientation: orientation,
      alternativeLabel: alternativeLabel,
      completed: completed,
      disabled: disabled,
      expanded: expanded,
      component: component
    });
    var classes = useUtilityClasses$n(ownerState);
    var newChildren = /*#__PURE__*/jsxRuntimeExports.jsxs(StepRoot, _extends({
      as: component,
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState
    }, other, {
      children: [connector && alternativeLabel && index !== 0 ? connector : null, children]
    }));
    return /*#__PURE__*/jsxRuntimeExports.jsx(StepContext$1.Provider, {
      value: contextValue,
      children: connector && !alternativeLabel && index !== 0 ? /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
        children: [connector, newChildren]
      }) : newChildren
    });
  });
  Step.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Sets the step as active. Is passed to child components.
     */
    active: PropTypes.bool,
    /**
     * Should be `Step` sub-components such as `StepLabel`, `StepContent`.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * Mark the step as completed. Is passed to child components.
     */
    completed: PropTypes.bool,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, the step is disabled, will also disable the button if
     * `StepButton` is a child of `Step`. Is passed to child components.
     */
    disabled: PropTypes.bool,
    /**
     * Expand the step.
     * @default false
     */
    expanded: PropTypes.bool,
    /**
     * The position of the step.
     * The prop defaults to the value inherited from the parent Stepper component.
     */
    index: integerPropType,
    /**
     * If `true`, the Step is displayed as rendered last.
     * The prop defaults to the value inherited from the parent Stepper component.
     */
    last: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var Step$1 = Step;

  var CheckCircle = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M12 0a12 12 0 1 0 0 24 12 12 0 0 0 0-24zm-2 17l-5-5 1.4-1.4 3.6 3.6 7.6-7.6L19 8l-9 9z"
  }), 'CheckCircle');

  var Warning = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"
  }), 'Warning');

  function getStepIconUtilityClass(slot) {
    return generateUtilityClass('MuiStepIcon', slot);
  }
  var stepIconClasses = generateUtilityClasses('MuiStepIcon', ['root', 'active', 'completed', 'error', 'text']);
  var stepIconClasses$1 = stepIconClasses;

  var _circle;
  var useUtilityClasses$m = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      active = ownerState.active,
      completed = ownerState.completed,
      error = ownerState.error;
    var slots = {
      root: ['root', active && 'active', completed && 'completed', error && 'error'],
      text: ['text']
    };
    return composeClasses(slots, getStepIconUtilityClass, classes);
  };
  var StepIconRoot = styled$1(SvgIcon$1, {
    name: 'MuiStepIcon',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })(function (_ref) {
    var theme = _ref.theme;
    return _defineProperty(_defineProperty(_defineProperty({
      display: 'block',
      transition: theme.transitions.create('color', {
        duration: theme.transitions.duration.shortest
      }),
      color: (theme.vars || theme).palette.text.disabled
    }, "&.".concat(stepIconClasses$1.completed), {
      color: (theme.vars || theme).palette.primary.main
    }), "&.".concat(stepIconClasses$1.active), {
      color: (theme.vars || theme).palette.primary.main
    }), "&.".concat(stepIconClasses$1.error), {
      color: (theme.vars || theme).palette.error.main
    });
  });
  var StepIconText = styled$1('text', {
    name: 'MuiStepIcon',
    slot: 'Text',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.text;
    }
  })(function (_ref3) {
    var theme = _ref3.theme;
    return {
      fill: (theme.vars || theme).palette.primary.contrastText,
      fontSize: theme.typography.caption.fontSize,
      fontFamily: theme.typography.fontFamily
    };
  });
  var StepIcon = /*#__PURE__*/React__namespace.forwardRef(function StepIcon(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiStepIcon'
    });
    var _props$active = props.active,
      active = _props$active === void 0 ? false : _props$active,
      classNameProp = props.className,
      _props$completed = props.completed,
      completed = _props$completed === void 0 ? false : _props$completed,
      _props$error = props.error,
      error = _props$error === void 0 ? false : _props$error,
      icon = props.icon,
      other = _objectWithoutProperties(props, ["active", "className", "completed", "error", "icon"]);
    var ownerState = _extends({}, props, {
      active: active,
      completed: completed,
      error: error
    });
    var classes = useUtilityClasses$m(ownerState);
    if (typeof icon === 'number' || typeof icon === 'string') {
      var className = clsx(classNameProp, classes.root);
      if (error) {
        return /*#__PURE__*/jsxRuntimeExports.jsx(StepIconRoot, _extends({
          as: Warning,
          className: className,
          ref: ref,
          ownerState: ownerState
        }, other));
      }
      if (completed) {
        return /*#__PURE__*/jsxRuntimeExports.jsx(StepIconRoot, _extends({
          as: CheckCircle,
          className: className,
          ref: ref,
          ownerState: ownerState
        }, other));
      }
      return /*#__PURE__*/jsxRuntimeExports.jsxs(StepIconRoot, _extends({
        className: className,
        ref: ref,
        ownerState: ownerState
      }, other, {
        children: [_circle || (_circle = /*#__PURE__*/jsxRuntimeExports.jsx("circle", {
          cx: "12",
          cy: "12",
          r: "12"
        })), /*#__PURE__*/jsxRuntimeExports.jsx(StepIconText, {
          className: classes.text,
          x: "12",
          y: "12",
          textAnchor: "middle",
          dominantBaseline: "central",
          ownerState: ownerState,
          children: icon
        })]
      }));
    }
    return icon;
  });
  StepIcon.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Whether this step is active.
     * @default false
     */
    active: PropTypes.bool,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * Mark the step as completed. Is passed to child components.
     * @default false
     */
    completed: PropTypes.bool,
    /**
     * If `true`, the step is marked as failed.
     * @default false
     */
    error: PropTypes.bool,
    /**
     * The label displayed in the step icon.
     */
    icon: PropTypes.node,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var StepIcon$1 = StepIcon;

  function getStepLabelUtilityClass(slot) {
    return generateUtilityClass('MuiStepLabel', slot);
  }
  var stepLabelClasses = generateUtilityClasses('MuiStepLabel', ['root', 'horizontal', 'vertical', 'label', 'active', 'completed', 'error', 'disabled', 'iconContainer', 'alternativeLabel', 'labelContainer']);
  var stepLabelClasses$1 = stepLabelClasses;

  var useUtilityClasses$l = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      orientation = ownerState.orientation,
      active = ownerState.active,
      completed = ownerState.completed,
      error = ownerState.error,
      disabled = ownerState.disabled,
      alternativeLabel = ownerState.alternativeLabel;
    var slots = {
      root: ['root', orientation, error && 'error', disabled && 'disabled', alternativeLabel && 'alternativeLabel'],
      label: ['label', active && 'active', completed && 'completed', error && 'error', disabled && 'disabled', alternativeLabel && 'alternativeLabel'],
      iconContainer: ['iconContainer', active && 'active', completed && 'completed', error && 'error', disabled && 'disabled', alternativeLabel && 'alternativeLabel'],
      labelContainer: ['labelContainer', alternativeLabel && 'alternativeLabel']
    };
    return composeClasses(slots, getStepLabelUtilityClass, classes);
  };
  var StepLabelRoot = styled$1('span', {
    name: 'MuiStepLabel',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.orientation]];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends(_defineProperty(_defineProperty({
      display: 'flex',
      alignItems: 'center'
    }, "&.".concat(stepLabelClasses$1.alternativeLabel), {
      flexDirection: 'column'
    }), "&.".concat(stepLabelClasses$1.disabled), {
      cursor: 'default'
    }), ownerState.orientation === 'vertical' && {
      textAlign: 'left',
      padding: '8px 0'
    });
  });
  var StepLabelLabel = styled$1('span', {
    name: 'MuiStepLabel',
    slot: 'Label',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.label;
    }
  })(function (_ref2) {
    var theme = _ref2.theme;
    return _extends({}, theme.typography.body2, _defineProperty(_defineProperty(_defineProperty(_defineProperty({
      display: 'block',
      transition: theme.transitions.create('color', {
        duration: theme.transitions.duration.shortest
      })
    }, "&.".concat(stepLabelClasses$1.active), {
      color: (theme.vars || theme).palette.text.primary,
      fontWeight: 500
    }), "&.".concat(stepLabelClasses$1.completed), {
      color: (theme.vars || theme).palette.text.primary,
      fontWeight: 500
    }), "&.".concat(stepLabelClasses$1.alternativeLabel), {
      marginTop: 16
    }), "&.".concat(stepLabelClasses$1.error), {
      color: (theme.vars || theme).palette.error.main
    }));
  });
  var StepLabelIconContainer = styled$1('span', {
    name: 'MuiStepLabel',
    slot: 'IconContainer',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.iconContainer;
    }
  })(function () {
    return _defineProperty({
      flexShrink: 0,
      // Fix IE11 issue
      display: 'flex',
      paddingRight: 8
    }, "&.".concat(stepLabelClasses$1.alternativeLabel), {
      paddingRight: 0
    });
  });
  var StepLabelLabelContainer = styled$1('span', {
    name: 'MuiStepLabel',
    slot: 'LabelContainer',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.labelContainer;
    }
  })(function (_ref4) {
    var theme = _ref4.theme;
    return _defineProperty({
      width: '100%',
      color: (theme.vars || theme).palette.text.secondary
    }, "&.".concat(stepLabelClasses$1.alternativeLabel), {
      textAlign: 'center'
    });
  });
  var StepLabel = /*#__PURE__*/React__namespace.forwardRef(function StepLabel(inProps, ref) {
    var _slotProps$label;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiStepLabel'
    });
    var children = props.children,
      className = props.className,
      _props$componentsProp = props.componentsProps,
      componentsProps = _props$componentsProp === void 0 ? {} : _props$componentsProp,
      _props$error = props.error,
      error = _props$error === void 0 ? false : _props$error,
      iconProp = props.icon,
      optional = props.optional,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      StepIconComponentProp = props.StepIconComponent,
      StepIconProps = props.StepIconProps,
      other = _objectWithoutProperties(props, ["children", "className", "componentsProps", "error", "icon", "optional", "slotProps", "StepIconComponent", "StepIconProps"]);
    var _React$useContext = React__namespace.useContext(StepperContext$1),
      alternativeLabel = _React$useContext.alternativeLabel,
      orientation = _React$useContext.orientation;
    var _React$useContext2 = React__namespace.useContext(StepContext$1),
      active = _React$useContext2.active,
      disabled = _React$useContext2.disabled,
      completed = _React$useContext2.completed,
      iconContext = _React$useContext2.icon;
    var icon = iconProp || iconContext;
    var StepIconComponent = StepIconComponentProp;
    if (icon && !StepIconComponent) {
      StepIconComponent = StepIcon$1;
    }
    var ownerState = _extends({}, props, {
      active: active,
      alternativeLabel: alternativeLabel,
      completed: completed,
      disabled: disabled,
      error: error,
      orientation: orientation
    });
    var classes = useUtilityClasses$l(ownerState);
    var labelSlotProps = (_slotProps$label = slotProps.label) != null ? _slotProps$label : componentsProps.label;
    return /*#__PURE__*/jsxRuntimeExports.jsxs(StepLabelRoot, _extends({
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState
    }, other, {
      children: [icon || StepIconComponent ? /*#__PURE__*/jsxRuntimeExports.jsx(StepLabelIconContainer, {
        className: classes.iconContainer,
        ownerState: ownerState,
        children: /*#__PURE__*/jsxRuntimeExports.jsx(StepIconComponent, _extends({
          completed: completed,
          active: active,
          error: error,
          icon: icon
        }, StepIconProps))
      }) : null, /*#__PURE__*/jsxRuntimeExports.jsxs(StepLabelLabelContainer, {
        className: classes.labelContainer,
        ownerState: ownerState,
        children: [children ? /*#__PURE__*/jsxRuntimeExports.jsx(StepLabelLabel, _extends({
          ownerState: ownerState
        }, labelSlotProps, {
          className: clsx(classes.label, labelSlotProps == null ? void 0 : labelSlotProps.className),
          children: children
        })) : null, optional]
      })]
    }));
  });
  StepLabel.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * In most cases will simply be a string containing a title for the label.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The props used for each slot inside.
     * @default {}
     */
    componentsProps: PropTypes.shape({
      label: PropTypes.object
    }),
    /**
     * If `true`, the step is marked as failed.
     * @default false
     */
    error: PropTypes.bool,
    /**
     * Override the default label of the step icon.
     */
    icon: PropTypes.node,
    /**
     * The optional node to display.
     */
    optional: PropTypes.node,
    /**
     * The props used for each slot inside.
     * @default {}
     */
    slotProps: PropTypes.shape({
      label: PropTypes.object
    }),
    /**
     * The component to render in place of the [`StepIcon`](/material-ui/api/step-icon/).
     */
    StepIconComponent: PropTypes.elementType,
    /**
     * Props applied to the [`StepIcon`](/material-ui/api/step-icon/) element.
     */
    StepIconProps: PropTypes.object,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  StepLabel.muiName = 'StepLabel';
  var StepLabel$1 = StepLabel;

  function getStepButtonUtilityClass(slot) {
    return generateUtilityClass('MuiStepButton', slot);
  }
  var stepButtonClasses = generateUtilityClasses('MuiStepButton', ['root', 'horizontal', 'vertical', 'touchRipple']);
  var stepButtonClasses$1 = stepButtonClasses;

  var useUtilityClasses$k = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      orientation = ownerState.orientation;
    var slots = {
      root: ['root', orientation],
      touchRipple: ['touchRipple']
    };
    return composeClasses(slots, getStepButtonUtilityClass, classes);
  };
  var StepButtonRoot = styled$1(ButtonBase$1, {
    name: 'MuiStepButton',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [_defineProperty({}, "& .".concat(stepButtonClasses$1.touchRipple), styles.touchRipple), styles.root, styles[ownerState.orientation]];
    }
  })(function (_ref2) {
    var ownerState = _ref2.ownerState;
    return _extends({
      width: '100%',
      padding: '24px 16px',
      margin: '-24px -16px',
      boxSizing: 'content-box'
    }, ownerState.orientation === 'vertical' && {
      justifyContent: 'flex-start',
      padding: '8px',
      margin: '-8px'
    }, _defineProperty({}, "& .".concat(stepButtonClasses$1.touchRipple), {
      color: 'rgba(0, 0, 0, 0.3)'
    }));
  });
  var StepButton = /*#__PURE__*/React__namespace.forwardRef(function StepButton(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiStepButton'
    });
    var children = props.children,
      className = props.className,
      icon = props.icon,
      optional = props.optional,
      other = _objectWithoutProperties(props, ["children", "className", "icon", "optional"]);
    var _React$useContext = React__namespace.useContext(StepContext$1),
      disabled = _React$useContext.disabled,
      active = _React$useContext.active;
    var _React$useContext2 = React__namespace.useContext(StepperContext$1),
      orientation = _React$useContext2.orientation;
    var ownerState = _extends({}, props, {
      orientation: orientation
    });
    var classes = useUtilityClasses$k(ownerState);
    var childProps = {
      icon: icon,
      optional: optional
    };
    var child = isMuiElement(children, ['StepLabel']) ? ( /*#__PURE__*/React__namespace.cloneElement(children, childProps)) : /*#__PURE__*/jsxRuntimeExports.jsx(StepLabel$1, _extends({}, childProps, {
      children: children
    }));
    return /*#__PURE__*/jsxRuntimeExports.jsx(StepButtonRoot, _extends({
      focusRipple: true,
      disabled: disabled,
      TouchRippleProps: {
        className: classes.touchRipple
      },
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState,
      "aria-current": active ? 'step' : undefined
    }, other, {
      children: child
    }));
  });
  StepButton.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Can be a `StepLabel` or a node to place inside `StepLabel` as children.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The icon displayed by the step label.
     */
    icon: PropTypes.node,
    /**
     * The optional node to display.
     */
    optional: PropTypes.node,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var StepButton$1 = StepButton;

  function getStepConnectorUtilityClass(slot) {
    return generateUtilityClass('MuiStepConnector', slot);
  }
  var stepConnectorClasses = generateUtilityClasses('MuiStepConnector', ['root', 'horizontal', 'vertical', 'alternativeLabel', 'active', 'completed', 'disabled', 'line', 'lineHorizontal', 'lineVertical']);
  var stepConnectorClasses$1 = stepConnectorClasses;

  var useUtilityClasses$j = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      orientation = ownerState.orientation,
      alternativeLabel = ownerState.alternativeLabel,
      active = ownerState.active,
      completed = ownerState.completed,
      disabled = ownerState.disabled;
    var slots = {
      root: ['root', orientation, alternativeLabel && 'alternativeLabel', active && 'active', completed && 'completed', disabled && 'disabled'],
      line: ['line', "line".concat(capitalize(orientation))]
    };
    return composeClasses(slots, getStepConnectorUtilityClass, classes);
  };
  var StepConnectorRoot = styled$1('div', {
    name: 'MuiStepConnector',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.orientation], ownerState.alternativeLabel && styles.alternativeLabel, ownerState.completed && styles.completed];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends({
      flex: '1 1 auto'
    }, ownerState.orientation === 'vertical' && {
      marginLeft: 12 // half icon
    }, ownerState.alternativeLabel && {
      position: 'absolute',
      top: 8 + 4,
      left: 'calc(-50% + 20px)',
      right: 'calc(50% + 20px)'
    });
  });
  var StepConnectorLine = styled$1('span', {
    name: 'MuiStepConnector',
    slot: 'Line',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.line, styles["line".concat(capitalize(ownerState.orientation))]];
    }
  })(function (_ref2) {
    var ownerState = _ref2.ownerState,
      theme = _ref2.theme;
    var borderColor = theme.palette.mode === 'light' ? theme.palette.grey[400] : theme.palette.grey[600];
    return _extends({
      display: 'block',
      borderColor: theme.vars ? theme.vars.palette.StepConnector.border : borderColor
    }, ownerState.orientation === 'horizontal' && {
      borderTopStyle: 'solid',
      borderTopWidth: 1
    }, ownerState.orientation === 'vertical' && {
      borderLeftStyle: 'solid',
      borderLeftWidth: 1,
      minHeight: 24
    });
  });
  var StepConnector = /*#__PURE__*/React__namespace.forwardRef(function StepConnector(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiStepConnector'
    });
    var className = props.className,
      other = _objectWithoutProperties(props, ["className"]);
    var _React$useContext = React__namespace.useContext(StepperContext$1),
      alternativeLabel = _React$useContext.alternativeLabel,
      _React$useContext$ori = _React$useContext.orientation,
      orientation = _React$useContext$ori === void 0 ? 'horizontal' : _React$useContext$ori;
    var _React$useContext2 = React__namespace.useContext(StepContext$1),
      active = _React$useContext2.active,
      disabled = _React$useContext2.disabled,
      completed = _React$useContext2.completed;
    var ownerState = _extends({}, props, {
      alternativeLabel: alternativeLabel,
      orientation: orientation,
      active: active,
      completed: completed,
      disabled: disabled
    });
    var classes = useUtilityClasses$j(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(StepConnectorRoot, _extends({
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState
    }, other, {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(StepConnectorLine, {
        className: classes.line,
        ownerState: ownerState
      })
    }));
  });
  StepConnector.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var StepConnector$1 = StepConnector;

  function getStepContentUtilityClass(slot) {
    return generateUtilityClass('MuiStepContent', slot);
  }
  var stepContentClasses = generateUtilityClasses('MuiStepContent', ['root', 'last', 'transition']);
  var stepContentClasses$1 = stepContentClasses;

  var useUtilityClasses$i = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      last = ownerState.last;
    var slots = {
      root: ['root', last && 'last'],
      transition: ['transition']
    };
    return composeClasses(slots, getStepContentUtilityClass, classes);
  };
  var StepContentRoot = styled$1('div', {
    name: 'MuiStepContent',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.last && styles.last];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState,
      theme = _ref.theme;
    return _extends({
      marginLeft: 12,
      // half icon
      paddingLeft: 8 + 12,
      // margin + half icon
      paddingRight: 8,
      borderLeft: theme.vars ? "1px solid ".concat(theme.vars.palette.StepContent.border) : "1px solid ".concat(theme.palette.mode === 'light' ? theme.palette.grey[400] : theme.palette.grey[600])
    }, ownerState.last && {
      borderLeft: 'none'
    });
  });
  var StepContentTransition = styled$1(Collapse$1, {
    name: 'MuiStepContent',
    slot: 'Transition',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.transition;
    }
  })({});
  var StepContent = /*#__PURE__*/React__namespace.forwardRef(function StepContent(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiStepContent'
    });
    var children = props.children,
      className = props.className,
      _props$TransitionComp = props.TransitionComponent,
      TransitionComponent = _props$TransitionComp === void 0 ? Collapse$1 : _props$TransitionComp,
      _props$transitionDura = props.transitionDuration,
      transitionDurationProp = _props$transitionDura === void 0 ? 'auto' : _props$transitionDura,
      TransitionProps = props.TransitionProps,
      other = _objectWithoutProperties(props, ["children", "className", "TransitionComponent", "transitionDuration", "TransitionProps"]);
    var _React$useContext = React__namespace.useContext(StepperContext$1),
      orientation = _React$useContext.orientation;
    var _React$useContext2 = React__namespace.useContext(StepContext$1),
      active = _React$useContext2.active,
      last = _React$useContext2.last,
      expanded = _React$useContext2.expanded;
    var ownerState = _extends({}, props, {
      last: last
    });
    var classes = useUtilityClasses$i(ownerState);
    {
      if (orientation !== 'vertical') {
        console.error('MUI: <StepContent /> is only designed for use with the vertical stepper.');
      }
    }
    var transitionDuration = transitionDurationProp;
    if (transitionDurationProp === 'auto' && !TransitionComponent.muiSupportAuto) {
      transitionDuration = undefined;
    }
    return /*#__PURE__*/jsxRuntimeExports.jsx(StepContentRoot, _extends({
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState
    }, other, {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(StepContentTransition, _extends({
        as: TransitionComponent,
        "in": active || expanded,
        className: classes.transition,
        ownerState: ownerState,
        timeout: transitionDuration,
        unmountOnExit: true
      }, TransitionProps, {
        children: children
      }))
    }));
  });
  StepContent.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The component used for the transition.
     * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
     * @default Collapse
     */
    TransitionComponent: PropTypes.elementType,
    /**
     * Adjust the duration of the content expand transition.
     * Passed as a prop to the transition component.
     *
     * Set to 'auto' to automatically calculate transition time based on height.
     * @default 'auto'
     */
    transitionDuration: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number, PropTypes.shape({
      appear: PropTypes.number,
      enter: PropTypes.number,
      exit: PropTypes.number
    })]),
    /**
     * Props applied to the transition element.
     * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
     */
    TransitionProps: PropTypes.object
  } ;
  var StepContent$1 = StepContent;

  function getStepperUtilityClass(slot) {
    return generateUtilityClass('MuiStepper', slot);
  }
  var stepperClasses = generateUtilityClasses('MuiStepper', ['root', 'horizontal', 'vertical', 'nonLinear', 'alternativeLabel']);
  var stepperClasses$1 = stepperClasses;

  var useUtilityClasses$h = function useUtilityClasses(ownerState) {
    var orientation = ownerState.orientation,
      nonLinear = ownerState.nonLinear,
      alternativeLabel = ownerState.alternativeLabel,
      classes = ownerState.classes;
    var slots = {
      root: ['root', orientation, nonLinear && 'nonLinear', alternativeLabel && 'alternativeLabel']
    };
    return composeClasses(slots, getStepperUtilityClass, classes);
  };
  var StepperRoot = styled$1('div', {
    name: 'MuiStepper',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.orientation], ownerState.alternativeLabel && styles.alternativeLabel, ownerState.nonLinear && styles.nonLinear];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends({
      display: 'flex'
    }, ownerState.orientation === 'horizontal' && {
      flexDirection: 'row',
      alignItems: 'center'
    }, ownerState.orientation === 'vertical' && {
      flexDirection: 'column'
    }, ownerState.alternativeLabel && {
      alignItems: 'flex-start'
    });
  });
  var defaultConnector = /*#__PURE__*/jsxRuntimeExports.jsx(StepConnector$1, {});
  var Stepper = /*#__PURE__*/React__namespace.forwardRef(function Stepper(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiStepper'
    });
    var _props$activeStep = props.activeStep,
      activeStep = _props$activeStep === void 0 ? 0 : _props$activeStep,
      _props$alternativeLab = props.alternativeLabel,
      alternativeLabel = _props$alternativeLab === void 0 ? false : _props$alternativeLab,
      children = props.children,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      _props$connector = props.connector,
      connector = _props$connector === void 0 ? defaultConnector : _props$connector,
      _props$nonLinear = props.nonLinear,
      nonLinear = _props$nonLinear === void 0 ? false : _props$nonLinear,
      _props$orientation = props.orientation,
      orientation = _props$orientation === void 0 ? 'horizontal' : _props$orientation,
      other = _objectWithoutProperties(props, ["activeStep", "alternativeLabel", "children", "className", "component", "connector", "nonLinear", "orientation"]);
    var ownerState = _extends({}, props, {
      nonLinear: nonLinear,
      alternativeLabel: alternativeLabel,
      orientation: orientation,
      component: component
    });
    var classes = useUtilityClasses$h(ownerState);
    var childrenArray = React__namespace.Children.toArray(children).filter(Boolean);
    var steps = childrenArray.map(function (step, index) {
      return /*#__PURE__*/React__namespace.cloneElement(step, _extends({
        index: index,
        last: index + 1 === childrenArray.length
      }, step.props));
    });
    var contextValue = React__namespace.useMemo(function () {
      return {
        activeStep: activeStep,
        alternativeLabel: alternativeLabel,
        connector: connector,
        nonLinear: nonLinear,
        orientation: orientation
      };
    }, [activeStep, alternativeLabel, connector, nonLinear, orientation]);
    return /*#__PURE__*/jsxRuntimeExports.jsx(StepperContext$1.Provider, {
      value: contextValue,
      children: /*#__PURE__*/jsxRuntimeExports.jsx(StepperRoot, _extends({
        as: component,
        ownerState: ownerState,
        className: clsx(classes.root, className),
        ref: ref
      }, other, {
        children: steps
      }))
    });
  });
  Stepper.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Set the active step (zero based index).
     * Set to -1 to disable all the steps.
     * @default 0
     */
    activeStep: integerPropType,
    /**
     * If set to 'true' and orientation is horizontal,
     * then the step label will be positioned under the icon.
     * @default false
     */
    alternativeLabel: PropTypes.bool,
    /**
     * Two or more `<Step />` components.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * An element to be placed between each step.
     * @default <StepConnector />
     */
    connector: PropTypes.element,
    /**
     * If set the `Stepper` will not assist in controlling steps for linear flow.
     * @default false
     */
    nonLinear: PropTypes.bool,
    /**
     * The component orientation (layout flow direction).
     * @default 'horizontal'
     */
    orientation: PropTypes.oneOf(['horizontal', 'vertical']),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var Stepper$1 = Stepper;

  var SwipeAreaRoot = styled$1('div', {
    shouldForwardProp: rootShouldForwardProp$1
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      position: 'fixed',
      top: 0,
      left: 0,
      bottom: 0,
      zIndex: theme.zIndex.drawer - 1
    }, ownerState.anchor === 'left' && {
      right: 'auto'
    }, ownerState.anchor === 'right' && {
      left: 'auto',
      right: 0
    }, ownerState.anchor === 'top' && {
      bottom: 'auto',
      right: 0
    }, ownerState.anchor === 'bottom' && {
      top: 'auto',
      bottom: 0,
      right: 0
    });
  });

  /**
   * @ignore - internal component.
   */
  var SwipeArea = /*#__PURE__*/React__namespace.forwardRef(function SwipeArea(props, ref) {
    var anchor = props.anchor,
      _props$classes = props.classes,
      classes = _props$classes === void 0 ? {} : _props$classes,
      className = props.className,
      width = props.width,
      style = props.style,
      other = _objectWithoutProperties(props, ["anchor", "classes", "className", "width", "style"]);
    var ownerState = props;
    return /*#__PURE__*/jsxRuntimeExports.jsx(SwipeAreaRoot, _extends({
      className: clsx('PrivateSwipeArea-root', classes.root, classes["anchor".concat(capitalize(anchor))], className),
      ref: ref,
      style: _extends(_defineProperty({}, isHorizontal(anchor) ? 'width' : 'height', width), style),
      ownerState: ownerState
    }, other));
  });
  SwipeArea.propTypes = {
    /**
     * Side on which to attach the discovery area.
     */
    anchor: PropTypes.oneOf(['left', 'top', 'right', 'bottom']).isRequired,
    /**
     * @ignore
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * @ignore
     */
    style: PropTypes.object,
    /**
     * The width of the left most (or right most) area in `px` where the
     * drawer can be swiped open from.
     */
    width: PropTypes.number.isRequired
  } ;
  var SwipeArea$1 = SwipeArea;

  var UNCERTAINTY_THRESHOLD = 3; // px

  // This is the part of the drawer displayed on touch start.
  var DRAG_STARTED_SIGNAL = 20; // px

  // We can only have one instance at the time claiming ownership for handling the swipe.
  // Otherwise, the UX would be confusing.
  // That's why we use a singleton here.
  var claimedSwipeInstance = null;
  function calculateCurrentX(anchor, touches, doc) {
    return anchor === 'right' ? doc.body.offsetWidth - touches[0].pageX : touches[0].pageX;
  }
  function calculateCurrentY(anchor, touches, containerWindow) {
    return anchor === 'bottom' ? containerWindow.innerHeight - touches[0].clientY : touches[0].clientY;
  }
  function getMaxTranslate(horizontalSwipe, paperInstance) {
    return horizontalSwipe ? paperInstance.clientWidth : paperInstance.clientHeight;
  }
  function getTranslate(currentTranslate, startLocation, open, maxTranslate) {
    return Math.min(Math.max(open ? startLocation - currentTranslate : maxTranslate + startLocation - currentTranslate, 0), maxTranslate);
  }

  /**
   * @param {Element | null} element
   * @param {Element} rootNode
   */
  function getDomTreeShapes(element, rootNode) {
    // Adapted from https://github.com/oliviertassinari/react-swipeable-views/blob/7666de1dba253b896911adf2790ce51467670856/packages/react-swipeable-views/src/SwipeableViews.js#L129
    var domTreeShapes = [];
    while (element && element !== rootNode.parentElement) {
      var style = ownerWindow(rootNode).getComputedStyle(element);
      if (
      // Ignore the scroll children if the element is absolute positioned.
      style.getPropertyValue('position') === 'absolute' ||
      // Ignore the scroll children if the element has an overflowX hidden
      style.getPropertyValue('overflow-x') === 'hidden') ; else if (element.clientWidth > 0 && element.scrollWidth > element.clientWidth || element.clientHeight > 0 && element.scrollHeight > element.clientHeight) {
        // Ignore the nodes that have no width.
        // Keep elements with a scroll
        domTreeShapes.push(element);
      }
      element = element.parentElement;
    }
    return domTreeShapes;
  }

  /**
   * @param {object} param0
   * @param {ReturnType<getDomTreeShapes>} param0.domTreeShapes
   */
  function computeHasNativeHandler(_ref) {
    var domTreeShapes = _ref.domTreeShapes,
      start = _ref.start,
      current = _ref.current,
      anchor = _ref.anchor;
    // Adapted from https://github.com/oliviertassinari/react-swipeable-views/blob/7666de1dba253b896911adf2790ce51467670856/packages/react-swipeable-views/src/SwipeableViews.js#L175
    var axisProperties = {
      scrollPosition: {
        x: 'scrollLeft',
        y: 'scrollTop'
      },
      scrollLength: {
        x: 'scrollWidth',
        y: 'scrollHeight'
      },
      clientLength: {
        x: 'clientWidth',
        y: 'clientHeight'
      }
    };
    return domTreeShapes.some(function (shape) {
      // Determine if we are going backward or forward.
      var goingForward = current >= start;
      if (anchor === 'top' || anchor === 'left') {
        goingForward = !goingForward;
      }
      var axis = anchor === 'left' || anchor === 'right' ? 'x' : 'y';
      var scrollPosition = Math.round(shape[axisProperties.scrollPosition[axis]]);
      var areNotAtStart = scrollPosition > 0;
      var areNotAtEnd = scrollPosition + shape[axisProperties.clientLength[axis]] < shape[axisProperties.scrollLength[axis]];
      if (goingForward && areNotAtEnd || !goingForward && areNotAtStart) {
        return true;
      }
      return false;
    });
  }
  var iOS = typeof navigator !== 'undefined' && /iPad|iPhone|iPod/.test(navigator.userAgent);
  var SwipeableDrawer = /*#__PURE__*/React__namespace.forwardRef(function SwipeableDrawer(inProps, ref) {
    var props = useDefaultProps({
      name: 'MuiSwipeableDrawer',
      props: inProps
    });
    var theme = useTheme();
    var transitionDurationDefault = {
      enter: theme.transitions.duration.enteringScreen,
      exit: theme.transitions.duration.leavingScreen
    };
    var _props$anchor = props.anchor,
      anchor = _props$anchor === void 0 ? 'left' : _props$anchor,
      _props$disableBackdro = props.disableBackdropTransition,
      disableBackdropTransition = _props$disableBackdro === void 0 ? false : _props$disableBackdro,
      _props$disableDiscove = props.disableDiscovery,
      disableDiscovery = _props$disableDiscove === void 0 ? false : _props$disableDiscove,
      _props$disableSwipeTo = props.disableSwipeToOpen,
      disableSwipeToOpen = _props$disableSwipeTo === void 0 ? iOS : _props$disableSwipeTo,
      hideBackdrop = props.hideBackdrop,
      _props$hysteresis = props.hysteresis,
      hysteresis = _props$hysteresis === void 0 ? 0.52 : _props$hysteresis,
      _props$allowSwipeInCh = props.allowSwipeInChildren,
      allowSwipeInChildren = _props$allowSwipeInCh === void 0 ? false : _props$allowSwipeInCh,
      _props$minFlingVeloci = props.minFlingVelocity,
      minFlingVelocity = _props$minFlingVeloci === void 0 ? 450 : _props$minFlingVeloci,
      _props$ModalProps = props.ModalProps,
      _props$ModalProps2 = _props$ModalProps === void 0 ? {} : _props$ModalProps,
      BackdropProps = _props$ModalProps2.BackdropProps,
      ModalPropsProp = _objectWithoutProperties(_props$ModalProps2, ["BackdropProps"]),
      onClose = props.onClose,
      onOpen = props.onOpen,
      _props$open = props.open,
      open = _props$open === void 0 ? false : _props$open,
      _props$PaperProps = props.PaperProps,
      PaperProps = _props$PaperProps === void 0 ? {} : _props$PaperProps,
      SwipeAreaProps = props.SwipeAreaProps,
      _props$swipeAreaWidth = props.swipeAreaWidth,
      swipeAreaWidth = _props$swipeAreaWidth === void 0 ? 20 : _props$swipeAreaWidth,
      _props$transitionDura = props.transitionDuration,
      transitionDuration = _props$transitionDura === void 0 ? transitionDurationDefault : _props$transitionDura,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'temporary' : _props$variant,
      other = _objectWithoutProperties(props, ["anchor", "disableBackdropTransition", "disableDiscovery", "disableSwipeToOpen", "hideBackdrop", "hysteresis", "allowSwipeInChildren", "minFlingVelocity", "ModalProps", "onClose", "onOpen", "open", "PaperProps", "SwipeAreaProps", "swipeAreaWidth", "transitionDuration", "variant"]);
    var _React$useState = React__namespace.useState(false),
      maybeSwiping = _React$useState[0],
      setMaybeSwiping = _React$useState[1];
    var swipeInstance = React__namespace.useRef({
      isSwiping: null
    });
    var swipeAreaRef = React__namespace.useRef();
    var backdropRef = React__namespace.useRef();
    var paperRef = React__namespace.useRef();
    var handleRef = useForkRef(PaperProps.ref, paperRef);
    var touchDetected = React__namespace.useRef(false);

    // Ref for transition duration based on / to match swipe speed
    var calculatedDurationRef = React__namespace.useRef();

    // Use a ref so the open value used is always up to date inside useCallback.
    useEnhancedEffect$1(function () {
      calculatedDurationRef.current = null;
    }, [open]);
    var setPosition = React__namespace.useCallback(function (translate) {
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var _options$mode = options.mode,
        mode = _options$mode === void 0 ? null : _options$mode,
        _options$changeTransi = options.changeTransition,
        changeTransition = _options$changeTransi === void 0 ? true : _options$changeTransi;
      var anchorRtl = getAnchor(theme, anchor);
      var rtlTranslateMultiplier = ['right', 'bottom'].indexOf(anchorRtl) !== -1 ? 1 : -1;
      var horizontalSwipe = isHorizontal(anchor);
      var transform = horizontalSwipe ? "translate(".concat(rtlTranslateMultiplier * translate, "px, 0)") : "translate(0, ".concat(rtlTranslateMultiplier * translate, "px)");
      var drawerStyle = paperRef.current.style;
      drawerStyle.webkitTransform = transform;
      drawerStyle.transform = transform;
      var transition = '';
      if (mode) {
        transition = theme.transitions.create('all', getTransitionProps({
          easing: undefined,
          style: undefined,
          timeout: transitionDuration
        }, {
          mode: mode
        }));
      }
      if (changeTransition) {
        drawerStyle.webkitTransition = transition;
        drawerStyle.transition = transition;
      }
      if (!disableBackdropTransition && !hideBackdrop) {
        var backdropStyle = backdropRef.current.style;
        backdropStyle.opacity = 1 - translate / getMaxTranslate(horizontalSwipe, paperRef.current);
        if (changeTransition) {
          backdropStyle.webkitTransition = transition;
          backdropStyle.transition = transition;
        }
      }
    }, [anchor, disableBackdropTransition, hideBackdrop, theme, transitionDuration]);
    var handleBodyTouchEnd = useEventCallback(function (nativeEvent) {
      if (!touchDetected.current) {
        return;
      }
      claimedSwipeInstance = null;
      touchDetected.current = false;
      ReactDOM__namespace.flushSync(function () {
        setMaybeSwiping(false);
      });

      // The swipe wasn't started.
      if (!swipeInstance.current.isSwiping) {
        swipeInstance.current.isSwiping = null;
        return;
      }
      swipeInstance.current.isSwiping = null;
      var anchorRtl = getAnchor(theme, anchor);
      var horizontal = isHorizontal(anchor);
      var current;
      if (horizontal) {
        current = calculateCurrentX(anchorRtl, nativeEvent.changedTouches, ownerDocument(nativeEvent.currentTarget));
      } else {
        current = calculateCurrentY(anchorRtl, nativeEvent.changedTouches, ownerWindow(nativeEvent.currentTarget));
      }
      var startLocation = horizontal ? swipeInstance.current.startX : swipeInstance.current.startY;
      var maxTranslate = getMaxTranslate(horizontal, paperRef.current);
      var currentTranslate = getTranslate(current, startLocation, open, maxTranslate);
      var translateRatio = currentTranslate / maxTranslate;
      if (Math.abs(swipeInstance.current.velocity) > minFlingVelocity) {
        // Calculate transition duration to match swipe speed
        calculatedDurationRef.current = Math.abs((maxTranslate - currentTranslate) / swipeInstance.current.velocity) * 1000;
      }
      if (open) {
        if (swipeInstance.current.velocity > minFlingVelocity || translateRatio > hysteresis) {
          onClose();
        } else {
          // Reset the position, the swipe was aborted.
          setPosition(0, {
            mode: 'exit'
          });
        }
        return;
      }
      if (swipeInstance.current.velocity < -minFlingVelocity || 1 - translateRatio > hysteresis) {
        onOpen();
      } else {
        // Reset the position, the swipe was aborted.
        setPosition(getMaxTranslate(horizontal, paperRef.current), {
          mode: 'enter'
        });
      }
    });
    var startMaybeSwiping = function startMaybeSwiping() {
      var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
      if (!maybeSwiping) {
        // on Safari Mobile, if you want to be able to have the 'click' event fired on child elements, nothing in the DOM can be changed.
        // this is because Safari Mobile will not fire any mouse events (still fires touch though) if the DOM changes during mousemove.
        // so do this change on first touchmove instead of touchstart
        if (force || !(disableDiscovery && allowSwipeInChildren)) {
          ReactDOM__namespace.flushSync(function () {
            setMaybeSwiping(true);
          });
        }
        var horizontalSwipe = isHorizontal(anchor);
        if (!open && paperRef.current) {
          // The ref may be null when a parent component updates while swiping.
          setPosition(getMaxTranslate(horizontalSwipe, paperRef.current) + (disableDiscovery ? 15 : -DRAG_STARTED_SIGNAL), {
            changeTransition: false
          });
        }
        swipeInstance.current.velocity = 0;
        swipeInstance.current.lastTime = null;
        swipeInstance.current.lastTranslate = null;
        swipeInstance.current.paperHit = false;
        touchDetected.current = true;
      }
    };
    var handleBodyTouchMove = useEventCallback(function (nativeEvent) {
      // the ref may be null when a parent component updates while swiping
      if (!paperRef.current || !touchDetected.current) {
        return;
      }

      // We are not supposed to handle this touch move because the swipe was started in a scrollable container in the drawer
      if (claimedSwipeInstance !== null && claimedSwipeInstance !== swipeInstance.current) {
        return;
      }
      startMaybeSwiping(true);
      var anchorRtl = getAnchor(theme, anchor);
      var horizontalSwipe = isHorizontal(anchor);
      var currentX = calculateCurrentX(anchorRtl, nativeEvent.touches, ownerDocument(nativeEvent.currentTarget));
      var currentY = calculateCurrentY(anchorRtl, nativeEvent.touches, ownerWindow(nativeEvent.currentTarget));
      if (open && paperRef.current.contains(nativeEvent.target) && claimedSwipeInstance === null) {
        var domTreeShapes = getDomTreeShapes(nativeEvent.target, paperRef.current);
        var hasNativeHandler = computeHasNativeHandler({
          domTreeShapes: domTreeShapes,
          start: horizontalSwipe ? swipeInstance.current.startX : swipeInstance.current.startY,
          current: horizontalSwipe ? currentX : currentY,
          anchor: anchor
        });
        if (hasNativeHandler) {
          claimedSwipeInstance = true;
          return;
        }
        claimedSwipeInstance = swipeInstance.current;
      }

      // We don't know yet.
      if (swipeInstance.current.isSwiping == null) {
        var dx = Math.abs(currentX - swipeInstance.current.startX);
        var dy = Math.abs(currentY - swipeInstance.current.startY);
        var definitelySwiping = horizontalSwipe ? dx > dy && dx > UNCERTAINTY_THRESHOLD : dy > dx && dy > UNCERTAINTY_THRESHOLD;
        if (definitelySwiping && nativeEvent.cancelable) {
          nativeEvent.preventDefault();
        }
        if (definitelySwiping === true || (horizontalSwipe ? dy > UNCERTAINTY_THRESHOLD : dx > UNCERTAINTY_THRESHOLD)) {
          swipeInstance.current.isSwiping = definitelySwiping;
          if (!definitelySwiping) {
            handleBodyTouchEnd(nativeEvent);
            return;
          }

          // Shift the starting point.
          swipeInstance.current.startX = currentX;
          swipeInstance.current.startY = currentY;

          // Compensate for the part of the drawer displayed on touch start.
          if (!disableDiscovery && !open) {
            if (horizontalSwipe) {
              swipeInstance.current.startX -= DRAG_STARTED_SIGNAL;
            } else {
              swipeInstance.current.startY -= DRAG_STARTED_SIGNAL;
            }
          }
        }
      }
      if (!swipeInstance.current.isSwiping) {
        return;
      }
      var maxTranslate = getMaxTranslate(horizontalSwipe, paperRef.current);
      var startLocation = horizontalSwipe ? swipeInstance.current.startX : swipeInstance.current.startY;
      if (open && !swipeInstance.current.paperHit) {
        startLocation = Math.min(startLocation, maxTranslate);
      }
      var translate = getTranslate(horizontalSwipe ? currentX : currentY, startLocation, open, maxTranslate);
      if (open) {
        if (!swipeInstance.current.paperHit) {
          var paperHit = horizontalSwipe ? currentX < maxTranslate : currentY < maxTranslate;
          if (paperHit) {
            swipeInstance.current.paperHit = true;
            swipeInstance.current.startX = currentX;
            swipeInstance.current.startY = currentY;
          } else {
            return;
          }
        } else if (translate === 0) {
          swipeInstance.current.startX = currentX;
          swipeInstance.current.startY = currentY;
        }
      }
      if (swipeInstance.current.lastTranslate === null) {
        swipeInstance.current.lastTranslate = translate;
        swipeInstance.current.lastTime = performance.now() + 1;
      }
      var velocity = (translate - swipeInstance.current.lastTranslate) / (performance.now() - swipeInstance.current.lastTime) * 1e3;

      // Low Pass filter.
      swipeInstance.current.velocity = swipeInstance.current.velocity * 0.4 + velocity * 0.6;
      swipeInstance.current.lastTranslate = translate;
      swipeInstance.current.lastTime = performance.now();

      // We are swiping, let's prevent the scroll event on iOS.
      if (nativeEvent.cancelable) {
        nativeEvent.preventDefault();
      }
      setPosition(translate);
    });
    var handleBodyTouchStart = useEventCallback(function (nativeEvent) {
      // We are not supposed to handle this touch move.
      // Example of use case: ignore the event if there is a Slider.
      if (nativeEvent.defaultPrevented) {
        return;
      }

      // We can only have one node at the time claiming ownership for handling the swipe.
      if (nativeEvent.defaultMuiPrevented) {
        return;
      }

      // At least one element clogs the drawer interaction zone.
      if (open && (hideBackdrop || !backdropRef.current.contains(nativeEvent.target)) && !paperRef.current.contains(nativeEvent.target)) {
        return;
      }
      var anchorRtl = getAnchor(theme, anchor);
      var horizontalSwipe = isHorizontal(anchor);
      var currentX = calculateCurrentX(anchorRtl, nativeEvent.touches, ownerDocument(nativeEvent.currentTarget));
      var currentY = calculateCurrentY(anchorRtl, nativeEvent.touches, ownerWindow(nativeEvent.currentTarget));
      if (!open) {
        var _paperRef$current;
        // logic for if swipe should be ignored:
        // if disableSwipeToOpen
        // if target != swipeArea, and target is not a child of paper ref
        // if is a child of paper ref, and `allowSwipeInChildren` does not allow it
        if (disableSwipeToOpen || !(nativeEvent.target === swipeAreaRef.current || (_paperRef$current = paperRef.current) != null && _paperRef$current.contains(nativeEvent.target) && (typeof allowSwipeInChildren === 'function' ? allowSwipeInChildren(nativeEvent, swipeAreaRef.current, paperRef.current) : allowSwipeInChildren))) {
          return;
        }
        if (horizontalSwipe) {
          if (currentX > swipeAreaWidth) {
            return;
          }
        } else if (currentY > swipeAreaWidth) {
          return;
        }
      }
      nativeEvent.defaultMuiPrevented = true;
      claimedSwipeInstance = null;
      swipeInstance.current.startX = currentX;
      swipeInstance.current.startY = currentY;
      startMaybeSwiping();
    });
    React__namespace.useEffect(function () {
      if (variant === 'temporary') {
        var doc = ownerDocument(paperRef.current);
        doc.addEventListener('touchstart', handleBodyTouchStart);
        // A blocking listener prevents Firefox's navbar to auto-hide on scroll.
        // It only needs to prevent scrolling on the drawer's content when open.
        // When closed, the overlay prevents scrolling.
        doc.addEventListener('touchmove', handleBodyTouchMove, {
          passive: !open
        });
        doc.addEventListener('touchend', handleBodyTouchEnd);
        return function () {
          doc.removeEventListener('touchstart', handleBodyTouchStart);
          doc.removeEventListener('touchmove', handleBodyTouchMove, {
            passive: !open
          });
          doc.removeEventListener('touchend', handleBodyTouchEnd);
        };
      }
      return undefined;
    }, [variant, open, handleBodyTouchStart, handleBodyTouchMove, handleBodyTouchEnd]);
    React__namespace.useEffect(function () {
      return function () {
        // We need to release the lock.
        if (claimedSwipeInstance === swipeInstance.current) {
          claimedSwipeInstance = null;
        }
      };
    }, []);
    React__namespace.useEffect(function () {
      if (!open) {
        setMaybeSwiping(false);
      }
    }, [open]);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
      children: [/*#__PURE__*/jsxRuntimeExports.jsx(Drawer$1, _extends({
        open: variant === 'temporary' && maybeSwiping ? true : open,
        variant: variant,
        ModalProps: _extends({
          BackdropProps: _extends({}, BackdropProps, {
            ref: backdropRef
          })
        }, variant === 'temporary' && {
          keepMounted: true
        }, ModalPropsProp),
        hideBackdrop: hideBackdrop,
        PaperProps: _extends({}, PaperProps, {
          style: _extends({
            pointerEvents: variant === 'temporary' && !open && !allowSwipeInChildren ? 'none' : ''
          }, PaperProps.style),
          ref: handleRef
        }),
        anchor: anchor,
        transitionDuration: calculatedDurationRef.current || transitionDuration,
        onClose: onClose,
        ref: ref
      }, other)), !disableSwipeToOpen && variant === 'temporary' && /*#__PURE__*/jsxRuntimeExports.jsx(NoSsr, {
        children: /*#__PURE__*/jsxRuntimeExports.jsx(SwipeArea$1, _extends({
          anchor: anchor,
          ref: swipeAreaRef,
          width: swipeAreaWidth
        }, SwipeAreaProps))
      })]
    });
  });
  SwipeableDrawer.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * If set to true, the swipe event will open the drawer even if the user begins the swipe on one of the drawer's children.
     * This can be useful in scenarios where the drawer is partially visible.
     * You can customize it further with a callback that determines which children the user can drag over to open the drawer
     * (for example, to ignore other elements that handle touch move events, like sliders).
     *
     * @param {TouchEvent} event The 'touchstart' event
     * @param {HTMLDivElement} swipeArea The swipe area element
     * @param {HTMLDivElement} paper The drawer's paper element
     *
     * @default false
     */
    allowSwipeInChildren: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),
    /**
     * @ignore
     */
    anchor: PropTypes.oneOf(['bottom', 'left', 'right', 'top']),
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Disable the backdrop transition.
     * This can improve the FPS on low-end devices.
     * @default false
     */
    disableBackdropTransition: PropTypes.bool,
    /**
     * If `true`, touching the screen near the edge of the drawer will not slide in the drawer a bit
     * to promote accidental discovery of the swipe gesture.
     * @default false
     */
    disableDiscovery: PropTypes.bool,
    /**
     * If `true`, swipe to open is disabled. This is useful in browsers where swiping triggers
     * navigation actions. Swipe to open is disabled on iOS browsers by default.
     * @default typeof navigator !== 'undefined' && /iPad|iPhone|iPod/.test(navigator.userAgent)
     */
    disableSwipeToOpen: PropTypes.bool,
    /**
     * @ignore
     */
    hideBackdrop: PropTypes.bool,
    /**
     * Affects how far the drawer must be opened/closed to change its state.
     * Specified as percent (0-1) of the width of the drawer
     * @default 0.52
     */
    hysteresis: PropTypes.number,
    /**
     * Defines, from which (average) velocity on, the swipe is
     * defined as complete although hysteresis isn't reached.
     * Good threshold is between 250 - 1000 px/s
     * @default 450
     */
    minFlingVelocity: PropTypes.number,
    /**
     * @ignore
     */
    ModalProps: PropTypes /* @typescript-to-proptypes-ignore */.shape({
      BackdropProps: PropTypes.shape({
        component: elementTypeAcceptingRef$1
      })
    }),
    /**
     * Callback fired when the component requests to be closed.
     *
     * @param {React.SyntheticEvent<{}>} event The event source of the callback.
     */
    onClose: PropTypes.func.isRequired,
    /**
     * Callback fired when the component requests to be opened.
     *
     * @param {React.SyntheticEvent<{}>} event The event source of the callback.
     */
    onOpen: PropTypes.func.isRequired,
    /**
     * If `true`, the component is shown.
     * @default false
     */
    open: PropTypes.bool,
    /**
     * @ignore
     */
    PaperProps: PropTypes /* @typescript-to-proptypes-ignore */.shape({
      component: elementTypeAcceptingRef$1,
      style: PropTypes.object
    }),
    /**
     * The element is used to intercept the touch events on the edge.
     */
    SwipeAreaProps: PropTypes.object,
    /**
     * The width of the left most (or right most) area in `px` that
     * the drawer can be swiped open from.
     * @default 20
     */
    swipeAreaWidth: PropTypes.number,
    /**
     * The duration for the transition, in milliseconds.
     * You may specify a single timeout for all transitions, or individually with an object.
     * @default {
     *   enter: theme.transitions.duration.enteringScreen,
     *   exit: theme.transitions.duration.leavingScreen,
     * }
     */
    transitionDuration: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
      appear: PropTypes.number,
      enter: PropTypes.number,
      exit: PropTypes.number
    })]),
    /**
     * @ignore
     */
    variant: PropTypes.oneOf(['permanent', 'persistent', 'temporary'])
  } ;
  var SwipeableDrawer$1 = SwipeableDrawer;

  function getSwitchUtilityClass(slot) {
    return generateUtilityClass('MuiSwitch', slot);
  }
  var switchClasses = generateUtilityClasses('MuiSwitch', ['root', 'edgeStart', 'edgeEnd', 'switchBase', 'colorPrimary', 'colorSecondary', 'sizeSmall', 'sizeMedium', 'checked', 'disabled', 'input', 'thumb', 'track']);
  var switchClasses$1 = switchClasses;

  var useUtilityClasses$g = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      edge = ownerState.edge,
      size = ownerState.size,
      color = ownerState.color,
      checked = ownerState.checked,
      disabled = ownerState.disabled;
    var slots = {
      root: ['root', edge && "edge".concat(capitalize(edge)), "size".concat(capitalize(size))],
      switchBase: ['switchBase', "color".concat(capitalize(color)), checked && 'checked', disabled && 'disabled'],
      thumb: ['thumb'],
      track: ['track'],
      input: ['input']
    };
    var composedClasses = composeClasses(slots, getSwitchUtilityClass, classes);
    return _extends({}, classes, composedClasses);
  };
  var SwitchRoot = styled$1('span', {
    name: 'MuiSwitch',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.edge && styles["edge".concat(capitalize(ownerState.edge))], styles["size".concat(capitalize(ownerState.size))]];
    }
  })({
    display: 'inline-flex',
    width: 34 + 12 * 2,
    height: 14 + 12 * 2,
    overflow: 'hidden',
    padding: 12,
    boxSizing: 'border-box',
    position: 'relative',
    flexShrink: 0,
    zIndex: 0,
    // Reset the stacking context.
    verticalAlign: 'middle',
    // For correct alignment with the text.
    '@media print': {
      colorAdjust: 'exact'
    },
    variants: [{
      props: {
        edge: 'start'
      },
      style: {
        marginLeft: -8
      }
    }, {
      props: {
        edge: 'end'
      },
      style: {
        marginRight: -8
      }
    }, {
      props: {
        size: 'small'
      },
      style: _defineProperty(_defineProperty({
        width: 40,
        height: 24,
        padding: 7
      }, "& .".concat(switchClasses$1.thumb), {
        width: 16,
        height: 16
      }), "& .".concat(switchClasses$1.switchBase), _defineProperty({
        padding: 4
      }, "&.".concat(switchClasses$1.checked), {
        transform: 'translateX(16px)'
      }))
    }]
  });
  var SwitchSwitchBase = styled$1(SwitchBase$1, {
    name: 'MuiSwitch',
    slot: 'SwitchBase',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.switchBase, _defineProperty({}, "& .".concat(switchClasses$1.input), styles.input), ownerState.color !== 'default' && styles["color".concat(capitalize(ownerState.color))]];
    }
  })(function (_ref2) {
    var theme = _ref2.theme;
    return _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
      position: 'absolute',
      top: 0,
      left: 0,
      zIndex: 1,
      // Render above the focus ripple.
      color: theme.vars ? theme.vars.palette.Switch.defaultColor : "".concat(theme.palette.mode === 'light' ? theme.palette.common.white : theme.palette.grey[300]),
      transition: theme.transitions.create(['left', 'transform'], {
        duration: theme.transitions.duration.shortest
      })
    }, "&.".concat(switchClasses$1.checked), {
      transform: 'translateX(20px)'
    }), "&.".concat(switchClasses$1.disabled), {
      color: theme.vars ? theme.vars.palette.Switch.defaultDisabledColor : "".concat(theme.palette.mode === 'light' ? theme.palette.grey[100] : theme.palette.grey[600])
    }), "&.".concat(switchClasses$1.checked, " + .").concat(switchClasses$1.track), {
      opacity: 0.5
    }), "&.".concat(switchClasses$1.disabled, " + .").concat(switchClasses$1.track), {
      opacity: theme.vars ? theme.vars.opacity.switchTrackDisabled : "".concat(theme.palette.mode === 'light' ? 0.12 : 0.2)
    }), "& .".concat(switchClasses$1.input), {
      left: '-100%',
      width: '300%'
    });
  }, function (_ref4) {
    var theme = _ref4.theme;
    return {
      '&:hover': {
        backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.action.activeChannel, " / ").concat(theme.vars.palette.action.hoverOpacity, ")") : alpha(theme.palette.action.active, theme.palette.action.hoverOpacity),
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: 'transparent'
        }
      },
      variants: _toConsumableArray(Object.entries(theme.palette).filter(function (_ref5) {
        var _ref6 = _slicedToArray(_ref5, 2),
          value = _ref6[1];
        return value.main && value.light;
      }) // check all the used fields in the style below
      .map(function (_ref7) {
        var _ref8 = _slicedToArray(_ref7, 1),
          color = _ref8[0];
        return {
          props: {
            color: color
          },
          style: _defineProperty(_defineProperty({}, "&.".concat(switchClasses$1.checked), _defineProperty({
            color: (theme.vars || theme).palette[color].main,
            '&:hover': {
              backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette[color].mainChannel, " / ").concat(theme.vars.palette.action.hoverOpacity, ")") : alpha(theme.palette[color].main, theme.palette.action.hoverOpacity),
              '@media (hover: none)': {
                backgroundColor: 'transparent'
              }
            }
          }, "&.".concat(switchClasses$1.disabled), {
            color: theme.vars ? theme.vars.palette.Switch["".concat(color, "DisabledColor")] : "".concat(theme.palette.mode === 'light' ? lighten(theme.palette[color].main, 0.62) : darken(theme.palette[color].main, 0.55))
          })), "&.".concat(switchClasses$1.checked, " + .").concat(switchClasses$1.track), {
            backgroundColor: (theme.vars || theme).palette[color].main
          })
        };
      }))
    };
  });
  var SwitchTrack = styled$1('span', {
    name: 'MuiSwitch',
    slot: 'Track',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.track;
    }
  })(function (_ref9) {
    var theme = _ref9.theme;
    return {
      height: '100%',
      width: '100%',
      borderRadius: 14 / 2,
      zIndex: -1,
      transition: theme.transitions.create(['opacity', 'background-color'], {
        duration: theme.transitions.duration.shortest
      }),
      backgroundColor: theme.vars ? theme.vars.palette.common.onBackground : "".concat(theme.palette.mode === 'light' ? theme.palette.common.black : theme.palette.common.white),
      opacity: theme.vars ? theme.vars.opacity.switchTrack : "".concat(theme.palette.mode === 'light' ? 0.38 : 0.3)
    };
  });
  var SwitchThumb = styled$1('span', {
    name: 'MuiSwitch',
    slot: 'Thumb',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.thumb;
    }
  })(function (_ref10) {
    var theme = _ref10.theme;
    return {
      boxShadow: (theme.vars || theme).shadows[1],
      backgroundColor: 'currentColor',
      width: 20,
      height: 20,
      borderRadius: '50%'
    };
  });
  var Switch = /*#__PURE__*/React__namespace.forwardRef(function Switch(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiSwitch'
    });
    var className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'primary' : _props$color,
      _props$edge = props.edge,
      edge = _props$edge === void 0 ? false : _props$edge,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      sx = props.sx,
      other = _objectWithoutProperties(props, ["className", "color", "edge", "size", "sx"]);
    var ownerState = _extends({}, props, {
      color: color,
      edge: edge,
      size: size
    });
    var classes = useUtilityClasses$g(ownerState);
    var icon = /*#__PURE__*/jsxRuntimeExports.jsx(SwitchThumb, {
      className: classes.thumb,
      ownerState: ownerState
    });
    return /*#__PURE__*/jsxRuntimeExports.jsxs(SwitchRoot, {
      className: clsx(classes.root, className),
      sx: sx,
      ownerState: ownerState,
      children: [/*#__PURE__*/jsxRuntimeExports.jsx(SwitchSwitchBase, _extends({
        type: "checkbox",
        icon: icon,
        checkedIcon: icon,
        ref: ref,
        ownerState: ownerState
      }, other, {
        classes: _extends({}, classes, {
          root: classes.switchBase
        })
      })), /*#__PURE__*/jsxRuntimeExports.jsx(SwitchTrack, {
        className: classes.track,
        ownerState: ownerState
      })]
    });
  });
  Switch.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * If `true`, the component is checked.
     */
    checked: PropTypes.bool,
    /**
     * The icon to display when the component is checked.
     */
    checkedIcon: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'primary'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['default', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * The default checked state. Use when the component is not controlled.
     */
    defaultChecked: PropTypes.bool,
    /**
     * If `true`, the component is disabled.
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the ripple effect is disabled.
     * @default false
     */
    disableRipple: PropTypes.bool,
    /**
     * If given, uses a negative margin to counteract the padding on one
     * side (this is often helpful for aligning the left or right
     * side of the icon with content above or below, without ruining the border
     * size and shape).
     * @default false
     */
    edge: PropTypes.oneOf(['end', 'start', false]),
    /**
     * The icon to display when the component is unchecked.
     */
    icon: PropTypes.node,
    /**
     * The id of the `input` element.
     */
    id: PropTypes.string,
    /**
     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
     */
    inputProps: PropTypes.object,
    /**
     * Pass a ref to the `input` element.
     */
    inputRef: refType$1,
    /**
     * Callback fired when the state is changed.
     *
     * @param {React.ChangeEvent<HTMLInputElement>} event The event source of the callback.
     * You can pull out the new value by accessing `event.target.value` (string).
     * You can pull out the new checked state by accessing `event.target.checked` (boolean).
     */
    onChange: PropTypes.func,
    /**
     * If `true`, the `input` element is required.
     * @default false
     */
    required: PropTypes.bool,
    /**
     * The size of the component.
     * `small` is equivalent to the dense switch styling.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['medium', 'small']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The value of the component. The DOM API casts this to a string.
     * The browser uses "on" as the default value.
     */
    value: PropTypes.any
  } ;
  var Switch$1 = Switch;

  function getTabUtilityClass(slot) {
    return generateUtilityClass('MuiTab', slot);
  }
  var tabClasses = generateUtilityClasses('MuiTab', ['root', 'labelIcon', 'textColorInherit', 'textColorPrimary', 'textColorSecondary', 'selected', 'disabled', 'fullWidth', 'wrapped', 'iconWrapper']);
  var tabClasses$1 = tabClasses;

  var useUtilityClasses$f = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      textColor = ownerState.textColor,
      fullWidth = ownerState.fullWidth,
      wrapped = ownerState.wrapped,
      icon = ownerState.icon,
      label = ownerState.label,
      selected = ownerState.selected,
      disabled = ownerState.disabled;
    var slots = {
      root: ['root', icon && label && 'labelIcon', "textColor".concat(capitalize(textColor)), fullWidth && 'fullWidth', wrapped && 'wrapped', selected && 'selected', disabled && 'disabled'],
      iconWrapper: ['iconWrapper']
    };
    return composeClasses(slots, getTabUtilityClass, classes);
  };
  var TabRoot = styled$1(ButtonBase$1, {
    name: 'MuiTab',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.label && ownerState.icon && styles.labelIcon, styles["textColor".concat(capitalize(ownerState.textColor))], ownerState.fullWidth && styles.fullWidth, ownerState.wrapped && styles.wrapped, _defineProperty({}, "& .".concat(tabClasses$1.iconWrapper), styles.iconWrapper)];
    }
  })(function (_ref2) {
    var theme = _ref2.theme,
      ownerState = _ref2.ownerState;
    return _extends({}, theme.typography.button, {
      maxWidth: 360,
      minWidth: 90,
      position: 'relative',
      minHeight: 48,
      flexShrink: 0,
      padding: '12px 16px',
      overflow: 'hidden',
      whiteSpace: 'normal',
      textAlign: 'center'
    }, ownerState.label && {
      flexDirection: ownerState.iconPosition === 'top' || ownerState.iconPosition === 'bottom' ? 'column' : 'row'
    }, {
      lineHeight: 1.25
    }, ownerState.icon && ownerState.label && _defineProperty({
      minHeight: 72,
      paddingTop: 9,
      paddingBottom: 9
    }, "& > .".concat(tabClasses$1.iconWrapper), _extends({}, ownerState.iconPosition === 'top' && {
      marginBottom: 6
    }, ownerState.iconPosition === 'bottom' && {
      marginTop: 6
    }, ownerState.iconPosition === 'start' && {
      marginRight: theme.spacing(1)
    }, ownerState.iconPosition === 'end' && {
      marginLeft: theme.spacing(1)
    })), ownerState.textColor === 'inherit' && _defineProperty(_defineProperty({
      color: 'inherit',
      opacity: 0.6
    }, "&.".concat(tabClasses$1.selected), {
      opacity: 1
    }), "&.".concat(tabClasses$1.disabled), {
      opacity: (theme.vars || theme).palette.action.disabledOpacity
    }), ownerState.textColor === 'primary' && _defineProperty(_defineProperty({
      color: (theme.vars || theme).palette.text.secondary
    }, "&.".concat(tabClasses$1.selected), {
      color: (theme.vars || theme).palette.primary.main
    }), "&.".concat(tabClasses$1.disabled), {
      color: (theme.vars || theme).palette.text.disabled
    }), ownerState.textColor === 'secondary' && _defineProperty(_defineProperty({
      color: (theme.vars || theme).palette.text.secondary
    }, "&.".concat(tabClasses$1.selected), {
      color: (theme.vars || theme).palette.secondary.main
    }), "&.".concat(tabClasses$1.disabled), {
      color: (theme.vars || theme).palette.text.disabled
    }), ownerState.fullWidth && {
      flexShrink: 1,
      flexGrow: 1,
      flexBasis: 0,
      maxWidth: 'none'
    }, ownerState.wrapped && {
      fontSize: theme.typography.pxToRem(12)
    });
  });
  var Tab = /*#__PURE__*/React__namespace.forwardRef(function Tab(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTab'
    });
    var className = props.className,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$disableFocusRi = props.disableFocusRipple,
      disableFocusRipple = _props$disableFocusRi === void 0 ? false : _props$disableFocusRi,
      fullWidth = props.fullWidth,
      iconProp = props.icon,
      _props$iconPosition = props.iconPosition,
      iconPosition = _props$iconPosition === void 0 ? 'top' : _props$iconPosition,
      indicator = props.indicator,
      label = props.label,
      onChange = props.onChange,
      onClick = props.onClick,
      onFocus = props.onFocus,
      selected = props.selected,
      selectionFollowsFocus = props.selectionFollowsFocus,
      _props$textColor = props.textColor,
      textColor = _props$textColor === void 0 ? 'inherit' : _props$textColor,
      value = props.value,
      _props$wrapped = props.wrapped,
      wrapped = _props$wrapped === void 0 ? false : _props$wrapped,
      other = _objectWithoutProperties(props, ["className", "disabled", "disableFocusRipple", "fullWidth", "icon", "iconPosition", "indicator", "label", "onChange", "onClick", "onFocus", "selected", "selectionFollowsFocus", "textColor", "value", "wrapped"]);
    var ownerState = _extends({}, props, {
      disabled: disabled,
      disableFocusRipple: disableFocusRipple,
      selected: selected,
      icon: !!iconProp,
      iconPosition: iconPosition,
      label: !!label,
      fullWidth: fullWidth,
      textColor: textColor,
      wrapped: wrapped
    });
    var classes = useUtilityClasses$f(ownerState);
    var icon = iconProp && label && /*#__PURE__*/React__namespace.isValidElement(iconProp) ? /*#__PURE__*/React__namespace.cloneElement(iconProp, {
      className: clsx(classes.iconWrapper, iconProp.props.className)
    }) : iconProp;
    var handleClick = function handleClick(event) {
      if (!selected && onChange) {
        onChange(event, value);
      }
      if (onClick) {
        onClick(event);
      }
    };
    var handleFocus = function handleFocus(event) {
      if (selectionFollowsFocus && !selected && onChange) {
        onChange(event, value);
      }
      if (onFocus) {
        onFocus(event);
      }
    };
    return /*#__PURE__*/jsxRuntimeExports.jsxs(TabRoot, _extends({
      focusRipple: !disableFocusRipple,
      className: clsx(classes.root, className),
      ref: ref,
      role: "tab",
      "aria-selected": selected,
      disabled: disabled,
      onClick: handleClick,
      onFocus: handleFocus,
      ownerState: ownerState,
      tabIndex: selected ? 0 : -1
    }, other, {
      children: [iconPosition === 'top' || iconPosition === 'start' ? /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
        children: [icon, label]
      }) : /*#__PURE__*/jsxRuntimeExports.jsxs(React__namespace.Fragment, {
        children: [label, icon]
      }), indicator]
    }));
  });
  Tab.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * This prop isn't supported.
     * Use the `component` prop if you need to change the children structure.
     */
    children: unsupportedProp,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the  keyboard focus ripple is disabled.
     * @default false
     */
    disableFocusRipple: PropTypes.bool,
    /**
     * If `true`, the ripple effect is disabled.
     *
     * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
     * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
     * @default false
     */
    disableRipple: PropTypes.bool,
    /**
     * The icon to display.
     */
    icon: PropTypes.oneOfType([PropTypes.element, PropTypes.string]),
    /**
     * The position of the icon relative to the label.
     * @default 'top'
     */
    iconPosition: PropTypes.oneOf(['bottom', 'end', 'start', 'top']),
    /**
     * The label element.
     */
    label: PropTypes.node,
    /**
     * @ignore
     */
    onChange: PropTypes.func,
    /**
     * @ignore
     */
    onClick: PropTypes.func,
    /**
     * @ignore
     */
    onFocus: PropTypes.func,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * You can provide your own value. Otherwise, we fallback to the child position index.
     */
    value: PropTypes.any,
    /**
     * Tab labels appear in a single row.
     * They can use a second line if needed.
     * @default false
     */
    wrapped: PropTypes.bool
  } ;
  var Tab$1 = Tab;

  /**
   * @ignore - internal component.
   */
  var TableContext = /*#__PURE__*/React__namespace.createContext();
  {
    TableContext.displayName = 'TableContext';
  }
  var TableContext$1 = TableContext;

  function getTableUtilityClass(slot) {
    return generateUtilityClass('MuiTable', slot);
  }
  var tableClasses = generateUtilityClasses('MuiTable', ['root', 'stickyHeader']);
  var tableClasses$1 = tableClasses;

  var useUtilityClasses$e = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      stickyHeader = ownerState.stickyHeader;
    var slots = {
      root: ['root', stickyHeader && 'stickyHeader']
    };
    return composeClasses(slots, getTableUtilityClass, classes);
  };
  var TableRoot = styled$1('table', {
    name: 'MuiTable',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.stickyHeader && styles.stickyHeader];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      display: 'table',
      width: '100%',
      borderCollapse: 'collapse',
      borderSpacing: 0,
      '& caption': _extends({}, theme.typography.body2, {
        padding: theme.spacing(2),
        color: (theme.vars || theme).palette.text.secondary,
        textAlign: 'left',
        captionSide: 'bottom'
      })
    }, ownerState.stickyHeader && {
      borderCollapse: 'separate'
    });
  });
  var defaultComponent$4 = 'table';
  var Table = /*#__PURE__*/React__namespace.forwardRef(function Table(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTable'
    });
    var className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? defaultComponent$4 : _props$component,
      _props$padding = props.padding,
      padding = _props$padding === void 0 ? 'normal' : _props$padding,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      _props$stickyHeader = props.stickyHeader,
      stickyHeader = _props$stickyHeader === void 0 ? false : _props$stickyHeader,
      other = _objectWithoutProperties(props, ["className", "component", "padding", "size", "stickyHeader"]);
    var ownerState = _extends({}, props, {
      component: component,
      padding: padding,
      size: size,
      stickyHeader: stickyHeader
    });
    var classes = useUtilityClasses$e(ownerState);
    var table = React__namespace.useMemo(function () {
      return {
        padding: padding,
        size: size,
        stickyHeader: stickyHeader
      };
    }, [padding, size, stickyHeader]);
    return /*#__PURE__*/jsxRuntimeExports.jsx(TableContext$1.Provider, {
      value: table,
      children: /*#__PURE__*/jsxRuntimeExports.jsx(TableRoot, _extends({
        as: component,
        role: component === defaultComponent$4 ? null : 'table',
        ref: ref,
        className: clsx(classes.root, className),
        ownerState: ownerState
      }, other))
    });
  });
  Table.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the table, normally `TableHead` and `TableBody`.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * Allows TableCells to inherit padding of the Table.
     * @default 'normal'
     */
    padding: PropTypes.oneOf(['checkbox', 'none', 'normal']),
    /**
     * Allows TableCells to inherit size of the Table.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['medium', 'small']), PropTypes.string]),
    /**
     * Set the header sticky.
     *
     * ⚠️ It doesn't work with IE11.
     * @default false
     */
    stickyHeader: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var Table$1 = Table;

  /**
   * @ignore - internal component.
   */
  var Tablelvl2Context = /*#__PURE__*/React__namespace.createContext();
  {
    Tablelvl2Context.displayName = 'Tablelvl2Context';
  }
  var Tablelvl2Context$1 = Tablelvl2Context;

  function getTableBodyUtilityClass(slot) {
    return generateUtilityClass('MuiTableBody', slot);
  }
  var tableBodyClasses = generateUtilityClasses('MuiTableBody', ['root']);
  var tableBodyClasses$1 = tableBodyClasses;

  var useUtilityClasses$d = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    return composeClasses(slots, getTableBodyUtilityClass, classes);
  };
  var TableBodyRoot = styled$1('tbody', {
    name: 'MuiTableBody',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })({
    display: 'table-row-group'
  });
  var tablelvl2$2 = {
    variant: 'body'
  };
  var defaultComponent$3 = 'tbody';
  var TableBody = /*#__PURE__*/React__namespace.forwardRef(function TableBody(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTableBody'
    });
    var className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? defaultComponent$3 : _props$component,
      other = _objectWithoutProperties(props, ["className", "component"]);
    var ownerState = _extends({}, props, {
      component: component
    });
    var classes = useUtilityClasses$d(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(Tablelvl2Context$1.Provider, {
      value: tablelvl2$2,
      children: /*#__PURE__*/jsxRuntimeExports.jsx(TableBodyRoot, _extends({
        className: clsx(classes.root, className),
        as: component,
        ref: ref,
        role: component === defaultComponent$3 ? null : 'rowgroup',
        ownerState: ownerState
      }, other))
    });
  });
  TableBody.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component, normally `TableRow`.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var TableBody$1 = TableBody;

  function getTableCellUtilityClass(slot) {
    return generateUtilityClass('MuiTableCell', slot);
  }
  var tableCellClasses = generateUtilityClasses('MuiTableCell', ['root', 'head', 'body', 'footer', 'sizeSmall', 'sizeMedium', 'paddingCheckbox', 'paddingNone', 'alignLeft', 'alignCenter', 'alignRight', 'alignJustify', 'stickyHeader']);
  var tableCellClasses$1 = tableCellClasses;

  var useUtilityClasses$c = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      variant = ownerState.variant,
      align = ownerState.align,
      padding = ownerState.padding,
      size = ownerState.size,
      stickyHeader = ownerState.stickyHeader;
    var slots = {
      root: ['root', variant, stickyHeader && 'stickyHeader', align !== 'inherit' && "align".concat(capitalize(align)), padding !== 'normal' && "padding".concat(capitalize(padding)), "size".concat(capitalize(size))]
    };
    return composeClasses(slots, getTableCellUtilityClass, classes);
  };
  var TableCellRoot = styled$1('td', {
    name: 'MuiTableCell',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles[ownerState.variant], styles["size".concat(capitalize(ownerState.size))], ownerState.padding !== 'normal' && styles["padding".concat(capitalize(ownerState.padding))], ownerState.align !== 'inherit' && styles["align".concat(capitalize(ownerState.align))], ownerState.stickyHeader && styles.stickyHeader];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({}, theme.typography.body2, {
      display: 'table-cell',
      verticalAlign: 'inherit',
      // Workaround for a rendering bug with spanned columns in Chrome 62.0.
      // Removes the alpha (sets it to 1), and lightens or darkens the theme color.
      borderBottom: theme.vars ? "1px solid ".concat(theme.vars.palette.TableCell.border) : "1px solid\n    ".concat(theme.palette.mode === 'light' ? lighten(alpha(theme.palette.divider, 1), 0.88) : darken(alpha(theme.palette.divider, 1), 0.68)),
      textAlign: 'left',
      padding: 16
    }, ownerState.variant === 'head' && {
      color: (theme.vars || theme).palette.text.primary,
      lineHeight: theme.typography.pxToRem(24),
      fontWeight: theme.typography.fontWeightMedium
    }, ownerState.variant === 'body' && {
      color: (theme.vars || theme).palette.text.primary
    }, ownerState.variant === 'footer' && {
      color: (theme.vars || theme).palette.text.secondary,
      lineHeight: theme.typography.pxToRem(21),
      fontSize: theme.typography.pxToRem(12)
    }, ownerState.size === 'small' && _defineProperty({
      padding: '6px 16px'
    }, "&.".concat(tableCellClasses$1.paddingCheckbox), {
      width: 24,
      // prevent the checkbox column from growing
      padding: '0 12px 0 16px',
      '& > *': {
        padding: 0
      }
    }), ownerState.padding === 'checkbox' && {
      width: 48,
      // prevent the checkbox column from growing
      padding: '0 0 0 4px'
    }, ownerState.padding === 'none' && {
      padding: 0
    }, ownerState.align === 'left' && {
      textAlign: 'left'
    }, ownerState.align === 'center' && {
      textAlign: 'center'
    }, ownerState.align === 'right' && {
      textAlign: 'right',
      flexDirection: 'row-reverse'
    }, ownerState.align === 'justify' && {
      textAlign: 'justify'
    }, ownerState.stickyHeader && {
      position: 'sticky',
      top: 0,
      zIndex: 2,
      backgroundColor: (theme.vars || theme).palette.background["default"]
    });
  });

  /**
   * The component renders a `<th>` element when the parent context is a header
   * or otherwise a `<td>` element.
   */
  var TableCell = /*#__PURE__*/React__namespace.forwardRef(function TableCell(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTableCell'
    });
    var _props$align = props.align,
      align = _props$align === void 0 ? 'inherit' : _props$align,
      className = props.className,
      componentProp = props.component,
      paddingProp = props.padding,
      scopeProp = props.scope,
      sizeProp = props.size,
      sortDirection = props.sortDirection,
      variantProp = props.variant,
      other = _objectWithoutProperties(props, ["align", "className", "component", "padding", "scope", "size", "sortDirection", "variant"]);
    var table = React__namespace.useContext(TableContext$1);
    var tablelvl2 = React__namespace.useContext(Tablelvl2Context$1);
    var isHeadCell = tablelvl2 && tablelvl2.variant === 'head';
    var component;
    if (componentProp) {
      component = componentProp;
    } else {
      component = isHeadCell ? 'th' : 'td';
    }
    var scope = scopeProp;
    // scope is not a valid attribute for <td/> elements.
    // source: https://html.spec.whatwg.org/multipage/tables.html#the-td-element
    if (component === 'td') {
      scope = undefined;
    } else if (!scope && isHeadCell) {
      scope = 'col';
    }
    var variant = variantProp || tablelvl2 && tablelvl2.variant;
    var ownerState = _extends({}, props, {
      align: align,
      component: component,
      padding: paddingProp || (table && table.padding ? table.padding : 'normal'),
      size: sizeProp || (table && table.size ? table.size : 'medium'),
      sortDirection: sortDirection,
      stickyHeader: variant === 'head' && table && table.stickyHeader,
      variant: variant
    });
    var classes = useUtilityClasses$c(ownerState);
    var ariaSort = null;
    if (sortDirection) {
      ariaSort = sortDirection === 'asc' ? 'ascending' : 'descending';
    }
    return /*#__PURE__*/jsxRuntimeExports.jsx(TableCellRoot, _extends({
      as: component,
      ref: ref,
      className: clsx(classes.root, className),
      "aria-sort": ariaSort,
      scope: scope,
      ownerState: ownerState
    }, other));
  });
  TableCell.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Set the text-align on the table cell content.
     *
     * Monetary or generally number fields **should be right aligned** as that allows
     * you to add them up quickly in your head without having to worry about decimals.
     * @default 'inherit'
     */
    align: PropTypes.oneOf(['center', 'inherit', 'justify', 'left', 'right']),
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * Sets the padding applied to the cell.
     * The prop defaults to the value (`'default'`) inherited from the parent Table component.
     */
    padding: PropTypes.oneOf(['checkbox', 'none', 'normal']),
    /**
     * Set scope attribute.
     */
    scope: PropTypes.string,
    /**
     * Specify the size of the cell.
     * The prop defaults to the value (`'medium'`) inherited from the parent Table component.
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['medium', 'small']), PropTypes.string]),
    /**
     * Set aria-sort direction.
     */
    sortDirection: PropTypes.oneOf(['asc', 'desc', false]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * Specify the cell type.
     * The prop defaults to the value inherited from the parent TableHead, TableBody, or TableFooter components.
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['body', 'footer', 'head']), PropTypes.string])
  } ;
  var TableCell$1 = TableCell;

  function getTableContainerUtilityClass(slot) {
    return generateUtilityClass('MuiTableContainer', slot);
  }
  var tableContainerClasses = generateUtilityClasses('MuiTableContainer', ['root']);
  var tableContainerClasses$1 = tableContainerClasses;

  var useUtilityClasses$b = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    return composeClasses(slots, getTableContainerUtilityClass, classes);
  };
  var TableContainerRoot = styled$1('div', {
    name: 'MuiTableContainer',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })({
    width: '100%',
    overflowX: 'auto'
  });
  var TableContainer = /*#__PURE__*/React__namespace.forwardRef(function TableContainer(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTableContainer'
    });
    var className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      other = _objectWithoutProperties(props, ["className", "component"]);
    var ownerState = _extends({}, props, {
      component: component
    });
    var classes = useUtilityClasses$b(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(TableContainerRoot, _extends({
      ref: ref,
      as: component,
      className: clsx(classes.root, className),
      ownerState: ownerState
    }, other));
  });
  TableContainer.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component, normally `Table`.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var TableContainer$1 = TableContainer;

  function getTableFooterUtilityClass(slot) {
    return generateUtilityClass('MuiTableFooter', slot);
  }
  var tableFooterClasses = generateUtilityClasses('MuiTableFooter', ['root']);
  var tableFooterClasses$1 = tableFooterClasses;

  var useUtilityClasses$a = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    return composeClasses(slots, getTableFooterUtilityClass, classes);
  };
  var TableFooterRoot = styled$1('tfoot', {
    name: 'MuiTableFooter',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })({
    display: 'table-footer-group'
  });
  var tablelvl2$1 = {
    variant: 'footer'
  };
  var defaultComponent$2 = 'tfoot';
  var TableFooter = /*#__PURE__*/React__namespace.forwardRef(function TableFooter(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTableFooter'
    });
    var className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? defaultComponent$2 : _props$component,
      other = _objectWithoutProperties(props, ["className", "component"]);
    var ownerState = _extends({}, props, {
      component: component
    });
    var classes = useUtilityClasses$a(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(Tablelvl2Context$1.Provider, {
      value: tablelvl2$1,
      children: /*#__PURE__*/jsxRuntimeExports.jsx(TableFooterRoot, _extends({
        as: component,
        className: clsx(classes.root, className),
        ref: ref,
        role: component === defaultComponent$2 ? null : 'rowgroup',
        ownerState: ownerState
      }, other))
    });
  });
  TableFooter.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component, normally `TableRow`.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var TableFooter$1 = TableFooter;

  function getTableHeadUtilityClass(slot) {
    return generateUtilityClass('MuiTableHead', slot);
  }
  var tableHeadClasses = generateUtilityClasses('MuiTableHead', ['root']);
  var tableHeadClasses$1 = tableHeadClasses;

  var useUtilityClasses$9 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    return composeClasses(slots, getTableHeadUtilityClass, classes);
  };
  var TableHeadRoot = styled$1('thead', {
    name: 'MuiTableHead',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })({
    display: 'table-header-group'
  });
  var tablelvl2 = {
    variant: 'head'
  };
  var defaultComponent$1 = 'thead';
  var TableHead = /*#__PURE__*/React__namespace.forwardRef(function TableHead(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTableHead'
    });
    var className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? defaultComponent$1 : _props$component,
      other = _objectWithoutProperties(props, ["className", "component"]);
    var ownerState = _extends({}, props, {
      component: component
    });
    var classes = useUtilityClasses$9(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(Tablelvl2Context$1.Provider, {
      value: tablelvl2,
      children: /*#__PURE__*/jsxRuntimeExports.jsx(TableHeadRoot, _extends({
        as: component,
        className: clsx(classes.root, className),
        ref: ref,
        role: component === defaultComponent$1 ? null : 'rowgroup',
        ownerState: ownerState
      }, other))
    });
  });
  TableHead.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component, normally `TableRow`.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var TableHead$1 = TableHead;

  function getToolbarUtilityClass(slot) {
    return generateUtilityClass('MuiToolbar', slot);
  }
  var toolbarClasses = generateUtilityClasses('MuiToolbar', ['root', 'gutters', 'regular', 'dense']);
  var toolbarClasses$1 = toolbarClasses;

  var useUtilityClasses$8 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      disableGutters = ownerState.disableGutters,
      variant = ownerState.variant;
    var slots = {
      root: ['root', !disableGutters && 'gutters', variant]
    };
    return composeClasses(slots, getToolbarUtilityClass, classes);
  };
  var ToolbarRoot = styled$1('div', {
    name: 'MuiToolbar',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, !ownerState.disableGutters && styles.gutters, styles[ownerState.variant]];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    return _extends({
      position: 'relative',
      display: 'flex',
      alignItems: 'center'
    }, !ownerState.disableGutters && _defineProperty({
      paddingLeft: theme.spacing(2),
      paddingRight: theme.spacing(2)
    }, theme.breakpoints.up('sm'), {
      paddingLeft: theme.spacing(3),
      paddingRight: theme.spacing(3)
    }), ownerState.variant === 'dense' && {
      minHeight: 48
    });
  }, function (_ref3) {
    var theme = _ref3.theme,
      ownerState = _ref3.ownerState;
    return ownerState.variant === 'regular' && theme.mixins.toolbar;
  });
  var Toolbar = /*#__PURE__*/React__namespace.forwardRef(function Toolbar(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiToolbar'
    });
    var className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      _props$disableGutters = props.disableGutters,
      disableGutters = _props$disableGutters === void 0 ? false : _props$disableGutters,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'regular' : _props$variant,
      other = _objectWithoutProperties(props, ["className", "component", "disableGutters", "variant"]);
    var ownerState = _extends({}, props, {
      component: component,
      disableGutters: disableGutters,
      variant: variant
    });
    var classes = useUtilityClasses$8(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(ToolbarRoot, _extends({
      as: component,
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState
    }, other));
  });
  Toolbar.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The Toolbar children, usually a mixture of `IconButton`, `Button` and `Typography`.
     * The Toolbar is a flex container, allowing flex item properties to be used to lay out the children.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, disables gutter padding.
     * @default false
     */
    disableGutters: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The variant to use.
     * @default 'regular'
     */
    variant: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['dense', 'regular']), PropTypes.string])
  } ;
  var Toolbar$1 = Toolbar;

  var KeyboardArrowLeft = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M15.41 16.09l-4.58-4.59 4.58-4.59L14 5.5l-6 6 6 6z"
  }), 'KeyboardArrowLeft');

  var KeyboardArrowRight = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M8.59 16.34l4.58-4.59-4.58-4.59L10 5.75l6 6-6 6z"
  }), 'KeyboardArrowRight');

  var TablePaginationActions = /*#__PURE__*/React__namespace.forwardRef(function TablePaginationActions(props, ref) {
    var _slots$firstButton, _slots$lastButton, _slots$nextButton, _slots$previousButton, _slots$firstButtonIco, _slots$lastButtonIcon, _slots$nextButtonIcon, _slots$previousButton2;
    var backIconButtonProps = props.backIconButtonProps,
      count = props.count,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      getItemAriaLabel = props.getItemAriaLabel,
      nextIconButtonProps = props.nextIconButtonProps,
      onPageChange = props.onPageChange,
      page = props.page,
      rowsPerPage = props.rowsPerPage,
      showFirstButton = props.showFirstButton,
      showLastButton = props.showLastButton,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      other = _objectWithoutProperties(props, ["backIconButtonProps", "count", "disabled", "getItemAriaLabel", "nextIconButtonProps", "onPageChange", "page", "rowsPerPage", "showFirstButton", "showLastButton", "slots", "slotProps"]);
    var isRtl = useRtl();
    var handleFirstPageButtonClick = function handleFirstPageButtonClick(event) {
      onPageChange(event, 0);
    };
    var handleBackButtonClick = function handleBackButtonClick(event) {
      onPageChange(event, page - 1);
    };
    var handleNextButtonClick = function handleNextButtonClick(event) {
      onPageChange(event, page + 1);
    };
    var handleLastPageButtonClick = function handleLastPageButtonClick(event) {
      onPageChange(event, Math.max(0, Math.ceil(count / rowsPerPage) - 1));
    };
    var FirstButton = (_slots$firstButton = slots.firstButton) != null ? _slots$firstButton : IconButton$1;
    var LastButton = (_slots$lastButton = slots.lastButton) != null ? _slots$lastButton : IconButton$1;
    var NextButton = (_slots$nextButton = slots.nextButton) != null ? _slots$nextButton : IconButton$1;
    var PreviousButton = (_slots$previousButton = slots.previousButton) != null ? _slots$previousButton : IconButton$1;
    var FirstButtonIcon = (_slots$firstButtonIco = slots.firstButtonIcon) != null ? _slots$firstButtonIco : FirstPageIconDefault;
    var LastButtonIcon = (_slots$lastButtonIcon = slots.lastButtonIcon) != null ? _slots$lastButtonIcon : LastPageIconDefault;
    var NextButtonIcon = (_slots$nextButtonIcon = slots.nextButtonIcon) != null ? _slots$nextButtonIcon : KeyboardArrowRight;
    var PreviousButtonIcon = (_slots$previousButton2 = slots.previousButtonIcon) != null ? _slots$previousButton2 : KeyboardArrowLeft;
    var FirstButtonSlot = isRtl ? LastButton : FirstButton;
    var PreviousButtonSlot = isRtl ? NextButton : PreviousButton;
    var NextButtonSlot = isRtl ? PreviousButton : NextButton;
    var LastButtonSlot = isRtl ? FirstButton : LastButton;
    var firstButtonSlotProps = isRtl ? slotProps.lastButton : slotProps.firstButton;
    var previousButtonSlotProps = isRtl ? slotProps.nextButton : slotProps.previousButton;
    var nextButtonSlotProps = isRtl ? slotProps.previousButton : slotProps.nextButton;
    var lastButtonSlotProps = isRtl ? slotProps.firstButton : slotProps.lastButton;
    return /*#__PURE__*/jsxRuntimeExports.jsxs("div", _extends({
      ref: ref
    }, other, {
      children: [showFirstButton && /*#__PURE__*/jsxRuntimeExports.jsx(FirstButtonSlot, _extends({
        onClick: handleFirstPageButtonClick,
        disabled: disabled || page === 0,
        "aria-label": getItemAriaLabel('first', page),
        title: getItemAriaLabel('first', page)
      }, firstButtonSlotProps, {
        children: isRtl ? /*#__PURE__*/jsxRuntimeExports.jsx(LastButtonIcon, _extends({}, slotProps.lastButtonIcon)) : /*#__PURE__*/jsxRuntimeExports.jsx(FirstButtonIcon, _extends({}, slotProps.firstButtonIcon))
      })), /*#__PURE__*/jsxRuntimeExports.jsx(PreviousButtonSlot, _extends({
        onClick: handleBackButtonClick,
        disabled: disabled || page === 0,
        color: "inherit",
        "aria-label": getItemAriaLabel('previous', page),
        title: getItemAriaLabel('previous', page)
      }, previousButtonSlotProps != null ? previousButtonSlotProps : backIconButtonProps, {
        children: isRtl ? /*#__PURE__*/jsxRuntimeExports.jsx(NextButtonIcon, _extends({}, slotProps.nextButtonIcon)) : /*#__PURE__*/jsxRuntimeExports.jsx(PreviousButtonIcon, _extends({}, slotProps.previousButtonIcon))
      })), /*#__PURE__*/jsxRuntimeExports.jsx(NextButtonSlot, _extends({
        onClick: handleNextButtonClick,
        disabled: disabled || (count !== -1 ? page >= Math.ceil(count / rowsPerPage) - 1 : false),
        color: "inherit",
        "aria-label": getItemAriaLabel('next', page),
        title: getItemAriaLabel('next', page)
      }, nextButtonSlotProps != null ? nextButtonSlotProps : nextIconButtonProps, {
        children: isRtl ? /*#__PURE__*/jsxRuntimeExports.jsx(PreviousButtonIcon, _extends({}, slotProps.previousButtonIcon)) : /*#__PURE__*/jsxRuntimeExports.jsx(NextButtonIcon, _extends({}, slotProps.nextButtonIcon))
      })), showLastButton && /*#__PURE__*/jsxRuntimeExports.jsx(LastButtonSlot, _extends({
        onClick: handleLastPageButtonClick,
        disabled: disabled || page >= Math.ceil(count / rowsPerPage) - 1,
        "aria-label": getItemAriaLabel('last', page),
        title: getItemAriaLabel('last', page)
      }, lastButtonSlotProps, {
        children: isRtl ? /*#__PURE__*/jsxRuntimeExports.jsx(FirstButtonIcon, _extends({}, slotProps.firstButtonIcon)) : /*#__PURE__*/jsxRuntimeExports.jsx(LastButtonIcon, _extends({}, slotProps.lastButtonIcon))
      }))]
    }));
  });
  TablePaginationActions.propTypes = {
    /**
     * Props applied to the back arrow [`IconButton`](/material-ui/api/icon-button/) element.
     */
    backIconButtonProps: PropTypes.object,
    /**
     * The total number of rows.
     */
    count: PropTypes.number.isRequired,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * Accepts a function which returns a string value that provides a user-friendly name for the current page.
     *
     * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
     *
     * @param {string} type The link or button type to format ('page' | 'first' | 'last' | 'next' | 'previous'). Defaults to 'page'.
     * @param {number} page The page number to format.
     * @returns {string}
     */
    getItemAriaLabel: PropTypes.func.isRequired,
    /**
     * Props applied to the next arrow [`IconButton`](/material-ui/api/icon-button/) element.
     */
    nextIconButtonProps: PropTypes.object,
    /**
     * Callback fired when the page is changed.
     *
     * @param {object} event The event source of the callback.
     * @param {number} page The page selected.
     */
    onPageChange: PropTypes.func.isRequired,
    /**
     * The zero-based index of the current page.
     */
    page: PropTypes.number.isRequired,
    /**
     * The number of rows per page.
     */
    rowsPerPage: PropTypes.number.isRequired,
    /**
     * If `true`, show the first-page button.
     */
    showFirstButton: PropTypes.bool.isRequired,
    /**
     * If `true`, show the last-page button.
     */
    showLastButton: PropTypes.bool.isRequired,
    /**
     * The props used for each slot inside the TablePaginationActions.
     * @default {}
     */
    slotProps: PropTypes.shape({
      firstButton: PropTypes.object,
      firstButtonIcon: PropTypes.object,
      lastButton: PropTypes.object,
      lastButtonIcon: PropTypes.object,
      nextButton: PropTypes.object,
      nextButtonIcon: PropTypes.object,
      previousButton: PropTypes.object,
      previousButtonIcon: PropTypes.object
    }),
    /**
     * The components used for each slot inside the TablePaginationActions.
     * Either a string to use a HTML element or a component.
     * @default {}
     */
    slots: PropTypes.shape({
      firstButton: PropTypes.elementType,
      firstButtonIcon: PropTypes.elementType,
      lastButton: PropTypes.elementType,
      lastButtonIcon: PropTypes.elementType,
      nextButton: PropTypes.elementType,
      nextButtonIcon: PropTypes.elementType,
      previousButton: PropTypes.elementType,
      previousButtonIcon: PropTypes.elementType
    })
  } ;
  var TablePaginationActions$1 = TablePaginationActions;

  function getTablePaginationUtilityClass(slot) {
    return generateUtilityClass('MuiTablePagination', slot);
  }
  var tablePaginationClasses = generateUtilityClasses('MuiTablePagination', ['root', 'toolbar', 'spacer', 'selectLabel', 'selectRoot', 'select', 'selectIcon', 'input', 'menuItem', 'displayedRows', 'actions']);
  var tablePaginationClasses$1 = tablePaginationClasses;

  var _InputBase;
  var TablePaginationRoot = styled$1(TableCell$1, {
    name: 'MuiTablePagination',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })(function (_ref) {
    var theme = _ref.theme;
    return {
      overflow: 'auto',
      color: (theme.vars || theme).palette.text.primary,
      fontSize: theme.typography.pxToRem(14),
      // Increase the specificity to override TableCell.
      '&:last-child': {
        padding: 0
      }
    };
  });
  var TablePaginationToolbar = styled$1(Toolbar$1, {
    name: 'MuiTablePagination',
    slot: 'Toolbar',
    overridesResolver: function overridesResolver(props, styles) {
      return _extends(_defineProperty({}, "& .".concat(tablePaginationClasses$1.actions), styles.actions), styles.toolbar);
    }
  })(function (_ref2) {
    var theme = _ref2.theme;
    return _defineProperty(_defineProperty(_defineProperty({
      minHeight: 52,
      paddingRight: 2
    }, "".concat(theme.breakpoints.up('xs'), " and (orientation: landscape)"), {
      minHeight: 52
    }), theme.breakpoints.up('sm'), {
      minHeight: 52,
      paddingRight: 2
    }), "& .".concat(tablePaginationClasses$1.actions), {
      flexShrink: 0,
      marginLeft: 20
    });
  });
  var TablePaginationSpacer = styled$1('div', {
    name: 'MuiTablePagination',
    slot: 'Spacer',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.spacer;
    }
  })({
    flex: '1 1 100%'
  });
  var TablePaginationSelectLabel = styled$1('p', {
    name: 'MuiTablePagination',
    slot: 'SelectLabel',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.selectLabel;
    }
  })(function (_ref4) {
    var theme = _ref4.theme;
    return _extends({}, theme.typography.body2, {
      flexShrink: 0
    });
  });
  var TablePaginationSelect = styled$1(Select$1, {
    name: 'MuiTablePagination',
    slot: 'Select',
    overridesResolver: function overridesResolver(props, styles) {
      return _extends(_defineProperty(_defineProperty({}, "& .".concat(tablePaginationClasses$1.selectIcon), styles.selectIcon), "& .".concat(tablePaginationClasses$1.select), styles.select), styles.input, styles.selectRoot);
    }
  })(_defineProperty({
    color: 'inherit',
    fontSize: 'inherit',
    flexShrink: 0,
    marginRight: 32,
    marginLeft: 8
  }, "& .".concat(tablePaginationClasses$1.select), {
    paddingLeft: 8,
    paddingRight: 24,
    textAlign: 'right',
    textAlignLast: 'right' // Align <select> on Chrome.
  }));
  var TablePaginationMenuItem = styled$1(MenuItem$1, {
    name: 'MuiTablePagination',
    slot: 'MenuItem',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.menuItem;
    }
  })({});
  var TablePaginationDisplayedRows = styled$1('p', {
    name: 'MuiTablePagination',
    slot: 'DisplayedRows',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.displayedRows;
    }
  })(function (_ref5) {
    var theme = _ref5.theme;
    return _extends({}, theme.typography.body2, {
      flexShrink: 0
    });
  });
  function defaultLabelDisplayedRows(_ref6) {
    var from = _ref6.from,
      to = _ref6.to,
      count = _ref6.count;
    return "".concat(from, "\u2013").concat(to, " of ").concat(count !== -1 ? count : "more than ".concat(to));
  }
  function defaultGetAriaLabel(type) {
    return "Go to ".concat(type, " page");
  }
  var useUtilityClasses$7 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root'],
      toolbar: ['toolbar'],
      spacer: ['spacer'],
      selectLabel: ['selectLabel'],
      select: ['select'],
      input: ['input'],
      selectIcon: ['selectIcon'],
      menuItem: ['menuItem'],
      displayedRows: ['displayedRows'],
      actions: ['actions']
    };
    return composeClasses(slots, getTablePaginationUtilityClass, classes);
  };

  /**
   * A `TableCell` based component for placing inside `TableFooter` for pagination.
   */
  var TablePagination = /*#__PURE__*/React__namespace.forwardRef(function TablePagination(inProps, ref) {
    var _slotProps$select;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTablePagination'
    });
    var _props$ActionsCompone = props.ActionsComponent,
      ActionsComponent = _props$ActionsCompone === void 0 ? TablePaginationActions$1 : _props$ActionsCompone,
      backIconButtonProps = props.backIconButtonProps,
      className = props.className,
      colSpanProp = props.colSpan,
      _props$component = props.component,
      component = _props$component === void 0 ? TableCell$1 : _props$component,
      count = props.count,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$getItemAriaLab = props.getItemAriaLabel,
      getItemAriaLabel = _props$getItemAriaLab === void 0 ? defaultGetAriaLabel : _props$getItemAriaLab,
      _props$labelDisplayed = props.labelDisplayedRows,
      labelDisplayedRows = _props$labelDisplayed === void 0 ? defaultLabelDisplayedRows : _props$labelDisplayed,
      _props$labelRowsPerPa = props.labelRowsPerPage,
      labelRowsPerPage = _props$labelRowsPerPa === void 0 ? 'Rows per page:' : _props$labelRowsPerPa,
      nextIconButtonProps = props.nextIconButtonProps,
      onPageChange = props.onPageChange,
      onRowsPerPageChange = props.onRowsPerPageChange,
      page = props.page,
      rowsPerPage = props.rowsPerPage,
      _props$rowsPerPageOpt = props.rowsPerPageOptions,
      rowsPerPageOptions = _props$rowsPerPageOpt === void 0 ? [10, 25, 50, 100] : _props$rowsPerPageOpt,
      _props$SelectProps = props.SelectProps,
      SelectProps = _props$SelectProps === void 0 ? {} : _props$SelectProps,
      _props$showFirstButto = props.showFirstButton,
      showFirstButton = _props$showFirstButto === void 0 ? false : _props$showFirstButto,
      _props$showLastButton = props.showLastButton,
      showLastButton = _props$showLastButton === void 0 ? false : _props$showLastButton,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      other = _objectWithoutProperties(props, ["ActionsComponent", "backIconButtonProps", "className", "colSpan", "component", "count", "disabled", "getItemAriaLabel", "labelDisplayedRows", "labelRowsPerPage", "nextIconButtonProps", "onPageChange", "onRowsPerPageChange", "page", "rowsPerPage", "rowsPerPageOptions", "SelectProps", "showFirstButton", "showLastButton", "slotProps", "slots"]);
    var ownerState = props;
    var classes = useUtilityClasses$7(ownerState);
    var selectProps = (_slotProps$select = slotProps == null ? void 0 : slotProps.select) != null ? _slotProps$select : SelectProps;
    var MenuItemComponent = selectProps["native"] ? 'option' : TablePaginationMenuItem;
    var colSpan;
    if (component === TableCell$1 || component === 'td') {
      colSpan = colSpanProp || 1000; // col-span over everything
    }
    var selectId = useId(selectProps.id);
    var labelId = useId(selectProps.labelId);
    var getLabelDisplayedRowsTo = function getLabelDisplayedRowsTo() {
      if (count === -1) {
        return (page + 1) * rowsPerPage;
      }
      return rowsPerPage === -1 ? count : Math.min(count, (page + 1) * rowsPerPage);
    };
    return /*#__PURE__*/jsxRuntimeExports.jsx(TablePaginationRoot, _extends({
      colSpan: colSpan,
      ref: ref,
      as: component,
      ownerState: ownerState,
      className: clsx(classes.root, className)
    }, other, {
      children: /*#__PURE__*/jsxRuntimeExports.jsxs(TablePaginationToolbar, {
        className: classes.toolbar,
        children: [/*#__PURE__*/jsxRuntimeExports.jsx(TablePaginationSpacer, {
          className: classes.spacer
        }), rowsPerPageOptions.length > 1 && /*#__PURE__*/jsxRuntimeExports.jsx(TablePaginationSelectLabel, {
          className: classes.selectLabel,
          id: labelId,
          children: labelRowsPerPage
        }), rowsPerPageOptions.length > 1 && /*#__PURE__*/jsxRuntimeExports.jsx(TablePaginationSelect, _extends({
          variant: "standard"
        }, !selectProps.variant && {
          input: _InputBase || (_InputBase = /*#__PURE__*/jsxRuntimeExports.jsx(InputBase$1, {}))
        }, {
          value: rowsPerPage,
          onChange: onRowsPerPageChange,
          id: selectId,
          labelId: labelId
        }, selectProps, {
          classes: _extends({}, selectProps.classes, {
            // TODO v5 remove `classes.input`
            root: clsx(classes.input, classes.selectRoot, (selectProps.classes || {}).root),
            select: clsx(classes.select, (selectProps.classes || {}).select),
            // TODO v5 remove `selectIcon`
            icon: clsx(classes.selectIcon, (selectProps.classes || {}).icon)
          }),
          disabled: disabled,
          children: rowsPerPageOptions.map(function (rowsPerPageOption) {
            return /*#__PURE__*/React.createElement(MenuItemComponent, _extends({}, !isHostComponent(MenuItemComponent) && {
              ownerState: ownerState
            }, {
              className: classes.menuItem,
              key: rowsPerPageOption.label ? rowsPerPageOption.label : rowsPerPageOption,
              value: rowsPerPageOption.value ? rowsPerPageOption.value : rowsPerPageOption
            }), rowsPerPageOption.label ? rowsPerPageOption.label : rowsPerPageOption);
          })
        })), /*#__PURE__*/jsxRuntimeExports.jsx(TablePaginationDisplayedRows, {
          className: classes.displayedRows,
          children: labelDisplayedRows({
            from: count === 0 ? 0 : page * rowsPerPage + 1,
            to: getLabelDisplayedRowsTo(),
            count: count === -1 ? -1 : count,
            page: page
          })
        }), /*#__PURE__*/jsxRuntimeExports.jsx(ActionsComponent, {
          className: classes.actions,
          backIconButtonProps: backIconButtonProps,
          count: count,
          nextIconButtonProps: nextIconButtonProps,
          onPageChange: onPageChange,
          page: page,
          rowsPerPage: rowsPerPage,
          showFirstButton: showFirstButton,
          showLastButton: showLastButton,
          slotProps: slotProps.actions,
          slots: slots.actions,
          getItemAriaLabel: getItemAriaLabel,
          disabled: disabled
        })]
      })
    }));
  });
  TablePagination.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The component used for displaying the actions.
     * Either a string to use a HTML element or a component.
     * @default TablePaginationActions
     */
    ActionsComponent: PropTypes.elementType,
    /**
     * Props applied to the back arrow [`IconButton`](/material-ui/api/icon-button/) component.
     *
     * This prop is an alias for `slotProps.actions.previousButton` and will be overriden by it if both are used.
     * @deprecated Use `slotProps.actions.previousButton` instead.
     */
    backIconButtonProps: PropTypes.object,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * @ignore
     */
    colSpan: PropTypes.number,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * The total number of rows.
     *
     * To enable server side pagination for an unknown number of items, provide -1.
     */
    count: integerPropType.isRequired,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * Accepts a function which returns a string value that provides a user-friendly name for the current page.
     * This is important for screen reader users.
     *
     * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
     * @param {string} type The link or button type to format ('first' | 'last' | 'next' | 'previous').
     * @returns {string}
     * @default function defaultGetAriaLabel(type) {
     *   return `Go to ${type} page`;
     * }
     */
    getItemAriaLabel: PropTypes.func,
    /**
     * Customize the displayed rows label. Invoked with a `{ from, to, count, page }`
     * object.
     *
     * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
     * @default function defaultLabelDisplayedRows({ from, to, count }) {
     *   return `${from}–${to} of ${count !== -1 ? count : `more than ${to}`}`;
     * }
     */
    labelDisplayedRows: PropTypes.func,
    /**
     * Customize the rows per page label.
     *
     * For localization purposes, you can use the provided [translations](/material-ui/guides/localization/).
     * @default 'Rows per page:'
     */
    labelRowsPerPage: PropTypes.node,
    /**
     * Props applied to the next arrow [`IconButton`](/material-ui/api/icon-button/) element.
     *
     * This prop is an alias for `slotProps.actions.nextButton` and will be overriden by it if both are used.
     * @deprecated Use `slotProps.actions.nextButton` instead.
     */
    nextIconButtonProps: PropTypes.object,
    /**
     * Callback fired when the page is changed.
     *
     * @param {React.MouseEvent<HTMLButtonElement> | null} event The event source of the callback.
     * @param {number} page The page selected.
     */
    onPageChange: PropTypes.func.isRequired,
    /**
     * Callback fired when the number of rows per page is changed.
     *
     * @param {React.ChangeEvent<HTMLTextAreaElement | HTMLInputElement>} event The event source of the callback.
     */
    onRowsPerPageChange: PropTypes.func,
    /**
     * The zero-based index of the current page.
     */
    page: chainPropTypes(integerPropType.isRequired, function (props) {
      var count = props.count,
        page = props.page,
        rowsPerPage = props.rowsPerPage;
      if (count === -1) {
        return null;
      }
      var newLastPage = Math.max(0, Math.ceil(count / rowsPerPage) - 1);
      if (page < 0 || page > newLastPage) {
        return new Error('MUI: The page prop of a TablePagination is out of range ' + "(0 to ".concat(newLastPage, ", but page is ").concat(page, ")."));
      }
      return null;
    }),
    /**
     * The number of rows per page.
     *
     * Set -1 to display all the rows.
     */
    rowsPerPage: integerPropType.isRequired,
    /**
     * Customizes the options of the rows per page select field. If less than two options are
     * available, no select field will be displayed.
     * Use -1 for the value with a custom label to show all the rows.
     * @default [10, 25, 50, 100]
     */
    rowsPerPageOptions: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
      label: PropTypes.string.isRequired,
      value: PropTypes.number.isRequired
    })]).isRequired),
    /**
     * Props applied to the rows per page [`Select`](/material-ui/api/select/) element.
     *
     * This prop is an alias for `slotProps.select` and will be overriden by it if both are used.
     * @deprecated Use `slotProps.select` instead.
     *
     * @default {}
     */
    SelectProps: PropTypes.object,
    /**
     * If `true`, show the first-page button.
     * @default false
     */
    showFirstButton: PropTypes.bool,
    /**
     * If `true`, show the last-page button.
     * @default false
     */
    showLastButton: PropTypes.bool,
    /**
     * The props used for each slot inside the TablePagination.
     * @default {}
     */
    slotProps: PropTypes.shape({
      actions: PropTypes.shape({
        firstButton: PropTypes.object,
        firstButtonIcon: PropTypes.object,
        lastButton: PropTypes.object,
        lastButtonIcon: PropTypes.object,
        nextButton: PropTypes.object,
        nextButtonIcon: PropTypes.object,
        previousButton: PropTypes.object,
        previousButtonIcon: PropTypes.object
      }),
      select: PropTypes.object
    }),
    /**
     * The components used for each slot inside the TablePagination.
     * Either a string to use a HTML element or a component.
     * @default {}
     */
    slots: PropTypes.shape({
      actions: PropTypes.shape({
        firstButton: PropTypes.elementType,
        firstButtonIcon: PropTypes.elementType,
        lastButton: PropTypes.elementType,
        lastButtonIcon: PropTypes.elementType,
        nextButton: PropTypes.elementType,
        nextButtonIcon: PropTypes.elementType,
        previousButton: PropTypes.elementType,
        previousButtonIcon: PropTypes.elementType
      })
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var TablePagination$1 = TablePagination;

  function getTableRowUtilityClass(slot) {
    return generateUtilityClass('MuiTableRow', slot);
  }
  var tableRowClasses = generateUtilityClasses('MuiTableRow', ['root', 'selected', 'hover', 'head', 'footer']);
  var tableRowClasses$1 = tableRowClasses;

  var useUtilityClasses$6 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      selected = ownerState.selected,
      hover = ownerState.hover,
      head = ownerState.head,
      footer = ownerState.footer;
    var slots = {
      root: ['root', selected && 'selected', hover && 'hover', head && 'head', footer && 'footer']
    };
    return composeClasses(slots, getTableRowUtilityClass, classes);
  };
  var TableRowRoot = styled$1('tr', {
    name: 'MuiTableRow',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.head && styles.head, ownerState.footer && styles.footer];
    }
  })(function (_ref) {
    var theme = _ref.theme;
    return _defineProperty(_defineProperty({
      color: 'inherit',
      display: 'table-row',
      verticalAlign: 'middle',
      // We disable the focus ring for mouse, touch and keyboard users.
      outline: 0
    }, "&.".concat(tableRowClasses$1.hover, ":hover"), {
      backgroundColor: (theme.vars || theme).palette.action.hover
    }), "&.".concat(tableRowClasses$1.selected), {
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / ").concat(theme.vars.palette.action.selectedOpacity, ")") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity),
      '&:hover': {
        backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.primary.mainChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.hoverOpacity, "))") : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity)
      }
    });
  });
  var defaultComponent = 'tr';
  /**
   * Will automatically set dynamic row height
   * based on the material table element parent (head, body, etc).
   */
  var TableRow = /*#__PURE__*/React__namespace.forwardRef(function TableRow(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTableRow'
    });
    var className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? defaultComponent : _props$component,
      _props$hover = props.hover,
      hover = _props$hover === void 0 ? false : _props$hover,
      _props$selected = props.selected,
      selected = _props$selected === void 0 ? false : _props$selected,
      other = _objectWithoutProperties(props, ["className", "component", "hover", "selected"]);
    var tablelvl2 = React__namespace.useContext(Tablelvl2Context$1);
    var ownerState = _extends({}, props, {
      component: component,
      hover: hover,
      selected: selected,
      head: tablelvl2 && tablelvl2.variant === 'head',
      footer: tablelvl2 && tablelvl2.variant === 'footer'
    });
    var classes = useUtilityClasses$6(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsx(TableRowRoot, _extends({
      as: component,
      ref: ref,
      className: clsx(classes.root, className),
      role: component === defaultComponent ? null : 'row',
      ownerState: ownerState
    }, other));
  });
  TableRow.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Should be valid `<tr>` children such as `TableCell`.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * If `true`, the table row will shade on hover.
     * @default false
     */
    hover: PropTypes.bool,
    /**
     * If `true`, the table row will have the selected shading.
     * @default false
     */
    selected: PropTypes.bool,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var TableRow$1 = TableRow;

  var ArrowDownwardIcon = createSvgIcon( /*#__PURE__*/jsxRuntimeExports.jsx("path", {
    d: "M20 12l-1.41-1.41L13 16.17V4h-2v12.17l-5.58-5.59L4 12l8 8 8-8z"
  }), 'ArrowDownward');

  function getTableSortLabelUtilityClass(slot) {
    return generateUtilityClass('MuiTableSortLabel', slot);
  }
  var tableSortLabelClasses = generateUtilityClasses('MuiTableSortLabel', ['root', 'active', 'icon', 'iconDirectionDesc', 'iconDirectionAsc']);
  var tableSortLabelClasses$1 = tableSortLabelClasses;

  var useUtilityClasses$5 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      direction = ownerState.direction,
      active = ownerState.active;
    var slots = {
      root: ['root', active && 'active'],
      icon: ['icon', "iconDirection".concat(capitalize(direction))]
    };
    return composeClasses(slots, getTableSortLabelUtilityClass, classes);
  };
  var TableSortLabelRoot = styled$1(ButtonBase$1, {
    name: 'MuiTableSortLabel',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.active && styles.active];
    }
  })(function (_ref) {
    var theme = _ref.theme;
    return _defineProperty({
      cursor: 'pointer',
      display: 'inline-flex',
      justifyContent: 'flex-start',
      flexDirection: 'inherit',
      alignItems: 'center',
      '&:focus': {
        color: (theme.vars || theme).palette.text.secondary
      },
      '&:hover': _defineProperty({
        color: (theme.vars || theme).palette.text.secondary
      }, "& .".concat(tableSortLabelClasses$1.icon), {
        opacity: 0.5
      })
    }, "&.".concat(tableSortLabelClasses$1.active), _defineProperty({
      color: (theme.vars || theme).palette.text.primary
    }, "& .".concat(tableSortLabelClasses$1.icon), {
      opacity: 1,
      color: (theme.vars || theme).palette.text.secondary
    }));
  });
  var TableSortLabelIcon = styled$1('span', {
    name: 'MuiTableSortLabel',
    slot: 'Icon',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.icon, styles["iconDirection".concat(capitalize(ownerState.direction))]];
    }
  })(function (_ref3) {
    var theme = _ref3.theme,
      ownerState = _ref3.ownerState;
    return _extends({
      fontSize: 18,
      marginRight: 4,
      marginLeft: 4,
      opacity: 0,
      transition: theme.transitions.create(['opacity', 'transform'], {
        duration: theme.transitions.duration.shorter
      }),
      userSelect: 'none'
    }, ownerState.direction === 'desc' && {
      transform: 'rotate(0deg)'
    }, ownerState.direction === 'asc' && {
      transform: 'rotate(180deg)'
    });
  });

  /**
   * A button based label for placing inside `TableCell` for column sorting.
   */
  var TableSortLabel = /*#__PURE__*/React__namespace.forwardRef(function TableSortLabel(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTableSortLabel'
    });
    var _props$active = props.active,
      active = _props$active === void 0 ? false : _props$active,
      children = props.children,
      className = props.className,
      _props$direction = props.direction,
      direction = _props$direction === void 0 ? 'asc' : _props$direction,
      _props$hideSortIcon = props.hideSortIcon,
      hideSortIcon = _props$hideSortIcon === void 0 ? false : _props$hideSortIcon,
      _props$IconComponent = props.IconComponent,
      IconComponent = _props$IconComponent === void 0 ? ArrowDownwardIcon : _props$IconComponent,
      other = _objectWithoutProperties(props, ["active", "children", "className", "direction", "hideSortIcon", "IconComponent"]);
    var ownerState = _extends({}, props, {
      active: active,
      direction: direction,
      hideSortIcon: hideSortIcon,
      IconComponent: IconComponent
    });
    var classes = useUtilityClasses$5(ownerState);
    return /*#__PURE__*/jsxRuntimeExports.jsxs(TableSortLabelRoot, _extends({
      className: clsx(classes.root, className),
      component: "span",
      disableRipple: true,
      ownerState: ownerState,
      ref: ref
    }, other, {
      children: [children, hideSortIcon && !active ? null : /*#__PURE__*/jsxRuntimeExports.jsx(TableSortLabelIcon, {
        as: IconComponent,
        className: clsx(classes.icon),
        ownerState: ownerState
      })]
    }));
  });
  TableSortLabel.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * If `true`, the label will have the active styling (should be true for the sorted column).
     * @default false
     */
    active: PropTypes.bool,
    /**
     * Label contents, the arrow will be appended automatically.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The current sort direction.
     * @default 'asc'
     */
    direction: PropTypes.oneOf(['asc', 'desc']),
    /**
     * Hide sort icon when active is false.
     * @default false
     */
    hideSortIcon: PropTypes.bool,
    /**
     * Sort icon to use.
     * @default ArrowDownwardIcon
     */
    IconComponent: PropTypes.elementType,
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var TableSortLabel$1 = TableSortLabel;

  function easeInOutSin(time) {
    return (1 + Math.sin(Math.PI * time - Math.PI / 2)) / 2;
  }
  function animate(property, element, to) {
    var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
    var cb = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : function () {};
    var _options$ease = options.ease,
      ease = _options$ease === void 0 ? easeInOutSin : _options$ease,
      _options$duration = options.duration,
      duration = _options$duration === void 0 ? 300 : _options$duration;
    var start = null;
    var from = element[property];
    var cancelled = false;
    var cancel = function cancel() {
      cancelled = true;
    };
    var step = function step(timestamp) {
      if (cancelled) {
        cb(new Error('Animation cancelled'));
        return;
      }
      if (start === null) {
        start = timestamp;
      }
      var time = Math.min(1, (timestamp - start) / duration);
      element[property] = ease(time) * (to - from) + from;
      if (time >= 1) {
        requestAnimationFrame(function () {
          cb(null);
        });
        return;
      }
      requestAnimationFrame(step);
    };
    if (from === to) {
      cb(new Error('Element already at target position'));
      return cancel;
    }
    requestAnimationFrame(step);
    return cancel;
  }

  var styles = {
    width: 99,
    height: 99,
    position: 'absolute',
    top: -9999,
    overflow: 'scroll'
  };

  /**
   * @ignore - internal component.
   * The component originates from https://github.com/STORIS/react-scrollbar-size.
   * It has been moved into the core in order to minimize the bundle size.
   */
  function ScrollbarSize(props) {
    var onChange = props.onChange,
      other = _objectWithoutProperties(props, ["onChange"]);
    var scrollbarHeight = React__namespace.useRef();
    var nodeRef = React__namespace.useRef(null);
    var setMeasurements = function setMeasurements() {
      scrollbarHeight.current = nodeRef.current.offsetHeight - nodeRef.current.clientHeight;
    };
    useEnhancedEffect$1(function () {
      var handleResize = debounce$1(function () {
        var prevHeight = scrollbarHeight.current;
        setMeasurements();
        if (prevHeight !== scrollbarHeight.current) {
          onChange(scrollbarHeight.current);
        }
      });
      var containerWindow = ownerWindow(nodeRef.current);
      containerWindow.addEventListener('resize', handleResize);
      return function () {
        handleResize.clear();
        containerWindow.removeEventListener('resize', handleResize);
      };
    }, [onChange]);
    React__namespace.useEffect(function () {
      setMeasurements();
      onChange(scrollbarHeight.current);
    }, [onChange]);
    return /*#__PURE__*/jsxRuntimeExports.jsx("div", _extends({
      style: styles
    }, other, {
      ref: nodeRef
    }));
  }
  ScrollbarSize.propTypes = {
    onChange: PropTypes.func.isRequired
  } ;

  function getTabScrollButtonUtilityClass(slot) {
    return generateUtilityClass('MuiTabScrollButton', slot);
  }
  var tabScrollButtonClasses = generateUtilityClasses('MuiTabScrollButton', ['root', 'vertical', 'horizontal', 'disabled']);
  var tabScrollButtonClasses$1 = tabScrollButtonClasses;

  var useUtilityClasses$4 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      orientation = ownerState.orientation,
      disabled = ownerState.disabled;
    var slots = {
      root: ['root', orientation, disabled && 'disabled']
    };
    return composeClasses(slots, getTabScrollButtonUtilityClass, classes);
  };
  var TabScrollButtonRoot = styled$1(ButtonBase$1, {
    name: 'MuiTabScrollButton',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, ownerState.orientation && styles[ownerState.orientation]];
    }
  })(function (_ref) {
    var ownerState = _ref.ownerState;
    return _extends(_defineProperty({
      width: 40,
      flexShrink: 0,
      opacity: 0.8
    }, "&.".concat(tabScrollButtonClasses$1.disabled), {
      opacity: 0
    }), ownerState.orientation === 'vertical' && {
      width: '100%',
      height: 40,
      '& svg': {
        transform: "rotate(".concat(ownerState.isRtl ? -90 : 90, "deg)")
      }
    });
  });
  var TabScrollButton = /*#__PURE__*/React__namespace.forwardRef(function TabScrollButton(inProps, ref) {
    var _slots$StartScrollBut, _slots$EndScrollButto;
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTabScrollButton'
    });
    var className = props.className,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      direction = props.direction;
      props.orientation;
      props.disabled;
      var other = _objectWithoutProperties(props, ["className", "slots", "slotProps", "direction", "orientation", "disabled"]);
    var isRtl = useRtl();
    var ownerState = _extends({
      isRtl: isRtl
    }, props);
    var classes = useUtilityClasses$4(ownerState);
    var StartButtonIcon = (_slots$StartScrollBut = slots.StartScrollButtonIcon) != null ? _slots$StartScrollBut : KeyboardArrowLeft;
    var EndButtonIcon = (_slots$EndScrollButto = slots.EndScrollButtonIcon) != null ? _slots$EndScrollButto : KeyboardArrowRight;
    var startButtonIconProps = useSlotProps({
      elementType: StartButtonIcon,
      externalSlotProps: slotProps.startScrollButtonIcon,
      additionalProps: {
        fontSize: 'small'
      },
      ownerState: ownerState
    });
    var endButtonIconProps = useSlotProps({
      elementType: EndButtonIcon,
      externalSlotProps: slotProps.endScrollButtonIcon,
      additionalProps: {
        fontSize: 'small'
      },
      ownerState: ownerState
    });
    return /*#__PURE__*/jsxRuntimeExports.jsx(TabScrollButtonRoot, _extends({
      component: "div",
      className: clsx(classes.root, className),
      ref: ref,
      role: null,
      ownerState: ownerState,
      tabIndex: null
    }, other, {
      children: direction === 'left' ? /*#__PURE__*/jsxRuntimeExports.jsx(StartButtonIcon, _extends({}, startButtonIconProps)) : /*#__PURE__*/jsxRuntimeExports.jsx(EndButtonIcon, _extends({}, endButtonIconProps))
    }));
  });
  TabScrollButton.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The direction the button should indicate.
     */
    direction: PropTypes.oneOf(['left', 'right']).isRequired,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * The component orientation (layout flow direction).
     */
    orientation: PropTypes.oneOf(['horizontal', 'vertical']).isRequired,
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     * @default {}
     */
    slotProps: PropTypes.shape({
      endScrollButtonIcon: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      startScrollButtonIcon: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * The components used for each slot inside.
     * @default {}
     */
    slots: PropTypes.shape({
      EndScrollButtonIcon: PropTypes.elementType,
      StartScrollButtonIcon: PropTypes.elementType
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
  } ;
  var TabScrollButton$1 = TabScrollButton;

  function getTabsUtilityClass(slot) {
    return generateUtilityClass('MuiTabs', slot);
  }
  var tabsClasses = generateUtilityClasses('MuiTabs', ['root', 'vertical', 'flexContainer', 'flexContainerVertical', 'centered', 'scroller', 'fixed', 'scrollableX', 'scrollableY', 'hideScrollbar', 'scrollButtons', 'scrollButtonsHideMobile', 'indicator']);
  var tabsClasses$1 = tabsClasses;

  var nextItem = function nextItem(list, item) {
    if (list === item) {
      return list.firstChild;
    }
    if (item && item.nextElementSibling) {
      return item.nextElementSibling;
    }
    return list.firstChild;
  };
  var previousItem = function previousItem(list, item) {
    if (list === item) {
      return list.lastChild;
    }
    if (item && item.previousElementSibling) {
      return item.previousElementSibling;
    }
    return list.lastChild;
  };
  var moveFocus = function moveFocus(list, currentFocus, traversalFunction) {
    var wrappedOnce = false;
    var nextFocus = traversalFunction(list, currentFocus);
    while (nextFocus) {
      // Prevent infinite loop.
      if (nextFocus === list.firstChild) {
        if (wrappedOnce) {
          return;
        }
        wrappedOnce = true;
      }

      // Same logic as useAutocomplete.js
      var nextFocusDisabled = nextFocus.disabled || nextFocus.getAttribute('aria-disabled') === 'true';
      if (!nextFocus.hasAttribute('tabindex') || nextFocusDisabled) {
        // Move to the next element.
        nextFocus = traversalFunction(list, nextFocus);
      } else {
        nextFocus.focus();
        return;
      }
    }
  };
  var useUtilityClasses$3 = function useUtilityClasses(ownerState) {
    var vertical = ownerState.vertical,
      fixed = ownerState.fixed,
      hideScrollbar = ownerState.hideScrollbar,
      scrollableX = ownerState.scrollableX,
      scrollableY = ownerState.scrollableY,
      centered = ownerState.centered,
      scrollButtonsHideMobile = ownerState.scrollButtonsHideMobile,
      classes = ownerState.classes;
    var slots = {
      root: ['root', vertical && 'vertical'],
      scroller: ['scroller', fixed && 'fixed', hideScrollbar && 'hideScrollbar', scrollableX && 'scrollableX', scrollableY && 'scrollableY'],
      flexContainer: ['flexContainer', vertical && 'flexContainerVertical', centered && 'centered'],
      indicator: ['indicator'],
      scrollButtons: ['scrollButtons', scrollButtonsHideMobile && 'scrollButtonsHideMobile'],
      scrollableX: [scrollableX && 'scrollableX'],
      hideScrollbar: [hideScrollbar && 'hideScrollbar']
    };
    return composeClasses(slots, getTabsUtilityClass, classes);
  };
  var TabsRoot = styled$1('div', {
    name: 'MuiTabs',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [_defineProperty({}, "& .".concat(tabsClasses$1.scrollButtons), styles.scrollButtons), _defineProperty({}, "& .".concat(tabsClasses$1.scrollButtons), ownerState.scrollButtonsHideMobile && styles.scrollButtonsHideMobile), styles.root, ownerState.vertical && styles.vertical];
    }
  })(function (_ref3) {
    var ownerState = _ref3.ownerState,
      theme = _ref3.theme;
    return _extends({
      overflow: 'hidden',
      minHeight: 48,
      // Add iOS momentum scrolling for iOS < 13.0
      WebkitOverflowScrolling: 'touch',
      display: 'flex'
    }, ownerState.vertical && {
      flexDirection: 'column'
    }, ownerState.scrollButtonsHideMobile && _defineProperty({}, "& .".concat(tabsClasses$1.scrollButtons), _defineProperty({}, theme.breakpoints.down('sm'), {
      display: 'none'
    })));
  });
  var TabsScroller = styled$1('div', {
    name: 'MuiTabs',
    slot: 'Scroller',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.scroller, ownerState.fixed && styles.fixed, ownerState.hideScrollbar && styles.hideScrollbar, ownerState.scrollableX && styles.scrollableX, ownerState.scrollableY && styles.scrollableY];
    }
  })(function (_ref5) {
    var ownerState = _ref5.ownerState;
    return _extends({
      position: 'relative',
      display: 'inline-block',
      flex: '1 1 auto',
      whiteSpace: 'nowrap'
    }, ownerState.fixed && {
      overflowX: 'hidden',
      width: '100%'
    }, ownerState.hideScrollbar && {
      // Hide dimensionless scrollbar on macOS
      scrollbarWidth: 'none',
      // Firefox
      '&::-webkit-scrollbar': {
        display: 'none' // Safari + Chrome
      }
    }, ownerState.scrollableX && {
      overflowX: 'auto',
      overflowY: 'hidden'
    }, ownerState.scrollableY && {
      overflowY: 'auto',
      overflowX: 'hidden'
    });
  });
  var FlexContainer = styled$1('div', {
    name: 'MuiTabs',
    slot: 'FlexContainer',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.flexContainer, ownerState.vertical && styles.flexContainerVertical, ownerState.centered && styles.centered];
    }
  })(function (_ref6) {
    var ownerState = _ref6.ownerState;
    return _extends({
      display: 'flex'
    }, ownerState.vertical && {
      flexDirection: 'column'
    }, ownerState.centered && {
      justifyContent: 'center'
    });
  });
  var TabsIndicator = styled$1('span', {
    name: 'MuiTabs',
    slot: 'Indicator',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.indicator;
    }
  })(function (_ref7) {
    var ownerState = _ref7.ownerState,
      theme = _ref7.theme;
    return _extends({
      position: 'absolute',
      height: 2,
      bottom: 0,
      width: '100%',
      transition: theme.transitions.create()
    }, ownerState.indicatorColor === 'primary' && {
      backgroundColor: (theme.vars || theme).palette.primary.main
    }, ownerState.indicatorColor === 'secondary' && {
      backgroundColor: (theme.vars || theme).palette.secondary.main
    }, ownerState.vertical && {
      height: '100%',
      width: 2,
      right: 0
    });
  });
  var TabsScrollbarSize = styled$1(ScrollbarSize)({
    overflowX: 'auto',
    overflowY: 'hidden',
    // Hide dimensionless scrollbar on macOS
    scrollbarWidth: 'none',
    // Firefox
    '&::-webkit-scrollbar': {
      display: 'none' // Safari + Chrome
    }
  });
  var defaultIndicatorStyle = {};
  var warnedOnceTabPresent = false;
  var Tabs = /*#__PURE__*/React__namespace.forwardRef(function Tabs(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTabs'
    });
    var theme = useTheme();
    var isRtl = useRtl();
    var ariaLabel = props['aria-label'],
      ariaLabelledBy = props['aria-labelledby'],
      action = props.action,
      _props$centered = props.centered,
      centered = _props$centered === void 0 ? false : _props$centered,
      childrenProp = props.children,
      className = props.className,
      _props$component = props.component,
      component = _props$component === void 0 ? 'div' : _props$component,
      _props$allowScrollBut = props.allowScrollButtonsMobile,
      allowScrollButtonsMobile = _props$allowScrollBut === void 0 ? false : _props$allowScrollBut,
      _props$indicatorColor = props.indicatorColor,
      indicatorColor = _props$indicatorColor === void 0 ? 'primary' : _props$indicatorColor,
      onChange = props.onChange,
      _props$orientation = props.orientation,
      orientation = _props$orientation === void 0 ? 'horizontal' : _props$orientation,
      _props$ScrollButtonCo = props.ScrollButtonComponent,
      ScrollButtonComponent = _props$ScrollButtonCo === void 0 ? TabScrollButton$1 : _props$ScrollButtonCo,
      _props$scrollButtons = props.scrollButtons,
      scrollButtons = _props$scrollButtons === void 0 ? 'auto' : _props$scrollButtons,
      selectionFollowsFocus = props.selectionFollowsFocus,
      _props$slots = props.slots,
      slots = _props$slots === void 0 ? {} : _props$slots,
      _props$slotProps = props.slotProps,
      slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
      _props$TabIndicatorPr = props.TabIndicatorProps,
      TabIndicatorProps = _props$TabIndicatorPr === void 0 ? {} : _props$TabIndicatorPr,
      _props$TabScrollButto = props.TabScrollButtonProps,
      TabScrollButtonProps = _props$TabScrollButto === void 0 ? {} : _props$TabScrollButto,
      _props$textColor = props.textColor,
      textColor = _props$textColor === void 0 ? 'primary' : _props$textColor,
      value = props.value,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'standard' : _props$variant,
      _props$visibleScrollb = props.visibleScrollbar,
      visibleScrollbar = _props$visibleScrollb === void 0 ? false : _props$visibleScrollb,
      other = _objectWithoutProperties(props, ["aria-label", "aria-labelledby", "action", "centered", "children", "className", "component", "allowScrollButtonsMobile", "indicatorColor", "onChange", "orientation", "ScrollButtonComponent", "scrollButtons", "selectionFollowsFocus", "slots", "slotProps", "TabIndicatorProps", "TabScrollButtonProps", "textColor", "value", "variant", "visibleScrollbar"]);
    var scrollable = variant === 'scrollable';
    var vertical = orientation === 'vertical';
    var scrollStart = vertical ? 'scrollTop' : 'scrollLeft';
    var start = vertical ? 'top' : 'left';
    var end = vertical ? 'bottom' : 'right';
    var clientSize = vertical ? 'clientHeight' : 'clientWidth';
    var size = vertical ? 'height' : 'width';
    var ownerState = _extends({}, props, {
      component: component,
      allowScrollButtonsMobile: allowScrollButtonsMobile,
      indicatorColor: indicatorColor,
      orientation: orientation,
      vertical: vertical,
      scrollButtons: scrollButtons,
      textColor: textColor,
      variant: variant,
      visibleScrollbar: visibleScrollbar,
      fixed: !scrollable,
      hideScrollbar: scrollable && !visibleScrollbar,
      scrollableX: scrollable && !vertical,
      scrollableY: scrollable && vertical,
      centered: centered && !scrollable,
      scrollButtonsHideMobile: !allowScrollButtonsMobile
    });
    var classes = useUtilityClasses$3(ownerState);
    var startScrollButtonIconProps = useSlotProps({
      elementType: slots.StartScrollButtonIcon,
      externalSlotProps: slotProps.startScrollButtonIcon,
      ownerState: ownerState
    });
    var endScrollButtonIconProps = useSlotProps({
      elementType: slots.EndScrollButtonIcon,
      externalSlotProps: slotProps.endScrollButtonIcon,
      ownerState: ownerState
    });
    {
      if (centered && scrollable) {
        console.error('MUI: You can not use the `centered={true}` and `variant="scrollable"` properties ' + 'at the same time on a `Tabs` component.');
      }
    }
    var _React$useState = React__namespace.useState(false),
      mounted = _React$useState[0],
      setMounted = _React$useState[1];
    var _React$useState2 = React__namespace.useState(defaultIndicatorStyle),
      indicatorStyle = _React$useState2[0],
      setIndicatorStyle = _React$useState2[1];
    var _React$useState3 = React__namespace.useState(false),
      displayStartScroll = _React$useState3[0],
      setDisplayStartScroll = _React$useState3[1];
    var _React$useState4 = React__namespace.useState(false),
      displayEndScroll = _React$useState4[0],
      setDisplayEndScroll = _React$useState4[1];
    var _React$useState5 = React__namespace.useState(false),
      updateScrollObserver = _React$useState5[0],
      setUpdateScrollObserver = _React$useState5[1];
    var _React$useState6 = React__namespace.useState({
        overflow: 'hidden',
        scrollbarWidth: 0
      }),
      scrollerStyle = _React$useState6[0],
      setScrollerStyle = _React$useState6[1];
    var valueToIndex = new Map();
    var tabsRef = React__namespace.useRef(null);
    var tabListRef = React__namespace.useRef(null);
    var getTabsMeta = function getTabsMeta() {
      var tabsNode = tabsRef.current;
      var tabsMeta;
      if (tabsNode) {
        var rect = tabsNode.getBoundingClientRect();
        // create a new object with ClientRect class props + scrollLeft
        tabsMeta = {
          clientWidth: tabsNode.clientWidth,
          scrollLeft: tabsNode.scrollLeft,
          scrollTop: tabsNode.scrollTop,
          scrollLeftNormalized: getNormalizedScrollLeft(tabsNode, isRtl ? 'rtl' : 'ltr'),
          scrollWidth: tabsNode.scrollWidth,
          top: rect.top,
          bottom: rect.bottom,
          left: rect.left,
          right: rect.right
        };
      }
      var tabMeta;
      if (tabsNode && value !== false) {
        var _children = tabListRef.current.children;
        if (_children.length > 0) {
          var tab = _children[valueToIndex.get(value)];
          {
            if (!tab) {
              console.error(["MUI: The `value` provided to the Tabs component is invalid.", "None of the Tabs' children match with \"".concat(value, "\"."), valueToIndex.keys ? "You can provide one of the following values: ".concat(Array.from(valueToIndex.keys()).join(', '), ".") : null].join('\n'));
            }
          }
          tabMeta = tab ? tab.getBoundingClientRect() : null;
          {
            if (!warnedOnceTabPresent && tabMeta && tabMeta.width === 0 && tabMeta.height === 0 &&
            // if the whole Tabs component is hidden, don't warn
            tabsMeta.clientWidth !== 0) {
              tabsMeta = null;
              console.error(['MUI: The `value` provided to the Tabs component is invalid.', "The Tab with this `value` (\"".concat(value, "\") is not part of the document layout."), "Make sure the tab item is present in the document or that it's not `display: none`."].join('\n'));
              warnedOnceTabPresent = true;
            }
          }
        }
      }
      return {
        tabsMeta: tabsMeta,
        tabMeta: tabMeta
      };
    };
    var updateIndicatorState = useEventCallback(function () {
      var _getTabsMeta = getTabsMeta(),
        tabsMeta = _getTabsMeta.tabsMeta,
        tabMeta = _getTabsMeta.tabMeta;
      var startValue = 0;
      var startIndicator;
      if (vertical) {
        startIndicator = 'top';
        if (tabMeta && tabsMeta) {
          startValue = tabMeta.top - tabsMeta.top + tabsMeta.scrollTop;
        }
      } else {
        startIndicator = isRtl ? 'right' : 'left';
        if (tabMeta && tabsMeta) {
          var correction = isRtl ? tabsMeta.scrollLeftNormalized + tabsMeta.clientWidth - tabsMeta.scrollWidth : tabsMeta.scrollLeft;
          startValue = (isRtl ? -1 : 1) * (tabMeta[startIndicator] - tabsMeta[startIndicator] + correction);
        }
      }
      var newIndicatorStyle = _defineProperty(_defineProperty({}, startIndicator, startValue), size, tabMeta ? tabMeta[size] : 0);

      // IE11 support, replace with Number.isNaN
      // eslint-disable-next-line no-restricted-globals
      if (isNaN(indicatorStyle[startIndicator]) || isNaN(indicatorStyle[size])) {
        setIndicatorStyle(newIndicatorStyle);
      } else {
        var dStart = Math.abs(indicatorStyle[startIndicator] - newIndicatorStyle[startIndicator]);
        var dSize = Math.abs(indicatorStyle[size] - newIndicatorStyle[size]);
        if (dStart >= 1 || dSize >= 1) {
          setIndicatorStyle(newIndicatorStyle);
        }
      }
    });
    var scroll = function scroll(scrollValue) {
      var _ref8 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
        _ref8$animation = _ref8.animation,
        animation = _ref8$animation === void 0 ? true : _ref8$animation;
      if (animation) {
        animate(scrollStart, tabsRef.current, scrollValue, {
          duration: theme.transitions.duration.standard
        });
      } else {
        tabsRef.current[scrollStart] = scrollValue;
      }
    };
    var moveTabsScroll = function moveTabsScroll(delta) {
      var scrollValue = tabsRef.current[scrollStart];
      if (vertical) {
        scrollValue += delta;
      } else {
        scrollValue += delta * (isRtl ? -1 : 1);
        // Fix for Edge
        scrollValue *= isRtl && detectScrollType() === 'reverse' ? -1 : 1;
      }
      scroll(scrollValue);
    };
    var getScrollSize = function getScrollSize() {
      var containerSize = tabsRef.current[clientSize];
      var totalSize = 0;
      var children = Array.from(tabListRef.current.children);
      for (var i = 0; i < children.length; i += 1) {
        var tab = children[i];
        if (totalSize + tab[clientSize] > containerSize) {
          // If the first item is longer than the container size, then only scroll
          // by the container size.
          if (i === 0) {
            totalSize = containerSize;
          }
          break;
        }
        totalSize += tab[clientSize];
      }
      return totalSize;
    };
    var handleStartScrollClick = function handleStartScrollClick() {
      moveTabsScroll(-1 * getScrollSize());
    };
    var handleEndScrollClick = function handleEndScrollClick() {
      moveTabsScroll(getScrollSize());
    };

    // TODO Remove <ScrollbarSize /> as browser support for hiding the scrollbar
    // with CSS improves.
    var handleScrollbarSizeChange = React__namespace.useCallback(function (scrollbarWidth) {
      setScrollerStyle({
        overflow: null,
        scrollbarWidth: scrollbarWidth
      });
    }, []);
    var getConditionalElements = function getConditionalElements() {
      var conditionalElements = {};
      conditionalElements.scrollbarSizeListener = scrollable ? /*#__PURE__*/jsxRuntimeExports.jsx(TabsScrollbarSize, {
        onChange: handleScrollbarSizeChange,
        className: clsx(classes.scrollableX, classes.hideScrollbar)
      }) : null;
      var scrollButtonsActive = displayStartScroll || displayEndScroll;
      var showScrollButtons = scrollable && (scrollButtons === 'auto' && scrollButtonsActive || scrollButtons === true);
      conditionalElements.scrollButtonStart = showScrollButtons ? /*#__PURE__*/jsxRuntimeExports.jsx(ScrollButtonComponent, _extends({
        slots: {
          StartScrollButtonIcon: slots.StartScrollButtonIcon
        },
        slotProps: {
          startScrollButtonIcon: startScrollButtonIconProps
        },
        orientation: orientation,
        direction: isRtl ? 'right' : 'left',
        onClick: handleStartScrollClick,
        disabled: !displayStartScroll
      }, TabScrollButtonProps, {
        className: clsx(classes.scrollButtons, TabScrollButtonProps.className)
      })) : null;
      conditionalElements.scrollButtonEnd = showScrollButtons ? /*#__PURE__*/jsxRuntimeExports.jsx(ScrollButtonComponent, _extends({
        slots: {
          EndScrollButtonIcon: slots.EndScrollButtonIcon
        },
        slotProps: {
          endScrollButtonIcon: endScrollButtonIconProps
        },
        orientation: orientation,
        direction: isRtl ? 'left' : 'right',
        onClick: handleEndScrollClick,
        disabled: !displayEndScroll
      }, TabScrollButtonProps, {
        className: clsx(classes.scrollButtons, TabScrollButtonProps.className)
      })) : null;
      return conditionalElements;
    };
    var scrollSelectedIntoView = useEventCallback(function (animation) {
      var _getTabsMeta2 = getTabsMeta(),
        tabsMeta = _getTabsMeta2.tabsMeta,
        tabMeta = _getTabsMeta2.tabMeta;
      if (!tabMeta || !tabsMeta) {
        return;
      }
      if (tabMeta[start] < tabsMeta[start]) {
        // left side of button is out of view
        var nextScrollStart = tabsMeta[scrollStart] + (tabMeta[start] - tabsMeta[start]);
        scroll(nextScrollStart, {
          animation: animation
        });
      } else if (tabMeta[end] > tabsMeta[end]) {
        // right side of button is out of view
        var _nextScrollStart = tabsMeta[scrollStart] + (tabMeta[end] - tabsMeta[end]);
        scroll(_nextScrollStart, {
          animation: animation
        });
      }
    });
    var updateScrollButtonState = useEventCallback(function () {
      if (scrollable && scrollButtons !== false) {
        setUpdateScrollObserver(!updateScrollObserver);
      }
    });
    React__namespace.useEffect(function () {
      var handleResize = debounce$1(function () {
        // If the Tabs component is replaced by Suspense with a fallback, the last
        // ResizeObserver's handler that runs because of the change in the layout is trying to
        // access a dom node that is no longer there (as the fallback component is being shown instead).
        // See https://github.com/mui/material-ui/issues/33276
        // TODO: Add tests that will ensure the component is not failing when
        // replaced by Suspense with a fallback, once React is updated to version 18
        if (tabsRef.current) {
          updateIndicatorState();
        }
      });
      var resizeObserver;

      /**
       * @type {MutationCallback}
       */
      var handleMutation = function handleMutation(records) {
        records.forEach(function (record) {
          record.removedNodes.forEach(function (item) {
            var _resizeObserver;
            (_resizeObserver = resizeObserver) == null || _resizeObserver.unobserve(item);
          });
          record.addedNodes.forEach(function (item) {
            var _resizeObserver2;
            (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.observe(item);
          });
        });
        handleResize();
        updateScrollButtonState();
      };
      var win = ownerWindow(tabsRef.current);
      win.addEventListener('resize', handleResize);
      var mutationObserver;
      if (typeof ResizeObserver !== 'undefined') {
        resizeObserver = new ResizeObserver(handleResize);
        Array.from(tabListRef.current.children).forEach(function (child) {
          resizeObserver.observe(child);
        });
      }
      if (typeof MutationObserver !== 'undefined') {
        mutationObserver = new MutationObserver(handleMutation);
        mutationObserver.observe(tabListRef.current, {
          childList: true
        });
      }
      return function () {
        var _mutationObserver, _resizeObserver3;
        handleResize.clear();
        win.removeEventListener('resize', handleResize);
        (_mutationObserver = mutationObserver) == null || _mutationObserver.disconnect();
        (_resizeObserver3 = resizeObserver) == null || _resizeObserver3.disconnect();
      };
    }, [updateIndicatorState, updateScrollButtonState]);

    /**
     * Toggle visibility of start and end scroll buttons
     * Using IntersectionObserver on first and last Tabs.
     */
    React__namespace.useEffect(function () {
      var tabListChildren = Array.from(tabListRef.current.children);
      var length = tabListChildren.length;
      if (typeof IntersectionObserver !== 'undefined' && length > 0 && scrollable && scrollButtons !== false) {
        var firstTab = tabListChildren[0];
        var lastTab = tabListChildren[length - 1];
        var observerOptions = {
          root: tabsRef.current,
          threshold: 0.99
        };
        var handleScrollButtonStart = function handleScrollButtonStart(entries) {
          setDisplayStartScroll(!entries[0].isIntersecting);
        };
        var firstObserver = new IntersectionObserver(handleScrollButtonStart, observerOptions);
        firstObserver.observe(firstTab);
        var handleScrollButtonEnd = function handleScrollButtonEnd(entries) {
          setDisplayEndScroll(!entries[0].isIntersecting);
        };
        var lastObserver = new IntersectionObserver(handleScrollButtonEnd, observerOptions);
        lastObserver.observe(lastTab);
        return function () {
          firstObserver.disconnect();
          lastObserver.disconnect();
        };
      }
      return undefined;
    }, [scrollable, scrollButtons, updateScrollObserver, childrenProp == null ? void 0 : childrenProp.length]);
    React__namespace.useEffect(function () {
      setMounted(true);
    }, []);
    React__namespace.useEffect(function () {
      updateIndicatorState();
    });
    React__namespace.useEffect(function () {
      // Don't animate on the first render.
      scrollSelectedIntoView(defaultIndicatorStyle !== indicatorStyle);
    }, [scrollSelectedIntoView, indicatorStyle]);
    React__namespace.useImperativeHandle(action, function () {
      return {
        updateIndicator: updateIndicatorState,
        updateScrollButtons: updateScrollButtonState
      };
    }, [updateIndicatorState, updateScrollButtonState]);
    var indicator = /*#__PURE__*/jsxRuntimeExports.jsx(TabsIndicator, _extends({}, TabIndicatorProps, {
      className: clsx(classes.indicator, TabIndicatorProps.className),
      ownerState: ownerState,
      style: _extends({}, indicatorStyle, TabIndicatorProps.style)
    }));
    var childIndex = 0;
    var children = React__namespace.Children.map(childrenProp, function (child) {
      if (! /*#__PURE__*/React__namespace.isValidElement(child)) {
        return null;
      }
      {
        if (reactIsExports.isFragment(child)) {
          console.error(["MUI: The Tabs component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n'));
        }
      }
      var childValue = child.props.value === undefined ? childIndex : child.props.value;
      valueToIndex.set(childValue, childIndex);
      var selected = childValue === value;
      childIndex += 1;
      return /*#__PURE__*/React__namespace.cloneElement(child, _extends({
        fullWidth: variant === 'fullWidth',
        indicator: selected && !mounted && indicator,
        selected: selected,
        selectionFollowsFocus: selectionFollowsFocus,
        onChange: onChange,
        textColor: textColor,
        value: childValue
      }, childIndex === 1 && value === false && !child.props.tabIndex ? {
        tabIndex: 0
      } : {}));
    });
    var handleKeyDown = function handleKeyDown(event) {
      var list = tabListRef.current;
      var currentFocus = ownerDocument(list).activeElement;
      // Keyboard navigation assumes that [role="tab"] are siblings
      // though we might warn in the future about nested, interactive elements
      // as a a11y violation
      var role = currentFocus.getAttribute('role');
      if (role !== 'tab') {
        return;
      }
      var previousItemKey = orientation === 'horizontal' ? 'ArrowLeft' : 'ArrowUp';
      var nextItemKey = orientation === 'horizontal' ? 'ArrowRight' : 'ArrowDown';
      if (orientation === 'horizontal' && isRtl) {
        // swap previousItemKey with nextItemKey
        previousItemKey = 'ArrowRight';
        nextItemKey = 'ArrowLeft';
      }
      switch (event.key) {
        case previousItemKey:
          event.preventDefault();
          moveFocus(list, currentFocus, previousItem);
          break;
        case nextItemKey:
          event.preventDefault();
          moveFocus(list, currentFocus, nextItem);
          break;
        case 'Home':
          event.preventDefault();
          moveFocus(list, null, nextItem);
          break;
        case 'End':
          event.preventDefault();
          moveFocus(list, null, previousItem);
          break;
      }
    };
    var conditionalElements = getConditionalElements();
    return /*#__PURE__*/jsxRuntimeExports.jsxs(TabsRoot, _extends({
      className: clsx(classes.root, className),
      ownerState: ownerState,
      ref: ref,
      as: component
    }, other, {
      children: [conditionalElements.scrollButtonStart, conditionalElements.scrollbarSizeListener, /*#__PURE__*/jsxRuntimeExports.jsxs(TabsScroller, {
        className: classes.scroller,
        ownerState: ownerState,
        style: _defineProperty({
          overflow: scrollerStyle.overflow
        }, vertical ? "margin".concat(isRtl ? 'Left' : 'Right') : 'marginBottom', visibleScrollbar ? undefined : -scrollerStyle.scrollbarWidth),
        ref: tabsRef,
        children: [/*#__PURE__*/jsxRuntimeExports.jsx(FlexContainer, {
          "aria-label": ariaLabel,
          "aria-labelledby": ariaLabelledBy,
          "aria-orientation": orientation === 'vertical' ? 'vertical' : null,
          className: classes.flexContainer,
          ownerState: ownerState,
          onKeyDown: handleKeyDown,
          ref: tabListRef,
          role: "tablist",
          children: children
        }), mounted && indicator]
      }), conditionalElements.scrollButtonEnd]
    }));
  });
  Tabs.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * Callback fired when the component mounts.
     * This is useful when you want to trigger an action programmatically.
     * It supports two actions: `updateIndicator()` and `updateScrollButtons()`
     *
     * @param {object} actions This object contains all possible actions
     * that can be triggered programmatically.
     */
    action: refType$1,
    /**
     * If `true`, the scroll buttons aren't forced hidden on mobile.
     * By default the scroll buttons are hidden on mobile and takes precedence over `scrollButtons`.
     * @default false
     */
    allowScrollButtonsMobile: PropTypes.bool,
    /**
     * The label for the Tabs as a string.
     */
    'aria-label': PropTypes.string,
    /**
     * An id or list of ids separated by a space that label the Tabs.
     */
    'aria-labelledby': PropTypes.string,
    /**
     * If `true`, the tabs are centered.
     * This prop is intended for large views.
     * @default false
     */
    centered: PropTypes.bool,
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The component used for the root node.
     * Either a string to use a HTML element or a component.
     */
    component: PropTypes.elementType,
    /**
     * Determines the color of the indicator.
     * @default 'primary'
     */
    indicatorColor: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['primary', 'secondary']), PropTypes.string]),
    /**
     * Callback fired when the value changes.
     *
     * @param {React.SyntheticEvent} event The event source of the callback. **Warning**: This is a generic event not a change event.
     * @param {any} value We default to the index of the child (number)
     */
    onChange: PropTypes.func,
    /**
     * The component orientation (layout flow direction).
     * @default 'horizontal'
     */
    orientation: PropTypes.oneOf(['horizontal', 'vertical']),
    /**
     * The component used to render the scroll buttons.
     * @default TabScrollButton
     */
    ScrollButtonComponent: PropTypes.elementType,
    /**
     * Determine behavior of scroll buttons when tabs are set to scroll:
     *
     * - `auto` will only present them when not all the items are visible.
     * - `true` will always present them.
     * - `false` will never present them.
     *
     * By default the scroll buttons are hidden on mobile.
     * This behavior can be disabled with `allowScrollButtonsMobile`.
     * @default 'auto'
     */
    scrollButtons: PropTypes /* @typescript-to-proptypes-ignore */.oneOf(['auto', false, true]),
    /**
     * If `true` the selected tab changes on focus. Otherwise it only
     * changes on activation.
     */
    selectionFollowsFocus: PropTypes.bool,
    /**
     * The extra props for the slot components.
     * You can override the existing props or add new ones.
     * @default {}
     */
    slotProps: PropTypes.shape({
      endScrollButtonIcon: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
      startScrollButtonIcon: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
    }),
    /**
     * The components used for each slot inside.
     * @default {}
     */
    slots: PropTypes.shape({
      EndScrollButtonIcon: PropTypes.elementType,
      StartScrollButtonIcon: PropTypes.elementType
    }),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * Props applied to the tab indicator element.
     * @default  {}
     */
    TabIndicatorProps: PropTypes.object,
    /**
     * Props applied to the [`TabScrollButton`](/material-ui/api/tab-scroll-button/) element.
     * @default {}
     */
    TabScrollButtonProps: PropTypes.object,
    /**
     * Determines the color of the `Tab`.
     * @default 'primary'
     */
    textColor: PropTypes.oneOf(['inherit', 'primary', 'secondary']),
    /**
     * The value of the currently selected `Tab`.
     * If you don't want any selected `Tab`, you can set this prop to `false`.
     */
    value: PropTypes.any,
    /**
     * Determines additional display behavior of the tabs:
     *
     *  - `scrollable` will invoke scrolling properties and allow for horizontally
     *  scrolling (or swiping) of the tab bar.
     *  - `fullWidth` will make the tabs grow to use all the available space,
     *  which should be used for small views, like on mobile.
     *  - `standard` will render the default state.
     * @default 'standard'
     */
    variant: PropTypes.oneOf(['fullWidth', 'scrollable', 'standard']),
    /**
     * If `true`, the scrollbar is visible. It can be useful when displaying
     * a long vertical list of tabs.
     * @default false
     */
    visibleScrollbar: PropTypes.bool
  } ;
  var Tabs$1 = Tabs;

  function getTextFieldUtilityClass(slot) {
    return generateUtilityClass('MuiTextField', slot);
  }
  var textFieldClasses = generateUtilityClasses('MuiTextField', ['root']);
  var textFieldClasses$1 = textFieldClasses;

  var variantComponent = {
    standard: Input$1,
    filled: FilledInput$1,
    outlined: OutlinedInput$1
  };
  var useUtilityClasses$2 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes;
    var slots = {
      root: ['root']
    };
    return composeClasses(slots, getTextFieldUtilityClass, classes);
  };
  var TextFieldRoot = styled$1(FormControl$1, {
    name: 'MuiTextField',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      return styles.root;
    }
  })({});

  /**
   * The `TextField` is a convenience wrapper for the most common cases (80%).
   * It cannot be all things to all people, otherwise the API would grow out of control.
   *
   * ## Advanced Configuration
   *
   * It's important to understand that the text field is a simple abstraction
   * on top of the following components:
   *
   * - [FormControl](/material-ui/api/form-control/)
   * - [InputLabel](/material-ui/api/input-label/)
   * - [FilledInput](/material-ui/api/filled-input/)
   * - [OutlinedInput](/material-ui/api/outlined-input/)
   * - [Input](/material-ui/api/input/)
   * - [FormHelperText](/material-ui/api/form-helper-text/)
   *
   * If you wish to alter the props applied to the `input` element, you can do so as follows:
   *
   * ```jsx
   * const inputProps = {
   *   step: 300,
   * };
   *
   * return <TextField id="time" type="time" inputProps={inputProps} />;
   * ```
   *
   * For advanced cases, please look at the source of TextField by clicking on the
   * "Edit this page" button above. Consider either:
   *
   * - using the upper case props for passing values directly to the components
   * - using the underlying components directly as shown in the demos
   */
  var TextField = /*#__PURE__*/React__namespace.forwardRef(function TextField(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiTextField'
    });
    var autoComplete = props.autoComplete,
      _props$autoFocus = props.autoFocus,
      autoFocus = _props$autoFocus === void 0 ? false : _props$autoFocus,
      children = props.children,
      className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'primary' : _props$color,
      defaultValue = props.defaultValue,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$error = props.error,
      error = _props$error === void 0 ? false : _props$error,
      FormHelperTextProps = props.FormHelperTextProps,
      _props$fullWidth = props.fullWidth,
      fullWidth = _props$fullWidth === void 0 ? false : _props$fullWidth,
      helperText = props.helperText,
      idOverride = props.id,
      InputLabelProps = props.InputLabelProps,
      inputProps = props.inputProps,
      InputProps = props.InputProps,
      inputRef = props.inputRef,
      label = props.label,
      maxRows = props.maxRows,
      minRows = props.minRows,
      _props$multiline = props.multiline,
      multiline = _props$multiline === void 0 ? false : _props$multiline,
      name = props.name,
      onBlur = props.onBlur,
      onChange = props.onChange,
      onFocus = props.onFocus,
      placeholder = props.placeholder,
      _props$required = props.required,
      required = _props$required === void 0 ? false : _props$required,
      rows = props.rows,
      _props$select = props.select,
      select = _props$select === void 0 ? false : _props$select,
      SelectProps = props.SelectProps,
      type = props.type,
      value = props.value,
      _props$variant = props.variant,
      variant = _props$variant === void 0 ? 'outlined' : _props$variant,
      other = _objectWithoutProperties(props, ["autoComplete", "autoFocus", "children", "className", "color", "defaultValue", "disabled", "error", "FormHelperTextProps", "fullWidth", "helperText", "id", "InputLabelProps", "inputProps", "InputProps", "inputRef", "label", "maxRows", "minRows", "multiline", "name", "onBlur", "onChange", "onFocus", "placeholder", "required", "rows", "select", "SelectProps", "type", "value", "variant"]);
    var ownerState = _extends({}, props, {
      autoFocus: autoFocus,
      color: color,
      disabled: disabled,
      error: error,
      fullWidth: fullWidth,
      multiline: multiline,
      required: required,
      select: select,
      variant: variant
    });
    var classes = useUtilityClasses$2(ownerState);
    {
      if (select && !children) {
        console.error('MUI: `children` must be passed when using the `TextField` component with `select`.');
      }
    }
    var InputMore = {};
    if (variant === 'outlined') {
      if (InputLabelProps && typeof InputLabelProps.shrink !== 'undefined') {
        InputMore.notched = InputLabelProps.shrink;
      }
      InputMore.label = label;
    }
    if (select) {
      // unset defaults from textbox inputs
      if (!SelectProps || !SelectProps["native"]) {
        InputMore.id = undefined;
      }
      InputMore['aria-describedby'] = undefined;
    }
    var id = useId(idOverride);
    var helperTextId = helperText && id ? "".concat(id, "-helper-text") : undefined;
    var inputLabelId = label && id ? "".concat(id, "-label") : undefined;
    var InputComponent = variantComponent[variant];
    var InputElement = /*#__PURE__*/jsxRuntimeExports.jsx(InputComponent, _extends({
      "aria-describedby": helperTextId,
      autoComplete: autoComplete,
      autoFocus: autoFocus,
      defaultValue: defaultValue,
      fullWidth: fullWidth,
      multiline: multiline,
      name: name,
      rows: rows,
      maxRows: maxRows,
      minRows: minRows,
      type: type,
      value: value,
      id: id,
      inputRef: inputRef,
      onBlur: onBlur,
      onChange: onChange,
      onFocus: onFocus,
      placeholder: placeholder,
      inputProps: inputProps
    }, InputMore, InputProps));
    return /*#__PURE__*/jsxRuntimeExports.jsxs(TextFieldRoot, _extends({
      className: clsx(classes.root, className),
      disabled: disabled,
      error: error,
      fullWidth: fullWidth,
      ref: ref,
      required: required,
      color: color,
      variant: variant,
      ownerState: ownerState
    }, other, {
      children: [label != null && label !== '' && /*#__PURE__*/jsxRuntimeExports.jsx(InputLabel$1, _extends({
        htmlFor: id,
        id: inputLabelId
      }, InputLabelProps, {
        children: label
      })), select ? /*#__PURE__*/jsxRuntimeExports.jsx(Select$1, _extends({
        "aria-describedby": helperTextId,
        id: id,
        labelId: inputLabelId,
        value: value,
        input: InputElement
      }, SelectProps, {
        children: children
      })) : InputElement, helperText && /*#__PURE__*/jsxRuntimeExports.jsx(FormHelperText$1, _extends({
        id: helperTextId
      }, FormHelperTextProps, {
        children: helperText
      }))]
    }));
  });
  TextField.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * This prop helps users to fill forms faster, especially on mobile devices.
     * The name can be confusing, as it's more like an autofill.
     * You can learn more about it [following the specification](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill).
     */
    autoComplete: PropTypes.string,
    /**
     * If `true`, the `input` element is focused during the first mount.
     * @default false
     */
    autoFocus: PropTypes.bool,
    /**
     * @ignore
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the component.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'primary'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * The default value. Use when the component is not controlled.
     */
    defaultValue: PropTypes.any,
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the label is displayed in an error state.
     * @default false
     */
    error: PropTypes.bool,
    /**
     * Props applied to the [`FormHelperText`](/material-ui/api/form-helper-text/) element.
     */
    FormHelperTextProps: PropTypes.object,
    /**
     * If `true`, the input will take up the full width of its container.
     * @default false
     */
    fullWidth: PropTypes.bool,
    /**
     * The helper text content.
     */
    helperText: PropTypes.node,
    /**
     * The id of the `input` element.
     * Use this prop to make `label` and `helperText` accessible for screen readers.
     */
    id: PropTypes.string,
    /**
     * Props applied to the [`InputLabel`](/material-ui/api/input-label/) element.
     * Pointer events like `onClick` are enabled if and only if `shrink` is `true`.
     */
    InputLabelProps: PropTypes.object,
    /**
     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
     */
    inputProps: PropTypes.object,
    /**
     * Props applied to the Input element.
     * It will be a [`FilledInput`](/material-ui/api/filled-input/),
     * [`OutlinedInput`](/material-ui/api/outlined-input/) or [`Input`](/material-ui/api/input/)
     * component depending on the `variant` prop value.
     */
    InputProps: PropTypes.object,
    /**
     * Pass a ref to the `input` element.
     */
    inputRef: refType$1,
    /**
     * The label content.
     */
    label: PropTypes.node,
    /**
     * If `dense` or `normal`, will adjust vertical spacing of this and contained components.
     * @default 'none'
     */
    margin: PropTypes.oneOf(['dense', 'none', 'normal']),
    /**
     * Maximum number of rows to display when multiline option is set to true.
     */
    maxRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * Minimum number of rows to display when multiline option is set to true.
     */
    minRows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * If `true`, a `textarea` element is rendered instead of an input.
     * @default false
     */
    multiline: PropTypes.bool,
    /**
     * Name attribute of the `input` element.
     */
    name: PropTypes.string,
    /**
     * @ignore
     */
    onBlur: PropTypes.func,
    /**
     * Callback fired when the value is changed.
     *
     * @param {object} event The event source of the callback.
     * You can pull out the new value by accessing `event.target.value` (string).
     */
    onChange: PropTypes.func,
    /**
     * @ignore
     */
    onFocus: PropTypes.func,
    /**
     * The short hint displayed in the `input` before the user enters a value.
     */
    placeholder: PropTypes.string,
    /**
     * If `true`, the label is displayed as required and the `input` element is required.
     * @default false
     */
    required: PropTypes.bool,
    /**
     * Number of rows to display when multiline option is set to true.
     */
    rows: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    /**
     * Render a [`Select`](/material-ui/api/select/) element while passing the Input element to `Select` as `input` parameter.
     * If this option is set you must pass the options of the select as children.
     * @default false
     */
    select: PropTypes.bool,
    /**
     * Props applied to the [`Select`](/material-ui/api/select/) element.
     */
    SelectProps: PropTypes.object,
    /**
     * The size of the component.
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['medium', 'small']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * Type of the `input` element. It should be [a valid HTML5 input type](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Form_%3Cinput%3E_types).
     */
    type: PropTypes /* @typescript-to-proptypes-ignore */.string,
    /**
     * The value of the `input` element, required for a controlled component.
     */
    value: PropTypes.any,
    /**
     * The variant to use.
     * @default 'outlined'
     */
    variant: PropTypes.oneOf(['filled', 'outlined', 'standard'])
  } ;
  var TextField$1 = TextField;

  function getToggleButtonUtilityClass(slot) {
    return generateUtilityClass('MuiToggleButton', slot);
  }
  var toggleButtonClasses = generateUtilityClasses('MuiToggleButton', ['root', 'disabled', 'selected', 'standard', 'primary', 'secondary', 'sizeSmall', 'sizeMedium', 'sizeLarge', 'fullWidth']);
  var toggleButtonClasses$1 = toggleButtonClasses;

  /**
   * @ignore - internal component.
   */
  var ToggleButtonGroupContext = /*#__PURE__*/React__namespace.createContext({});
  {
    ToggleButtonGroupContext.displayName = 'ToggleButtonGroupContext';
  }
  var ToggleButtonGroupContext$1 = ToggleButtonGroupContext;

  /**
   * @ignore - internal component.
   */
  var ToggleButtonGroupButtonContext = /*#__PURE__*/React__namespace.createContext(undefined);
  {
    ToggleButtonGroupButtonContext.displayName = 'ToggleButtonGroupButtonContext';
  }
  var ToggleButtonGroupButtonContext$1 = ToggleButtonGroupButtonContext;

  // Determine if the toggle button value matches, or is contained in, the
  // candidate group value.
  function isValueSelected(value, candidate) {
    if (candidate === undefined || value === undefined) {
      return false;
    }
    if (Array.isArray(candidate)) {
      return candidate.indexOf(value) >= 0;
    }
    return value === candidate;
  }

  var useUtilityClasses$1 = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      fullWidth = ownerState.fullWidth,
      selected = ownerState.selected,
      disabled = ownerState.disabled,
      size = ownerState.size,
      color = ownerState.color;
    var slots = {
      root: ['root', selected && 'selected', disabled && 'disabled', fullWidth && 'fullWidth', "size".concat(capitalize(size)), color]
    };
    return composeClasses(slots, getToggleButtonUtilityClass, classes);
  };
  var ToggleButtonRoot = styled$1(ButtonBase$1, {
    name: 'MuiToggleButton',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [styles.root, styles["size".concat(capitalize(ownerState.size))]];
    }
  })(function (_ref) {
    var theme = _ref.theme,
      ownerState = _ref.ownerState;
    var selectedColor = ownerState.color === 'standard' ? theme.palette.text.primary : theme.palette[ownerState.color].main;
    var selectedColorChannel;
    if (theme.vars) {
      selectedColor = ownerState.color === 'standard' ? theme.vars.palette.text.primary : theme.vars.palette[ownerState.color].main;
      selectedColorChannel = ownerState.color === 'standard' ? theme.vars.palette.text.primaryChannel : theme.vars.palette[ownerState.color].mainChannel;
    }
    return _extends({}, theme.typography.button, {
      borderRadius: (theme.vars || theme).shape.borderRadius,
      padding: 11,
      border: "1px solid ".concat((theme.vars || theme).palette.divider),
      color: (theme.vars || theme).palette.action.active
    }, ownerState.fullWidth && {
      width: '100%'
    }, _defineProperty(_defineProperty(_defineProperty({}, "&.".concat(toggleButtonClasses$1.disabled), {
      color: (theme.vars || theme).palette.action.disabled,
      border: "1px solid ".concat((theme.vars || theme).palette.action.disabledBackground)
    }), '&:hover', {
      textDecoration: 'none',
      // Reset on mouse devices
      backgroundColor: theme.vars ? "rgba(".concat(theme.vars.palette.text.primaryChannel, " / ").concat(theme.vars.palette.action.hoverOpacity, ")") : alpha(theme.palette.text.primary, theme.palette.action.hoverOpacity),
      '@media (hover: none)': {
        backgroundColor: 'transparent'
      }
    }), "&.".concat(toggleButtonClasses$1.selected), {
      color: selectedColor,
      backgroundColor: theme.vars ? "rgba(".concat(selectedColorChannel, " / ").concat(theme.vars.palette.action.selectedOpacity, ")") : alpha(selectedColor, theme.palette.action.selectedOpacity),
      '&:hover': {
        backgroundColor: theme.vars ? "rgba(".concat(selectedColorChannel, " / calc(").concat(theme.vars.palette.action.selectedOpacity, " + ").concat(theme.vars.palette.action.hoverOpacity, "))") : alpha(selectedColor, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity),
        // Reset on touch devices, it doesn't add specificity
        '@media (hover: none)': {
          backgroundColor: theme.vars ? "rgba(".concat(selectedColorChannel, " / ").concat(theme.vars.palette.action.selectedOpacity, ")") : alpha(selectedColor, theme.palette.action.selectedOpacity)
        }
      }
    }), ownerState.size === 'small' && {
      padding: 7,
      fontSize: theme.typography.pxToRem(13)
    }, ownerState.size === 'large' && {
      padding: 15,
      fontSize: theme.typography.pxToRem(15)
    });
  });
  var ToggleButton = /*#__PURE__*/React__namespace.forwardRef(function ToggleButton(inProps, ref) {
    // props priority: `inProps` > `contextProps` > `themeDefaultProps`
    var _React$useContext = React__namespace.useContext(ToggleButtonGroupContext$1),
      contextValue = _React$useContext.value,
      contextProps = _objectWithoutProperties(_React$useContext, ["value"]);
    var toggleButtonGroupButtonContextPositionClassName = React__namespace.useContext(ToggleButtonGroupButtonContext$1);
    var resolvedProps = resolveProps(_extends({}, contextProps, {
      selected: isValueSelected(inProps.value, contextValue)
    }), inProps);
    var props = useDefaultProps({
      props: resolvedProps,
      name: 'MuiToggleButton'
    });
    var children = props.children,
      className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'standard' : _props$color,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$disableFocusRi = props.disableFocusRipple,
      disableFocusRipple = _props$disableFocusRi === void 0 ? false : _props$disableFocusRi,
      _props$fullWidth = props.fullWidth,
      fullWidth = _props$fullWidth === void 0 ? false : _props$fullWidth,
      onChange = props.onChange,
      onClick = props.onClick,
      selected = props.selected,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      value = props.value,
      other = _objectWithoutProperties(props, ["children", "className", "color", "disabled", "disableFocusRipple", "fullWidth", "onChange", "onClick", "selected", "size", "value"]);
    var ownerState = _extends({}, props, {
      color: color,
      disabled: disabled,
      disableFocusRipple: disableFocusRipple,
      fullWidth: fullWidth,
      size: size
    });
    var classes = useUtilityClasses$1(ownerState);
    var handleChange = function handleChange(event) {
      if (onClick) {
        onClick(event, value);
        if (event.defaultPrevented) {
          return;
        }
      }
      if (onChange) {
        onChange(event, value);
      }
    };
    var positionClassName = toggleButtonGroupButtonContextPositionClassName || '';
    return /*#__PURE__*/jsxRuntimeExports.jsx(ToggleButtonRoot, _extends({
      className: clsx(contextProps.className, classes.root, className, positionClassName),
      disabled: disabled,
      focusRipple: !disableFocusRipple,
      ref: ref,
      onClick: handleChange,
      onChange: onChange,
      value: value,
      ownerState: ownerState,
      "aria-pressed": selected
    }, other, {
      children: children
    }));
  });
  ToggleButton.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the button when it is in an active state.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'standard'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['standard', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * If `true`, the component is disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, the  keyboard focus ripple is disabled.
     * @default false
     */
    disableFocusRipple: PropTypes.bool,
    /**
     * If `true`, the ripple effect is disabled.
     *
     * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
     * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
     * @default false
     */
    disableRipple: PropTypes.bool,
    /**
     * If `true`, the button will take up the full width of its container.
     * @default false
     */
    fullWidth: PropTypes.bool,
    /**
     * Callback fired when the state changes.
     *
     * @param {React.MouseEvent<HTMLElement>} event The event source of the callback.
     * @param {any} value of the selected button.
     */
    onChange: PropTypes.func,
    /**
     * Callback fired when the button is clicked.
     *
     * @param {React.MouseEvent<HTMLElement>} event The event source of the callback.
     * @param {any} value of the selected button.
     */
    onClick: PropTypes.func,
    /**
     * If `true`, the button is rendered in an active state.
     */
    selected: PropTypes.bool,
    /**
     * The size of the component.
     * The prop defaults to the value inherited from the parent ToggleButtonGroup component.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['small', 'medium', 'large']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The value to associate with the button when selected in a
     * ToggleButtonGroup.
     */
    value: PropTypes /* @typescript-to-proptypes-ignore */.any.isRequired
  } ;
  var ToggleButton$1 = ToggleButton;

  function getToggleButtonGroupUtilityClass(slot) {
    return generateUtilityClass('MuiToggleButtonGroup', slot);
  }
  var toggleButtonGroupClasses = generateUtilityClasses('MuiToggleButtonGroup', ['root', 'selected', 'horizontal', 'vertical', 'disabled', 'grouped', 'groupedHorizontal', 'groupedVertical', 'fullWidth', 'firstButton', 'lastButton', 'middleButton']);
  var toggleButtonGroupClasses$1 = toggleButtonGroupClasses;

  var useUtilityClasses = function useUtilityClasses(ownerState) {
    var classes = ownerState.classes,
      orientation = ownerState.orientation,
      fullWidth = ownerState.fullWidth,
      disabled = ownerState.disabled;
    var slots = {
      root: ['root', orientation === 'vertical' && 'vertical', fullWidth && 'fullWidth'],
      grouped: ['grouped', "grouped".concat(capitalize(orientation)), disabled && 'disabled'],
      firstButton: ['firstButton'],
      lastButton: ['lastButton'],
      middleButton: ['middleButton']
    };
    return composeClasses(slots, getToggleButtonGroupUtilityClass, classes);
  };
  var ToggleButtonGroupRoot = styled$1('div', {
    name: 'MuiToggleButtonGroup',
    slot: 'Root',
    overridesResolver: function overridesResolver(props, styles) {
      var ownerState = props.ownerState;
      return [_defineProperty({}, "& .".concat(toggleButtonGroupClasses$1.grouped), styles.grouped), _defineProperty({}, "& .".concat(toggleButtonGroupClasses$1.grouped), styles["grouped".concat(capitalize(ownerState.orientation))]), _defineProperty({}, "& .".concat(toggleButtonGroupClasses$1.firstButton), styles.firstButton), _defineProperty({}, "& .".concat(toggleButtonGroupClasses$1.lastButton), styles.lastButton), _defineProperty({}, "& .".concat(toggleButtonGroupClasses$1.middleButton), styles.middleButton), styles.root, ownerState.orientation === 'vertical' && styles.vertical, ownerState.fullWidth && styles.fullWidth];
    }
  })(function (_ref6) {
    var ownerState = _ref6.ownerState,
      theme = _ref6.theme;
    return _extends({
      display: 'inline-flex',
      borderRadius: (theme.vars || theme).shape.borderRadius
    }, ownerState.orientation === 'vertical' && {
      flexDirection: 'column'
    }, ownerState.fullWidth && {
      width: '100%'
    }, _defineProperty({}, "& .".concat(toggleButtonGroupClasses$1.grouped), _extends({}, ownerState.orientation === 'horizontal' ? _defineProperty({}, "&.".concat(toggleButtonGroupClasses$1.selected, " + .").concat(toggleButtonGroupClasses$1.grouped, ".").concat(toggleButtonGroupClasses$1.selected), {
      borderLeft: 0,
      marginLeft: 0
    }) : _defineProperty({}, "&.".concat(toggleButtonGroupClasses$1.selected, " + .").concat(toggleButtonGroupClasses$1.grouped, ".").concat(toggleButtonGroupClasses$1.selected), {
      borderTop: 0,
      marginTop: 0
    }))), ownerState.orientation === 'horizontal' ? _defineProperty(_defineProperty({}, "& .".concat(toggleButtonGroupClasses$1.firstButton, ",& .").concat(toggleButtonGroupClasses$1.middleButton), {
      borderTopRightRadius: 0,
      borderBottomRightRadius: 0
    }), "& .".concat(toggleButtonGroupClasses$1.lastButton, ",& .").concat(toggleButtonGroupClasses$1.middleButton), {
      marginLeft: -1,
      borderLeft: '1px solid transparent',
      borderTopLeftRadius: 0,
      borderBottomLeftRadius: 0
    }) : _defineProperty(_defineProperty({}, "& .".concat(toggleButtonGroupClasses$1.firstButton, ",& .").concat(toggleButtonGroupClasses$1.middleButton), {
      borderBottomLeftRadius: 0,
      borderBottomRightRadius: 0
    }), "& .".concat(toggleButtonGroupClasses$1.lastButton, ",& .").concat(toggleButtonGroupClasses$1.middleButton), {
      marginTop: -1,
      borderTop: '1px solid transparent',
      borderTopLeftRadius: 0,
      borderTopRightRadius: 0
    }), ownerState.orientation === 'horizontal' ? _defineProperty({}, "& .".concat(toggleButtonGroupClasses$1.lastButton, ".").concat(toggleButtonClasses$1.disabled, ",& .").concat(toggleButtonGroupClasses$1.middleButton, ".").concat(toggleButtonClasses$1.disabled), {
      borderLeft: '1px solid transparent'
    }) : _defineProperty({}, "& .".concat(toggleButtonGroupClasses$1.lastButton, ".").concat(toggleButtonClasses$1.disabled, ",& .").concat(toggleButtonGroupClasses$1.middleButton, ".").concat(toggleButtonClasses$1.disabled), {
      borderTop: '1px solid transparent'
    }));
  });
  var ToggleButtonGroup = /*#__PURE__*/React__namespace.forwardRef(function ToggleButtonGroup(inProps, ref) {
    var props = useDefaultProps({
      props: inProps,
      name: 'MuiToggleButtonGroup'
    });
    var children = props.children,
      className = props.className,
      _props$color = props.color,
      color = _props$color === void 0 ? 'standard' : _props$color,
      _props$disabled = props.disabled,
      disabled = _props$disabled === void 0 ? false : _props$disabled,
      _props$exclusive = props.exclusive,
      exclusive = _props$exclusive === void 0 ? false : _props$exclusive,
      _props$fullWidth = props.fullWidth,
      fullWidth = _props$fullWidth === void 0 ? false : _props$fullWidth,
      onChange = props.onChange,
      _props$orientation = props.orientation,
      orientation = _props$orientation === void 0 ? 'horizontal' : _props$orientation,
      _props$size = props.size,
      size = _props$size === void 0 ? 'medium' : _props$size,
      value = props.value,
      other = _objectWithoutProperties(props, ["children", "className", "color", "disabled", "exclusive", "fullWidth", "onChange", "orientation", "size", "value"]);
    var ownerState = _extends({}, props, {
      disabled: disabled,
      fullWidth: fullWidth,
      orientation: orientation,
      size: size
    });
    var classes = useUtilityClasses(ownerState);
    var handleChange = React__namespace.useCallback(function (event, buttonValue) {
      if (!onChange) {
        return;
      }
      var index = value && value.indexOf(buttonValue);
      var newValue;
      if (value && index >= 0) {
        newValue = value.slice();
        newValue.splice(index, 1);
      } else {
        newValue = value ? value.concat(buttonValue) : [buttonValue];
      }
      onChange(event, newValue);
    }, [onChange, value]);
    var handleExclusiveChange = React__namespace.useCallback(function (event, buttonValue) {
      if (!onChange) {
        return;
      }
      onChange(event, value === buttonValue ? null : buttonValue);
    }, [onChange, value]);
    var context = React__namespace.useMemo(function () {
      return {
        className: classes.grouped,
        onChange: exclusive ? handleExclusiveChange : handleChange,
        value: value,
        size: size,
        fullWidth: fullWidth,
        color: color,
        disabled: disabled
      };
    }, [classes.grouped, exclusive, handleExclusiveChange, handleChange, value, size, fullWidth, color, disabled]);
    var validChildren = getValidReactChildren(children);
    var childrenCount = validChildren.length;
    var getButtonPositionClassName = function getButtonPositionClassName(index) {
      var isFirstButton = index === 0;
      var isLastButton = index === childrenCount - 1;
      if (isFirstButton && isLastButton) {
        return '';
      }
      if (isFirstButton) {
        return classes.firstButton;
      }
      if (isLastButton) {
        return classes.lastButton;
      }
      return classes.middleButton;
    };
    return /*#__PURE__*/jsxRuntimeExports.jsx(ToggleButtonGroupRoot, _extends({
      role: "group",
      className: clsx(classes.root, className),
      ref: ref,
      ownerState: ownerState
    }, other, {
      children: /*#__PURE__*/jsxRuntimeExports.jsx(ToggleButtonGroupContext$1.Provider, {
        value: context,
        children: validChildren.map(function (child, index) {
          {
            if (reactIsExports.isFragment(child)) {
              console.error(["MUI: The ToggleButtonGroup component doesn't accept a Fragment as a child.", 'Consider providing an array instead.'].join('\n'));
            }
          }
          return /*#__PURE__*/jsxRuntimeExports.jsx(ToggleButtonGroupButtonContext$1.Provider, {
            value: getButtonPositionClassName(index),
            children: child
          }, index);
        })
      })
    }));
  });
  ToggleButtonGroup.propTypes /* remove-proptypes */ = {
    // ┌────────────────────────────── Warning ──────────────────────────────┐
    // │ These PropTypes are generated from the TypeScript type definitions. │
    // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
    // └─────────────────────────────────────────────────────────────────────┘
    /**
     * The content of the component.
     */
    children: PropTypes.node,
    /**
     * Override or extend the styles applied to the component.
     */
    classes: PropTypes.object,
    /**
     * @ignore
     */
    className: PropTypes.string,
    /**
     * The color of the button when it is selected.
     * It supports both default and custom theme colors, which can be added as shown in the
     * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
     * @default 'standard'
     */
    color: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['standard', 'primary', 'secondary', 'error', 'info', 'success', 'warning']), PropTypes.string]),
    /**
     * If `true`, the component is disabled. This implies that all ToggleButton children will be disabled.
     * @default false
     */
    disabled: PropTypes.bool,
    /**
     * If `true`, only allow one of the child ToggleButton values to be selected.
     * @default false
     */
    exclusive: PropTypes.bool,
    /**
     * If `true`, the button group will take up the full width of its container.
     * @default false
     */
    fullWidth: PropTypes.bool,
    /**
     * Callback fired when the value changes.
     *
     * @param {React.MouseEvent<HTMLElement>} event The event source of the callback.
     * @param {any} value of the selected buttons. When `exclusive` is true
     * this is a single value; when false an array of selected values. If no value
     * is selected and `exclusive` is true the value is null; when false an empty array.
     */
    onChange: PropTypes.func,
    /**
     * The component orientation (layout flow direction).
     * @default 'horizontal'
     */
    orientation: PropTypes.oneOf(['horizontal', 'vertical']),
    /**
     * The size of the component.
     * @default 'medium'
     */
    size: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.oneOf(['small', 'medium', 'large']), PropTypes.string]),
    /**
     * The system prop that allows defining system overrides as well as additional CSS styles.
     */
    sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
    /**
     * The currently selected value within the group or an array of selected
     * values when `exclusive` is false.
     *
     * The value must have reference equality with the option in order to be selected.
     */
    value: PropTypes.any
  } ;
  var ToggleButtonGroup$1 = ToggleButtonGroup;

  function defaultTrigger(store, options) {
    var _options$disableHyste = options.disableHysteresis,
      disableHysteresis = _options$disableHyste === void 0 ? false : _options$disableHyste,
      _options$threshold = options.threshold,
      threshold = _options$threshold === void 0 ? 100 : _options$threshold,
      target = options.target;
    var previous = store.current;
    if (target) {
      // Get vertical scroll
      store.current = target.pageYOffset !== undefined ? target.pageYOffset : target.scrollTop;
    }
    if (!disableHysteresis && previous !== undefined) {
      if (store.current < previous) {
        return false;
      }
    }
    return store.current > threshold;
  }
  var defaultTarget = typeof window !== 'undefined' ? window : null;
  function useScrollTrigger() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var _options$getTrigger = options.getTrigger,
      getTrigger = _options$getTrigger === void 0 ? defaultTrigger : _options$getTrigger,
      _options$target = options.target,
      target = _options$target === void 0 ? defaultTarget : _options$target,
      other = _objectWithoutProperties(options, ["getTrigger", "target"]);
    var store = React__namespace.useRef();
    var _React$useState = React__namespace.useState(function () {
        return getTrigger(store, other);
      }),
      trigger = _React$useState[0],
      setTrigger = _React$useState[1];
    React__namespace.useEffect(function () {
      var handleScroll = function handleScroll() {
        setTrigger(getTrigger(store, _extends({
          target: target
        }, other)));
      };
      handleScroll(); // Re-evaluate trigger when dependencies change
      target.addEventListener('scroll', handleScroll, {
        passive: true
      });
      return function () {
        target.removeEventListener('scroll', handleScroll, {
          passive: true
        });
      };
      // See Option 3. https://github.com/facebook/react/issues/14476#issuecomment-471199055
      // eslint-disable-next-line react-hooks/exhaustive-deps
    }, [target, getTrigger, JSON.stringify(other)]);
    return trigger;
  }

  var version = undefined;
  var major = Number(undefined);
  var minor = Number(undefined);
  var patch = Number(undefined);
  var preReleaseLabel = null;
  var preReleaseNumber = Number(undefined) || null;

  exports.Accordion = Accordion$1;
  exports.AccordionActions = AccordionActions$1;
  exports.AccordionDetails = AccordionDetails$1;
  exports.AccordionSummary = AccordionSummary$1;
  exports.Alert = Alert$1;
  exports.AlertTitle = AlertTitle$1;
  exports.AppBar = AppBar$1;
  exports.Autocomplete = Autocomplete$1;
  exports.Avatar = Avatar$1;
  exports.AvatarGroup = AvatarGroup$1;
  exports.Backdrop = Backdrop$1;
  exports.Badge = Badge$1;
  exports.BottomNavigation = BottomNavigation$1;
  exports.BottomNavigationAction = BottomNavigationAction$1;
  exports.Box = Box$1;
  exports.Breadcrumbs = Breadcrumbs$1;
  exports.Button = Button$1;
  exports.ButtonBase = ButtonBase$1;
  exports.ButtonGroup = ButtonGroup$1;
  exports.ButtonGroupButtonContext = ButtonGroupButtonContext$1;
  exports.ButtonGroupContext = ButtonGroupContext$1;
  exports.Card = Card$1;
  exports.CardActionArea = CardActionArea$1;
  exports.CardActions = CardActions$1;
  exports.CardContent = CardContent$1;
  exports.CardHeader = CardHeader$1;
  exports.CardMedia = CardMedia$1;
  exports.Checkbox = Checkbox$1;
  exports.Chip = Chip$1;
  exports.CircularProgress = CircularProgress$1;
  exports.ClickAwayListener = ClickAwayListener;
  exports.Collapse = Collapse$1;
  exports.Container = Container$1;
  exports.CssBaseline = CssBaseline;
  exports.Dialog = Dialog$1;
  exports.DialogActions = DialogActions$1;
  exports.DialogContent = DialogContent$1;
  exports.DialogContentText = DialogContentText$1;
  exports.DialogTitle = DialogTitle$1;
  exports.Divider = Divider$1;
  exports.Drawer = Drawer$1;
  exports.Experimental_CssVarsProvider = CssVarsProvider;
  exports.Fab = Fab$1;
  exports.Fade = Fade$1;
  exports.FilledInput = FilledInput$1;
  exports.FormControl = FormControl$1;
  exports.FormControlLabel = FormControlLabel$1;
  exports.FormGroup = FormGroup$1;
  exports.FormHelperText = FormHelperText$1;
  exports.FormLabel = FormLabel$1;
  exports.FormLabelRoot = FormLabelRoot;
  exports.GlobalStyles = GlobalStyles;
  exports.Grid = Grid$1;
  exports.Grow = Grow$1;
  exports.Hidden = Hidden;
  exports.Icon = Icon$1;
  exports.IconButton = IconButton$1;
  exports.ImageList = ImageList$1;
  exports.ImageListItem = ImageListItem$1;
  exports.ImageListItemBar = ImageListItemBar$1;
  exports.Input = Input$1;
  exports.InputAdornment = InputAdornment$1;
  exports.InputBase = InputBase$1;
  exports.InputLabel = InputLabel$1;
  exports.LinearProgress = LinearProgress$1;
  exports.Link = Link$1;
  exports.List = List$1;
  exports.ListItem = ListItem$1;
  exports.ListItemAvatar = ListItemAvatar$1;
  exports.ListItemButton = ListItemButton$1;
  exports.ListItemIcon = ListItemIcon$1;
  exports.ListItemSecondaryAction = ListItemSecondaryAction$1;
  exports.ListItemText = ListItemText$1;
  exports.ListSubheader = ListSubheader$1;
  exports.Menu = Menu$1;
  exports.MenuItem = MenuItem$1;
  exports.MenuList = MenuList$1;
  exports.MobileStepper = MobileStepper$1;
  exports.Modal = Modal$1;
  exports.ModalManager = ModalManager;
  exports.NativeSelect = NativeSelect$1;
  exports.NoSsr = NoSsr;
  exports.OutlinedInput = OutlinedInput$1;
  exports.Pagination = Pagination$1;
  exports.PaginationItem = PaginationItem$1;
  exports.Paper = Paper$1;
  exports.Popover = Popover$1;
  exports.PopoverPaper = PopoverPaper;
  exports.PopoverRoot = PopoverRoot;
  exports.Popper = Popper$1;
  exports.Portal = Portal$1;
  exports.Radio = Radio$1;
  exports.RadioGroup = RadioGroup$1;
  exports.Rating = Rating$1;
  exports.ScopedCssBaseline = ScopedCssBaseline$1;
  exports.Select = Select$1;
  exports.Skeleton = Skeleton$1;
  exports.Slide = Slide$1;
  exports.Slider = Slider$1;
  exports.SliderMark = SliderMark;
  exports.SliderMarkLabel = SliderMarkLabel;
  exports.SliderRail = SliderRail;
  exports.SliderRoot = SliderRoot;
  exports.SliderThumb = SliderThumb;
  exports.SliderTrack = SliderTrack;
  exports.SliderValueLabel = SliderValueLabel;
  exports.Snackbar = Snackbar$1;
  exports.SnackbarContent = SnackbarContent$1;
  exports.SpeedDial = SpeedDial$1;
  exports.SpeedDialAction = SpeedDialAction$1;
  exports.SpeedDialIcon = SpeedDialIcon$1;
  exports.Stack = Stack$1;
  exports.Step = Step$1;
  exports.StepButton = StepButton$1;
  exports.StepConnector = StepConnector$1;
  exports.StepContent = StepContent$1;
  exports.StepContext = StepContext$1;
  exports.StepIcon = StepIcon$1;
  exports.StepLabel = StepLabel$1;
  exports.Stepper = Stepper$1;
  exports.StepperContext = StepperContext$1;
  exports.StyledEngineProvider = StyledEngineProvider;
  exports.SvgIcon = SvgIcon$1;
  exports.SwipeableDrawer = SwipeableDrawer$1;
  exports.Switch = Switch$1;
  exports.THEME_ID = THEME_ID;
  exports.Tab = Tab$1;
  exports.TabScrollButton = TabScrollButton$1;
  exports.Table = Table$1;
  exports.TableBody = TableBody$1;
  exports.TableCell = TableCell$1;
  exports.TableContainer = TableContainer$1;
  exports.TableFooter = TableFooter$1;
  exports.TableHead = TableHead$1;
  exports.TablePagination = TablePagination$1;
  exports.TableRow = TableRow$1;
  exports.TableSortLabel = TableSortLabel$1;
  exports.Tabs = Tabs$1;
  exports.TextField = TextField$1;
  exports.TextareaAutosize = TextareaAutosize$1;
  exports.ThemeProvider = ThemeProvider;
  exports.ToggleButton = ToggleButton$1;
  exports.ToggleButtonGroup = ToggleButtonGroup$1;
  exports.Toolbar = Toolbar$1;
  exports.Tooltip = Tooltip$1;
  exports.Typography = Typography$1;
  exports.Unstable_Grid2 = Grid2$1;
  exports.Unstable_TrapFocus = FocusTrap;
  exports.Zoom = Zoom$1;
  exports.accordionActionsClasses = accordionActionsClasses$1;
  exports.accordionClasses = accordionClasses$1;
  exports.accordionDetailsClasses = accordionDetailsClasses$1;
  exports.accordionSummaryClasses = accordionSummaryClasses$1;
  exports.adaptV4Theme = adaptV4Theme;
  exports.alertClasses = alertClasses$1;
  exports.alertTitleClasses = alertTitleClasses$1;
  exports.alpha = alpha;
  exports.appBarClasses = appBarClasses$1;
  exports.autocompleteClasses = autocompleteClasses$1;
  exports.avatarClasses = avatarClasses$1;
  exports.avatarGroupClasses = avatarGroupClasses$1;
  exports.backdropClasses = backdropClasses$1;
  exports.badgeClasses = badgeClasses$1;
  exports.bottomNavigationActionClasses = bottomNavigationActionClasses$1;
  exports.bottomNavigationClasses = bottomNavigationClasses$1;
  exports.boxClasses = boxClasses$1;
  exports.breadcrumbsClasses = breadcrumbsClasses$1;
  exports.buttonBaseClasses = buttonBaseClasses$1;
  exports.buttonClasses = buttonClasses$1;
  exports.buttonGroupClasses = buttonGroupClasses$1;
  exports.capitalize = capitalize;
  exports.cardActionAreaClasses = cardActionAreaClasses$1;
  exports.cardActionsClasses = cardActionsClasses$1;
  exports.cardClasses = cardClasses$1;
  exports.cardContentClasses = cardContentClasses$1;
  exports.cardHeaderClasses = cardHeaderClasses$1;
  exports.cardMediaClasses = cardMediaClasses$1;
  exports.checkboxClasses = checkboxClasses$1;
  exports.chipClasses = chipClasses$1;
  exports.circularProgressClasses = circularProgressClasses$1;
  exports.collapseClasses = collapseClasses$1;
  exports.colors = index;
  exports.containerClasses = containerClasses$1;
  exports.createChainedFunction = createChainedFunction;
  exports.createFilterOptions = createFilterOptions;
  exports.createMuiTheme = createMuiTheme;
  exports.createStyles = createStyles;
  exports.createSvgIcon = createSvgIcon;
  exports.createTheme = createTheme;
  exports.css = css;
  exports.darkScrollbar = darkScrollbar;
  exports.darken = darken;
  exports.debounce = debounce$1;
  exports.decomposeColor = decomposeColor;
  exports.deprecatedPropType = deprecatedPropType;
  exports.dialogActionsClasses = dialogActionsClasses$1;
  exports.dialogClasses = dialogClasses$1;
  exports.dialogContentClasses = dialogContentClasses$1;
  exports.dialogContentTextClasses = dialogContentTextClasses$1;
  exports.dialogTitleClasses = dialogTitleClasses$1;
  exports.dividerClasses = dividerClasses$1;
  exports.drawerClasses = drawerClasses$1;
  exports.duration = duration;
  exports.easing = easing;
  exports.emphasize = emphasize;
  exports.experimentalStyled = styled$1;
  exports.experimental_extendTheme = extendTheme;
  exports.experimental_sx = experimental_sx;
  exports.fabClasses = fabClasses$1;
  exports.filledInputClasses = filledInputClasses$1;
  exports.formControlClasses = formControlClasses$1;
  exports.formControlLabelClasses = formControlLabelClasses$1;
  exports.formGroupClasses = formGroupClasses$1;
  exports.formHelperTextClasses = formHelperTextClasses$1;
  exports.formLabelClasses = formLabelClasses$1;
  exports.generateUtilityClass = generateUtilityClass;
  exports.generateUtilityClasses = generateUtilityClasses;
  exports.getAccordionActionsUtilityClass = getAccordionActionsUtilityClass;
  exports.getAccordionDetailsUtilityClass = getAccordionDetailsUtilityClass;
  exports.getAccordionSummaryUtilityClass = getAccordionSummaryUtilityClass;
  exports.getAccordionUtilityClass = getAccordionUtilityClass;
  exports.getAlertTitleUtilityClass = getAlertTitleUtilityClass;
  exports.getAlertUtilityClass = getAlertUtilityClass;
  exports.getAppBarUtilityClass = getAppBarUtilityClass;
  exports.getAutocompleteUtilityClass = getAutocompleteUtilityClass;
  exports.getAvatarGroupUtilityClass = getAvatarGroupUtilityClass;
  exports.getAvatarUtilityClass = getAvatarUtilityClass;
  exports.getBackdropUtilityClass = getBackdropUtilityClass;
  exports.getBadgeUtilityClass = getBadgeUtilityClass;
  exports.getBottomNavigationActionUtilityClass = getBottomNavigationActionUtilityClass;
  exports.getBottomNavigationUtilityClass = getBottomNavigationUtilityClass;
  exports.getBreadcrumbsUtilityClass = getBreadcrumbsUtilityClass;
  exports.getButtonBaseUtilityClass = getButtonBaseUtilityClass;
  exports.getButtonGroupUtilityClass = getButtonGroupUtilityClass;
  exports.getButtonUtilityClass = getButtonUtilityClass;
  exports.getCardActionAreaUtilityClass = getCardActionAreaUtilityClass;
  exports.getCardActionsUtilityClass = getCardActionsUtilityClass;
  exports.getCardContentUtilityClass = getCardContentUtilityClass;
  exports.getCardHeaderUtilityClass = getCardHeaderUtilityClass;
  exports.getCardMediaUtilityClass = getCardMediaUtilityClass;
  exports.getCardUtilityClass = getCardUtilityClass;
  exports.getCheckboxUtilityClass = getCheckboxUtilityClass;
  exports.getChipUtilityClass = getChipUtilityClass;
  exports.getCircularProgressUtilityClass = getCircularProgressUtilityClass;
  exports.getCollapseUtilityClass = getCollapseUtilityClass;
  exports.getContainerUtilityClass = getContainerUtilityClass;
  exports.getContrastRatio = getContrastRatio;
  exports.getDialogActionsUtilityClass = getDialogActionsUtilityClass;
  exports.getDialogContentTextUtilityClass = getDialogContentTextUtilityClass;
  exports.getDialogContentUtilityClass = getDialogContentUtilityClass;
  exports.getDialogTitleUtilityClass = getDialogTitleUtilityClass;
  exports.getDialogUtilityClass = getDialogUtilityClass;
  exports.getDividerUtilityClass = getDividerUtilityClass;
  exports.getDrawerUtilityClass = getDrawerUtilityClass;
  exports.getFabUtilityClass = getFabUtilityClass;
  exports.getFilledInputUtilityClass = getFilledInputUtilityClass;
  exports.getFormControlLabelUtilityClasses = getFormControlLabelUtilityClasses;
  exports.getFormControlUtilityClasses = getFormControlUtilityClasses;
  exports.getFormGroupUtilityClass = getFormGroupUtilityClass;
  exports.getFormHelperTextUtilityClasses = getFormHelperTextUtilityClasses;
  exports.getFormLabelUtilityClasses = getFormLabelUtilityClasses;
  exports.getGrid2UtilityClass = getGrid2UtilityClass;
  exports.getGridUtilityClass = getGridUtilityClass;
  exports.getIconButtonUtilityClass = getIconButtonUtilityClass;
  exports.getIconUtilityClass = getIconUtilityClass;
  exports.getImageListItemBarUtilityClass = getImageListItemBarUtilityClass;
  exports.getImageListItemUtilityClass = getImageListItemUtilityClass;
  exports.getImageListUtilityClass = getImageListUtilityClass;
  exports.getInitColorSchemeScript = getInitColorSchemeScript;
  exports.getInputAdornmentUtilityClass = getInputAdornmentUtilityClass;
  exports.getInputBaseUtilityClass = getInputBaseUtilityClass;
  exports.getInputLabelUtilityClasses = getInputLabelUtilityClasses;
  exports.getInputUtilityClass = getInputUtilityClass;
  exports.getLinearProgressUtilityClass = getLinearProgressUtilityClass;
  exports.getLinkUtilityClass = getLinkUtilityClass;
  exports.getListItemAvatarUtilityClass = getListItemAvatarUtilityClass;
  exports.getListItemButtonUtilityClass = getListItemButtonUtilityClass;
  exports.getListItemIconUtilityClass = getListItemIconUtilityClass;
  exports.getListItemSecondaryActionClassesUtilityClass = getListItemSecondaryActionClassesUtilityClass;
  exports.getListItemTextUtilityClass = getListItemTextUtilityClass;
  exports.getListItemUtilityClass = getListItemUtilityClass;
  exports.getListSubheaderUtilityClass = getListSubheaderUtilityClass;
  exports.getListUtilityClass = getListUtilityClass;
  exports.getLuminance = getLuminance;
  exports.getMenuItemUtilityClass = getMenuItemUtilityClass;
  exports.getMenuUtilityClass = getMenuUtilityClass;
  exports.getMobileStepperUtilityClass = getMobileStepperUtilityClass;
  exports.getModalUtilityClass = getModalUtilityClass;
  exports.getNativeSelectUtilityClasses = getNativeSelectUtilityClasses;
  exports.getOffsetLeft = getOffsetLeft;
  exports.getOffsetTop = getOffsetTop;
  exports.getOutlinedInputUtilityClass = getOutlinedInputUtilityClass;
  exports.getOverlayAlpha = getOverlayAlpha$1;
  exports.getPaginationItemUtilityClass = getPaginationItemUtilityClass;
  exports.getPaginationUtilityClass = getPaginationUtilityClass;
  exports.getPaperUtilityClass = getPaperUtilityClass;
  exports.getPopoverUtilityClass = getPopoverUtilityClass;
  exports.getPopperUtilityClass = getPopperUtilityClass;
  exports.getRadioGroupUtilityClass = getRadioGroupUtilityClass;
  exports.getRadioUtilityClass = getRadioUtilityClass;
  exports.getRatingUtilityClass = getRatingUtilityClass;
  exports.getScopedCssBaselineUtilityClass = getScopedCssBaselineUtilityClass;
  exports.getSelectUtilityClasses = getSelectUtilityClasses;
  exports.getSkeletonUtilityClass = getSkeletonUtilityClass;
  exports.getSliderUtilityClass = getSliderUtilityClass;
  exports.getSnackbarContentUtilityClass = getSnackbarContentUtilityClass;
  exports.getSnackbarUtilityClass = getSnackbarUtilityClass;
  exports.getSpeedDialActionUtilityClass = getSpeedDialActionUtilityClass;
  exports.getSpeedDialIconUtilityClass = getSpeedDialIconUtilityClass;
  exports.getSpeedDialUtilityClass = getSpeedDialUtilityClass;
  exports.getStepButtonUtilityClass = getStepButtonUtilityClass;
  exports.getStepConnectorUtilityClass = getStepConnectorUtilityClass;
  exports.getStepContentUtilityClass = getStepContentUtilityClass;
  exports.getStepIconUtilityClass = getStepIconUtilityClass;
  exports.getStepLabelUtilityClass = getStepLabelUtilityClass;
  exports.getStepUtilityClass = getStepUtilityClass;
  exports.getStepperUtilityClass = getStepperUtilityClass;
  exports.getSvgIconUtilityClass = getSvgIconUtilityClass;
  exports.getSwitchUtilityClass = getSwitchUtilityClass;
  exports.getTabScrollButtonUtilityClass = getTabScrollButtonUtilityClass;
  exports.getTabUtilityClass = getTabUtilityClass;
  exports.getTableBodyUtilityClass = getTableBodyUtilityClass;
  exports.getTableCellUtilityClass = getTableCellUtilityClass;
  exports.getTableContainerUtilityClass = getTableContainerUtilityClass;
  exports.getTableFooterUtilityClass = getTableFooterUtilityClass;
  exports.getTableHeadUtilityClass = getTableHeadUtilityClass;
  exports.getTablePaginationUtilityClass = getTablePaginationUtilityClass;
  exports.getTableRowUtilityClass = getTableRowUtilityClass;
  exports.getTableSortLabelUtilityClass = getTableSortLabelUtilityClass;
  exports.getTableUtilityClass = getTableUtilityClass;
  exports.getTabsUtilityClass = getTabsUtilityClass;
  exports.getTextFieldUtilityClass = getTextFieldUtilityClass;
  exports.getToggleButtonGroupUtilityClass = getToggleButtonGroupUtilityClass;
  exports.getToggleButtonUtilityClass = getToggleButtonUtilityClass;
  exports.getToolbarUtilityClass = getToolbarUtilityClass;
  exports.getTooltipUtilityClass = getTooltipUtilityClass;
  exports.getTouchRippleUtilityClass = getTouchRippleUtilityClass;
  exports.getTypographyUtilityClass = getTypographyUtilityClass;
  exports.grid2Classes = grid2Classes$1;
  exports.gridClasses = gridClasses$1;
  exports.hexToRgb = hexToRgb;
  exports.hslToRgb = hslToRgb;
  exports.iconButtonClasses = iconButtonClasses$1;
  exports.iconClasses = iconClasses$1;
  exports.imageListClasses = imageListClasses$1;
  exports.imageListItemBarClasses = imageListItemBarClasses$1;
  exports.imageListItemClasses = imageListItemClasses$1;
  exports.inputAdornmentClasses = inputAdornmentClasses$1;
  exports.inputBaseClasses = inputBaseClasses$1;
  exports.inputClasses = inputClasses$1;
  exports.inputLabelClasses = inputLabelClasses$1;
  exports.isMuiElement = isMuiElement;
  exports.keyframes = keyframes;
  exports.lighten = lighten;
  exports.linearProgressClasses = linearProgressClasses$1;
  exports.linkClasses = linkClasses$1;
  exports.listClasses = listClasses$1;
  exports.listItemAvatarClasses = listItemAvatarClasses$1;
  exports.listItemButtonClasses = listItemButtonClasses$1;
  exports.listItemClasses = listItemClasses$1;
  exports.listItemIconClasses = listItemIconClasses$1;
  exports.listItemSecondaryActionClasses = listItemSecondaryActionClasses$1;
  exports.listItemTextClasses = listItemTextClasses$1;
  exports.listSubheaderClasses = listSubheaderClasses$1;
  exports.major = major;
  exports.makeStyles = makeStyles;
  exports.menuClasses = menuClasses$1;
  exports.menuItemClasses = menuItemClasses$1;
  exports.minor = minor;
  exports.mobileStepperClasses = mobileStepperClasses$1;
  exports.modalClasses = modalClasses$1;
  exports.nativeSelectClasses = nativeSelectClasses$1;
  exports.outlinedInputClasses = outlinedInputClasses$1;
  exports.ownerDocument = ownerDocument;
  exports.ownerWindow = ownerWindow;
  exports.paginationClasses = paginationClasses$1;
  exports.paginationItemClasses = paginationItemClasses$1;
  exports.paperClasses = paperClasses$1;
  exports.patch = patch;
  exports.popoverClasses = popoverClasses$1;
  exports.preReleaseLabel = preReleaseLabel;
  exports.preReleaseNumber = preReleaseNumber;
  exports.private_createMixins = createMixins;
  exports.private_createTypography = createTypography;
  exports.private_excludeVariablesFromRoot = excludeVariablesFromRoot$1;
  exports.radioClasses = radioClasses$1;
  exports.radioGroupClasses = radioGroupClasses$1;
  exports.ratingClasses = ratingClasses$1;
  exports.recomposeColor = recomposeColor;
  exports.requirePropFactory = requirePropFactory;
  exports.responsiveFontSizes = responsiveFontSizes;
  exports.rgbToHex = rgbToHex;
  exports.scopedCssBaselineClasses = scopedCssBaselineClasses$1;
  exports.selectClasses = selectClasses$1;
  exports.setRef = setRef;
  exports.shouldSkipGeneratingVar = shouldSkipGeneratingVar;
  exports.skeletonClasses = skeletonClasses$1;
  exports.sliderClasses = sliderClasses$1;
  exports.snackbarClasses = snackbarClasses$1;
  exports.snackbarContentClasses = snackbarContentClasses$1;
  exports.speedDialActionClasses = speedDialActionClasses$1;
  exports.speedDialClasses = speedDialClasses$1;
  exports.speedDialIconClasses = speedDialIconClasses$1;
  exports.stackClasses = stackClasses$1;
  exports.stepButtonClasses = stepButtonClasses$1;
  exports.stepClasses = stepClasses$1;
  exports.stepConnectorClasses = stepConnectorClasses$1;
  exports.stepContentClasses = stepContentClasses$1;
  exports.stepIconClasses = stepIconClasses$1;
  exports.stepLabelClasses = stepLabelClasses$1;
  exports.stepperClasses = stepperClasses$1;
  exports.styled = styled$1;
  exports.svgIconClasses = svgIconClasses$1;
  exports.switchClasses = switchClasses$1;
  exports.tabClasses = tabClasses$1;
  exports.tabScrollButtonClasses = tabScrollButtonClasses$1;
  exports.tableBodyClasses = tableBodyClasses$1;
  exports.tableCellClasses = tableCellClasses$1;
  exports.tableClasses = tableClasses$1;
  exports.tableContainerClasses = tableContainerClasses$1;
  exports.tableFooterClasses = tableFooterClasses$1;
  exports.tableHeadClasses = tableHeadClasses$1;
  exports.tablePaginationClasses = tablePaginationClasses$1;
  exports.tableRowClasses = tableRowClasses$1;
  exports.tableSortLabelClasses = tableSortLabelClasses$1;
  exports.tabsClasses = tabsClasses$1;
  exports.textFieldClasses = textFieldClasses$1;
  exports.toggleButtonClasses = toggleButtonClasses$1;
  exports.toggleButtonGroupClasses = toggleButtonGroupClasses$1;
  exports.toolbarClasses = toolbarClasses$1;
  exports.tooltipClasses = tooltipClasses$1;
  exports.touchRippleClasses = touchRippleClasses$1;
  exports.typographyClasses = typographyClasses$1;
  exports.unstable_ClassNameGenerator = unstable_ClassNameGenerator;
  exports.unstable_composeClasses = composeClasses;
  exports.unstable_createMuiStrictModeTheme = createMuiStrictModeTheme;
  exports.unstable_getUnit = getUnit;
  exports.unstable_toUnitless = toUnitless;
  exports.unstable_useEnhancedEffect = useEnhancedEffect$1;
  exports.unstable_useId = useId;
  exports.unsupportedProp = unsupportedProp;
  exports.useAutocomplete = useAutocomplete;
  exports.useColorScheme = useColorScheme;
  exports.useControlled = useControlled;
  exports.useEventCallback = useEventCallback;
  exports.useForkRef = useForkRef;
  exports.useFormControl = useFormControl;
  exports.useIsFocusVisible = useIsFocusVisible;
  exports.useMediaQuery = useMediaQuery;
  exports.usePagination = usePagination;
  exports.useRadioGroup = useRadioGroup;
  exports.useScrollTrigger = useScrollTrigger;
  exports.useStepContext = useStepContext;
  exports.useStepperContext = useStepperContext;
  exports.useTheme = useTheme;
  exports.useThemeProps = useThemeProps;
  exports.version = version;
  exports.withStyles = withStyles;
  exports.withTheme = withTheme;

}));
