import { Util, Badge as Badge$1, Button as Button$1, Collapse as Collapse$1, FormGroup as FormGroup$1, Label, Input as Input$1, NavbarBrand, Navbar, NavbarToggler, Jumbotron, Nav as Nav$1, Card as Card$1 } from 'reactstrap';
export { Alert, Breadcrumb, BreadcrumbItem, ButtonDropdown, ButtonGroup, ButtonToolbar, CardBody, CardColumns, CardDeck, CardFooter, CardGroup, CardHeader, CardImg, CardImgOverlay, CardLink, CardSubtitle, CardText, CardTitle, Carousel, CarouselCaption, CarouselControl, CarouselIndicators, CarouselItem, Col, Container, Dropdown, DropdownItem, DropdownMenu, DropdownToggle, Fade, Form, FormFeedback, FormText, InputGroup, InputGroupAddon, InputGroupButtonDropdown, InputGroupText, Jumbotron, Label, ListGroup, ListGroupItem, ListGroupItemHeading, ListGroupItemText, Media, Modal, ModalBody, ModalFooter, ModalHeader, NavItem, NavLink, Navbar, NavbarBrand, NavbarToggler, PaginationItem as PagerItem, PaginationLink as PagerLink, Popover, PopoverBody, PopoverHeader, PopperContent, PopperTargetHelper, Row, TabContent, TabPane, Table, Tooltip, UncontrolledAlert, UncontrolledButtonDropdown, UncontrolledCarousel, UncontrolledCollapse, UncontrolledDropdown, UncontrolledTooltip, Util } from 'reactstrap';
export { default as Scrollspy } from 'react-scrollspy';
import React, { Component, PureComponent, Fragment } from 'react';
import PropTypes from 'prop-types';
import Transition from 'react-transition-group/Transition';
import { StickyProvider, Sticky } from 'react-stickup';

function _defineProperty(obj, key, value) {
  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 || 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 _inheritsLoose(subClass, superClass) {
  subClass.prototype = Object.create(superClass.prototype);
  subClass.prototype.constructor = subClass;
  subClass.__proto__ = superClass;
}

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 _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return self;
}

function createCommonjsModule(fn, module) {
	return module = { exports: {} }, fn(module, module.exports), module.exports;
}

var classnames = createCommonjsModule(function (module) {
  /*!
    Copyright (c) 2017 Jed Watson.
    Licensed under the MIT License (MIT), see
    http://jedwatson.github.io/classnames
  */

  /* global define */
  (function () {

    var hasOwn = {}.hasOwnProperty;

    function classNames() {
      var classes = [];

      for (var i = 0; i < arguments.length; i++) {
        var arg = arguments[i];
        if (!arg) continue;
        var argType = typeof arg;

        if (argType === 'string' || argType === 'number') {
          classes.push(arg);
        } else if (Array.isArray(arg) && arg.length) {
          var inner = classNames.apply(null, arg);

          if (inner) {
            classes.push(inner);
          }
        } else if (argType === 'object') {
          for (var key in arg) {
            if (hasOwn.call(arg, key) && arg[key]) {
              classes.push(key);
            }
          }
        }
      }

      return classes.join(' ');
    }

    if ( module.exports) {
      classNames["default"] = classNames;
      module.exports = classNames;
    } else {
      window.classNames = classNames;
    }
  })();
});

var propTypes = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string
};
var defaultProps = {
  tag: 'div'
};
function Accordion(props) {
  var className = props.className,
      Tag = props.tag,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag"]);

  var classes = classnames('collapse-div', className);
  return React.createElement(Tag, _extends({}, attributes, {
    className: classes
  }));
}
Accordion.propTypes = propTypes;
Accordion.defaultProps = defaultProps;

var propTypes$1 = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string,
  active: PropTypes.bool,
  onToggle: PropTypes.func
};
var defaultProps$1 = {
  tag: 'button'
};
function AccordionHeader(props) {
  var className = props.className,
      Tag = props.tag,
      active = props.active,
      onToggle = props.onToggle,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag", "active", "onToggle"]);

  var classes = classnames('collapse-header');
  var toggleClasses = classnames(className, {
    collapsed: active
  });
  return React.createElement("div", {
    className: classes
  }, React.createElement(Tag, _extends({
    "data-toggle": "collapse",
    "aria-expanded": active ? 'true' : 'false',
    className: toggleClasses,
    onClick: onToggle
  }, attributes)));
}
AccordionHeader.propTypes = propTypes$1;
AccordionHeader.defaultProps = defaultProps$1;

var _transitionStatusToCl;
var TransitionTimeouts = Util.TransitionTimeouts,
    TransitionPropTypeKeys = Util.TransitionPropTypeKeys,
    TransitionStatuses = Util.TransitionStatuses,
    pick = Util.pick,
    omit = Util.omit;

var propTypes$2 = _extends({}, Transition.propTypes, {
  // eslint-disable-line react/forbid-foreign-prop-types
  children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string,
  active: PropTypes.bool,
  onToggle: PropTypes.func
});

var defaultProps$2 = _extends({}, Transition.defaultProps, {
  timeout: TransitionTimeouts.Collapse,
  tag: 'div'
});

var transitionStatusToClassHash = (_transitionStatusToCl = {}, _transitionStatusToCl[TransitionStatuses.ENTERING] = 'collapsing', _transitionStatusToCl[TransitionStatuses.ENTERED] = 'collapse show', _transitionStatusToCl[TransitionStatuses.EXITING] = 'collapsing', _transitionStatusToCl[TransitionStatuses.EXITED] = 'collapse', _transitionStatusToCl);

function getTransitionClass(status) {
  return transitionStatusToClassHash[status] || 'collapse';
}

function getHeight(node) {
  return node.scrollHeight;
}

var AccordionBody =
/*#__PURE__*/
function (_Component) {
  _inheritsLoose(AccordionBody, _Component);

  function AccordionBody() {
    var _this;

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

    _this = _Component.call.apply(_Component, [this].concat(args)) || this;

    _defineProperty(_assertThisInitialized(_this), "state", {
      height: null
    });

    _defineProperty(_assertThisInitialized(_this), "onEntering", function (node, isAppearing) {
      _this.setState({
        height: getHeight(node)
      });

      _this.props.onEntering(node, isAppearing);
    });

    _defineProperty(_assertThisInitialized(_this), "onEntered", function (node, isAppearing) {
      _this.setState({
        height: null
      });

      _this.props.onEntered(node, isAppearing);
    });

    _defineProperty(_assertThisInitialized(_this), "onExit", function (node) {
      _this.setState({
        height: getHeight(node)
      });

      _this.props.onExit(node);
    });

    _defineProperty(_assertThisInitialized(_this), "onExiting", function (node) {
      // getting this variable triggers a reflow
      var _unused = node.offsetHeight; // eslint-disable-line no-unused-vars

      _this.setState({
        height: 0
      });

      _this.props.onExiting(node);
    });

    _defineProperty(_assertThisInitialized(_this), "onExited", function (node) {
      _this.setState({
        height: null
      });

      _this.props.onExited(node);
    });

    return _this;
  }

  var _proto = AccordionBody.prototype;

  _proto.render = function render() {
    var _this$props = this.props,
        className = _this$props.className,
        Tag = _this$props.tag,
        active = _this$props.active,
        children = _this$props.children,
        attributes = _objectWithoutPropertiesLoose(_this$props, ["className", "tag", "active", "children"]);

    var height = this.state.height;
    var transitionProps = pick(attributes, TransitionPropTypeKeys);
    var childProps = omit(attributes, TransitionPropTypeKeys);
    return React.createElement(Transition, _extends({}, transitionProps, {
      "in": active,
      onEntering: this.onEntering,
      onEntered: this.onEntered,
      onExit: this.onExit,
      onExiting: this.onExiting,
      onExited: this.onExited
    }), function (status) {
      var transitionClass = getTransitionClass(status);
      var classes = classnames(className, transitionClass);
      var style = height === null ? null : {
        height: height
      };
      return React.createElement(Tag, _extends({
        className: classes,
        style: _extends({}, childProps.style, {}, style)
      }, childProps), React.createElement("div", {
        className: "collapse-body"
      }, children));
    });
  };

  return AccordionBody;
}(Component);
AccordionBody.propTypes = propTypes$2;
AccordionBody.defaultProps = defaultProps$2;

var propTypes$3 = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string
};
var defaultProps$3 = {
  tag: 'div'
};

var AvatarContainer = function AvatarContainer(props) {
  var className = props.className,
      Tag = props.tag,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag"]);

  var wrapperClasses = classnames('d-flex align-items-center justify-content-around flex-wrap flex-sm-nowrap', className);
  return React.createElement(Tag, _extends({}, attributes, {
    className: wrapperClasses
  }));
};

AvatarContainer.propTypes = propTypes$3;
AvatarContainer.defaultProps = defaultProps$3;

var propTypes$4 = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string,
  wrapperClassName: PropTypes.string
};
var defaultProps$4 = {
  tag: 'ul'
};

var AvatarGroupContainer = function AvatarGroupContainer(props) {
  var className = props.className,
      Tag = props.tag,
      wrapperClassName = props.wrapperClassName,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag", "wrapperClassName"]);

  var wrapperClasses = classnames('avatar-group-stacked', wrapperClassName);
  return React.createElement(Tag, _extends({}, attributes, {
    className: wrapperClasses
  }));
};

AvatarGroupContainer.propTypes = propTypes$4;
AvatarGroupContainer.defaultProps = defaultProps$4;

var propTypes$5 = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string
};
var defaultProps$5 = {
  tag: 'div'
};

var AvatarExtraText = function AvatarExtraText(props) {
  var className = props.className,
      Tag = props.tag,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag"]);

  var wrapperClass = classnames('extra-text', className);
  return React.createElement(Tag, _extends({
    className: wrapperClass
  }, attributes));
};

AvatarExtraText.propTypes = propTypes$5;
AvatarExtraText.defaultProps = defaultProps$5;

var propTypes$6 = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string,
  href: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  color: PropTypes.string,
  size: PropTypes.string
};
var defaultProps$6 = {
  tag: 'div'
};

var AvatarIcon = function AvatarIcon(props) {
  var _classNames;

  var className = props.className,
      Tag = props.tag,
      size = props.size,
      href = props.href,
      color = props.color,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag", "size", "href", "color"]);

  var typeClass = classnames('avatar', (_classNames = {}, _classNames["size-" + size] = size, _classNames["avatar-" + color] = color, _classNames));

  if (href) {
    return React.createElement("a", _extends({
      href: href
    }, attributes, {
      className: typeClass
    }));
  }

  return React.createElement(Tag, _extends({}, attributes, {
    className: typeClass
  }));
};

AvatarIcon.propTypes = propTypes$6;
AvatarIcon.defaultProps = defaultProps$6;

var propTypes$7 = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string,
  presence: PropTypes.string
};
var defaultProps$7 = {
  tag: 'div'
};

var AvatarPresence = function AvatarPresence(props) {
  var _classNames;

  var className = props.className,
      Tag = props.tag,
      presence = props.presence,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag", "presence"]);

  var typeClass = classnames('avatar-presence', (_classNames = {}, _classNames["" + presence] = presence, _classNames));
  return React.createElement(Tag, _extends({}, attributes, {
    className: typeClass
  }));
};

AvatarPresence.propTypes = propTypes$7;
AvatarPresence.defaultProps = defaultProps$7;

var propTypes$8 = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string,
  status: PropTypes.string
};
var defaultProps$8 = {
  tag: 'div'
};

var AvatarStatus = function AvatarStatus(props) {
  var _classNames;

  var className = props.className,
      Tag = props.tag,
      status = props.status,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag", "status"]);

  var typeClass = classnames('avatar-status', (_classNames = {}, _classNames["" + status] = status, _classNames));
  return React.createElement(Tag, _extends({}, attributes, {
    className: typeClass
  }));
};

AvatarStatus.propTypes = propTypes$8;
AvatarStatus.defaultProps = defaultProps$8;

var propTypes$9 = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string,
  extra: PropTypes.string
};
var defaultProps$9 = {
  tag: 'div'
};

var AvatarWrapper = function AvatarWrapper(props) {
  var _classNames;

  var className = props.className,
      Tag = props.tag,
      extra = props.extra,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag", "extra"]);

  var wrapperClass = classnames('avatar-wrapper', className, (_classNames = {}, _classNames["avatar-extra-" + extra] = extra, _classNames));
  return React.createElement(Tag, _extends({}, attributes, {
    className: wrapperClass
  }));
};

AvatarWrapper.propTypes = propTypes$9;
AvatarWrapper.defaultProps = defaultProps$9;

var propTypes$a = {
  color: PropTypes.string,
  pill: PropTypes.bool,
  tag: PropTypes.string,
  children: PropTypes.node,
  cssModule: PropTypes.object,
  className: PropTypes.string
};
var defaultProps$a = {
  color: 'secondary',
  pill: false,
  tag: 'span'
};

var Badge = function Badge(props) {
  var children = props.children;
  return React.createElement(Badge$1, props, children);
};

Badge.propTypes = propTypes$a;
Badge.defaultProps = defaultProps$a;

var propTypes$b = _extends({}, Button$1.propTypes, {
  icon: PropTypes.bool
});

var defaultProps$b = _extends({}, Button$1.defaultProps, {
  icon: false
});

var Button = function Button(_ref) {
  var icon = _ref.icon,
      className = _ref.className,
      attributes = _objectWithoutPropertiesLoose(_ref, ["icon", "className"]);

  var classes = classnames(className, {
    'btn-icon': icon
  });
  return React.createElement(Button$1, _extends({
    className: classes
  }, attributes));
};

Button.propTypes = propTypes$b;
Button.defaultProps = defaultProps$b;

var propTypes$c = {
  children: PropTypes.node,
  className: PropTypes.string,
  color: PropTypes.string,
  highlight: PropTypes.bool,
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string])
};
var defaultProps$c = {
  color: '',
  highlight: false,
  tag: 'div'
};

var Callout = function Callout(_ref) {
  var children = _ref.children,
      color = _ref.color,
      highlight = _ref.highlight,
      Tag = _ref.tag,
      attributes = _objectWithoutPropertiesLoose(_ref, ["children", "color", "highlight", "tag"]);

  var classes = classnames('callout', color, {
    'callout-highlight': highlight
  });
  return React.createElement(Tag, _extends({
    className: classes
  }, attributes), children);
};

Callout.propTypes = propTypes$c;
Callout.defaultProps = defaultProps$c;

var propTypes$d = {
  bigText: PropTypes.bool,
  className: PropTypes.string,
  children: PropTypes.node,
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string])
};
var defaultProps$d = {
  bigText: false,
  tag: 'p'
};

var CalloutText = function CalloutText(_ref) {
  var bigText = _ref.bigText,
      children = _ref.children,
      className = _ref.className,
      Tag = _ref.tag,
      attributes = _objectWithoutPropertiesLoose(_ref, ["bigText", "children", "className", "tag"]);

  var classes = classnames(className, {
    'callout-big-text': bigText
  });
  return React.createElement(Tag, _extends({
    className: classes
  }, attributes), children);
};

CalloutText.propTypes = propTypes$d;
CalloutText.defaultProps = defaultProps$d;

var propTypes$e = {
  children: PropTypes.node,
  className: PropTypes.string,
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string])
};
var defaultProps$e = {
  tag: 'div'
};

var CalloutTitle = function CalloutTitle(_ref) {
  var children = _ref.children,
      className = _ref.className,
      Tag = _ref.tag,
      attributes = _objectWithoutPropertiesLoose(_ref, ["children", "className", "tag"]);

  var classes = classnames(className, 'callout-title');
  return React.createElement(Tag, _extends({
    className: classes
  }, attributes), children);
};

CalloutTitle.propTypes = propTypes$e;
CalloutTitle.defaultProps = defaultProps$e;

var propTypes$f = _extends({}, Collapse$1.propTypes, {
  // eslint-disable-line react/forbid-foreign-prop-types

  /** Indica se il componente Collapse è usato all'interno di un componente Header */
  header: PropTypes.bool,

  /** Indica se il menu HeaderNav sia aperto o meno. Usato unicamente nel caso della HeaderNav, ovvero con navbar e header entrambi true */
  inOpen: PropTypes.bool,

  /** Funzione chiamata su click di overlay dell'HeaderNav aperto. Usato unicamente nel caso della HeaderNav, ovvero con navbar e header entrambi true */
  onOverlayClick: PropTypes.func
});

var Collapse = function Collapse(_ref) {
  var header = _ref.header,
      className = _ref.className,
      navbar = _ref.navbar,
      children = _ref.children,
      isOpen = _ref.isOpen,
      onOverlayClick = _ref.onOverlayClick,
      attributes = _objectWithoutPropertiesLoose(_ref, ["header", "className", "navbar", "children", "isOpen", "onOverlayClick"]);

  if (navbar && header) {
    var _classes = classnames(className, 'navbar-collapsable', {
      expanded: isOpen
    });

    return React.createElement(Collapse$1, _extends({
      className: _classes,
      navbar: navbar,
      style: {
        display: isOpen ? 'block' : 'none'
      }
    }, attributes), React.createElement("div", {
      className: "overlay",
      style: {
        display: isOpen ? 'block' : 'none'
      },
      onClick: onOverlayClick
    }), React.createElement("div", {
      className: "close-div sr-only"
    }, React.createElement("button", {
      className: "btn close-menu",
      type: "button"
    }, React.createElement("span", {
      className: "it-close"
    }), "close")), children);
  }

  var classes = classnames(className, {
    'link-list-wrapper': header
  });
  return React.createElement(Collapse$1, _extends({
    className: classes
  }, attributes, {
    navbar: navbar,
    isOpen: isOpen
  }), children);
};

Collapse.propTypes = propTypes$f;
Collapse.defaultProps = Collapse$1.defaultProps;

var FormGroup =
/*#__PURE__*/
function (_Component) {
  _inheritsLoose(FormGroup, _Component);

  function FormGroup() {
    var _this;

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

    _this = _Component.call.apply(_Component, [this].concat(args)) || this;

    _defineProperty(_assertThisInitialized(_this), "state", {
      active: _this.props.active || false,
      value: null
    });

    _defineProperty(_assertThisInitialized(_this), "onFocus", function (callback, active) {
      if (active === void 0) {
        active = true;
      }

      _this.setState({
        active: active
      }, function () {
        if (callback) {
          callback();
        }
      });
    });

    _defineProperty(_assertThisInitialized(_this), "onBlur", function (callback, active) {
      if (active === void 0) {
        active = false;
      }

      _this.setState({
        active: active
      }, function () {
        if (callback) {
          callback();
        }
      });
    });

    _defineProperty(_assertThisInitialized(_this), "onChange", function (callback, event) {
      var value;
      var target;

      if (event && event.persist) {
        // SyntheticEvent
        event.persist();
        target = {
          event: event
        };
        value = {
          target: target
        };
      } else if (event.label) {
        // Autocomplete
        value = event.label;
      }

      _this.setState({
        value: value
      }, function () {
        if (callback) {
          callback(event);
        }
      });
    });

    return _this;
  }

  var _proto = FormGroup.prototype;

  _proto.render = function render() {
    var _this2 = this;

    var _this$state = this.state,
        active = _this$state.active,
        value = _this$state.value;

    var _this$props = this.props,
        children = _this$props.children,
        className = _this$props.className,
        col = _this$props.col,
        rest = _objectWithoutPropertiesLoose(_this$props, ["children", "className", "col"]);

    var hasValue = !!value;
    var classNames = [className, active ? 'active' : '', col ? 'col' : ''].join(' ');
    return React.createElement(FormGroup$1, _extends({}, rest, {
      className: classNames
    }), function () {
      return React.Children.map(children, function (child) {
        if (child === null) return;
        var _child$props = child.props,
            _onFocus = _child$props.onFocus,
            _onBlur = _child$props.onBlur,
            _onChange = _child$props.onChange,
            className = _child$props.className;

        switch (child.type) {
          case Input$1:
            var isLabelActive = null;
            return React.cloneElement(child, _extends({}, child.props, {
              onFocus: function onFocus() {
                _this2.onFocus(_onFocus);
              },
              onBlur: function onBlur() {
                _this2.onBlur(_onBlur);
              },
              onChange: function onChange(e) {
                _this2.onChange(_onChange, e);
              }
            }, isLabelActive));

          case Label:
            var hasChildValue = false;
            React.Children.toArray(children).filter(function (child) {
              switch (child.type) {
                case Input$1:
                  return true;

                default:
                  return false;
              }
            }).map(function (child) {
              if (child.props.value) {
                hasChildValue = true;
              }

              return false;
            });
            classNames = hasValue || hasChildValue ? [className, 'active'].join(' ') : className;
            return React.cloneElement(child, _extends({}, child.props, {
              className: classNames
            }));

          default:
            return child;
        }
      });
    }());
  };

  return FormGroup;
}(Component);

FormGroup.defaultProps = FormGroup$1.defaultProps;
FormGroup.propTypes = FormGroup$1.propTypes;

/**
 * HeaderContext
 * {
 *  type: PropTypes.oneOf([SLIM, CENTER, NAVBAR]).isRequired
 * }
 */

var HeaderContext = React.createContext({});
var SLIM = 'slim';
var CENTER = 'center';
var NAVBAR = 'navbar';

var propTypes$g = {
  /** Classi addizionali per il componente Header */
  className: PropTypes.string,
  // cannot use variables above here or storybook writes the full import stacktrace

  /** Tipo di componente Header: può essere solamente uno di questi tre tipi */
  type: PropTypes.oneOf(['slim', 'center', 'navbar']).isRequired,

  /** Riduce la grandezza del componente Header. Funziona solamente con Header "center". */
  small: PropTypes.bool,

  /** Imposta il tema per il componente Header. Per gli Header di tipo "slim" o "center"
   *  il valore di default è "dark". Per l'Header di tipo "nav" il tema di default è "light"
   *  in mobile, mentre "dark" in versione desktop.
   */
  theme: PropTypes.oneOf(['', 'light', 'dark'])
};
var defaultProps$f = {
  small: false
};

var Header = function Header(_ref) {
  var _classNames;

  var className = _ref.className,
      small = _ref.small,
      theme = _ref.theme,
      type = _ref.type,
      attributes = _objectWithoutPropertiesLoose(_ref, ["className", "small", "theme", "type"]);

  // use context here as theme
  var classes = classnames(className, (_classNames = {}, _classNames["it-header-" + type + "-wrapper"] = type, _classNames['it-small-header'] = type === CENTER && small, _classNames["theme-" + theme] = type !== NAVBAR && theme, _classNames['theme-dark-mobile'] = type === NAVBAR && theme === 'dark', _classNames['theme-light-desk'] = type === NAVBAR && theme === 'light', _classNames));
  return React.createElement(HeaderContext.Provider, {
    value: {
      type: type
    }
  }, React.createElement("div", _extends({
    className: classes
  }, attributes)));
};

Header.propTypes = propTypes$g;
Header.defaultProps = defaultProps$f;

var propTypes$h = {
  /** Aggiunge un ombra per enfatizzare il componente rispetto alla pagina in cui è contenuto */
  shadow: PropTypes.bool,

  /** Aggiunge il comportamento "sticky" ai componenti Header contenuti */
  sticky: PropTypes.bool,

  /** Classi addizionali per il componente Headers */
  className: PropTypes.string
};
var defaultProps$g = {
  shadow: false,
  sticky: false
};

var Headers = function Headers(_ref) {
  var className = _ref.className,
      shadow = _ref.shadow,
      sticky = _ref.sticky,
      attributes = _objectWithoutPropertiesLoose(_ref, ["className", "shadow", "sticky"]);

  var classes = classnames('it-header-wrapper', {
    'it-shadow': shadow,
    'it-header-sticky': sticky
  }, className);

  if (!sticky) {
    return React.createElement("div", _extends({
      className: classes
    }, attributes));
  }

  return React.createElement(StickyProvider, null, React.createElement(Sticky, {
    style: {
      position: 'sticky',
      zIndex: 2
    }
  }, React.createElement("div", _extends({
    className: classes
  }, attributes))));
};

Headers.propTypes = propTypes$h;
Headers.defaultProps = defaultProps$g;

var iconSprite = 'data:image/svg+xml;base64, ';

var propTypes$i = {
  className: PropTypes.string,
  color: PropTypes.string,
  size: PropTypes.string,
  icon: PropTypes.string,
  padding: PropTypes.bool
};
var defaultProps$h = {
  color: '',
  size: '',
  icon: '',
  padding: false
};

var Icon = function Icon(_ref) {
  var _classNames;

  var color = _ref.color,
      size = _ref.size,
      icon = _ref.icon,
      className = _ref.className,
      padding = _ref.padding,
      attributes = _objectWithoutPropertiesLoose(_ref, ["color", "size", "icon", "className", "padding"]);

  var classes = classnames('icon', className, (_classNames = {}, _classNames["icon-" + color] = color, _classNames["icon-" + size] = size, _classNames['icon-padded'] = padding, _classNames), size);
  return React.createElement("svg", _extends({
    className: classes
  }, attributes), React.createElement("use", {
    xlinkHref: iconSprite + "#" + icon
  }));
};

Icon.propTypes = propTypes$i;
Icon.defaultProps = defaultProps$h;

var propTypes$j = {
  /** Utilizzarlo in caso di utilizzo di componenti personalizzati */
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),

  /** Classi aggiuntive da usare per il componente HeaderBrand */
  className: PropTypes.string,

  /** Da usare per la sovrascrittura di classi predefinite */
  cssModule: PropTypes.object,

  /** Da usare con il componente Header Nav in versione "responsive" */
  responsive: PropTypes.bool,

  /** Da utilizzare per specificare URL risorsa esterna. */
  href: PropTypes.string,

  /** Icona da utilizzare nel componente. Utilizzata unicamente quando l'Header è di tipo Center.  */
  iconName: PropTypes.string,

  /** Elementi React da renderizzare al proprio interno. */
  children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node])
};
var defaultProps$i = {
  tag: 'a',
  responsive: false
};

var HeaderBrand =
/*#__PURE__*/
function (_PureComponent) {
  _inheritsLoose(HeaderBrand, _PureComponent);

  function HeaderBrand() {
    return _PureComponent.apply(this, arguments) || this;
  }

  var _proto = HeaderBrand.prototype;

  _proto.addChildClasses = function addChildClasses(child, i) {
    // convention here: first item is the main title, while others subtext
    var className = classnames(child.props.className, 'no_toc', {
      'd-none d-md-block': i
    } // subtext is anything but first element
    );
    var props = {
      className: className
    };
    return React.cloneElement(child, props);
  };

  _proto.render = function render() {
    var _this = this;

    var _this$props = this.props,
        className = _this$props.className,
        href = _this$props.href,
        iconName = _this$props.iconName,
        children = _this$props.children,
        responsive = _this$props.responsive,
        attributes = _objectWithoutPropertiesLoose(_this$props, ["className", "href", "iconName", "children", "responsive"]);

    var type = this.context.type;

    if (type !== CENTER) {
      var classes = classnames('d-lg-block', className, {
        'd-none': !responsive
      });
      return React.createElement(NavbarBrand, _extends({
        className: classes,
        href: href
      }, attributes), children);
    }

    return React.createElement("div", {
      className: "it-brand-wrapper"
    }, React.createElement("a", {
      href: href
    }, iconName && React.createElement(Icon, {
      icon: iconName
    }), React.createElement("div", {
      className: "it-brand-text"
    }, React.Children.map(children, function (child, i) {
      return _this.addChildClasses(child, i);
    }))));
  };

  return HeaderBrand;
}(PureComponent);

_defineProperty(HeaderBrand, "propTypes", propTypes$j);

_defineProperty(HeaderBrand, "defaultProps", defaultProps$i);

_defineProperty(HeaderBrand, "contextType", HeaderContext);

var propTypes$k = {
  /** Classi addizionali per il componente HeaderContent */
  className: PropTypes.string,

  /** Da utilizzare per indicare che all'interno dell'Header verrà utilizzato un Megamenu */
  megamenu: PropTypes.bool,

  /** Parametro per il controllo responsive del componente: valori Bootstrap standard sono "sm", "md", "lg", "xl" */
  expand: PropTypes.oneOfType([PropTypes.bool, PropTypes.string])
};
var defaultProps$j = {};

var HeaderContent =
/*#__PURE__*/
function (_PureComponent) {
  _inheritsLoose(HeaderContent, _PureComponent);

  function HeaderContent() {
    return _PureComponent.apply(this, arguments) || this;
  }

  var _proto = HeaderContent.prototype;

  _proto.render = function render() {
    var _this$props = this.props,
        className = _this$props.className,
        megamenu = _this$props.megamenu,
        attributes = _objectWithoutPropertiesLoose(_this$props, ["className", "megamenu"]);

    var type = this.context.type;
    var classes = classnames(className, {
      'it-header-slim-wrapper-content': type === SLIM,
      'it-header-center-content-wrapper': type === CENTER,
      navbar: type === NAVBAR,
      'has-megamenu': megamenu
    });
    var Content = type === NAVBAR ? React.createElement(Navbar, _extends({
      className: classes
    }, attributes)) : React.createElement("div", _extends({
      className: classes
    }, attributes));
    return React.createElement("div", {
      className: "container"
    }, React.createElement("div", {
      className: "row"
    }, React.createElement("div", {
      className: "col-12"
    }, Content)));
  };

  return HeaderContent;
}(PureComponent);

_defineProperty(HeaderContent, "propTypes", propTypes$k);

_defineProperty(HeaderContent, "defaultProps", defaultProps$j);

_defineProperty(HeaderContent, "contextType", HeaderContext);

var propTypes$l = {
  /** Classi addizionali per il componente HeaderLinkZone, applicata all'element "nav" annidato */
  className: PropTypes.string
};
var defaultProps$k = {};

var HeaderLinkZone = function HeaderLinkZone(_ref) {
  var className = _ref.className,
      attributes = _objectWithoutPropertiesLoose(_ref, ["className"]);

  var classes = classnames(className);
  return React.createElement("div", {
    className: "nav-mobile"
  }, React.createElement("nav", _extends({
    className: classes
  }, attributes)));
};

HeaderLinkZone.propTypes = propTypes$l;
HeaderLinkZone.defaultProps = defaultProps$k;

var propTypes$m = {
  /** Classi addizionali per il componente HeaderRightZone */
  className: PropTypes.string
};
var defaultProps$l = {};

var HeaderRightZone =
/*#__PURE__*/
function (_PureComponent) {
  _inheritsLoose(HeaderRightZone, _PureComponent);

  function HeaderRightZone() {
    return _PureComponent.apply(this, arguments) || this;
  }

  var _proto = HeaderRightZone.prototype;

  _proto.render = function render() {
    var _this$props = this.props,
        className = _this$props.className,
        attributes = _objectWithoutPropertiesLoose(_this$props, ["className"]);

    var type = this.context.type;
    var classes = classnames(className, {
      // BI >= 1.3.6
      'it-header-slim-right-zone': type === SLIM,
      // BI < 1.3.6
      'header-slim-right-zone': type === SLIM,
      'it-right-zone': type !== SLIM
    });
    return React.createElement("div", _extends({
      className: classes
    }, attributes));
  };

  return HeaderRightZone;
}(PureComponent);

_defineProperty(HeaderRightZone, "propTypes", propTypes$m);

_defineProperty(HeaderRightZone, "defaultProps", defaultProps$l);

_defineProperty(HeaderRightZone, "contextType", HeaderContext);

var propTypes$n = {
  /** Classi addizionali per il componente HeaderSearch */
  className: PropTypes.string,

  /** Etichetta di testo da applicare all'elemento. In caso di stringa vuota non verrà mostrato alcun testo */
  label: PropTypes.string,

  /** Nome dell'icona da utilizzare */
  iconName: PropTypes.string,

  /** Indirizzo di indirizzamento al click dell'icona */
  href: PropTypes.string
};
var defaultProps$m = {
  iconName: 'it-search'
};

var HeaderSearch = function HeaderSearch(_ref) {
  var className = _ref.className,
      label = _ref.label,
      href = _ref.href,
      iconName = _ref.iconName,
      attributes = _objectWithoutPropertiesLoose(_ref, ["className", "label", "href", "iconName"]);

  var classes = classnames('it-search-wrapper', className);
  return React.createElement("div", _extends({
    className: classes
  }, attributes), label && React.createElement("span", {
    className: "d-none d-md-block"
  }, label), React.createElement("a", {
    className: "search-link rounded-icon",
    "aria-label": label,
    href: href
  }, React.createElement(Icon, {
    icon: iconName
  })));
};

HeaderSearch.propTypes = propTypes$n;
HeaderSearch.defaultProps = defaultProps$m;

var propTypes$o = {
  /** Classi addizionali per il componente HeaderSocialsZone, verrà applicato all'elemento wrapper più esterno. */
  className: PropTypes.string,

  /** Etichetta utilizzata per presentare i social presenti. In caso di stringa vuota non verrà mostrata alcuna etichetta */
  label: PropTypes.string,

  /** Utilizzato per elencare i social da mostrare */
  children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node])
};
var defaultProps$n = {};

var HeaderSocialsZone = function HeaderSocialsZone(_ref) {
  var className = _ref.className,
      children = _ref.children,
      label = _ref.label,
      attributes = _objectWithoutPropertiesLoose(_ref, ["className", "children", "label"]);

  var classes = classnames('it-socials d-none d-md-flex', className);
  return React.createElement("div", _extends({
    className: classes
  }, attributes), label && React.createElement("span", null, label), children);
};

HeaderSocialsZone.propTypes = propTypes$o;
HeaderSocialsZone.defaultProps = defaultProps$n;

var propTypes$p = {
  /** Tipo di elemento DOM da utilizzare: di default "a" per Header Slim, "button" per altri tipi di Header.
   * Se fornito questo sovrascriverà il valore di default.
   */
  tag: PropTypes.string,

  /** Indica l'attributo "type" sull'elemento DOM. Di default '' per Header Slim, "button" per altri tipi di Header.
   * Se fornito questo sovrascriverà il valore di default.
   */
  type: PropTypes.string,

  /** Classi addizionali per il componente HeaderToggler */
  className: PropTypes.string
};
var defaultProps$o = {};

var HeaderToggler =
/*#__PURE__*/
function (_PureComponent) {
  _inheritsLoose(HeaderToggler, _PureComponent);

  function HeaderToggler() {
    return _PureComponent.apply(this, arguments) || this;
  }

  var _proto = HeaderToggler.prototype;

  _proto.render = function render() {
    var _this$props = this.props,
        className = _this$props.className,
        tag = _this$props.tag,
        type = _this$props.type,
        attributes = _objectWithoutPropertiesLoose(_this$props, ["className", "tag", "type"]);

    var HeaderType = this.context.type;
    var BUTTON = 'button';
    var defaultTag = HeaderType === SLIM ? 'a' : BUTTON;
    var defaultType = HeaderType === SLIM ? '' : BUTTON;
    var classes = classnames({
      'it-opener d-lg-none': HeaderType === SLIM,
      'custom-navbar-toggler': HeaderType === NAVBAR
    }, className);
    return React.createElement(NavbarToggler, _extends({
      className: classes
    }, attributes, {
      tag: tag || defaultTag,
      type: type || defaultType,
      href: "#"
    }));
  };

  return HeaderToggler;
}(PureComponent);

_defineProperty(HeaderToggler, "propTypes", propTypes$p);

_defineProperty(HeaderToggler, "defaultProps", defaultProps$o);

_defineProperty(HeaderToggler, "contextType", HeaderContext);

function Hero(props) {
  return React.createElement(Jumbotron, props);
}
Hero.defaultProps = Jumbotron.defaultProps;
Hero.propTypes = Jumbotron.propTypes;

var mapToCssModules = Util.mapToCssModules,
    deprecated = Util.deprecated,
    warnOnce = Util.warnOnce;
var propTypes$q = {
  children: PropTypes.node,
  type: PropTypes.string,
  size: PropTypes.string,
  label: PropTypes.string,
  placeholder: PropTypes.string,
  value: PropTypes.string,
  id: PropTypes.string,
  infoText: PropTypes.string,
  normalized: PropTypes.bool,
  bsSize: PropTypes.string,
  state: deprecated(PropTypes.string, 'Please use the props "valid" and "invalid" to indicate the state.'),
  valid: PropTypes.bool,
  invalid: PropTypes.bool,
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.string]),
  "static": deprecated(PropTypes.bool, 'Please use the prop "plaintext"'),
  plaintext: PropTypes.bool,
  addon: PropTypes.bool,
  className: PropTypes.string,
  cssModule: PropTypes.object
};
var defaultProps$p = {
  type: 'text'
};

var Input =
/*#__PURE__*/
function (_React$Component) {
  _inheritsLoose(Input, _React$Component);

  function Input() {
    var _this;

    _this = _React$Component.call(this) || this;

    _defineProperty(_assertThisInitialized(_this), "toggleFocusLabel", function () {
      _this.setState({
        isFocused: true
      });
    });

    _defineProperty(_assertThisInitialized(_this), "toggleBlurLabel", function (e) {
      if (e.target.value === '') {
        _this.setState({
          isFocused: !_this.state.isFocused
        });
      }
    });

    _this.state = {
      isFocused: false,
      hidden: true,
      icon: true
    };
    _this.toggleShow = _this.toggleShow.bind(_assertThisInitialized(_this));
    return _this;
  }

  var _proto = Input.prototype;

  _proto.toggleShow = function toggleShow() {
    this.setState({
      hidden: !this.state.hidden,
      icon: !this.state.icon
    });
  };

  _proto.render = function render() {
    var _this2 = this;

    var _this$props = this.props,
        className = _this$props.className,
        cssModule = _this$props.cssModule,
        type = _this$props.type,
        state = _this$props.state,
        tag = _this$props.tag,
        addon = _this$props.addon,
        staticInput = _this$props["static"],
        plaintext = _this$props.plaintext,
        innerRef = _this$props.innerRef,
        label = _this$props.label,
        infoText = _this$props.infoText,
        placeholder = _this$props.placeholder,
        normalized = _this$props.normalized,
        value = _this$props.value,
        attributes = _objectWithoutPropertiesLoose(_this$props, ["className", "cssModule", "type", "state", "tag", "addon", "static", "plaintext", "innerRef", "label", "infoText", "placeholder", "normalized", "value"]);

    var _this$props2 = this.props,
        bsSize = _this$props2.bsSize,
        valid = _this$props2.valid,
        invalid = _this$props2.invalid;
    var checkInput = ['radio', 'checkbox'].indexOf(type) > -1;
    var isNotaNumber = new RegExp('\\D', 'g');
    var fileInput = type === 'file';
    var textareaInput = type === 'textarea';
    var selectInput = type === 'select';
    var Tag = tag || (selectInput || textareaInput ? type : 'input');
    var formControlClass = 'form-control';
    var infoTextControlClass = 'form-text text-muted';

    if (plaintext || staticInput) {
      formControlClass = formControlClass + "-plaintext";
      Tag = tag || 'p';
    } else if (fileInput) {
      formControlClass = formControlClass + "-file";
    } else if (checkInput) {
      if (addon) {
        formControlClass = null;
      }
      /* Causes a regression with `bootstrap-italia`
            else {
                formControlClass = 'form-check-input';
            }
            */

    }

    if (valid || invalid) {
      infoTextControlClass = null;
    }

    if (state && typeof valid === 'undefined' && typeof invalid === 'undefined') {
      if (state === 'danger') {
        invalid = true;
      } else if (state === 'success') {
        valid = true;
      }
    }

    if (attributes.size && isNotaNumber.test(attributes.size)) {
      warnOnce('Please use the prop "bsSize" instead of the "size" to bootstrap\'s input sizing.');
      bsSize = attributes.size;
      delete attributes.size;
    }

    var classes = mapToCssModules(classnames(className, invalid && 'is-invalid', valid && 'is-valid', bsSize ? "form-control-" + bsSize : false, formControlClass), cssModule);
    var wrapperClass = mapToCssModules(classnames(className, 'form-group'), cssModule);
    var infoTextClass = mapToCssModules(classnames(className, valid ? 'valid-feedback' : false, invalid ? 'invalid-feedback' : false, infoTextControlClass));

    if (Tag === 'input' || typeof tag !== 'string') {
      attributes.type = type;
    }

    if (attributes.children && !(plaintext || staticInput || type === 'select' || typeof Tag !== 'string' || Tag === 'select')) {
      warnOnce("Input with a type of \"" + type + "\" cannot have children. Please use \"value\"/\"defaultValue\" instead.");
      delete attributes.children;
    }

    if (placeholder || value) {
      return React.createElement("div", {
        className: wrapperClass
      }, React.createElement(Tag, _extends({}, attributes, {
        ref: innerRef,
        className: classes,
        id: this.props.id,
        onFocus: this.toggleFocusLabel,
        onBlur: function onBlur(e) {
          return _this2.toggleBlurLabel(e);
        },
        placeholder: this.props.placeholder,
        value: this.props.value
      })), React.createElement("label", {
        htmlFor: this.props.id,
        className: "active"
      }, this.props.label), React.createElement("small", {
        className: infoTextClass
      }, this.props.infoText));
    }

    if (attributes.type === 'password') {
      return React.createElement("div", {
        className: wrapperClass
      }, React.createElement(Tag, _extends({}, attributes, {
        ref: innerRef,
        type: this.state.hidden ? 'password' : 'text',
        className: this.state.isFocused ? 'form-control input-password focus--mouse' : 'form-control input-password',
        onFocus: this.toggleFocusLabel,
        onBlur: function onBlur(e) {
          return _this2.toggleBlurLabel(e);
        },
        id: this.props.id,
        placeholder: this.props.placeholder,
        value: this.props.value
      })), React.createElement("span", {
        className: "password-icon",
        "aria-hidden": "true"
      }, React.createElement("svg", {
        className: "password-icon-visible icon icon-sm",
        onClick: this.toggleShow
      }, React.createElement("use", {
        xlinkHref: "/svg/sprite.svg#it-password-" + (this.state.icon ? 'visible' : 'invisible')
      }))), React.createElement("label", {
        htmlFor: this.props.id,
        className: this.state.isFocused ? 'active' : ''
      }, this.props.label), React.createElement("small", {
        className: infoTextClass
      }, this.props.infoText));
    }

    if (normalized) {
      return React.createElement("div", {
        className: wrapperClass
      }, React.createElement(Tag, _extends({}, attributes, {
        className: this.state.isFocused ? 'form-control-plaintext focus--mouse' : 'form-control-plaintext',
        onFocus: this.toggleFocusLabel,
        onBlur: function onBlur(e) {
          return _this2.toggleBlurLabel(e);
        },
        id: this.props.id,
        value: this.props.value,
        readOnly: true
      })), React.createElement("label", {
        htmlFor: this.props.id,
        className: this.state.isFocused ? 'active' : ''
      }, this.props.label), React.createElement("small", {
        className: infoTextClass
      }, this.props.infoText));
    }

    if (label || infoText) {
      return React.createElement("div", {
        className: wrapperClass
      }, React.createElement(Tag, _extends({}, attributes, {
        ref: innerRef,
        className: classes,
        id: this.props.id,
        onFocus: this.toggleFocusLabel,
        onBlur: function onBlur(e) {
          return _this2.toggleBlurLabel(e);
        },
        value: this.props.value
      })), React.createElement("label", {
        htmlFor: this.props.id,
        className: this.state.isFocused ? 'active' : ''
      }, this.props.label), React.createElement("small", {
        className: infoTextClass
      }, this.props.infoText));
    }

    return React.createElement(Tag, _extends({}, attributes, {
      ref: innerRef,
      className: classes
    }));
  };

  return Input;
}(React.Component);

Input.propTypes = propTypes$q;
Input.defaultProps = defaultProps$p;

var propTypes$r = {
  /** Utilizzarlo in caso di utilizzo di componenti personalizzati */
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),

  /** Da utilizzare in caso di titolo principale della lista. Passare una componente React da mostrare come titolo */
  header: PropTypes.node,

  /** Classi aggiuntive da usare per il componente lista del LinkList */
  className: PropTypes.string,

  /** Classi aggiuntive da usare per il componente wrapper del LinkList */
  wrapperClassName: PropTypes.string,

  /** Quando è abilitato gestisce una lista in cui ciascun elemento è composto da più componenti/elementi. */
  multiline: PropTypes.bool,
  sublist: PropTypes.bool,
  avatar: PropTypes.bool
};
var defaultProps$q = {
  tag: 'div'
};

var LinkList = function LinkList(props) {
  var className = props.className,
      wrapperClassName = props.wrapperClassName,
      Tag = props.tag,
      multiline = props.multiline,
      header = props.header,
      sublist = props.sublist,
      avatar = props.avatar,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "wrapperClassName", "tag", "multiline", "header", "sublist", "avatar"]);

  var wrapperClasses = classnames(multiline ? 'multiline' : false, 'link-list-wrapper', wrapperClassName);
  var classes = classnames(className, sublist ? 'link-sublist' : 'link-list', avatar && 'avatar-group');

  if (sublist) {
    return React.createElement(React.Fragment, null, header, React.createElement("ul", _extends({}, attributes, {
      className: classes
    })));
  }

  return React.createElement(Tag, {
    className: wrapperClasses
  }, header, React.createElement("ul", _extends({}, attributes, {
    className: classes
  })));
};

LinkList.propTypes = propTypes$r;
LinkList.defaultProps = defaultProps$q;

var propTypes$s = {
  /** Indica se l'elemento è attivo o no */
  active: PropTypes.bool,

  /** Indica se l'elemento è disabilitato o no */
  disabled: PropTypes.bool,

  /** Indica se l'elemento è un titolo. */
  header: PropTypes.bool,

  /** Indica se l'elemento è un divisore */
  divider: PropTypes.bool,

  /** Utilizzarlo in caso di utilizzo di componenti personalizzati */
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),

  /** Classi aggiuntive da usare per il componente LinkListItem */
  className: PropTypes.any,

  /** Indica il link a cui l'elemento deve puntare. */
  href: PropTypes.string,

  /** Indica la taglia/grandezza dell'elemento */
  size: PropTypes.string
};
var defaultProps$r = {
  tag: 'a'
};

var handleDisabledOnClick = function handleDisabledOnClick(e) {
  e.preventDefault();
};

var LinkListItem = function LinkListItem(_ref) {
  var className = _ref.className,
      active = _ref.active,
      disabled = _ref.disabled,
      header = _ref.header,
      divider = _ref.divider,
      href = _ref.href,
      size = _ref.size,
      Tag = _ref.tag,
      attributes = _objectWithoutPropertiesLoose(_ref, ["className", "active", "disabled", "header", "divider", "href", "size", "tag"]);

  var classes = classnames(className, {
    active: active,
    disabled: disabled,
    header: header,
    divider: divider,
    size: size
  }, 'list-item'); // Prevent click event when disabled.

  if (disabled) {
    attributes.onClick = handleDisabledOnClick;
  }

  if (header) {
    Tag = 'h3';
  } else if (divider) {
    Tag = 'span';
  }

  if (header && href) {
    return React.createElement("li", null, React.createElement(Tag, null, React.createElement("a", _extends({
      href: href || '#'
    }, attributes, {
      className: classes
    }))));
  }

  attributes.href = href;
  return React.createElement("li", null, React.createElement(Tag, _extends({}, attributes, {
    className: classes
  })));
};

LinkListItem.propTypes = propTypes$s;
LinkListItem.defaultProps = defaultProps$r;

var propTypes$t = {
  /** Renderizza i componenti NavItem al suo interno come tab. */
  tabs: PropTypes.bool,

  /** Renderizza i componenti NavItem al suo interno come pills. */
  pills: PropTypes.bool,

  /** Renderizza i componenti NavItem al suo interno come tab. */
  card: PropTypes.bool,

  /** Se abilitato tutti i NavItem all'interno avranno la stessa larghezza */
  justified: PropTypes.bool,

  /** Se abilitato i NavItem all'intero occuperanno tutto lo spazio disponibile  */
  fill: PropTypes.bool,

  /** Da utilizzare per rendere il componente Nav verticale. Viene abilitato automaticamente in versione mobile. Valori possibili sono `true`, `false` o `"xs"` */
  vertical: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),

  /** Da utilizzare per cambiare l'allineamento all'interno della Nav. Valori possibili sono `"center"` o `"end"` per posizionare il contenuto a centro o sulla destra. */
  horizontal: PropTypes.string,

  /** Se utilizzata all'interno di una navbar, impostarlo su `true`. In caso di Header Nav, impostarlo a `true` insieme a inHeader. */
  navbar: PropTypes.bool,

  /** Utilizzarlo in caso di utilizzo di componenti personalizzati */
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string])
};
var defaultProps$s = {
  tag: 'ul',
  vertical: false
};

var Nav = function Nav(_ref) {
  var attributes = _extends({}, _ref);

  return React.createElement(Nav$1, attributes);
};

Nav.propTypes = propTypes$t;
Nav.defaultProps = defaultProps$s;

var propTypes$u = {
  children: PropTypes.node,
  className: PropTypes.string,
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  'aria-label': PropTypes.string
};
var defaultProps$t = {
  tag: 'nav',
  'aria-label': 'pagination'
};

var Pager = function Pager(props) {
  var children = props.children,
      className = props.className,
      Tag = props.tag,
      label = props['aria-label'];
  var classes = classnames(className, 'pagination-wrapper');
  return React.createElement(Tag, {
    className: classes,
    "aria-label": label
  }, children);
};

Pager.propTypes = propTypes$u;
Pager.defaultProps = defaultProps$t;

var propTypes$v = {
  className: PropTypes.string,
  size: PropTypes.string,
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string])
};
var defaultProps$u = {
  tag: 'ul'
};

var PagerList = function PagerList(props) {
  var _classNames;

  var className = props.className,
      size = props.size,
      Tag = props.tag,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "size", "tag"]);

  var listClasses = classnames(className, 'pagination', (_classNames = {}, _classNames["pagination-" + size] = !!size, _classNames));
  return React.createElement(Tag, _extends({}, attributes, {
    className: listClasses
  }));
};

PagerList.propTypes = propTypes$v;
PagerList.defaultProps = defaultProps$u;

var PasswordInput =
/*#__PURE__*/
function (_Component) {
  _inheritsLoose(PasswordInput, _Component);

  function PasswordInput() {
    var _this;

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

    _this = _Component.call.apply(_Component, [this].concat(args)) || this;

    _defineProperty(_assertThisInitialized(_this), "state", {
      showPassword: false
    });

    _defineProperty(_assertThisInitialized(_this), "onPasswordToggle", function () {
      _this.setState(function (prevState) {
        return {
          showPassword: !prevState.showPassword
        };
      });
    });

    return _this;
  }

  var _proto = PasswordInput.prototype;

  _proto.render = function render() {
    var showPassword = this.state.showPassword;

    var _this$props = this.props,
        type = _this$props.type,
        rest = _objectWithoutPropertiesLoose(_this$props, ["type"]);

    var classNames = ['btn-eye', showPassword ? 'eye-off' : 'eye-on'].join(' ');
    return React.createElement(Fragment, null, React.createElement("span", {
      className: classNames,
      onClick: this.onPasswordToggle
    }), React.createElement(Input, _extends({}, rest, {
      type: showPassword ? 'text' : type
    })));
  };

  return PasswordInput;
}(Component);

_defineProperty(PasswordInput, "defaultProps", {
  type: 'password'
});

PasswordInput.propTypes = _extends({}, Input.propTypes);

var defaultSteps = [{
  score: 0,
  label: 'inserisci almeno 8 caratteri e una lettera maiuscola',
  className: 'danger'
}, {
  score: 1,
  label: 'password troppo debole',
  className: 'danger'
}, {
  score: 25,
  label: 'password debole',
  className: 'danger'
}, {
  score: 50,
  label: 'password sicura',
  className: 'warning'
}, {
  score: 75,
  label: 'password molto sicura',
  className: 'success'
}];

var PasswordMeter =
/*#__PURE__*/
function (_Component) {
  _inheritsLoose(PasswordMeter, _Component);

  function PasswordMeter() {
    return _Component.apply(this, arguments) || this;
  }

  var _proto = PasswordMeter.prototype;

  _proto.render = function render() {
    var _this$props = this.props,
        steps = _this$props.steps,
        score = _this$props.score;
    var currentStep = steps.filter(function (step) {
      return step.score <= score;
    }).reduce(function (acc, current) {
      return acc.score > current.score ? acc : current;
    });
    var label = currentStep.label,
        className = currentStep.className;
    return React.createElement("div", {
      className: "psw-wrapper"
    }, React.createElement("span", {
      className: "psw-text text-" + className + " " + className
    }, label), React.createElement("div", {
      className: "progress rounded-0 position-relative psw-meter"
    }, React.createElement("div", {
      className: "row position-absolute w-100 m-0"
    }, React.createElement("div", {
      className: "col-3 border-left border-right border-white"
    }), React.createElement("div", {
      className: "col-3 border-left border-right border-white"
    }), React.createElement("div", {
      className: "col-3 border-left border-right border-white"
    }), React.createElement("div", {
      className: "col-3 border-left border-right border-white"
    })), React.createElement("div", {
      className: "progress-bar bg-" + className + " " + className,
      style: {
        width: score + "%"
      }
    })));
  };

  return PasswordMeter;
}(Component);

_defineProperty(PasswordMeter, "defaultProps", {
  score: 0,
  steps: defaultSteps
});

PasswordMeter.propTypes = {
  score: PropTypes.number,
  steps: PropTypes.arrayOf(PropTypes.shape({
    score: PropTypes.number,
    label: PropTypes.string,
    className: PropTypes.string
  }))
};

var propTypes$w = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string
};
var defaultProps$v = {
  tag: 'div'
};

var Skiplink = function Skiplink(props) {
  var className = props.className,
      Tag = props.tag,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag"]);

  var classes = classnames(className, 'skiplinks');
  return React.createElement(Tag, _extends({
    className: classes
  }, attributes));
};

Skiplink.propTypes = propTypes$w;
Skiplink.defaultProps = defaultProps$v;

var propTypes$x = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string
};
var defaultProps$w = {
  tag: 'a'
};

var SkiplinkItem = function SkiplinkItem(props) {
  var className = props.className,
      Tag = props.tag,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag"]);

  var classes = classnames(className, 'sr-only', 'sr-only-focusable');
  return React.createElement(Tag, _extends({
    className: classes
  }, attributes));
};

SkiplinkItem.propTypes = propTypes$x;
SkiplinkItem.defaultProps = defaultProps$w;

var Toggle =
/*#__PURE__*/
function (_Component) {
  _inheritsLoose(Toggle, _Component);

  function Toggle() {
    return _Component.apply(this, arguments) || this;
  }

  var _proto = Toggle.prototype;

  _proto.render = function render() {
    var _this$props = this.props,
        label = _this$props.label,
        rest = _objectWithoutPropertiesLoose(_this$props, ["label"]);

    return React.createElement("div", {
      className: "toggles"
    }, React.createElement(Label, {
      check: true
    }, label, React.createElement(Input$1, _extends({
      type: "checkbox"
    }, rest)), React.createElement("span", {
      className: "lever"
    })));
  };

  return Toggle;
}(Component);

Toggle.propTypes = _extends({
  label: PropTypes.oneOfType([PropTypes.string, PropTypes.element])
}, Input$1.propTypes);

var propTypes$y = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string,
  secondary: PropTypes.bool,
  left: PropTypes.bool,
  right: PropTypes.bool,
  dark: PropTypes.bool
};
var defaultProps$x = {
  tag: 'div'
};

var Sidebar = function Sidebar(props) {
  var className = props.className,
      Tag = props.tag,
      secondary = props.secondary,
      left = props.left,
      right = props.right,
      dark = props.dark,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag", "secondary", "left", "right", "dark"]);

  var wrapperClasses = classnames(className, left ? 'it-line-left-side' : false, right ? 'it-line-right-side' : false, dark ? 'theme-dark' : false, 'sidebar-wrapper');
  var wrapperClassesLinkList = classnames(secondary ? 'linklist-secondary' : false, 'sidebar-linklist-wrapper');

  if (secondary) {
    return React.createElement(Tag, _extends({}, attributes, {
      className: wrapperClassesLinkList
    }));
  }

  return React.createElement(Tag, {
    className: wrapperClasses
  }, React.createElement(Tag, _extends({}, attributes, {
    className: wrapperClassesLinkList
  })));
};

Sidebar.propTypes = propTypes$y;
Sidebar.defaultProps = defaultProps$x;

var propTypes$z = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string,
  value: PropTypes.number,
  label: PropTypes.string,
  indeterminate: PropTypes.bool,
  color: PropTypes.string
};
var defaultProps$y = {
  tag: 'div',
  role: 'progressbar',
  indeterminate: false
};

var Progress =
/*#__PURE__*/
function (_React$Component) {
  _inheritsLoose(Progress, _React$Component);

  function Progress() {
    return _React$Component.apply(this, arguments) || this;
  }

  var _proto = Progress.prototype;

  _proto.render = function render() {
    var _this$props = this.props,
        className = _this$props.className,
        Tag = _this$props.tag,
        value = _this$props.value,
        label = _this$props.label,
        indeterminate = _this$props.indeterminate,
        color = _this$props.color,
        attributes = _objectWithoutPropertiesLoose(_this$props, ["className", "tag", "value", "label", "indeterminate", "color"]);

    var wrapperClasses = classnames('progress-bar-wrapper');
    var secondaryWrapperClasses = classnames(className, indeterminate ? 'progress-indeterminate' : false, color ? 'progress-color' : false, 'progress');
    var classes = classnames(className, 'progress-bar', color ? "bg-" + this.props.color : false);

    if (label && value) {
      return React.createElement(Tag, {
        className: wrapperClasses
      }, React.createElement("div", {
        className: "progress-bar-label"
      }, React.createElement("span", {
        className: "sr-only"
      }, this.props.label), this.props.value + '%'), React.createElement(Tag, {
        className: secondaryWrapperClasses
      }, React.createElement("div", _extends({}, attributes, {
        className: classes,
        role: "progressbar",
        style: {
          width: this.props.value + '%'
        },
        "aria-valuenow": this.props.value,
        "aria-valuemin": "0",
        "aria-valuemax": "100"
      }))));
    }

    return React.createElement(Tag, {
      className: secondaryWrapperClasses
    }, React.createElement("div", {
      className: "progress-bar-label"
    }, React.createElement("span", {
      className: "sr-only"
    }, this.props.label)), React.createElement("div", _extends({}, attributes, {
      className: classes,
      role: "progressbar",
      style: {
        width: this.props.value + '%'
      },
      "aria-valuenow": this.props.value,
      "aria-valuemin": "0",
      "aria-valuemax": "100"
    })));
  };

  return Progress;
}(React.Component);

Progress.propTypes = propTypes$z;
Progress.defaultProps = defaultProps$y;

var propTypes$A = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string,
  active: PropTypes.bool,
  small: PropTypes.bool,
  "double": PropTypes.bool
};
var defaultProps$z = {
  tag: 'span',
  active: false,
  small: false,
  "double": false
};

var Spinner =
/*#__PURE__*/
function (_React$Component) {
  _inheritsLoose(Spinner, _React$Component);

  function Spinner() {
    return _React$Component.apply(this, arguments) || this;
  }

  var _proto = Spinner.prototype;

  _proto.render = function render() {
    var _this$props = this.props,
        className = _this$props.className,
        Tag = _this$props.tag,
        active = _this$props.active,
        small = _this$props.small,
        _double = _this$props["double"],
        attributes = _objectWithoutPropertiesLoose(_this$props, ["className", "tag", "active", "small", "double"]);

    var wrapperClasses = classnames(active ? 'progress-spinner-active' : false, small ? 'size-sm' : false, _double ? 'progress-spinner-double' : false, 'progress-spinner');
    var innerClasses = classnames('progress-spinner-inner');
    var classes = classnames(className, 'sr-only');

    if (_double) {
      return React.createElement(Tag, {
        className: wrapperClasses
      }, React.createElement("div", {
        className: innerClasses
      }), React.createElement("div", {
        className: innerClasses
      }), React.createElement(Tag, _extends({}, attributes, {
        className: classes
      }), "Caricamento..."));
    }

    return React.createElement(Tag, {
      className: wrapperClasses
    }, React.createElement(Tag, _extends({}, attributes, {
      className: classes
    }), "Caricamento..."));
  };

  return Spinner;
}(React.Component);

Spinner.propTypes = propTypes$A;
Spinner.defaultProps = defaultProps$z;

var propTypes$B = _extends({}, Card$1.propTypes, {
  teaser: PropTypes.bool,
  spacing: PropTypes.bool,
  noWrapper: PropTypes.bool,
  wrapperClassName: PropTypes.string
});

var defaultProps$A = _extends({}, Card$1.defaultProps, {
  noWrapper: false
});

var Card = function Card(_ref) {
  var teaser = _ref.teaser,
      spacing = _ref.spacing,
      noWrapper = _ref.noWrapper,
      wrapperClassName = _ref.wrapperClassName,
      attributes = _objectWithoutPropertiesLoose(_ref, ["teaser", "spacing", "noWrapper", "wrapperClassName"]);

  var wrapperClasses = classnames('card-wrapper', wrapperClassName, {
    'card-space': spacing,
    'card-teaser-wrapper': teaser
  });
  var cardClasses = classnames(attributes.className, {
    'card-teaser': teaser
  });

  if (noWrapper) {
    return React.createElement(Card$1, _extends({}, attributes, {
      className: cardClasses
    }));
  }

  return React.createElement("div", {
    className: wrapperClasses
  }, React.createElement(Card$1, _extends({}, attributes, {
    className: cardClasses
  })));
};

Card.propTypes = propTypes$B;
Card.defaultProps = defaultProps$A;

var propTypes$C = {
  iconName: PropTypes.string,
  date: PropTypes.string,
  href: PropTypes.string
};

var CardCategory = function CardCategory(props) {
  var iconName = props.iconName,
      date = props.date,
      href = props.href,
      attributes = _objectWithoutPropertiesLoose(props, ["iconName", "date", "href"]);

  var children = attributes.children,
      rest = _objectWithoutPropertiesLoose(attributes, ["children"]);

  var classes = classnames({
    'category-top': !iconName,
    'categoryicon-top': iconName
  }); // Simple category link

  var categoryLink = !iconName && React.createElement("a", {
    href: href,
    className: "category"
  }, children);
  var categoryDate = !iconName && React.createElement("span", {
    className: "data"
  }, date); // Category with icon

  var categoryText = iconName && React.createElement("span", {
    className: "text"
  }, children);
  var categoryIcon = iconName && React.createElement(Icon, {
    icon: iconName
  });
  return React.createElement("div", _extends({
    className: classes
  }, rest), categoryLink, categoryDate, categoryIcon, categoryText);
};

CardCategory.propTypes = propTypes$C;

var propTypes$D = {
  tag: PropTypes.string,
  className: PropTypes.string
};
var defaultProps$B = {
  tag: 'a'
};

var CardTag = function CardTag(props) {
  var className = props.className,
      Tag = props.tag,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag"]);

  var classes = classnames(className, 'card-tag');
  return React.createElement(Tag, _extends({
    className: classes
  }, attributes));
};

CardTag.propTypes = propTypes$D;
CardTag.defaultProps = defaultProps$B;

var propTypes$E = {
  children: PropTypes.node,
  date: PropTypes.string
};

var CardTagsHeader = function CardTagsHeader(props) {
  var date = props.date,
      children = props.children,
      attributes = _objectWithoutPropertiesLoose(props, ["date", "children"]);

  return React.createElement("div", _extends({
    className: "head-tags"
  }, attributes), children, date && React.createElement("span", {
    className: "data"
  }, date));
};

CardTagsHeader.propTypes = propTypes$E;

var propTypes$F = {
  className: PropTypes.string
};

var CardSignature = function CardSignature(props) {
  var className = props.className,
      attributes = _objectWithoutPropertiesLoose(props, ["className"]);

  var classes = classnames(className, 'card-signature');
  return React.createElement("span", _extends({
    className: classes
  }, attributes));
};

CardSignature.propTypes = propTypes$F;

var propTypes$G = {
  className: PropTypes.string
};

var CardFooterCTA = function CardFooterCTA(props) {
  var className = props.className,
      attributes = _objectWithoutPropertiesLoose(props, ["className"]);

  var classes = classnames(className, 'it-card-footer');
  return React.createElement("div", _extends({
    className: classes
  }, attributes));
};

CardFooterCTA.propTypes = propTypes$G;

var propTypes$H = {
  className: PropTypes.string,
  iconName: PropTypes.string,
  href: PropTypes.string,
  text: PropTypes.string,
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string, PropTypes.shape({
    $$typeof: PropTypes.symbol,
    render: PropTypes.func
  }), PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.string, PropTypes.shape({
    $$typeof: PropTypes.symbol,
    render: PropTypes.func
  })]))])
};
var defaultProps$C = {
  tag: 'a',
  iconName: 'it-arrow-right'
};

var CardReadMore = function CardReadMore(props) {
  var className = props.className,
      text = props.text,
      iconName = props.iconName,
      Tag = props.tag,
      href = props.href,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "text", "iconName", "tag", "href"]);

  var classes = classnames(className, 'read-more');
  return React.createElement(Tag, _extends({
    className: classes,
    href: href
  }, attributes), React.createElement("span", {
    className: "text"
  }, text), iconName && React.createElement(Icon, {
    icon: iconName
  }));
};

CardReadMore.propTypes = propTypes$H;
CardReadMore.defaultProps = defaultProps$C;

var propTypes$I = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string
};
var defaultProps$D = {
  tag: 'nav'
};

var BottomNav = function BottomNav(props) {
  var Tag = props.tag,
      attributes = _objectWithoutPropertiesLoose(props, ["tag"]);

  var wrapperClasses = classnames('bottom-nav');
  return React.createElement(Tag, {
    className: wrapperClasses
  }, React.createElement("ul", attributes));
};

BottomNav.propTypes = propTypes$I;
BottomNav.defaultProps = defaultProps$D;

var propTypes$J = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string,
  active: PropTypes.bool,
  link: PropTypes.string,
  label: PropTypes.string,
  iconName: PropTypes.string,
  srText: PropTypes.string,
  alert: PropTypes.bool,
  badge: PropTypes.bool
};
var defaultProps$E = {
  tag: 'a',
  link: '#',
  iconName: 'it-comment',
  srText: false
};

var BottomNavItem = function BottomNavItem(_ref) {
  var active = _ref.active,
      badge = _ref.badge,
      alert = _ref.alert,
      link = _ref.link,
      srText = _ref.srText,
      iconName = _ref.iconName,
      label = _ref.label,
      Tag = _ref.tag,
      attributes = _objectWithoutPropertiesLoose(_ref, ["active", "badge", "alert", "link", "srText", "iconName", "label", "tag"]);

  var activeClass = classnames(active ? 'active' : false);
  var badgeWrapper = badge ? React.createElement("div", {
    className: "badge-wrapper"
  }, React.createElement("span", {
    className: "bottom-nav-badge"
  }, badge)) : false;
  var alertWrapper = alert ? React.createElement("div", {
    className: "badge-wrapper"
  }, React.createElement("span", {
    className: "bottom-nav-alert"
  })) : false;
  return React.createElement("li", attributes, React.createElement(Tag, {
    href: link,
    className: activeClass
  }, badgeWrapper, alertWrapper, React.createElement(Icon, {
    icon: iconName
  }), React.createElement("span", {
    className: "bottom-nav-label"
  }, label, React.createElement("span", {
    className: "sr-only"
  }, srText))));
};

BottomNavItem.propTypes = propTypes$J;
BottomNavItem.defaultProps = defaultProps$E;

var propTypes$K = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string
};
var defaultProps$F = {
  tag: 'div'
};

function CookieBar(props) {
  var className = props.className,
      Tag = props.tag,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag"]);

  var wrapperClasses = classnames('cookiebar show', className);
  return React.createElement(Tag, _extends({}, attributes, {
    className: wrapperClasses
  }));
}

CookieBar.propTypes = propTypes$K;
CookieBar.defaultProps = defaultProps$F;

var propTypes$L = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string
};
var defaultProps$G = {
  tag: 'div'
};

var CookieBarButtons = function CookieBarButtons(props) {
  var className = props.className,
      Tag = props.tag,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag"]);

  var buttonClasses = classnames(className, 'cookiebar-buttons');
  return React.createElement(Tag, _extends({
    className: buttonClasses
  }, attributes));
};

CookieBarButtons.propTypes = propTypes$L;
CookieBarButtons.defaultProps = defaultProps$G;

var propTypes$M = {
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  className: PropTypes.string
};
var defaultProps$H = {
  tag: 'button'
};

var CookieBarButton =
/*#__PURE__*/
function (_React$Component) {
  _inheritsLoose(CookieBarButton, _React$Component);

  function CookieBarButton() {
    return _React$Component.apply(this, arguments) || this;
  }

  var _proto = CookieBarButton.prototype;

  _proto.render = function render() {
    var _this$props = this.props,
        Tag = _this$props.tag,
        className = _this$props.className,
        attributes = _objectWithoutPropertiesLoose(_this$props, ["tag", "className"]);

    var activeClass = classnames(className, 'cookiebar-btn');
    return React.createElement(Tag, _extends({
      href: true,
      className: activeClass
    }, attributes));
  };

  return CookieBarButton;
}(React.Component);

CookieBarButton.propTypes = propTypes$M;
CookieBarButton.defaultProps = defaultProps$H;

var propTypes$N = {
  /** Utilizzarlo in caso di utilizzo di componenti personalizzati */
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),

  /** Classi aggiuntive da usare per il componente Chip */
  className: PropTypes.string,

  /** Impostarlo su `true` per centrare la label all'interno */
  simple: PropTypes.bool,

  /** Impostarlo su `true` per una versione più grande del componente Chip. */
  large: PropTypes.bool,

  /** Impostarlo su `true` per renderizzare il componente Chip come disabilitato */
  disabled: PropTypes.bool,
  color: PropTypes.string
};
var defaultProps$I = {
  tag: 'div',
  simple: false,
  large: false,
  disabled: false,
  color: ''
};

var Chip = function Chip(props) {
  var _classNames;

  var className = props.className,
      color = props.color,
      Tag = props.tag,
      simple = props.simple,
      large = props.large,
      disabled = props.disabled,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "color", "tag", "simple", "large", "disabled"]);

  var classes = classnames('chip', className, (_classNames = {
    'chip-simple': simple,
    'chip-lg': large,
    'chip-disabled': disabled
  }, _classNames["chip-" + color] = color, _classNames));
  return React.createElement(Tag, _extends({
    className: classes
  }, attributes));
};

Chip.propTypes = propTypes$N;
Chip.defaultProps = defaultProps$I;

var propTypes$O = {
  /** Utilizzarlo in caso di utilizzo di componenti personalizzati */
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),

  /** Classi aggiuntive da usare per il componente ChipLabel */
  className: PropTypes.string
};
var defaultProps$J = {
  tag: 'span'
};

var ChipLabel = function ChipLabel(props) {
  var className = props.className,
      Tag = props.tag,
      attributes = _objectWithoutPropertiesLoose(props, ["className", "tag"]);

  var classes = classnames(className, 'chip-label');
  return React.createElement(Tag, _extends({}, attributes, {
    className: classes
  }));
};

ChipLabel.propTypes = propTypes$O;
ChipLabel.defaultProps = defaultProps$J;

var ToolkitFontLoader =
/*#__PURE__*/
function (_Component) {
  _inheritsLoose(ToolkitFontLoader, _Component);

  function ToolkitFontLoader() {
    return _Component.apply(this, arguments) || this;
  }

  var _proto = ToolkitFontLoader.prototype;

  _proto.componentDidMount = function componentDidMount() {
    if (typeof window !== 'undefined') {
      var WebFont = require('webfontloader');

      WebFont.load({
        custom: {
          families: ['Titillium Web:300,400,600,700:latin-ext', 'Lora:400,700:latin-ext', 'Roboto Mono:400,700:latin-ext']
        }
      });
    }
  };

  _proto.render = function render() {
    return null;
  };

  return ToolkitFontLoader;
}(Component);

var propTypes$P = {
  icon: PropTypes.string,
  color: PropTypes.string,
  className: PropTypes.string
};

var Dimmer = function Dimmer(props) {
  var _classNames;

  var icon = props.icon,
      color = props.color,
      className = props.className,
      attributes = _objectWithoutPropertiesLoose(props, ["icon", "color", "className"]);

  var children = attributes.children,
      rest = _objectWithoutPropertiesLoose(attributes, ["children"]);

  var classes = classnames('dimmer', className, (_classNames = {}, _classNames["dimmer-" + color] = color, _classNames));
  var innerClasses = classnames('dimmer-inner', className);
  var dimmerIcon = icon && React.createElement("div", {
    className: "dimmer-icon"
  }, React.createElement(Icon, {
    icon: icon
  }));
  return React.createElement("div", _extends({
    className: classes
  }, rest, {
    style: {
      display: 'flex'
    }
  }), React.createElement("div", _extends({
    className: innerClasses
  }, rest), dimmerIcon, children));
};

Dimmer.propTypes = propTypes$P;

var propTypes$Q = {
  color: PropTypes.string,
  dark: PropTypes.string,
  single: PropTypes.string,
  className: PropTypes.string
};
var defaultProps$K = {
  single: false,
  dark: false
};

var DimmerButtons = function DimmerButtons(props) {
  var color = props.color,
      dark = props.dark,
      className = props.className,
      single = props.single,
      attributes = _objectWithoutPropertiesLoose(props, ["color", "dark", "className", "single"]);

  var children = attributes.children,
      rest = _objectWithoutPropertiesLoose(attributes, ["children"]);

  var classes = classnames('dimmer-buttons', className, {
    'single-button': single,
    'bg-dark': dark
  });
  return React.createElement("div", _extends({
    className: classes
  }, rest), children);
};

DimmerButtons.propTypes = propTypes$Q;
DimmerButtons.defaultProps = defaultProps$K;

export { Accordion, AccordionBody, AccordionHeader, AvatarContainer, AvatarExtraText, AvatarGroupContainer, AvatarIcon, AvatarPresence, AvatarStatus, AvatarWrapper, Badge, BottomNav, BottomNavItem, Button, Callout, CalloutText, CalloutTitle, Card, CardCategory, CardFooterCTA, CardReadMore, CardSignature, CardTag, CardTagsHeader, Chip, ChipLabel, Collapse, CookieBar, CookieBarButton, CookieBarButtons, Dimmer, DimmerButtons, ToolkitFontLoader as FontLoader, FormGroup, Header, HeaderBrand, HeaderContent, HeaderLinkZone, HeaderRightZone, HeaderSearch, HeaderSocialsZone, HeaderToggler, Headers, Hero, Icon, Input, LinkList, LinkListItem, Nav, Pager, PagerList, PasswordInput, PasswordMeter, Progress, Sidebar, Skiplink, SkiplinkItem, Spinner, Toggle };
//# sourceMappingURL=design-react-kit.es.js.map
