mui-react.js

(function (global) {
  var babelHelpers = global.babelHelpers = {};

  babelHelpers.classCallCheck = function (instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  };

  babelHelpers.createClass = 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);
      }
    }

    return function (Constructor, protoProps, staticProps) {
      if (protoProps) defineProperties(Constructor.prototype, protoProps);
      if (staticProps) defineProperties(Constructor, staticProps);
      return Constructor;
    };
  }();

  babelHelpers.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;
  };

  babelHelpers.inherits = function (subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
    if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  };

  babelHelpers.interopRequireDefault = function (obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  };

  babelHelpers.interopRequireWildcard = function (obj) {
    if (obj && obj.__esModule) {
      return obj;
    } else {
      var newObj = {};

      if (obj != null) {
        for (var key in obj) {
          if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
        }
      }

      newObj.default = obj;
      return newObj;
    }
  };

  babelHelpers.objectWithoutProperties = function (obj, keys) {
    var target = {};

    for (var i in obj) {
      if (keys.indexOf(i) >= 0) continue;
      if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
      target[i] = obj[i];
    }

    return target;
  };

  babelHelpers.possibleConstructorReturn = function (self, call) {
    if (!self) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return call && (typeof call === "object" || typeof call === "function") ? call : self;
  };
})(typeof global === "undefined" ? self : global);(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
'use strict';

/**
 * MUI React main module
 * @module react/main
 */

(function (win) {
  // return if library has been loaded already
  if (win._muiReactLoaded) return;else win._muiReactLoaded = true;

  var mui = win.mui = win.mui || [],
      react = mui.react = {},
      lib;

  react.Appbar = require('src/react/appbar');
  react.Button = require('src/react/button');
  react.Caret = require('src/react/caret');
  react.Checkbox = require('src/react/checkbox');
  react.Col = require('src/react/col');
  react.Container = require('src/react/container');
  react.Divider = require('src/react/divider');
  react.Dropdown = require('src/react/dropdown'), react.DropdownItem = require('src/react/dropdown-item'), react.Form = require('src/react/form');
  react.Input = require('src/react/input');
  react.Option = require('src/react/option');
  react.Panel = require('src/react/panel');
  react.Radio = require('src/react/radio');
  react.Row = require('src/react/row');
  react.Select = require('src/react/select');
  react.Tab = require('src/react/tab');
  react.Tabs = require('src/react/tabs');
  react.Textarea = require('src/react/textarea');
})(window);

},{"src/react/appbar":11,"src/react/button":12,"src/react/caret":13,"src/react/checkbox":14,"src/react/col":15,"src/react/container":16,"src/react/divider":17,"src/react/dropdown":19,"src/react/dropdown-item":18,"src/react/form":20,"src/react/input":21,"src/react/option":22,"src/react/panel":23,"src/react/radio":24,"src/react/row":25,"src/react/select":26,"src/react/tab":27,"src/react/tabs":28,"src/react/textarea":29}],2:[function(require,module,exports){
"use strict";

/**
 * MUI config module
 * @module config
 */

/** Define module API */
module.exports = {
  /** Use debug mode */
  debug: true
};

},{}],3:[function(require,module,exports){
/**
 * MUI CSS/JS form helpers module
 * @module lib/forms.py
 */

'use strict';

var wrapperPadding = 15,
    // from CSS
inputHeight = 32,
    // from CSS
optionHeight = 42,
    // from CSS
menuPadding = 8; // from CSS

/**
 * Menu position/size/scroll helper
 * @returns {Object} Object with keys 'height', 'top', 'scrollTop'
 */
function getMenuPositionalCSSFn(wrapperEl, numOptions, currentIndex) {
  var viewHeight = document.documentElement.clientHeight;

  // determine 'height'
  var h = numOptions * optionHeight + 2 * menuPadding,
      height = Math.min(h, viewHeight);

  // determine 'top'
  var top, initTop, minTop, maxTop;

  initTop = menuPadding + optionHeight - (wrapperPadding + inputHeight);
  initTop -= currentIndex * optionHeight;

  minTop = -1 * wrapperEl.getBoundingClientRect().top;
  maxTop = viewHeight - height + minTop;

  top = Math.min(Math.max(initTop, minTop), maxTop);

  // determine 'scrollTop'
  var scrollTop = 0,
      scrollIdeal,
      scrollMax;

  if (h > viewHeight) {
    scrollIdeal = menuPadding + (currentIndex + 1) * optionHeight - (-1 * top + wrapperPadding + inputHeight);
    scrollMax = numOptions * optionHeight + 2 * menuPadding - height;
    scrollTop = Math.min(scrollIdeal, scrollMax);
  }

  return {
    'height': height + 'px',
    'top': top + 'px',
    'scrollTop': scrollTop
  };
}

/** Define module API */
module.exports = {
  getMenuPositionalCSS: getMenuPositionalCSSFn
};

},{}],4:[function(require,module,exports){
/**
 * MUI CSS/JS jqLite module
 * @module lib/jqLite
 */

'use strict';

/**
 * Add a class to an element.
 * @param {Element} element - The DOM element.
 * @param {string} cssClasses - Space separated list of class names.
 */

function jqLiteAddClass(element, cssClasses) {
  if (!cssClasses || !element.setAttribute) return;

  var existingClasses = _getExistingClasses(element),
      splitClasses = cssClasses.split(' '),
      cssClass;

  for (var i = 0; i < splitClasses.length; i++) {
    cssClass = splitClasses[i].trim();
    if (existingClasses.indexOf(' ' + cssClass + ' ') === -1) {
      existingClasses += cssClass + ' ';
    }
  }

  element.setAttribute('class', existingClasses.trim());
}

/**
 * Get or set CSS properties.
 * @param {Element} element - The DOM element.
 * @param {string} [name] - The property name.
 * @param {string} [value] - The property value.
 */
function jqLiteCss(element, name, value) {
  // Return full style object
  if (name === undefined) {
    return getComputedStyle(element);
  }

  var nameType = jqLiteType(name);

  // Set multiple values
  if (nameType === 'object') {
    for (var key in name) {
      element.style[_camelCase(key)] = name[key];
    }return;
  }

  // Set a single value
  if (nameType === 'string' && value !== undefined) {
    element.style[_camelCase(name)] = value;
  }

  var styleObj = getComputedStyle(element),
      isArray = jqLiteType(name) === 'array';

  // Read single value
  if (!isArray) return _getCurrCssProp(element, name, styleObj);

  // Read multiple values
  var outObj = {},
      key;

  for (var i = 0; i < name.length; i++) {
    key = name[i];
    outObj[key] = _getCurrCssProp(element, key, styleObj);
  }

  return outObj;
}

/**
 * Check if element has class.
 * @param {Element} element - The DOM element.
 * @param {string} cls - The class name string.
 */
function jqLiteHasClass(element, cls) {
  if (!cls || !element.getAttribute) return false;
  return _getExistingClasses(element).indexOf(' ' + cls + ' ') > -1;
}

/**
 * Return the type of a variable.
 * @param {} somevar - The JavaScript variable.
 */
function jqLiteType(somevar) {
  // handle undefined
  if (somevar === undefined) return 'undefined';

  // handle others (of type [object <Type>])
  var typeStr = Object.prototype.toString.call(somevar);
  if (typeStr.indexOf('[object ') === 0) {
    return typeStr.slice(8, -1).toLowerCase();
  } else {
    throw new Error("MUI: Could not understand type: " + typeStr);
  }
}

/**
 * Attach an event handler to a DOM element
 * @param {Element} element - The DOM element.
 * @param {string} events - Space separated event names.
 * @param {Function} callback - The callback function.
 * @param {Boolean} useCapture - Use capture flag.
 */
function jqLiteOn(element, events, callback, useCapture) {
  useCapture = useCapture === undefined ? false : useCapture;

  var cache = element._muiEventCache = element._muiEventCache || {};

  events.split(' ').map(function (event) {
    // add to DOM
    element.addEventListener(event, callback, useCapture);

    // add to cache
    cache[event] = cache[event] || [];
    cache[event].push([callback, useCapture]);
  });
}

/**
 * Remove an event handler from a DOM element
 * @param {Element} element - The DOM element.
 * @param {string} events - Space separated event names.
 * @param {Function} callback - The callback function.
 * @param {Boolean} useCapture - Use capture flag.
 */
function jqLiteOff(element, events, callback, useCapture) {
  useCapture = useCapture === undefined ? false : useCapture;

  // remove from cache
  var cache = element._muiEventCache = element._muiEventCache || {},
      argsList,
      args,
      i;

  events.split(' ').map(function (event) {
    argsList = cache[event] || [];

    i = argsList.length;
    while (i--) {
      args = argsList[i];

      // remove all events if callback is undefined
      if (callback === undefined || args[0] === callback && args[1] === useCapture) {

        // remove from cache
        argsList.splice(i, 1);

        // remove from DOM
        element.removeEventListener(event, args[0], args[1]);
      }
    }
  });
}

/**
 * Attach an event hander which will only execute once per element per event
 * @param {Element} element - The DOM element.
 * @param {string} events - Space separated event names.
 * @param {Function} callback - The callback function.
 * @param {Boolean} useCapture - Use capture flag.
 */
function jqLiteOne(element, events, callback, useCapture) {
  events.split(' ').map(function (event) {
    jqLiteOn(element, event, function onFn(ev) {
      // execute callback
      if (callback) callback.apply(this, arguments);

      // remove wrapper
      jqLiteOff(element, event, onFn);
    }, useCapture);
  });
}

/**
 * Get or set horizontal scroll position
 * @param {Element} element - The DOM element
 * @param {number} [value] - The scroll position
 */
function jqLiteScrollLeft(element, value) {
  var win = window;

  // get
  if (value === undefined) {
    if (element === win) {
      var docEl = document.documentElement;
      return (win.pageXOffset || docEl.scrollLeft) - (docEl.clientLeft || 0);
    } else {
      return element.scrollLeft;
    }
  }

  // set
  if (element === win) win.scrollTo(value, jqLiteScrollTop(win));else element.scrollLeft = value;
}

/**
 * Get or set vertical scroll position
 * @param {Element} element - The DOM element
 * @param {number} value - The scroll position
 */
function jqLiteScrollTop(element, value) {
  var win = window;

  // get
  if (value === undefined) {
    if (element === win) {
      var docEl = document.documentElement;
      return (win.pageYOffset || docEl.scrollTop) - (docEl.clientTop || 0);
    } else {
      return element.scrollTop;
    }
  }

  // set
  if (element === win) win.scrollTo(jqLiteScrollLeft(win), value);else element.scrollTop = value;
}

/**
 * Return object representing top/left offset and element height/width.
 * @param {Element} element - The DOM element.
 */
function jqLiteOffset(element) {
  var win = window,
      rect = element.getBoundingClientRect(),
      scrollTop = jqLiteScrollTop(win),
      scrollLeft = jqLiteScrollLeft(win);

  return {
    top: rect.top + scrollTop,
    left: rect.left + scrollLeft,
    height: rect.height,
    width: rect.width
  };
}

/**
 * Attach a callback to the DOM ready event listener
 * @param {Function} fn - The callback function.
 */
function jqLiteReady(fn) {
  var done = false,
      top = true,
      doc = document,
      win = doc.defaultView,
      root = doc.documentElement,
      add = doc.addEventListener ? 'addEventListener' : 'attachEvent',
      rem = doc.addEventListener ? 'removeEventListener' : 'detachEvent',
      pre = doc.addEventListener ? '' : 'on';

  var init = function init(e) {
    if (e.type == 'readystatechange' && doc.readyState != 'complete') {
      return;
    }

    (e.type == 'load' ? win : doc)[rem](pre + e.type, init, false);
    if (!done && (done = true)) fn.call(win, e.type || e);
  };

  var poll = function poll() {
    try {
      root.doScroll('left');
    } catch (e) {
      setTimeout(poll, 50);return;
    }
    init('poll');
  };

  if (doc.readyState == 'complete') {
    fn.call(win, 'lazy');
  } else {
    if (doc.createEventObject && root.doScroll) {
      try {
        top = !win.frameElement;
      } catch (e) {}
      if (top) poll();
    }
    doc[add](pre + 'DOMContentLoaded', init, false);
    doc[add](pre + 'readystatechange', init, false);
    win[add](pre + 'load', init, false);
  }
}

/**
 * Remove classes from a DOM element
 * @param {Element} element - The DOM element.
 * @param {string} cssClasses - Space separated list of class names.
 */
function jqLiteRemoveClass(element, cssClasses) {
  if (!cssClasses || !element.setAttribute) return;

  var existingClasses = _getExistingClasses(element),
      splitClasses = cssClasses.split(' '),
      cssClass;

  for (var i = 0; i < splitClasses.length; i++) {
    cssClass = splitClasses[i].trim();
    while (existingClasses.indexOf(' ' + cssClass + ' ') >= 0) {
      existingClasses = existingClasses.replace(' ' + cssClass + ' ', ' ');
    }
  }

  element.setAttribute('class', existingClasses.trim());
}

// ------------------------------
// Utilities
// ------------------------------
var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g,
    MOZ_HACK_REGEXP = /^moz([A-Z])/,
    ESCAPE_REGEXP = /([.*+?^=!:${}()|\[\]\/\\])/g;

function _getExistingClasses(element) {
  var classes = (element.getAttribute('class') || '').replace(/[\n\t]/g, '');
  return ' ' + classes + ' ';
}

function _camelCase(name) {
  return name.replace(SPECIAL_CHARS_REGEXP, function (_, separator, letter, offset) {
    return offset ? letter.toUpperCase() : letter;
  }).replace(MOZ_HACK_REGEXP, 'Moz$1');
}

function _escapeRegExp(string) {
  return string.replace(ESCAPE_REGEXP, "\\$1");
}

function _getCurrCssProp(elem, name, computed) {
  var ret;

  // try computed style
  ret = computed.getPropertyValue(name);

  // try style attribute (if element is not attached to document)
  if (ret === '' && !elem.ownerDocument) ret = elem.style[_camelCase(name)];

  return ret;
}

/**
 * Module API
 */
module.exports = {
  /** Add classes */
  addClass: jqLiteAddClass,

  /** Get or set CSS properties */
  css: jqLiteCss,

  /** Check for class */
  hasClass: jqLiteHasClass,

  /** Remove event handlers */
  off: jqLiteOff,

  /** Return offset values */
  offset: jqLiteOffset,

  /** Add event handlers */
  on: jqLiteOn,

  /** Add an execute-once event handler */
  one: jqLiteOne,

  /** DOM ready event handler */
  ready: jqLiteReady,

  /** Remove classes */
  removeClass: jqLiteRemoveClass,

  /** Check JavaScript variable instance type */
  type: jqLiteType,

  /** Get or set horizontal scroll position */
  scrollLeft: jqLiteScrollLeft,

  /** Get or set vertical scroll position */
  scrollTop: jqLiteScrollTop
};

},{}],5:[function(require,module,exports){
/**
 * MUI CSS/JS utilities module
 * @module lib/util
 */

'use strict';

var config = require('../config'),
    jqLite = require('./jqLite'),
    nodeInsertedCallbacks = [],
    scrollLock = 0,
    scrollLockCls = 'mui-body--scroll-lock',
    scrollLockPos,
    _supportsPointerEvents;

/**
 * Logging function
 */
function logFn() {
  var win = window;

  if (config.debug && typeof win.console !== "undefined") {
    try {
      win.console.log.apply(win.console, arguments);
    } catch (a) {
      var e = Array.prototype.slice.call(arguments);
      win.console.log(e.join("\n"));
    }
  }
}

/**
 * Load CSS text in new stylesheet
 * @param {string} cssText - The css text.
 */
function loadStyleFn(cssText) {
  var doc = document,
      head;

  // copied from jQuery
  head = doc.head || doc.getElementsByTagName('head')[0] || doc.documentElement;

  var e = doc.createElement('style');
  e.type = 'text/css';

  if (e.styleSheet) e.styleSheet.cssText = cssText;else e.appendChild(doc.createTextNode(cssText));

  // add to document
  head.insertBefore(e, head.firstChild);

  return e;
}

/**
 * Raise an error
 * @param {string} msg - The error message.
 */
function raiseErrorFn(msg, useConsole) {
  if (useConsole) {
    if (typeof console !== 'undefined') console.error('MUI Warning: ' + msg);
  } else {
    throw new Error('MUI: ' + msg);
  }
}

/**
 * Register callbacks on muiNodeInserted event
 * @param {function} callbackFn - The callback function.
 */
function onNodeInsertedFn(callbackFn) {
  nodeInsertedCallbacks.push(callbackFn);

  // initalize listeners
  if (nodeInsertedCallbacks._initialized === undefined) {
    var doc = document,
        events = 'animationstart mozAnimationStart webkitAnimationStart';

    jqLite.on(doc, events, animationHandlerFn);
    nodeInsertedCallbacks._initialized = true;
  }
}

/**
 * Execute muiNodeInserted callbacks
 * @param {Event} ev - The DOM event.
 */
function animationHandlerFn(ev) {
  // check animation name
  if (ev.animationName !== 'mui-node-inserted') return;

  var el = ev.target;

  // iterate through callbacks
  for (var i = nodeInsertedCallbacks.length - 1; i >= 0; i--) {
    nodeInsertedCallbacks[i](el);
  }
}

/**
 * Convert Classname object, with class as key and true/false as value, to an
 * class string.
 * @param  {Object} classes The classes
 * @return {String}         class string
 */
function classNamesFn(classes) {
  var cs = '';
  for (var i in classes) {
    cs += classes[i] ? i + ' ' : '';
  }
  return cs.trim();
}

/**
 * Check if client supports pointer events.
 */
function supportsPointerEventsFn() {
  // check cache
  if (_supportsPointerEvents !== undefined) return _supportsPointerEvents;

  var element = document.createElement('x');
  element.style.cssText = 'pointer-events:auto';
  _supportsPointerEvents = element.style.pointerEvents === 'auto';
  return _supportsPointerEvents;
}

/**
 * Create callback closure.
 * @param {Object} instance - The object instance.
 * @param {String} funcName - The name of the callback function.
 */
function callbackFn(instance, funcName) {
  return function () {
    instance[funcName].apply(instance, arguments);
  };
}

/**
 * Dispatch event.
 * @param {Element} element - The DOM element.
 * @param {String} eventType - The event type.
 * @param {Boolean} bubbles=true - If true, event bubbles.
 * @param {Boolean} cancelable=true = If true, event is cancelable
 * @param {Object} [data] - Data to add to event object
 */
function dispatchEventFn(element, eventType, bubbles, cancelable, data) {
  var ev = document.createEvent('HTMLEvents'),
      bubbles = bubbles !== undefined ? bubbles : true,
      cancelable = cancelable !== undefined ? cancelable : true,
      k;

  ev.initEvent(eventType, bubbles, cancelable);

  // add data to event object
  if (data) for (k in data) {
    ev[k] = data[k];
  } // dispatch
  if (element) element.dispatchEvent(ev);

  return ev;
}

/**
 * Turn on window scroll lock.
 */
function enableScrollLockFn() {
  // increment counter
  scrollLock += 1;

  // add lock
  if (scrollLock === 1) {
    var win = window,
        doc = document;

    scrollLockPos = { left: jqLite.scrollLeft(win), top: jqLite.scrollTop(win) };
    jqLite.addClass(doc.body, scrollLockCls);
    win.scrollTo(scrollLockPos.left, scrollLockPos.top);
  }
}

/**
 * Turn off window scroll lock.
 */
function disableScrollLockFn() {
  // ignore
  if (scrollLock === 0) return;

  // decrement counter
  scrollLock -= 1;

  // remove lock
  if (scrollLock === 0) {
    var win = window,
        doc = document;

    jqLite.removeClass(doc.body, scrollLockCls);
    win.scrollTo(scrollLockPos.left, scrollLockPos.top);
  }
}

/**
 * requestAnimationFrame polyfilled
 * @param {Function} callback - The callback function
 */
function requestAnimationFrameFn(callback) {
  var fn = window.requestAnimationFrame;
  if (fn) fn(callback);else setTimeout(callback, 0);
}

/**
 * Define the module API
 */
module.exports = {
  /** Create callback closures */
  callback: callbackFn,

  /** Classnames object to string */
  classNames: classNamesFn,

  /** Disable scroll lock */
  disableScrollLock: disableScrollLockFn,

  /** Dispatch event */
  dispatchEvent: dispatchEventFn,

  /** Enable scroll lock */
  enableScrollLock: enableScrollLockFn,

  /** Log messages to the console when debug is turned on */
  log: logFn,

  /** Load CSS text as new stylesheet */
  loadStyle: loadStyleFn,

  /** Register muiNodeInserted handler */
  onNodeInserted: onNodeInsertedFn,

  /** Raise MUI error */
  raiseError: raiseErrorFn,

  /** Request animation frame */
  requestAnimationFrame: requestAnimationFrameFn,

  /** Support Pointer Events check */
  supportsPointerEvents: supportsPointerEventsFn
};

},{"../config":2,"./jqLite":4}],6:[function(require,module,exports){
/**
 * MUI React helpers
 * @module react/_helpers
 */

'use strict';

var controlledMessage = 'You provided a `value` prop to a form field ' + 'without an `OnChange` handler. Please see React documentation on ' + 'controlled components';

/** Module export */
module.exports = { controlledMessage: controlledMessage };

},{}],7:[function(require,module,exports){
/**
 * MUI React button module
 * @module react/button
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

var _jqLite = require('../js/lib/jqLite');

var jqLite = babelHelpers.interopRequireWildcard(_jqLite);

var _util = require('../js/lib/util');

var util = babelHelpers.interopRequireWildcard(_util);


var PropTypes = _react2.default.PropTypes,
    btnClass = 'mui-btn',
    btnAttrs = { color: 1, variant: 1, size: 1 },
    animationDuration = 600;

/**
 * Button element
 * @class
 */

var Button = function (_React$Component) {
  babelHelpers.inherits(Button, _React$Component);

  function Button(props) {
    babelHelpers.classCallCheck(this, Button);

    var _this = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Button).call(this, props));

    _this.state = {
      ripples: {}
    };

    _this.rippleTimers = [];

    var cb = util.callback;
    _this.onMouseDownCB = cb(_this, 'onMouseDown');
    _this.onMouseUpCB = cb(_this, 'onMouseUp');
    _this.onMouseLeaveCB = cb(_this, 'onMouseLeave');
    _this.onTouchStartCB = cb(_this, 'onTouchStart');
    _this.onTouchEndCB = cb(_this, 'onTouchEnd');
    return _this;
  }

  babelHelpers.createClass(Button, [{
    key: 'componentDidMount',
    value: function componentDidMount() {
      // disable MUI js
      var el = this.refs.buttonEl;
      el._muiDropdown = true;
      el._muiRipple = true;
    }
  }, {
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      // clear ripple timers
      var timers = this.rippleTimers,
          i = timers.length;

      while (i--) {
        clearTimeout(timers[i]);
      }
    }
  }, {
    key: 'onMouseDown',
    value: function onMouseDown(ev) {
      this.addRipple(ev);

      // execute callback
      var fn = this.props.onMouseDown;
      fn && fn(ev);
    }
  }, {
    key: 'onMouseUp',
    value: function onMouseUp(ev) {
      this.removeRipples(ev);

      // execute callback
      var fn = this.props.onMouseUp;
      fn && fn(ev);
    }
  }, {
    key: 'onMouseLeave',
    value: function onMouseLeave(ev) {
      this.removeRipples(ev);

      // execute callback
      var fn = this.props.onMouseLeave;
      fn && fn(ev);
    }
  }, {
    key: 'onTouchStart',
    value: function onTouchStart(ev) {
      this.addRipple(ev);

      // execute callback
      var fn = this.props.onTouchStart;
      fn && fn(ev);
    }
  }, {
    key: 'onTouchEnd',
    value: function onTouchEnd(ev) {
      this.removeRipples(ev);

      // execute callback
      var fn = this.props.onTouchEnd;
      fn && fn(ev);
    }
  }, {
    key: 'addRipple',
    value: function addRipple(ev) {
      var buttonEl = this.refs.buttonEl;

      // de-dupe touch events
      if ('ontouchstart' in buttonEl && ev.type === 'mousedown') return;

      // get (x, y) position of click
      var offset = jqLite.offset(this.refs.buttonEl),
          clickEv = void 0;

      if (ev.type === 'touchstart' && ev.touches) clickEv = ev.touches[0];else clickEv = ev;

      // choose diameter
      var diameter = Math.sqrt(offset.width * offset.width + offset.height * offset.height) * 2;

      // add ripple to state
      var ripples = this.state.ripples;
      var key = Date.now();

      ripples[key] = {
        xPos: clickEv.pageX - offset.left,
        yPos: clickEv.pageY - offset.top,
        diameter: diameter,
        animateOut: false
      };

      this.setState({ ripples: ripples });
    }
  }, {
    key: 'removeRipples',
    value: function removeRipples(ev) {
      var _this2 = this;

      // animate out ripples
      var ripples = this.state.ripples,
          deleteKeys = Object.keys(ripples),
          k = void 0;

      for (k in ripples) {
        ripples[k].animateOut = true;
      }this.setState({ ripples: ripples });

      // remove ripples after animation
      var timer = setTimeout(function () {
        var ripples = _this2.state.ripples,
            i = deleteKeys.length;

        while (i--) {
          delete ripples[deleteKeys[i]];
        }_this2.setState({ ripples: ripples });
      }, animationDuration);

      this.rippleTimers.push(timer);
    }
  }, {
    key: 'render',
    value: function render() {
      var cls = btnClass,
          k = void 0,
          v = void 0;

      var ripples = this.state.ripples;
      var _props = this.props;
      var color = _props.color;
      var size = _props.size;
      var variant = _props.variant;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['color', 'size', 'variant']);

      // button attributes

      for (k in btnAttrs) {
        v = this.props[k];
        if (v !== 'default') cls += ' ' + btnClass + '--' + v;
      }

      return _react2.default.createElement(
        'button',
        babelHelpers.extends({}, reactProps, {
          ref: 'buttonEl',
          className: cls + ' ' + this.props.className,
          onMouseUp: this.onMouseUpCB,
          onMouseDown: this.onMouseDownCB,
          onMouseLeave: this.onMouseLeaveCB,
          onTouchStart: this.onTouchStartCB,
          onTouchEnd: this.onTouchEndCB
        }),
        this.props.children,
        Object.keys(ripples).map(function (k, i) {
          var v = ripples[k];

          return _react2.default.createElement(Ripple, {
            key: k,
            xPos: v.xPos,
            yPos: v.yPos,
            diameter: v.diameter,
            animateOut: v.animateOut
          });
        })
      );
    }
  }]);
  return Button;
}(_react2.default.Component);

/**
 * Ripple component
 * @class
 */


Button.propTypes = {
  color: PropTypes.oneOf(['default', 'primary', 'danger', 'dark', 'accent']),
  size: PropTypes.oneOf(['default', 'small', 'large']),
  variant: PropTypes.oneOf(['default', 'flat', 'raised', 'fab'])
};
Button.defaultProps = {
  className: '',
  color: 'default',
  size: 'default',
  variant: 'default'
};

var Ripple = function (_React$Component2) {
  babelHelpers.inherits(Ripple, _React$Component2);

  function Ripple() {
    var _Object$getPrototypeO;

    var _temp, _this3, _ret;

    babelHelpers.classCallCheck(this, Ripple);

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

    return _ret = (_temp = (_this3 = babelHelpers.possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(Ripple)).call.apply(_Object$getPrototypeO, [this].concat(args))), _this3), _this3.state = {
      animateIn: false
    }, _temp), babelHelpers.possibleConstructorReturn(_this3, _ret);
  }

  babelHelpers.createClass(Ripple, [{
    key: 'componentDidMount',
    value: function componentDidMount() {
      var _this4 = this;

      util.requestAnimationFrame(function () {
        _this4.setState({ animateIn: true });
      });
    }
  }, {
    key: 'render',
    value: function render() {
      var diameter = this.props.diameter,
          radius = diameter / 2;

      var style = {
        height: diameter,
        width: diameter,
        top: this.props.yPos - radius || 0,
        left: this.props.xPos - radius || 0
      };

      // define class
      var cls = 'mui-ripple-effect';
      if (this.state.animateIn) cls += ' mui--animate-in mui--active';
      if (this.props.animateOut) cls += ' mui--animate-out';

      return _react2.default.createElement('div', { className: cls, style: style });
    }
  }]);
  return Ripple;
}(_react2.default.Component);

/** Define module API */


Ripple.propTypes = {
  xPos: PropTypes.number,
  yPos: PropTypes.number,
  diameter: PropTypes.number,
  animateOut: PropTypes.bool
};
Ripple.defaultProps = {
  xPos: 0,
  yPos: 0,
  diameter: 0,
  animateOut: false
};
exports.default = Button;
module.exports = exports['default'];

},{"../js/lib/jqLite":4,"../js/lib/util":5,"react":"CwoHg3"}],8:[function(require,module,exports){
/**
 * MUI React Caret Module
 * @module react/caret
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

/**
 * Caret constructor
 * @class
 */

var Caret = function (_React$Component) {
  babelHelpers.inherits(Caret, _React$Component);

  function Caret() {
    babelHelpers.classCallCheck(this, Caret);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Caret).apply(this, arguments));
  }

  babelHelpers.createClass(Caret, [{
    key: 'render',
    value: function render() {
      var _props = this.props;
      var children = _props.children;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children']);


      return _react2.default.createElement('span', babelHelpers.extends({}, reactProps, {
        className: 'mui-caret ' + this.props.className
      }));
    }
  }]);
  return Caret;
}(_react2.default.Component);

/** Define module API */


Caret.defaultProps = {
  className: ''
};
exports.default = Caret;
module.exports = exports['default'];

},{"react":"CwoHg3"}],9:[function(require,module,exports){
/**
 * MUI React tabs module
 * @module react/tabs
 */
/* jshint quotmark:false */
// jscs:disable validateQuoteMarks

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

var PropTypes = _react2.default.PropTypes;

/**
 * Tab constructor
 * @class
 */

var Tab = function (_React$Component) {
  babelHelpers.inherits(Tab, _React$Component);

  function Tab() {
    babelHelpers.classCallCheck(this, Tab);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Tab).apply(this, arguments));
  }

  babelHelpers.createClass(Tab, [{
    key: 'render',
    value: function render() {
      return null;
    }
  }]);
  return Tab;
}(_react2.default.Component);

/** Define module API */


Tab.propTypes = {
  value: PropTypes.any,
  label: PropTypes.string,
  onActive: PropTypes.func
};
Tab.defaultProps = {
  value: null,
  label: '',
  onActive: null
};
exports.default = Tab;
module.exports = exports['default'];

},{"react":"CwoHg3"}],10:[function(require,module,exports){
/**
 * MUI React TextInput Component
 * @module react/text-field
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.TextField = undefined;

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

var _util = require('../js/lib/util');

var util = babelHelpers.interopRequireWildcard(_util);

var _helpers = require('./_helpers');

var PropTypes = _react2.default.PropTypes;

/**
 * Input constructor
 * @class
 */

var Input = function (_React$Component) {
  babelHelpers.inherits(Input, _React$Component);

  function Input(props) {
    babelHelpers.classCallCheck(this, Input);

    var _this = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Input).call(this, props));

    var value = props.value;
    var innerValue = value || props.defaultValue;

    _this.state = {
      innerValue: innerValue,
      isDirty: Boolean(innerValue)
    };

    // warn if value defined but onChange is not
    if (value !== undefined && !props.onChange) {
      util.raiseError(_helpers.controlledMessage, true);
    }

    var cb = util.callback;
    _this.onChangeCB = cb(_this, 'onChange');
    _this.onFocusCB = cb(_this, 'onFocus');
    return _this;
  }

  babelHelpers.createClass(Input, [{
    key: 'componentDidMount',
    value: function componentDidMount() {
      // disable MUI js
      this.refs.inputEl._muiTextfield = true;
    }
  }, {
    key: 'onChange',
    value: function onChange(ev) {
      this.setState({ innerValue: ev.target.value });

      // execute callback
      var fn = this.props.onChange;
      if (fn) fn(ev);
    }
  }, {
    key: 'onFocus',
    value: function onFocus(ev) {
      this.setState({ isDirty: true });
    }
  }, {
    key: 'triggerFocus',
    value: function triggerFocus() {
      // hack to enable IE10 pointer-events shim
      this.refs.inputEl.focus();
    }
  }, {
    key: 'render',
    value: function render() {
      var cls = {},
          isNotEmpty = Boolean(this.state.innerValue),
          inputEl = void 0;

      var _props = this.props;
      var hint = _props.hint;
      var invalid = _props.invalid;
      var rows = _props.rows;
      var type = _props.type;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['hint', 'invalid', 'rows', 'type']);


      cls['mui--is-empty'] = !isNotEmpty;
      cls['mui--is-not-empty'] = isNotEmpty;
      cls['mui--is-dirty'] = this.state.isDirty;
      cls['mui--is-invalid'] = invalid;

      cls = util.classNames(cls);

      if (type === 'textarea') {
        inputEl = _react2.default.createElement('textarea', babelHelpers.extends({}, reactProps, {
          ref: 'inputEl',
          className: cls,
          rows: rows,
          placeholder: hint,
          onChange: this.onChangeCB,
          onFocus: this.onFocusCB
        }));
      } else {
        inputEl = _react2.default.createElement('input', babelHelpers.extends({}, reactProps, {
          ref: 'inputEl',
          className: cls,
          type: type,
          placeholder: this.props.hint,
          onChange: this.onChangeCB,
          onFocus: this.onFocusCB
        }));
      }

      return inputEl;
    }
  }]);
  return Input;
}(_react2.default.Component);

/**
 * Label constructor
 * @class
 */


Input.propTypes = {
  hint: PropTypes.string,
  invalid: PropTypes.bool,
  rows: PropTypes.number
};
Input.defaultProps = {
  hint: null,
  invalid: false,
  rows: 2
};

var Label = function (_React$Component2) {
  babelHelpers.inherits(Label, _React$Component2);

  function Label() {
    var _Object$getPrototypeO;

    var _temp, _this2, _ret;

    babelHelpers.classCallCheck(this, Label);

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

    return _ret = (_temp = (_this2 = babelHelpers.possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(Label)).call.apply(_Object$getPrototypeO, [this].concat(args))), _this2), _this2.state = {
      style: {}
    }, _temp), babelHelpers.possibleConstructorReturn(_this2, _ret);
  }

  babelHelpers.createClass(Label, [{
    key: 'componentDidMount',
    value: function componentDidMount() {
      var _this3 = this;

      this.styleTimer = setTimeout(function () {
        var s = '.15s ease-out';
        var style = void 0;

        style = {
          transition: s,
          WebkitTransition: s,
          MozTransition: s,
          OTransition: s,
          msTransform: s
        };

        _this3.setState({ style: style });
      }, 150);
    }
  }, {
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      // clear timer
      clearTimeout(this.styleTimer);
    }
  }, {
    key: 'render',
    value: function render() {
      return _react2.default.createElement(
        'label',
        {
          style: this.state.style,
          onClick: this.props.onClick
        },
        this.props.text
      );
    }
  }]);
  return Label;
}(_react2.default.Component);

/**
 * TextField constructor
 * @class
 */


Label.defaultProps = {
  text: '',
  onClick: null
};

var TextField = function (_React$Component3) {
  babelHelpers.inherits(TextField, _React$Component3);

  function TextField(props) {
    babelHelpers.classCallCheck(this, TextField);

    var _this4 = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(TextField).call(this, props));

    _this4.onClickCB = util.callback(_this4, 'onClick');
    return _this4;
  }

  babelHelpers.createClass(TextField, [{
    key: 'onClick',
    value: function onClick(ev) {
      // pointer-events shim
      if (util.supportsPointerEvents() === false) {
        ev.target.style.cursor = 'text';
        this.refs.inputEl.triggerFocus();
      }
    }
  }, {
    key: 'render',
    value: function render() {
      var cls = {},
          labelEl = void 0;

      var _props2 = this.props;
      var children = _props2.children;
      var className = _props2.className;
      var style = _props2.style;
      var label = _props2.label;
      var floatingLabel = _props2.floatingLabel;
      var other = babelHelpers.objectWithoutProperties(_props2, ['children', 'className', 'style', 'label', 'floatingLabel']);


      if (label.length) {
        labelEl = _react2.default.createElement(Label, { text: label, onClick: this.onClickCB });
      }

      cls['mui-textfield'] = true;
      cls['mui-textfield--float-label'] = floatingLabel;
      cls = util.classNames(cls);

      return _react2.default.createElement(
        'div',
        {
          className: cls + ' ' + className,
          style: style
        },
        _react2.default.createElement(Input, babelHelpers.extends({ ref: 'inputEl' }, other)),
        labelEl
      );
    }
  }]);
  return TextField;
}(_react2.default.Component);

/** Define module API */


TextField.propTypes = {
  label: PropTypes.string,
  floatingLabel: PropTypes.bool
};
TextField.defaultProps = {
  className: '',
  label: '',
  floatingLabel: false
};
exports.TextField = TextField;

},{"../js/lib/util":5,"./_helpers":6,"react":"CwoHg3"}],11:[function(require,module,exports){
/**
 * MUI React Appbar Module
 * @module react/appbar
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

/**
 * Appbar constructor
 * @class
 */

var Appbar = function (_React$Component) {
  babelHelpers.inherits(Appbar, _React$Component);

  function Appbar() {
    babelHelpers.classCallCheck(this, Appbar);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Appbar).apply(this, arguments));
  }

  babelHelpers.createClass(Appbar, [{
    key: 'render',
    value: function render() {
      var _props = this.props;
      var children = _props.children;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children']);


      return _react2.default.createElement(
        'div',
        babelHelpers.extends({}, reactProps, {
          className: 'mui-appbar ' + this.props.className
        }),
        children
      );
    }
  }]);
  return Appbar;
}(_react2.default.Component);

/** Define module API */


Appbar.defaultProps = {
  className: ''
};
exports.default = Appbar;
module.exports = exports['default'];

},{"react":"CwoHg3"}],12:[function(require,module,exports){
module.exports=require(7)
},{"../js/lib/jqLite":4,"../js/lib/util":5,"react":"CwoHg3"}],13:[function(require,module,exports){
module.exports=require(8)
},{"react":"CwoHg3"}],14:[function(require,module,exports){
/**
 * MUI React checkbox module
 * @module react/checkbox
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

var _util = require('../js/lib/util');

var util = babelHelpers.interopRequireWildcard(_util);

var _helpers = require('./_helpers');

var PropTypes = _react2.default.PropTypes;

/**
 * Checkbox constructor
 * @class
 */

var Checkbox = function (_React$Component) {
  babelHelpers.inherits(Checkbox, _React$Component);

  function Checkbox() {
    babelHelpers.classCallCheck(this, Checkbox);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Checkbox).apply(this, arguments));
  }

  babelHelpers.createClass(Checkbox, [{
    key: 'render',
    value: function render() {
      var _props = this.props;
      var children = _props.children;
      var className = _props.className;
      var label = _props.label;
      var autoFocus = _props.autoFocus;
      var checked = _props.checked;
      var defaultChecked = _props.defaultChecked;
      var defaultValue = _props.defaultValue;
      var disabled = _props.disabled;
      var form = _props.form;
      var name = _props.name;
      var required = _props.required;
      var value = _props.value;
      var onChange = _props.onChange;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children', 'className', 'label', 'autoFocus', 'checked', 'defaultChecked', 'defaultValue', 'disabled', 'form', 'name', 'required', 'value', 'onChange']);


      return _react2.default.createElement(
        'div',
        babelHelpers.extends({}, reactProps, {
          className: 'mui-checkbox ' + className
        }),
        _react2.default.createElement(
          'label',
          null,
          _react2.default.createElement('input', {
            ref: 'inputEl',
            type: 'checkbox',
            autoFocus: autoFocus,
            checked: checked,
            defaultChecked: defaultChecked,
            defaultValue: defaultValue,
            disabled: disabled,
            form: form,
            name: name,
            required: required,
            value: value,
            onChange: onChange
          }),
          label
        )
      );
    }
  }]);
  return Checkbox;
}(_react2.default.Component);

/** Define module API */


Checkbox.propTypes = {
  label: PropTypes.string
};
Checkbox.defaultProps = {
  className: '',
  label: null
};
exports.default = Checkbox;
module.exports = exports['default'];

},{"../js/lib/util":5,"./_helpers":6,"react":"CwoHg3"}],15:[function(require,module,exports){
/**
 * MUI React Col Component
 * @module react/col
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

var _util = require('../js/lib/util');

var util = babelHelpers.interopRequireWildcard(_util);


var breakpoints = ['xs', 'sm', 'md', 'lg', 'xl'];

/**
 * Col constructor
 * @class
 */

var Col = function (_React$Component) {
  babelHelpers.inherits(Col, _React$Component);

  function Col() {
    babelHelpers.classCallCheck(this, Col);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Col).apply(this, arguments));
  }

  babelHelpers.createClass(Col, [{
    key: 'defaultProps',
    value: function defaultProps() {
      var props = { className: '' },
          i = void 0,
          v = void 0;

      // add {breakpoint}, {breakpoint}-offset to props
      for (i = breakpoints.length - 1; i > -1; i--) {
        v = breakpoints[i];
        props[v] = null;
        props[v + '-offset'] = null;
      }

      return props;
    }
  }, {
    key: 'render',
    value: function render() {
      var cls = {},
          i = void 0,
          bk = void 0,
          val = void 0,
          baseCls = void 0;

      var _props = this.props;
      var children = _props.children;
      var className = _props.className;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children', 'className']);

      // add mui-col classes

      for (i = breakpoints.length - 1; i > -1; i--) {
        bk = breakpoints[i];
        baseCls = 'mui-col-' + bk;

        // add mui-col-{bk}-{val}
        val = this.props[bk];
        if (val) cls[baseCls + '-' + val] = true;

        // add mui-col-{bk}-offset-{val}
        val = this.props[bk + '-offset'];
        if (val) cls[baseCls + '-offset-' + val] = true;

        // remove from reactProps
        delete reactProps[bk];
        delete reactProps[bk + '-offset'];
      }

      cls = util.classNames(cls);

      return _react2.default.createElement(
        'div',
        babelHelpers.extends({}, reactProps, {
          className: cls + ' ' + className
        }),
        children
      );
    }
  }]);
  return Col;
}(_react2.default.Component);

/** Define module API */


exports.default = Col;
module.exports = exports['default'];

},{"../js/lib/util":5,"react":"CwoHg3"}],16:[function(require,module,exports){
/**
 * MUI React container module
 * @module react/container
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

/**
 * Container constructor
 * @class
 */

var Container = function (_React$Component) {
  babelHelpers.inherits(Container, _React$Component);

  function Container() {
    babelHelpers.classCallCheck(this, Container);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Container).apply(this, arguments));
  }

  babelHelpers.createClass(Container, [{
    key: 'render',
    value: function render() {
      var _props = this.props;
      var children = _props.children;
      var className = _props.className;
      var fluid = _props.fluid;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children', 'className', 'fluid']);


      var cls = 'mui-container';

      // fluid containers
      if (fluid) cls += '-fluid';

      return _react2.default.createElement(
        'div',
        babelHelpers.extends({}, reactProps, {
          className: cls + ' ' + className
        }),
        children
      );
    }
  }]);
  return Container;
}(_react2.default.Component);

/** Define module API */


Container.propTypes = {
  fluid: _react2.default.PropTypes.bool
};
Container.defaultProps = {
  className: '',
  fluid: false
};
exports.default = Container;
module.exports = exports['default'];

},{"react":"CwoHg3"}],17:[function(require,module,exports){
/**
 * MUI React divider module
 * @module react/divider
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

/**
 * Divider constructor
 * @class
 */

var Divider = function (_React$Component) {
  babelHelpers.inherits(Divider, _React$Component);

  function Divider() {
    babelHelpers.classCallCheck(this, Divider);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Divider).apply(this, arguments));
  }

  babelHelpers.createClass(Divider, [{
    key: 'render',
    value: function render() {
      var _props = this.props;
      var children = _props.children;
      var className = _props.className;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children', 'className']);


      return _react2.default.createElement('div', babelHelpers.extends({}, reactProps, {
        className: 'mui-divider ' + className
      }));
    }
  }]);
  return Divider;
}(_react2.default.Component);

/** Define module API */


Divider.defaultProps = {
  className: ''
};
exports.default = Divider;
module.exports = exports['default'];

},{"react":"CwoHg3"}],18:[function(require,module,exports){
/**
 * MUI React dropdowns module
 * @module react/dropdowns
 */
/* jshint quotmark:false */
// jscs:disable validateQuoteMarks

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

var _util = require('../js/lib/util');

var util = babelHelpers.interopRequireWildcard(_util);


var PropTypes = _react2.default.PropTypes;

/**
 * DropdownItem constructor
 * @class
 */

var DropdownItem = function (_React$Component) {
  babelHelpers.inherits(DropdownItem, _React$Component);

  function DropdownItem() {
    babelHelpers.classCallCheck(this, DropdownItem);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(DropdownItem).apply(this, arguments));
  }

  babelHelpers.createClass(DropdownItem, [{
    key: 'render',
    value: function render() {
      var _props = this.props;
      var children = _props.children;
      var link = _props.link;
      var target = _props.target;
      var value = _props.value;
      var onClick = _props.onClick;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children', 'link', 'target', 'value', 'onClick']);


      return _react2.default.createElement(
        'li',
        reactProps,
        _react2.default.createElement(
          'a',
          {
            href: link,
            target: target,
            'data-mui-value': value,
            onClick: onClick
          },
          children
        )
      );
    }
  }]);
  return DropdownItem;
}(_react2.default.Component);

/** Define module API */


DropdownItem.propTypes = {
  link: PropTypes.string,
  target: PropTypes.string,
  onClick: PropTypes.func
};
exports.default = DropdownItem;
module.exports = exports['default'];

},{"../js/lib/util":5,"react":"CwoHg3"}],19:[function(require,module,exports){
/**
 * MUI React dropdowns module
 * @module react/dropdowns
 */
/* jshint quotmark:false */
// jscs:disable validateQuoteMarks

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

var _button = require('./button');

var _button2 = babelHelpers.interopRequireDefault(_button);

var _caret = require('./caret');

var _caret2 = babelHelpers.interopRequireDefault(_caret);

var _jqLite = require('../js/lib/jqLite');

var jqLite = babelHelpers.interopRequireWildcard(_jqLite);

var _util = require('../js/lib/util');

var util = babelHelpers.interopRequireWildcard(_util);


var PropTypes = _react2.default.PropTypes,
    dropdownClass = 'mui-dropdown',
    menuClass = 'mui-dropdown__menu',
    openClass = 'mui--is-open',
    rightClass = 'mui-dropdown__menu--right';

/**
 * Dropdown constructor
 * @class
 */

var Dropdown = function (_React$Component) {
  babelHelpers.inherits(Dropdown, _React$Component);

  function Dropdown(props) {
    babelHelpers.classCallCheck(this, Dropdown);

    var _this = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Dropdown).call(this, props));

    _this.state = {
      opened: false,
      menuTop: 0
    };

    var cb = util.callback;
    _this.selectCB = cb(_this, 'select');
    _this.onClickCB = cb(_this, 'onClick');
    _this.onOutsideClickCB = cb(_this, 'onOutsideClick');
    return _this;
  }

  babelHelpers.createClass(Dropdown, [{
    key: 'componentDidMount',
    value: function componentDidMount() {
      document.addEventListener('click', this.onOutsideClickCB);
    }
  }, {
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      document.removeEventListener('click', this.onOutsideClickCB);
    }
  }, {
    key: 'onClick',
    value: function onClick(ev) {
      // only left clicks
      if (ev.button !== 0) return;

      // exit if toggle button is disabled
      if (this.props.disabled) return;

      if (!ev.defaultPrevented) {
        this.toggle();

        // execute <Dropdown> onClick method
        var onClickFn = this.props.onClick;
        onClickFn && onClickFn(ev);
      }
    }
  }, {
    key: 'toggle',
    value: function toggle() {
      // exit if no menu element
      if (!this.props.children) {
        return util.raiseError('Dropdown menu element not found');
      }

      if (this.state.opened) this.close();else this.open();
    }
  }, {
    key: 'open',
    value: function open() {
      // position menu element below toggle button
      var wrapperRect = this.refs.wrapperEl.getBoundingClientRect(),
          toggleRect = void 0;

      toggleRect = this.refs.button.refs.buttonEl.getBoundingClientRect();

      this.setState({
        opened: true,
        menuTop: toggleRect.top - wrapperRect.top + toggleRect.height
      });
    }
  }, {
    key: 'close',
    value: function close() {
      this.setState({ opened: false });
    }
  }, {
    key: 'select',
    value: function select(ev) {
      // onSelect callback
      if (this.props.onSelect && ev.target.tagName === 'A') {
        this.props.onSelect(ev.target.getAttribute('data-mui-value'));
      }

      // close menu
      if (!ev.defaultPrevented) this.close();
    }
  }, {
    key: 'onOutsideClick',
    value: function onOutsideClick(ev) {
      var isClickInside = this.refs.wrapperEl.contains(ev.target);
      if (!isClickInside) this.close();
    }
  }, {
    key: 'render',
    value: function render() {
      var buttonEl = void 0,
          menuEl = void 0,
          labelEl = void 0;

      var _props = this.props;
      var children = _props.children;
      var className = _props.className;
      var color = _props.color;
      var variant = _props.variant;
      var size = _props.size;
      var label = _props.label;
      var alignMenu = _props.alignMenu;
      var onClick = _props.onClick;
      var onSelect = _props.onSelect;
      var disabled = _props.disabled;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children', 'className', 'color', 'variant', 'size', 'label', 'alignMenu', 'onClick', 'onSelect', 'disabled']);

      // build label

      if (jqLite.type(label) === 'string') {
        labelEl = _react2.default.createElement(
          'span',
          null,
          label,
          ' ',
          _react2.default.createElement(_caret2.default, null)
        );
      } else {
        labelEl = label;
      }

      buttonEl = _react2.default.createElement(
        _button2.default,
        {
          ref: 'button',
          type: 'button',
          onClick: this.onClickCB,
          color: color,
          variant: variant,
          size: size,
          disabled: disabled
        },
        labelEl
      );

      if (this.state.opened) {
        var cs = {};

        cs[menuClass] = true;
        cs[openClass] = this.state.opened;
        cs[rightClass] = alignMenu === 'right';
        cs = util.classNames(cs);

        menuEl = _react2.default.createElement(
          'ul',
          {
            ref: 'menuEl',
            className: cs,
            style: { top: this.state.menuTop },
            onClick: this.selectCB
          },
          children
        );
      } else {
        menuEl = _react2.default.createElement('div', null);
      }

      return _react2.default.createElement(
        'div',
        babelHelpers.extends({}, reactProps, {
          ref: 'wrapperEl',
          className: dropdownClass + ' ' + className
        }),
        buttonEl,
        menuEl
      );
    }
  }]);
  return Dropdown;
}(_react2.default.Component);

/** Define module API */


Dropdown.propTypes = {
  color: PropTypes.oneOf(['default', 'primary', 'danger', 'dark', 'accent']),
  variant: PropTypes.oneOf(['default', 'flat', 'raised', 'fab']),
  size: PropTypes.oneOf(['default', 'small', 'large']),
  label: PropTypes.oneOfType([PropTypes.string, PropTypes.element]),
  alignMenu: PropTypes.oneOf(['left', 'right']),
  onClick: PropTypes.func,
  onSelect: PropTypes.func,
  disabled: PropTypes.bool
};
Dropdown.defaultProps = {
  className: '',
  color: 'default',
  variant: 'default',
  size: 'default',
  label: '',
  alignMenu: 'left',
  onClick: null,
  onSelect: null,
  disabled: false
};
exports.default = Dropdown;
module.exports = exports['default'];

},{"../js/lib/jqLite":4,"../js/lib/util":5,"./button":7,"./caret":8,"react":"CwoHg3"}],20:[function(require,module,exports){
/**
 * MUI React form module
 * @module react/form
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

/**
 * Form constructor
 * @class
 */

var Form = function (_React$Component) {
  babelHelpers.inherits(Form, _React$Component);

  function Form() {
    babelHelpers.classCallCheck(this, Form);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Form).apply(this, arguments));
  }

  babelHelpers.createClass(Form, [{
    key: 'render',
    value: function render() {
      var _props = this.props;
      var children = _props.children;
      var className = _props.className;
      var inline = _props.inline;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children', 'className', 'inline']);

      var cls = '';

      // inline form
      if (inline) cls = 'mui-form--inline';

      return _react2.default.createElement(
        'form',
        babelHelpers.extends({}, reactProps, {
          className: cls + ' ' + className
        }),
        children
      );
    }
  }]);
  return Form;
}(_react2.default.Component);

/** Define module API */


Form.propTypes = {
  inline: _react2.default.PropTypes.bool
};
Form.defaultProps = {
  className: '',
  inline: false
};
exports.default = Form;
module.exports = exports['default'];

},{"react":"CwoHg3"}],21:[function(require,module,exports){
/**                                                                            
 * MUI React Input Component
 * @module react/input
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

var _textField = require('./text-field');

var PropTypes = _react2.default.PropTypes;

/**
 * Input constructor
 * @class
 */

var Input = function (_React$Component) {
  babelHelpers.inherits(Input, _React$Component);

  function Input() {
    babelHelpers.classCallCheck(this, Input);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Input).apply(this, arguments));
  }

  babelHelpers.createClass(Input, [{
    key: 'render',
    value: function render() {
      return _react2.default.createElement(_textField.TextField, this.props);
    }
  }]);
  return Input;
}(_react2.default.Component);

Input.propTypes = {
  type: PropTypes.oneOf(['text', 'email', 'url', 'tel', 'password'])
};
Input.defaultProps = {
  type: 'text'
};
exports.default = Input;
module.exports = exports['default'];

},{"./text-field":10,"react":"CwoHg3"}],22:[function(require,module,exports){
/**
 * MUI React options module
 * @module react/option
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

var _forms = require('../js/lib/forms');

var formlib = babelHelpers.interopRequireWildcard(_forms);

var _jqLite = require('../js/lib/jqLite');

var jqLite = babelHelpers.interopRequireWildcard(_jqLite);

var _util = require('../js/lib/util');

var util = babelHelpers.interopRequireWildcard(_util);

var _helpers = require('./_helpers');

var PropTypes = _react2.default.PropTypes;

/**
 * Option constructor
 * @class
 */

var Option = function (_React$Component) {
  babelHelpers.inherits(Option, _React$Component);

  function Option() {
    babelHelpers.classCallCheck(this, Option);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Option).apply(this, arguments));
  }

  babelHelpers.createClass(Option, [{
    key: 'render',
    value: function render() {
      var _props = this.props;
      var children = _props.children;
      var label = _props.label;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children', 'label']);


      return _react2.default.createElement(
        'option',
        reactProps,
        label
      );
    }
  }]);
  return Option;
}(_react2.default.Component);

/** Define module API */


Option.propTypes = {
  label: PropTypes.string
};
Option.defaultProps = {
  label: null
};
exports.default = Option;
module.exports = exports['default'];

},{"../js/lib/forms":3,"../js/lib/jqLite":4,"../js/lib/util":5,"./_helpers":6,"react":"CwoHg3"}],23:[function(require,module,exports){
/**
 * MUI React layout module
 * @module react/layout
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

/**
 * Panel constructor
 * @class
 */

var Panel = function (_React$Component) {
  babelHelpers.inherits(Panel, _React$Component);

  function Panel() {
    babelHelpers.classCallCheck(this, Panel);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Panel).apply(this, arguments));
  }

  babelHelpers.createClass(Panel, [{
    key: 'render',
    value: function render() {
      var _props = this.props;
      var children = _props.children;
      var className = _props.className;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children', 'className']);


      return _react2.default.createElement(
        'div',
        babelHelpers.extends({}, reactProps, {
          className: 'mui-panel ' + className
        }),
        children
      );
    }
  }]);
  return Panel;
}(_react2.default.Component);

/** Define module API */


Panel.defaultProps = {
  className: ''
};
exports.default = Panel;
module.exports = exports['default'];

},{"react":"CwoHg3"}],24:[function(require,module,exports){
/**
 * MUI React radio module
 * @module react/radio
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

var PropTypes = _react2.default.PropTypes;

/**
 * Radio constructor
 * @class
 */

var Radio = function (_React$Component) {
  babelHelpers.inherits(Radio, _React$Component);

  function Radio() {
    babelHelpers.classCallCheck(this, Radio);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Radio).apply(this, arguments));
  }

  babelHelpers.createClass(Radio, [{
    key: 'render',
    value: function render() {
      var _props = this.props;
      var children = _props.children;
      var className = _props.className;
      var label = _props.label;
      var autoFocus = _props.autoFocus;
      var checked = _props.checked;
      var defaultChecked = _props.defaultChecked;
      var defaultValue = _props.defaultValue;
      var disabled = _props.disabled;
      var form = _props.form;
      var name = _props.name;
      var required = _props.required;
      var value = _props.value;
      var onChange = _props.onChange;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children', 'className', 'label', 'autoFocus', 'checked', 'defaultChecked', 'defaultValue', 'disabled', 'form', 'name', 'required', 'value', 'onChange']);


      return _react2.default.createElement(
        'div',
        babelHelpers.extends({}, reactProps, {
          className: 'mui-radio ' + className
        }),
        _react2.default.createElement(
          'label',
          null,
          _react2.default.createElement('input', {
            ref: 'inputEl',
            type: 'radio',
            autoFocus: autoFocus,
            checked: checked,
            defaultChecked: defaultChecked,
            defaultValue: defaultValue,
            disabled: disabled,
            form: form,
            name: name,
            required: required,
            value: value,
            onChange: onChange
          }),
          label
        )
      );
    }
  }]);
  return Radio;
}(_react2.default.Component);

/** Define module API */


Radio.propTypes = {
  label: PropTypes.string
};
Radio.defaultProps = {
  className: '',
  label: null
};
exports.default = Radio;
module.exports = exports['default'];

},{"react":"CwoHg3"}],25:[function(require,module,exports){
/**
 * MUI React Row Component
 * @module react/row
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

var _util = require('../js/lib/util');

var util = babelHelpers.interopRequireWildcard(_util);


var breakpoints = ['xs', 'sm', 'md', 'lg'];

/**
 * Row constructor
 * @class
 */

var Row = function (_React$Component) {
  babelHelpers.inherits(Row, _React$Component);

  function Row() {
    babelHelpers.classCallCheck(this, Row);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Row).apply(this, arguments));
  }

  babelHelpers.createClass(Row, [{
    key: 'render',
    value: function render() {
      var _props = this.props;
      var children = _props.children;
      var className = _props.className;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children', 'className']);


      return _react2.default.createElement(
        'div',
        babelHelpers.extends({}, reactProps, {
          className: 'mui-row ' + className
        }),
        children
      );
    }
  }]);
  return Row;
}(_react2.default.Component);

/** Define module API */


Row.defaultProps = {
  className: ''
};
exports.default = Row;
module.exports = exports['default'];

},{"../js/lib/util":5,"react":"CwoHg3"}],26:[function(require,module,exports){
/**
 * MUI React select module
 * @module react/select
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

var _forms = require('../js/lib/forms');

var formlib = babelHelpers.interopRequireWildcard(_forms);

var _jqLite = require('../js/lib/jqLite');

var jqLite = babelHelpers.interopRequireWildcard(_jqLite);

var _util = require('../js/lib/util');

var util = babelHelpers.interopRequireWildcard(_util);

var _helpers = require('./_helpers');

var PropTypes = _react2.default.PropTypes;

/**
 * Select constructor
 * @class
 */

var Select = function (_React$Component) {
  babelHelpers.inherits(Select, _React$Component);

  function Select(props) {
    babelHelpers.classCallCheck(this, Select);


    // warn if value defined but onChange is not

    var _this = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Select).call(this, props));

    _this.state = {
      showMenu: false
    };
    if (props.readOnly === false && props.value !== undefined && props.onChange === null) {
      util.raiseError(_helpers.controlledMessage, true);
    }

    _this.state.value = props.value;

    // bind callback function
    var cb = util.callback;
    _this.hideMenuCB = cb(_this, 'hideMenu');
    _this.onInnerChangeCB = cb(_this, 'onInnerChange');
    _this.onInnerClickCB = cb(_this, 'onInnerClick');
    _this.onInnerFocusCB = cb(_this, 'onInnerFocus');
    _this.onInnerMouseDownCB = cb(_this, 'onInnerMouseDown');
    _this.onKeydownCB = cb(_this, 'onKeydown');
    _this.onMenuChangeCB = cb(_this, 'onMenuChange');
    _this.onOuterFocusCB = cb(_this, 'onOuterFocus');
    _this.onOuterBlurCB = cb(_this, 'onOuterBlur');
    return _this;
  }

  babelHelpers.createClass(Select, [{
    key: 'componentDidMount',
    value: function componentDidMount() {
      // disable MUI js
      this.refs.selectEl._muiSelect = true;

      // make wrapper element focusable (to enable Firefox bugfix)
      this.refs.wrapperEl.tabIndex = -1;

      // handle autofocus
      if (this.props.autoFocus) this.refs.wrapperEl.focus();
    }
  }, {
    key: 'componentWillReceiveProps',
    value: function componentWillReceiveProps(nextProps) {
      this.setState({ value: nextProps.value });
    }
  }, {
    key: 'onInnerMouseDown',
    value: function onInnerMouseDown(ev) {
      if (ev.button !== 0 || this.props.useDefault === true) return;
      ev.preventDefault();

      // execute callback
      var fn = this.props.onMouseDown;
      fn && fn(ev);
    }
  }, {
    key: 'onInnerChange',
    value: function onInnerChange(ev) {
      var value = ev.target.value;
      this.setState({ value: value });

      // execute callback
      var fn = this.props.onChange;
      fn && fn(value);
    }
  }, {
    key: 'onInnerClick',
    value: function onInnerClick(ev) {
      if (ev.button !== 0) return; // only left clicks
      this.showMenu();

      // execute callback
      var fn = this.props.onClick;
      fn && fn(ev);
    }
  }, {
    key: 'onInnerFocus',
    value: function onInnerFocus(ev) {
      var _this2 = this;

      // check flag
      if (this.props.useDefault === true) return;

      // defer focus to parent
      setTimeout(function () {
        _this2.refs.wrapperEl.focus();
      }, 0);
    }
  }, {
    key: 'onOuterFocus',
    value: function onOuterFocus(ev) {
      // ignore focus on inner element (react artifact)
      if (ev.target !== this.refs.wrapperEl) return;

      // disable tabfocus on inner element
      var selectEl = this.refs.selectEl;
      selectEl._muiOrigIndex = selectEl.tabIndex;
      selectEl.tabIndex = -1;

      // firefox bugfix
      if (selectEl.disabled) return this.refs.wrapperEl.blur();

      // attach keydown handler
      jqLite.on(document, 'keydown', this.onKeydownCB);

      // execute callback
      var fn = this.onFocus;
      fn && fn(ev);
    }
  }, {
    key: 'onOuterBlur',
    value: function onOuterBlur(ev) {
      // ignore blur on inner element
      if (ev.target !== this.refs.wrapperEl) return;

      // restore tab focus on inner element
      var selectEl = this.refs.selectEl;
      selectEl.tabIndex = selectEl._muiOrigIndex;

      // remove keydown handler
      jqLite.off(document, 'keydown', this.onKeydownCB);

      // execute callback
      var fn = this.onBlur;
      fn && fn(ev);
    }
  }, {
    key: 'onKeydown',
    value: function onKeydown(ev) {
      // spacebar, down, up
      if (ev.keyCode === 32 || ev.keyCode === 38 || ev.keyCode === 40) {
        // prevent win scroll
        ev.preventDefault();

        if (this.refs.selectEl.disabled !== true) this.showMenu();
      }
    }
  }, {
    key: 'showMenu',
    value: function showMenu() {
      // check useDefault flag
      if (this.props.useDefault === true) return;

      // add scroll lock
      util.enableScrollLock();

      // add event listeners
      jqLite.on(window, 'resize', this.hideMenuCB);
      jqLite.on(document, 'click', this.hideMenuCB);

      // re-draw
      this.setState({ showMenu: true });
    }
  }, {
    key: 'hideMenu',
    value: function hideMenu() {
      // remove scroll lock
      util.disableScrollLock();

      // remove event listeners
      jqLite.off(window, 'resize', this.hideMenuCB);
      jqLite.off(document, 'click', this.hideMenuCB);

      // re-draw
      this.setState({ showMenu: false });

      // refocus
      this.refs.selectEl.focus();
    }
  }, {
    key: 'onMenuChange',
    value: function onMenuChange(value) {
      if (this.props.readOnly === true) return;

      this.setState({ value: value });

      // execute onChange method
      var fn = this.props.onChange;
      if (fn) fn(value);
    }
  }, {
    key: 'render',
    value: function render() {
      var menuElem = void 0;

      if (this.state.showMenu) {
        menuElem = _react2.default.createElement(Menu, {
          optionEls: this.refs.selectEl.children,
          wrapperEl: this.refs.wrapperEl,
          onChange: this.onMenuChangeCB,
          onClose: this.hideMenuCB
        });
      }

      var _props = this.props;
      var children = _props.children;
      var className = _props.className;
      var style = _props.style;
      var label = _props.label;
      var value = _props.value;
      var defaultValue = _props.defaultValue;
      var readOnly = _props.readOnly;
      var useDefault = _props.useDefault;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children', 'className', 'style', 'label', 'value', 'defaultValue', 'readOnly', 'useDefault']);


      return _react2.default.createElement(
        'div',
        {
          ref: 'wrapperEl',
          style: style,
          className: 'mui-select ' + className,
          onFocus: this.onOuterFocusCB,
          onBlur: this.onOuterBlurCB
        },
        _react2.default.createElement(
          'select',
          babelHelpers.extends({}, reactProps, {
            ref: 'selectEl',
            value: value,
            defaultValue: defaultValue,
            readOnly: this.props.readOnly,
            onChange: this.onInnerChangeCB,
            onMouseDown: this.onInnerMouseDownCB,
            onClick: this.onInnerClickCB,
            onFocus: this.onInnerFocusCB
          }),
          children
        ),
        _react2.default.createElement(
          'label',
          null,
          label
        ),
        menuElem
      );
    }
  }]);
  return Select;
}(_react2.default.Component);

/**
 * Menu constructor
 * @class
 */


Select.propTypes = {
  label: PropTypes.string,
  value: PropTypes.string,
  defaultValue: PropTypes.string,
  readOnly: PropTypes.bool,
  useDefault: PropTypes.bool,
  onChange: PropTypes.func
};
Select.defaultProps = {
  className: '',
  readOnly: false,
  useDefault: false,
  onChange: null
};

var Menu = function (_React$Component2) {
  babelHelpers.inherits(Menu, _React$Component2);

  function Menu(props) {
    babelHelpers.classCallCheck(this, Menu);

    var _this3 = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Menu).call(this, props));

    _this3.state = {
      origIndex: null,
      currentIndex: null
    };


    _this3.onKeydownCB = util.callback(_this3, 'onKeydown');
    return _this3;
  }

  babelHelpers.createClass(Menu, [{
    key: 'componentWillMount',
    value: function componentWillMount() {
      var optionEls = this.props.optionEls,
          m = optionEls.length,
          selectedPos = 0,
          i = void 0;

      // get current selected position
      for (i = m - 1; i > -1; i--) {
        if (optionEls[i].selected) selectedPos = i;
      }this.setState({ origIndex: selectedPos, currentIndex: selectedPos });
    }
  }, {
    key: 'componentDidMount',
    value: function componentDidMount() {
      // blur active element (IE10 bugfix)
      this.blurTimer = setTimeout(function () {
        var el = document.activeElement;
        if (el.nodeName.toLowerCase() !== 'body') el.blur();
      }, 0);

      // set position
      var props = formlib.getMenuPositionalCSS(this.props.wrapperEl, this.props.optionEls.length, this.state.currentIndex);

      var el = this.refs.wrapperEl;
      jqLite.css(el, props);
      jqLite.scrollTop(el, props.scrollTop);

      // attach keydown handler
      jqLite.on(document, 'keydown', this.onKeydownCB);
    }
  }, {
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      // clear timer
      clearTimeout(this.blurTimer);

      // remove keydown handler
      jqLite.off(document, 'keydown', this.onKeydownCB);
    }
  }, {
    key: 'onClick',
    value: function onClick(pos, ev) {
      // don't allow events to bubble
      ev.stopPropagation();
      this.selectAndDestroy(pos);
    }
  }, {
    key: 'onKeydown',
    value: function onKeydown(ev) {
      var keyCode = ev.keyCode;

      // tab
      if (keyCode === 9) return this.destroy();

      // escape | up | down | enter
      if (keyCode === 27 || keyCode === 40 || keyCode === 38 || keyCode === 13) {
        ev.preventDefault();
      }

      if (keyCode === 27) this.destroy();else if (keyCode === 40) this.increment();else if (keyCode === 38) this.decrement();else if (keyCode === 13) this.selectAndDestroy();
    }
  }, {
    key: 'increment',
    value: function increment() {
      if (this.state.currentIndex === this.props.optionEls.length - 1) {
        return;
      }

      this.setState({ currentIndex: this.state.currentIndex + 1 });
    }
  }, {
    key: 'decrement',
    value: function decrement() {
      if (this.state.currentIndex === 0) return;
      this.setState({ currentIndex: this.state.currentIndex - 1 });
    }
  }, {
    key: 'selectAndDestroy',
    value: function selectAndDestroy(pos) {
      pos = pos === undefined ? this.state.currentIndex : pos;

      // handle onChange
      if (pos !== this.state.origIndex) {
        this.props.onChange(this.props.optionEls[pos].value);
      }

      // close menu
      this.destroy();
    }
  }, {
    key: 'destroy',
    value: function destroy() {
      this.props.onClose();
    }
  }, {
    key: 'render',
    value: function render() {
      var menuItems = [],
          optionEls = this.props.optionEls,
          m = optionEls.length,
          optionEl = void 0,
          cls = void 0,
          i = void 0;

      // define menu items
      for (i = 0; i < m; i++) {
        cls = i === this.state.currentIndex ? 'mui--is-selected' : '';

        menuItems.push(_react2.default.createElement(
          'div',
          {
            key: i,
            className: cls,
            onClick: this.onClick.bind(this, i)
          },
          optionEls[i].textContent
        ));
      }

      return _react2.default.createElement(
        'div',
        { ref: 'wrapperEl', className: 'mui-select__menu' },
        menuItems
      );
    }
  }]);
  return Menu;
}(_react2.default.Component);

/** Define module API */


Menu.defaultProps = {
  optionEls: [],
  wrapperEl: null,
  onChange: null,
  onClose: null
};
exports.default = Select;
module.exports = exports['default'];

},{"../js/lib/forms":3,"../js/lib/jqLite":4,"../js/lib/util":5,"./_helpers":6,"react":"CwoHg3"}],27:[function(require,module,exports){
module.exports=require(9)
},{"react":"CwoHg3"}],28:[function(require,module,exports){
/**
 * MUI React tabs module
 * @module react/tabs
 */
/* jshint quotmark:false */
// jscs:disable validateQuoteMarks

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

var _tab = require('./tab');

var _tab2 = babelHelpers.interopRequireDefault(_tab);

var _util = require('../js/lib/util');

var util = babelHelpers.interopRequireWildcard(_util);


var PropTypes = _react2.default.PropTypes,
    tabsBarClass = 'mui-tabs__bar',
    tabsBarJustifiedClass = 'mui-tabs__bar--justified',
    tabsPaneClass = 'mui-tabs__pane',
    isActiveClass = 'mui--is-active';

/**
 * Tabs constructor
 * @class
 */

var Tabs = function (_React$Component) {
  babelHelpers.inherits(Tabs, _React$Component);

  function Tabs(props) {
    babelHelpers.classCallCheck(this, Tabs);

    var _this = babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Tabs).call(this, props));

    _this.state = { currentSelectedIndex: props.initialSelectedIndex };
    return _this;
  }

  babelHelpers.createClass(Tabs, [{
    key: 'onClick',
    value: function onClick(i, tab, ev) {
      if (i !== this.state.currentSelectedIndex) {
        this.setState({ currentSelectedIndex: i });

        // onActive callback
        if (tab.props.onActive) tab.props.onActive(tab);

        // onChange callback
        if (this.props.onChange) {
          this.props.onChange(i, tab.props.value, tab, ev);
        }
      }
    }
  }, {
    key: 'render',
    value: function render() {
      var _props = this.props;
      var children = _props.children;
      var initialSelectedIndex = _props.initialSelectedIndex;
      var justified = _props.justified;
      var reactProps = babelHelpers.objectWithoutProperties(_props, ['children', 'initialSelectedIndex', 'justified']);


      var tabEls = [],
          paneEls = [],
          m = children.length,
          selectedIndex = this.state.currentSelectedIndex % m,
          isActive = void 0,
          item = void 0,
          cls = void 0,
          i = void 0;

      for (i = 0; i < m; i++) {
        item = children[i];

        // only accept MUITab elements
        if (item.type !== _tab2.default) util.raiseError('Expecting MUITab React Element');

        isActive = i === selectedIndex ? true : false;

        // tab element
        tabEls.push(_react2.default.createElement(
          'li',
          { key: i, className: isActive ? isActiveClass : '' },
          _react2.default.createElement(
            'a',
            { onClick: this.onClick.bind(this, i, item) },
            item.props.label
          )
        ));

        // pane element
        cls = tabsPaneClass + ' ';
        if (isActive) cls += isActiveClass;

        paneEls.push(_react2.default.createElement(
          'div',
          { key: i, className: cls },
          item.props.children
        ));
      }

      cls = tabsBarClass;
      if (justified) cls += ' ' + tabsBarJustifiedClass;

      return _react2.default.createElement(
        'div',
        reactProps,
        _react2.default.createElement(
          'ul',
          { className: cls },
          tabEls
        ),
        paneEls
      );
    }
  }]);
  return Tabs;
}(_react2.default.Component);

/** Define module API */


Tabs.propTypes = {
  initialSelectedIndex: PropTypes.number,
  justified: PropTypes.bool,
  onChange: PropTypes.func
};
Tabs.defaultProps = {
  className: '',
  initialSelectedIndex: 0,
  justified: false,
  onChange: null
};
exports.default = Tabs;
module.exports = exports['default'];

},{"../js/lib/util":5,"./tab":9,"react":"CwoHg3"}],29:[function(require,module,exports){
/**
 * MUI React Textarea Component
 * @module react/textarea
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = window.React;

var _react2 = babelHelpers.interopRequireDefault(_react);

var _textField = require('./text-field');

var PropTypes = _react2.default.PropTypes;

/**
 * Textarea constructor
 * @class
 */

var Textarea = function (_React$Component) {
  babelHelpers.inherits(Textarea, _React$Component);

  function Textarea() {
    babelHelpers.classCallCheck(this, Textarea);
    return babelHelpers.possibleConstructorReturn(this, Object.getPrototypeOf(Textarea).apply(this, arguments));
  }

  babelHelpers.createClass(Textarea, [{
    key: 'render',
    value: function render() {
      return _react2.default.createElement(_textField.TextField, this.props);
    }
  }]);
  return Textarea;
}(_react2.default.Component);

Textarea.defaultProps = {
  type: 'textarea'
};
exports.default = Textarea;
module.exports = exports['default'];

},{"./text-field":10,"react":"CwoHg3"}]},{},[1])