text: import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
  import _extends from "@babel/runtime/helpers/esm/extends";
  const _excluded = ["className", "columns", "columnSpacing", "component", "container", "direction", "item", "lg", "md", "rowSpacing", "sm", "spacing", "wrap", "xl", "xs", "zeroMinWidth"];
  // A grid component using the following libs as inspiration.
  //
  // For the implementation:
  // - https://getbootstrap.com/docs/4.3/layout/grid/
  // - https://github.com/kristoferjoseph/flexboxgrid/blob/master/src/css/flexboxgrid.css
  // - https://github.com/roylee0704/react-flexbox-grid
  // - https://material.angularjs.org/latest/layout/introduction
  //
  // Follow this flexbox Guide to better understand the underlying model:
  // - https://css-tricks.com/snippets/css/a-guide-to-flexbox/
  import * as React from 'react';
  import PropTypes from 'prop-types';
  import clsx from 'clsx';
  import { unstable_extendSxProp as extendSxProp, handleBreakpoints, unstable_resolveBreakpointValues as resolveBreakpointValues } from '@mui/system';
  import { unstable_composeClasses as composeClasses } from '@mui/base';
  import requirePropFactory from '../utils/requirePropFactory';
  import styled from '../styles/styled';
  import useThemeProps from '../styles/useThemeProps';
  import GridContext from './GridContext';
  import gridClasses, { getGridUtilityClass } from './gridClasses';
  import { jsx as _jsx } from "react/jsx-runtime";
  
  function getOffset(val) {
    const parse = parseFloat(val);
    return `${parse}${String(val).replace(String(parse), '') || 'px'}`;
  }
  
  function generateGrid(globalStyles, theme, breakpoint, ownerState) {
    const size = ownerState[breakpoint];
  
    if (!size) {
      return;
    }
  
    let styles = {};
  
    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 {
      const columnsBreakpointValues = resolveBreakpointValues({
        values: ownerState.columns,
        breakpoints: theme.breakpoints.values
      });
      const columnValue = typeof columnsBreakpointValues === 'object' ? columnsBreakpointValues[breakpoint] : columnsBreakpointValues; // Keep 7 significant numbers.
  
      const width = `${Math.round(size / columnValue * 10e7) / 10e5}%`;
      let more = {};
  
      if (ownerState.container && ownerState.item && ownerState.columnSpacing !== 0) {
        const themeSpacing = theme.spacing(ownerState.columnSpacing);
  
        if (themeSpacing !== '0px') {
          const fullWidth = `calc(${width} + ${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;
    }
  }
  
  export function generateDirection({
    theme,
    ownerState
  }) {
    const directionValues = resolveBreakpointValues({
      values: ownerState.direction,
      breakpoints: theme.breakpoints.values
    });
    return handleBreakpoints({
      theme
    }, directionValues, propValue => {
      const output = {
        flexDirection: propValue
      };
  
      if (propValue.indexOf('column') === 0) {
        output[`& > .${gridClasses.item}`] = {
          maxWidth: 'none'
        };
      }
  
      return output;
    });
  }
  export function generateRowGap({
    theme,
    ownerState
  }) {
    const {
      container,
      rowSpacing
    } = ownerState;
    let styles = {};
  
    if (container && rowSpacing !== 0) {
      const rowSpacingValues = resolveBreakpointValues({
        values: rowSpacing,
        breakpoints: theme.breakpoints.values
      });
      styles = handleBreakpoints({
        theme
      }, rowSpacingValues, propValue => {
        const themeSpacing = theme.spacing(propValue);
  
        if (themeSpacing !== '0px') {
          return {
            marginTop: `-${getOffset(themeSpacing)}`,
            [`& > .${gridClasses.item}`]: {
              paddingTop: getOffset(themeSpacing)
            }
          };
        }
  
        return {};
      });
    }
  
    return styles;
  }
  export function generateColumnGap({
    theme,
    ownerState
  }) {
    const {
      container,
      columnSpacing
    } = ownerState;
    let styles = {};
  
    if (container && columnSpacing !== 0) {
      const columnSpacingValues = resolveBreakpointValues({
        values: columnSpacing,
        breakpoints: theme.breakpoints.values
      });
      styles = handleBreakpoints({
        theme
      }, columnSpacingValues, propValue => {
        const themeSpacing = theme.spacing(propValue);
  
        if (themeSpacing !== '0px') {
          return {
            width: `calc(100% + ${getOffset(themeSpacing)})`,
            marginLeft: `-${getOffset(themeSpacing)}`,
            [`& > .${gridClasses.item}`]: {
              paddingLeft: getOffset(themeSpacing)
            }
          };
        }
  
        return {};
      });
    }
  
    return styles;
  }
  export function resolveSpacingClasses(spacing, container, styles = {}) {
    // in case of grid item or undefined/null or `spacing` <= 0
    if (!container || !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-${String(spacing)}`] || `spacing-xs-${String(spacing)}`];
    } // in case of object `spacing`
  
  
    const {
      xs,
      sm,
      md,
      lg,
      xl
    } = spacing;
    return [Number(xs) > 0 && (styles[`spacing-xs-${String(xs)}`] || `spacing-xs-${String(xs)}`), Number(sm) > 0 && (styles[`spacing-sm-${String(sm)}`] || `spacing-sm-${String(sm)}`), Number(md) > 0 && (styles[`spacing-md-${String(md)}`] || `spacing-md-${String(md)}`), Number(lg) > 0 && (styles[`spacing-lg-${String(lg)}`] || `spacing-lg-${String(lg)}`), Number(xl) > 0 && (styles[`spacing-xl-${String(xl)}`] || `spacing-xl-${String(xl)}`)];
  } // Default CSS values
  // flex: '0 1 auto',
  // flexDirection: 'row',
  // alignItems: 'flex-start',
  // flexWrap: 'nowrap',
  // justifyContent: 'flex-start',
  
  const GridRoot = styled('div', {
    name: 'MuiGrid',
    slot: 'Root',
    overridesResolver: (props, styles) => {
      const {
        container,
        direction,
        item,
        lg,
        md,
        sm,
        spacing,
        wrap,
        xl,
        xs,
        zeroMinWidth
      } = props.ownerState;
      return [styles.root, container && styles.container, item && styles.item, zeroMinWidth && styles.zeroMinWidth, ...resolveSpacingClasses(spacing, container, styles), direction !== 'row' && styles[`direction-xs-${String(direction)}`], wrap !== 'wrap' && styles[`wrap-xs-${String(wrap)}`], xs !== false && styles[`grid-xs-${String(xs)}`], sm !== false && styles[`grid-sm-${String(sm)}`], md !== false && styles[`grid-md-${String(md)}`], lg !== false && styles[`grid-lg-${String(lg)}`], xl !== false && styles[`grid-xl-${String(xl)}`]];
    }
  })(({
    ownerState
  }) => _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 === 'nowrap' && {
    flexWrap: 'nowrap'
  }, ownerState.wrap === 'reverse' && {
    flexWrap: 'wrap-reverse'
  }), generateDirection, generateRowGap, generateColumnGap, ({
    theme,
    ownerState
  }) => theme.breakpoints.keys.reduce((globalStyles, breakpoint) => {
    // Use side effect over immutability for better performance.
    generateGrid(globalStyles, theme, breakpoint, ownerState);
    return globalStyles;
  }, {}));
  
  const useUtilityClasses = ownerState => {
    const {
      classes,
      container,
      direction,
      item,
      lg,
      md,
      sm,
      spacing,
      wrap,
      xl,
      xs,
      zeroMinWidth
    } = ownerState;
    const slots = {
      root: ['root', container && 'container', item && 'item', zeroMinWidth && 'zeroMinWidth', ...resolveSpacingClasses(spacing, container), direction !== 'row' && `direction-xs-${String(direction)}`, wrap !== 'wrap' && `wrap-xs-${String(wrap)}`, xs !== false && `grid-xs-${String(xs)}`, sm !== false && `grid-sm-${String(sm)}`, md !== false && `grid-md-${String(md)}`, lg !== false && `grid-lg-${String(lg)}`, xl !== false && `grid-xl-${String(xl)}`]
    };
    return composeClasses(slots, getGridUtilityClass, classes);
  };
  
  const Grid = /*#__PURE__*/React.forwardRef(function Grid(inProps, ref) {
    const themeProps = useThemeProps({
      props: inProps,
      name: 'MuiGrid'
    });
    const props = extendSxProp(themeProps);
  
    const {
      className,
      columns: columnsProp,
      columnSpacing: columnSpacingProp,
      component = 'div',
      container = false,
      direction = 'row',
      item = false,
      lg = false,
      md = false,
      rowSpacing: rowSpacingProp,
      sm = false,
      spacing = 0,
      wrap = 'wrap',
      xl = false,
      xs = false,
      zeroMinWidth = false
    } = props,
          other = _objectWithoutPropertiesLoose(props, _excluded);
  
    const rowSpacing = rowSpacingProp || spacing;
    const columnSpacing = columnSpacingProp || spacing;
    const columnsContext = React.useContext(GridContext); // setting prop before context to accomodate nesting
    // colums set with default breakpoint unit of 12
  
    const columns = columnsProp || columnsContext || 12;
  
    const ownerState = _extends({}, props, {
      columns,
      container,
      direction,
      item,
      lg,
      md,
      sm,
      rowSpacing,
      columnSpacing,
      wrap,
      xl,
      xs,
      zeroMinWidth
    });
  
    const classes = useUtilityClasses(ownerState);
  
    const wrapChild = element => columns !== 12 ? /*#__PURE__*/_jsx(GridContext.Provider, {
      value: columns,
      children: element
    }) : element;
  
    return wrapChild( /*#__PURE__*/_jsx(GridRoot, _extends({
      ownerState: ownerState,
      className: clsx(classes.root, className),
      as: component,
      ref: ref
    }, other)));
  });
  process.env.NODE_ENV !== "production" ? Grid.propTypes
  /* remove-proptypes */
  = {
    // ----------------------------- Warning --------------------------------
    // | These PropTypes are generated from the TypeScript type definitions |
    // |     To update them edit the d.ts file and run "yarn 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
  } : void 0;
  
  if (process.env.NODE_ENV !== 'production') {
    const 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')
    });
  }
  
  export default Grid;