text: function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
  
  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
  
  function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
  
  function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  import React from 'react';
  import Utils from '../utils/utils';
  import Mixins from '../utils/mixins';
  import __reactComponentSlots from '../runtime-helpers/react-component-slots.js';
  import __reactComponentSetProps from '../runtime-helpers/react-component-set-props.js';
  
  var F7NavTitle =
  /*#__PURE__*/
  function (_React$Component) {
    _inherits(F7NavTitle, _React$Component);
  
    function F7NavTitle(props, context) {
      _classCallCheck(this, F7NavTitle);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(F7NavTitle).call(this, props, context));
    }
  
    _createClass(F7NavTitle, [{
      key: "render",
      value: function render() {
        var self = this;
        var props = self.props;
        var title = props.title,
            subtitle = props.subtitle,
            id = props.id,
            style = props.style,
            sliding = props.sliding,
            className = props.className;
        var subtitleEl;
  
        if (subtitle) {
          subtitleEl = React.createElement('span', {
            className: 'subtitle'
          }, subtitle);
        }
  
        var classes = Utils.classNames(className, 'title', {
          sliding: sliding
        }, Mixins.colorClasses(props));
        var children;
        var slots = self.slots;
  
        if (slots && Object.keys(slots).length) {
          children = [];
          Object.keys(slots).forEach(function (key) {
            var _children;
  
            (_children = children).push.apply(_children, _toConsumableArray(slots[key]));
          });
        }
  
        return React.createElement('div', {
          id: id,
          style: style,
          className: classes
        }, children, !children && title, !children && subtitleEl);
      }
    }, {
      key: "slots",
      get: function get() {
        return __reactComponentSlots(this.props);
      }
    }]);
  
    return F7NavTitle;
  }(React.Component);
  
  __reactComponentSetProps(F7NavTitle, Object.assign({
    id: [String, Number],
    className: String,
    style: Object,
    title: String,
    subtitle: String,
    sliding: Boolean
  }, Mixins.colorProps));
  
  F7NavTitle.displayName = 'f7-nav-title';
  export default F7NavTitle;