@mui/system 5.8.7 → 5.9.2

package/getThemeValue.js

@@ -13,7 +13,7 @@ var _display = _interopRequireDefault(require("./display"));
 
 var _flexbox = _interopRequireDefault(require("./flexbox"));
 
-var _grid = _interopRequireDefault(require("./grid"));
+var _cssGrid = _interopRequireDefault(require("./cssGrid"));
 
 var _positions = _interopRequireDefault(require("./positions"));
 
@@ -31,7 +31,7 @@ const filterPropsMapping = {
   borders: _borders.default.filterProps,
   display: _display.default.filterProps,
   flexbox: _flexbox.default.filterProps,
-  grid: _grid.default.filterProps,
+  grid: _cssGrid.default.filterProps,
   positions: _positions.default.filterProps,
   palette: _palette.default.filterProps,
   shadows: _shadows.default.filterProps,
@@ -43,7 +43,7 @@ const styleFunctionMapping = {
   borders: _borders.default,
   display: _display.default,
   flexbox: _flexbox.default,
-  grid: _grid.default,
+  grid: _cssGrid.default,
   positions: _positions.default,
   palette: _palette.default,
   shadows: _shadows.default,

package/index.d.ts

@@ -175,3 +175,6 @@ export * from './Container/createContainer';
 
 export { default as Container } from './Container';
 export * from './Container';
+
+export { default as Unstable_Grid } from './Unstable_Grid';
+export * from './Unstable_Grid';

package/index.js

@@ -1,4 +1,4 @@
-/** @license MUI v5.8.7
+/** @license MUI v5.9.2
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -53,7 +53,8 @@ var _exportNames = {
   unstable_createCssVarsProvider: true,
   unstable_createGetCssVar: true,
   createContainer: true,
-  Container: true
+  Container: true,
+  Unstable_Grid: true
 };
 Object.defineProperty(exports, "Box", {
   enumerable: true,
@@ -85,6 +86,12 @@ Object.defineProperty(exports, "ThemeProvider", {
     return _ThemeProvider.default;
   }
 });
+Object.defineProperty(exports, "Unstable_Grid", {
+  enumerable: true,
+  get: function () {
+    return _Grid.default;
+  }
+});
 Object.defineProperty(exports, "borders", {
   enumerable: true,
   get: function () {
@@ -178,7 +185,7 @@ Object.defineProperty(exports, "getThemeProps", {
 Object.defineProperty(exports, "grid", {
   enumerable: true,
   get: function () {
-    return _grid.default;
+    return _cssGrid.default;
   }
 });
 Object.defineProperty(exports, "handleBreakpoints", {
@@ -350,16 +357,16 @@ Object.keys(_flexbox).forEach(function (key) {
   });
 });
 
-var _grid = _interopRequireWildcard(require("./grid"));
+var _cssGrid = _interopRequireWildcard(require("./cssGrid"));
 
-Object.keys(_grid).forEach(function (key) {
+Object.keys(_cssGrid).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _grid[key]) return;
+  if (key in exports && exports[key] === _cssGrid[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _grid[key];
+      return _cssGrid[key];
     }
   });
 });
@@ -514,6 +521,22 @@ Object.keys(_Container).forEach(function (key) {
   });
 });
 
+var _Grid = _interopRequireDefault(require("./Unstable_Grid/Grid"));
+
+var _Unstable_Grid = require("./Unstable_Grid");
+
+Object.keys(_Unstable_Grid).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Unstable_Grid[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Unstable_Grid[key];
+    }
+  });
+});
+
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

package/legacy/Unstable_Grid/Grid.js

@@ -0,0 +1,184 @@
+import PropTypes from 'prop-types';
+import createGrid from './createGrid';
+/**
+ *
+ * Demos:
+ *
+ * - [Grid (Material UI)](https://mui.com/material-ui/react-grid/)
+ *
+ * API:
+ *
+ * - [Grid API](https://mui.com/system/api/grid/)
+ */
+
+var Grid = createGrid();
+process.env.NODE_ENV !== "production" ? Grid.propTypes
+/* remove-proptypes */
+= {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // |     To update them edit TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+
+  /**
+   * The content of the component.
+   */
+  children: PropTypes.node,
+
+  /**
+   * The number of columns.
+   * @default 12
+   */
+  columns: PropTypes
+  /* @typescript-to-proptypes-ignore */
+  .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
+  /* @typescript-to-proptypes-ignore */
+  .oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),
+
+  /**
+   * 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
+  /* @typescript-to-proptypes-ignore */
+  .oneOfType([PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row']), PropTypes.arrayOf(PropTypes.oneOf(['column-reverse', 'column', 'row-reverse', 'row'])), PropTypes.object]),
+
+  /**
+   * If `true`, the negative margin and padding are apply only to the top and left sides of the grid.
+   */
+  disableEqualOverflow: 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 margin-left equals to the number of columns the grid item uses.
+   * If 'auto', the grid item push itself to the right-end of the container.
+   * The value is applied for the `lg` breakpoint and wider screens if not overridden.
+   */
+  lgOffset: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]),
+
+  /**
+   * 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]),
+
+  /**
+   * If a number, it sets the margin-left equals to the number of columns the grid item uses.
+   * If 'auto', the grid item push itself to the right-end of the container.
+   * The value is applied for the `md` breakpoint and wider screens if not overridden.
+   */
+  mdOffset: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]),
+
+  /**
+   * Defines the vertical space between the type `item` components.
+   * It overrides the value of the `spacing` prop.
+   */
+  rowSpacing: PropTypes
+  /* @typescript-to-proptypes-ignore */
+  .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]),
+
+  /**
+   * If a number, it sets the margin-left equals to the number of columns the grid item uses.
+   * If 'auto', the grid item push itself to the right-end of the container.
+   * The value is applied for the `sm` breakpoint and wider screens if not overridden.
+   */
+  smOffset: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]),
+
+  /**
+   * Defines the space between the type `item` components.
+   * It can only be used on a type `container` component.
+   * @default 0
+   */
+  spacing: PropTypes
+  /* @typescript-to-proptypes-ignore */
+  .oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.string])), PropTypes.number, PropTypes.object, PropTypes.string]),
+
+  /**
+   * @ignore
+   */
+  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 margin-left equals to the number of columns the grid item uses.
+   * If 'auto', the grid item push itself to the right-end of the container.
+   * The value is applied for the `xl` breakpoint and wider screens if not overridden.
+   */
+  xlOffset: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]),
+
+  /**
+   * 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 a number, it sets the margin-left equals to the number of columns the grid item uses.
+   * If 'auto', the grid item push itself to the right-end of the container.
+   * The value is applied for the `xs` breakpoint and wider screens if not overridden.
+   */
+  xsOffset: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number])
+} : void 0;
+export default Grid;

package/legacy/Unstable_Grid/GridProps.js

@@ -0,0 +1 @@
+export {};

package/legacy/Unstable_Grid/createGrid.js

@@ -0,0 +1,191 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+import { unstable_composeClasses as composeClasses, unstable_generateUtilityClass as generateUtilityClass } from '@mui/utils';
+import systemStyled from '../styled';
+import useThemePropsSystem from '../useThemeProps';
+import useTheme from '../useTheme';
+import { extendSxProp } from '../styleFunctionSx';
+import createTheme from '../createTheme';
+import { generateGridStyles, generateGridSizeStyles, generateGridColumnsStyles, generateGridColumnSpacingStyles, generateGridRowSpacingStyles, generateGridDirectionStyles, generateGridOffsetStyles, generateSizeClassNames, generateSpacingClassNames } from './gridGenerator';
+import { jsx as _jsx } from "react/jsx-runtime";
+var defaultTheme = createTheme(); // widening Theme to any so that the consumer can own the theme structure.
+
+var defaultCreateStyledComponent = systemStyled('div', {
+  name: 'MuiGrid',
+  slot: 'Root',
+  overridesResolver: function overridesResolver(props, styles) {
+    return styles.root;
+  }
+});
+
+function useThemePropsDefault(props) {
+  return useThemePropsSystem({
+    props: props,
+    name: 'MuiGrid',
+    defaultTheme: defaultTheme
+  });
+}
+
+export default function createGrid() {
+  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 ? 'MuiGrid' : _options$componentNam;
+  var NestedContext = /*#__PURE__*/React.createContext(false);
+  var OverflowContext = /*#__PURE__*/React.createContext(undefined);
+
+  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', direction !== 'row' && "direction-xs-".concat(String(direction)), wrap !== 'wrap' && "wrap-xs-".concat(String(wrap))].concat(_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.forwardRef(function Grid(inProps, ref) {
+    var _inProps$columns, _inProps$spacing, _ref3, _inProps$rowSpacing, _ref4, _inProps$columnSpacin, _ref5, _disableEqualOverflow;
+
+    var theme = useTheme();
+    var themeProps = useThemeProps(inProps);
+    var props = extendSxProp(themeProps); // `color` type conflicts with html color attribute.
+
+    var nested = React.useContext(NestedContext);
+    var overflow = React.useContext(OverflowContext);
+
+    var className = props.className,
+        _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,
+        rest = _objectWithoutProperties(props, ["className", "columns", "container", "component", "direction", "wrap", "spacing", "rowSpacing", "columnSpacing", "disableEqualOverflow"]); // Because `disableEqualOverflow` can be set from the theme's defaultProps, the **nested** grid should look at the instance props instead.
+
+
+    var disableEqualOverflow = themeDisableEqualOverflow;
+
+    if (nested && 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 : nested ? undefined : columnsProp;
+    var spacing = (_inProps$spacing = inProps.spacing) != null ? _inProps$spacing : nested ? undefined : spacingProp;
+    var rowSpacing = (_ref3 = (_inProps$rowSpacing = inProps.rowSpacing) != null ? _inProps$rowSpacing : inProps.spacing) != null ? _ref3 : nested ? undefined : rowSpacingProp;
+    var columnSpacing = (_ref4 = (_inProps$columnSpacin = inProps.columnSpacing) != null ? _inProps$columnSpacin : inProps.spacing) != null ? _ref4 : nested ? undefined : columnSpacingProp;
+
+    var ownerState = _extends({}, props, {
+      nested: nested,
+      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__*/_jsx(GridRoot, _extends({
+      ref: ref,
+      as: component,
+      ownerState: ownerState,
+      className: clsx(classes.root, className)
+    }, other));
+
+    if (!nested) {
+      result = /*#__PURE__*/_jsx(NestedContext.Provider, {
+        value: true,
+        children: result
+      });
+    }
+
+    if (disableEqualOverflow !== undefined && disableEqualOverflow !== (overflow != null ? overflow : false)) {
+      // There are 2 possibilities that should wrap with the OverflowContext 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__*/_jsx(OverflowContext.Provider, {
+        value: disableEqualOverflow,
+        children: result
+      });
+    }
+
+    return result;
+  });
+  process.env.NODE_ENV !== "production" ? 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])
+  } : void 0;
+  return Grid;
+}

package/legacy/Unstable_Grid/gridClasses.js

@@ -0,0 +1,27 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { unstable_generateUtilityClass as generateUtilityClass, unstable_generateUtilityClasses as generateUtilityClasses } from '@mui/utils';
+export function getGridUtilityClass(slot) {
+  return generateUtilityClass('MuiGrid', 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 gridClasses = generateUtilityClasses('MuiGrid', ['root', 'container', 'item'].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);
+}))));
+export default gridClasses;