How to use the @babel/runtime/helpers/objectSpread function in @babel/runtime

[classes.disabled]: fcs.disabled,
      [classes.inputType]: type !== 'text',
      [classes.inputTypeSearch]: type === 'search',
      [classes.inputMultiline]: multiline,
      [classes.inputMarginDense]: fcs.margin === 'dense',
      [classes.inputAdornedStart]: startAdornment,
      [classes.inputAdornedEnd]: endAdornment
    }, inputPropsClassName);
    let InputComponent = inputComponent;

    let inputProps = _objectSpread({}, inputPropsProp, {
      ref: this.handleRefInput
    });

    if (typeof InputComponent !== 'string') {
      inputProps = _objectSpread({
        // Rename ref to inputRef as we don't know the
        // provided `inputComponent` structure.
        inputRef: this.handleRefInput,
        type
      }, inputProps, {
        ref: null
      });
    } else if (multiline) {
      if (rows && !rowsMax) {
        InputComponent = 'textarea';
      } else {
        inputProps = _objectSpread({
          rowsMax,
          textareaRef: this.handleRefInput
        }, inputProps, {
          ref: null

justifyContent: 'center',
      alignItems: 'center'
    },

    /* Styles applied to the root element if `anchorOrigin={{ 'top', 'center' }}`. */
    anchorOriginTopCenter: _objectSpread({}, top, {
      [theme.breakpoints.up('md')]: _objectSpread({}, center)
    }),

    /* Styles applied to the root element if `anchorOrigin={{ 'bottom', 'center' }}`. */
    anchorOriginBottomCenter: _objectSpread({}, bottom, {
      [theme.breakpoints.up('md')]: _objectSpread({}, center)
    }),

    /* Styles applied to the root element if `anchorOrigin={{ 'top', 'right' }}`. */
    anchorOriginTopRight: _objectSpread({}, top, right, {
      [theme.breakpoints.up('md')]: _objectSpread({
        left: 'auto'
      }, topSpace, rightSpace)
    }),

    /* Styles applied to the root element if `anchorOrigin={{ 'bottom', 'right' }}`. */
    anchorOriginBottomRight: _objectSpread({}, bottom, right, {
      [theme.breakpoints.up('md')]: _objectSpread({
        left: 'auto'
      }, bottomSpace, rightSpace)
    }),

    /* Styles applied to the root element if `anchorOrigin={{ 'top', 'left' }}`. */
    anchorOriginTopLeft: _objectSpread({}, top, left, {
      [theme.breakpoints.up('md')]: _objectSpread({
        right: 'auto'

this.handleExit = node => {
      const {
        theme
      } = this.props;
      const transitionProps = getTransitionProps(this.props, {
        mode: 'exit'
      });
      node.style.webkitTransition = theme.transitions.create('-webkit-transform', _objectSpread({}, transitionProps, {
        easing: theme.transitions.easing.sharp
      }));
      node.style.transition = theme.transitions.create('transform', _objectSpread({}, transitionProps, {
        easing: theme.transitions.easing.sharp
      }));
      setTranslateValue(this.props, node);

      if (this.props.onExit) {
        this.props.onExit(node);
      }
    };

name: name,
      ref: this.handleInputRef,
      type: type
    }, other)), React.createElement(IconComponent, {
      className: classes.icon
    }), React.createElement(Menu, _extends({
      id: `menu-${name || ''}`,
      anchorEl: this.displayRef,
      open: open,
      onClose: this.handleClose
    }, MenuProps, {
      MenuListProps: _objectSpread({
        role: 'listbox'
      }, MenuProps.MenuListProps),
      PaperProps: _objectSpread({}, MenuProps.PaperProps, {
        style: _objectSpread({
          minWidth: menuMinWidth
        }, MenuProps.PaperProps != null ? MenuProps.PaperProps.style : null)
      })
    }), items));
  }

var index;

      if (element === 'timeDimensions') {
        index = this[element].findIndex(function (x) {
          return x.dimension.name === old.dimension;
        });
        mem = this["available".concat(name)].find(function (m) {
          return m.name === member.dimension;
        });

        if (mem) {
          var dimension = _objectSpread({}, this.meta.resolveMember(mem.name, 'dimensions'), {
            granularities: this.granularities
          });

          mem = _objectSpread({}, mem, {
            dimension: dimension,
            granularity: member.granularity,
            dateRange: member.dateRange,
            index: index
          });
        }
      } else if (element === 'filters') {
        index = this[element].findIndex(function (x) {
          return x.dimension === old;
        });

        var filterMember = _objectSpread({}, this.meta.resolveMember(member.member || member.dimension, ['dimensions', 'measures']));

        mem = _objectSpread({}, member, {
          member: filterMember
        });

function FilledInput(props) {
  const {
    classes
  } = props,
        other = _objectWithoutProperties(props, ["classes"]);

  return React.createElement(InputBase, _extends({
    classes: _objectSpread({}, classes, {
      root: classNames(classes.root, classes.underline, {}),
      underline: null
    })
  }, other));
}

refs: 0,
          sheet: null
        };
        sheetManager.set(theme, sheetManagerTheme);
      }

      if (sheetManagerTheme.refs === 0) {
        const styles = stylesCreatorSaved.create(theme, name);
        let meta = name;

        if (process.env.NODE_ENV !== 'production' && !meta) {
          meta = getDisplayName(Component);
          process.env.NODE_ENV !== "production" ? warning(typeof meta === 'string', ['Material-UI: the component displayName is invalid. It needs to be a string.', `Please fix the following component: ${Component}.`].join('\n')) : void 0;
        }

        const sheet = this.jss.createStyleSheet(styles, _objectSpread({
          meta,
          classNamePrefix: meta,
          flip: typeof flip === 'boolean' ? flip : theme.direction === 'rtl',
          link: false
        }, this.sheetOptions, stylesCreatorSaved.options, {
          name
        }, styleSheetOptions));
        sheetManagerTheme.sheet = sheet;
        sheet.attach();
        const sheetsRegistry = this.context[ns.sheetsRegistry];

        if (sheetsRegistry) {
          sheetsRegistry.add(sheet);
        }
      }

this.timeDimensions = (timeDimensions || []).map(function (m, i) {
        return _objectSpread({}, m, {
          dimension: _objectSpread({}, _this3.meta.resolveMember(m.dimension, 'dimensions'), {
            granularities: _this3.granularities
          }),
          index: i
        });
      });
      this.filters = (filters || []).map(function (m, i) {

disableStylesGeneration: PropTypes.bool,

  /**
   * The sheetsManager is used to deduplicate style sheet injection in the page.
   * It's deduplicating using the (theme, styles) couple.
   * On the server, you should provide a new instance for each request.
   */
  sheetsManager: PropTypes.object,

  /**
   * A theme object.
   */
  theme: PropTypes.oneOfType([PropTypes.object, PropTypes.func]).isRequired
} : {};
MuiThemeProvider.propTypes = process.env.NODE_ENV !== "production" ? exactProp(MuiThemeProvider.propTypes) : {};
MuiThemeProvider.childContextTypes = _objectSpread({}, themeListener.contextTypes, {
  muiThemeProviderOptions: PropTypes.object
});
MuiThemeProvider.contextTypes = _objectSpread({}, themeListener.contextTypes, {
  muiThemeProviderOptions: PropTypes.object
});
export default MuiThemeProvider;

});

          if (mem) {
            var dimension = _objectSpread({}, _this4.meta.resolveMember(mem.name, 'dimensions'), {
              granularities: _this4.granularities
            });

            mem = _objectSpread({}, mem, {
              granularity: m.granularity,
              dateRange: m.dateRange,
              dimension: dimension,
              index: _this4[element].length
            });
          }
        } else if (element === 'filters') {
          var member = _objectSpread({}, _this4.meta.resolveMember(m.member || m.dimension, ['dimensions', 'measures']));

          mem = _objectSpread({}, m, {
            member: member
          });
        } else {
          mem = _this4["available".concat(name)].find(function (x) {
            return x.name === m;
          });
        }

        if (mem) {
          elements.push(mem);
        }
      });
      this[element] = elements;