material_components_web-sass 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 59f1f332cb247cd990daa0eb55e74a2c6ee66a97
-  data.tar.gz: 688dbe9025f3e7d289bb129e496f1a3d05acfeb4
+  metadata.gz: bf304e5a7f4fb9aa0e5ca3694feaffd6f15fe86a
+  data.tar.gz: 31b7b07dd10423a6a93a849edce4686bb262428b
 SHA512:
-  metadata.gz: 383cb970896719d80de84c2cc8adab4e2525dce76cc747465e600f19c58c40cc0406648b8f55739eef0ed82d6fa3b44e7e89a74dc5ca4a6f3488f10dc8f10e5e
-  data.tar.gz: '08a151b718467b56e3c591f7e06f135a2b551190fca774a5986fcb719d3c0b897244f55a6e59d309e2d3f405cf10dbb7c2520b3305872ef36d82ff848044c20a'
+  metadata.gz: 8cc879dc83a2e975c89d3d538e171f2cc9c09637626982b773a65c4223d2704b61b85475d47c7ef797755d4c4147d4dba269678b1fe161b72ab41d0ebd3f9061
+  data.tar.gz: 4fded022b8095bf9438b3e49ad4df55fa4e85ac97ccca778c9690a87dfd19765113116c1780236a331c059d24c74ddd2d74c514247c9c5874e1148b7d1f04504

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.4.0 (2017-02-07)
+
+- Update assets to match upstream version
+
+Library version: 
+
+- Material Components for the web v0.4.0
+- Material Icons v3.0.0
+
 ## 0.3.0 (2017-01-24)
 
 - Update assets to match upstream version

data/README.md

@@ -51,12 +51,14 @@ Individual Sass components can be included like this:
 @import "@material/fab/mdc-fab";
 @import "@material/form-field/mdc-form-field";
 @import "@material/icon-toggle/mdc-icon-toggle";
+@import "@material/layout-grid/mdc-layout-grid";
 @import "@material/list/mdc-list";
 @import "@material/menu/mdc-menu";
 @import "@material/radio/mdc-radio";
 @import "@material/ripple/mdc-ripple";
 @import "@material/select/mdc-select";
 @import "@material/snackbar/mdc-snackbar";
+@import "@material/switch/mdc-switch";
 @import "@material/textfield/mdc-textfield";
 @import "@material/theme/mdc-theme";
 @import "@material/typography/mdc-typography";

data/lib/material_components_web/sass/version.rb

@@ -1,5 +1,5 @@
 module MaterialComponentsWeb
   module Sass
-    VERSION = '0.3.0'.freeze
+    VERSION = '0.4.0'.freeze
   end
 end

data/vendor/assets/javascripts/material-components-web.js

@@ -74,7 +74,7 @@ return /******/ (function(modules) { // webpackBootstrap
 
 	var checkbox = _interopRequireWildcard(_checkbox);
 
-	var _iconToggle = __webpack_require__(8);
+	var _iconToggle = __webpack_require__(12);
 
 	var iconToggle = _interopRequireWildcard(_iconToggle);
 
@@ -82,7 +82,7 @@ return /******/ (function(modules) { // webpackBootstrap
 
 	var radio = _interopRequireWildcard(_radio);
 
-	var _ripple = __webpack_require__(9);
+	var _ripple = __webpack_require__(5);
 
 	var ripple = _interopRequireWildcard(_ripple);
 
@@ -415,13 +415,21 @@ return /******/ (function(modules) { // webpackBootstrap
 	});
 	exports.MDCCheckbox = exports.MDCCheckboxFoundation = undefined;
 
+	var _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; };
+
+	var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
 	var _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; }; }();
 
 	var _base = __webpack_require__(1);
 
-	var _animation = __webpack_require__(5);
+	var _ripple = __webpack_require__(5);
 
-	var _foundation = __webpack_require__(6);
+	var _util = __webpack_require__(9);
+
+	var _animation = __webpack_require__(7);
+
+	var _foundation = __webpack_require__(10);
 
 	var _foundation2 = _interopRequireDefault(_foundation);
 
@@ -452,53 +460,113 @@ return /******/ (function(modules) { // webpackBootstrap
 	var MDCCheckbox = exports.MDCCheckbox = function (_MDCComponent) {
 	  _inherits(MDCCheckbox, _MDCComponent);
 
+	  _createClass(MDCCheckbox, [{
+	    key: 'nativeCb_',
+	    get: function get() {
+	      var NATIVE_CONTROL_SELECTOR = _foundation2.default.strings.NATIVE_CONTROL_SELECTOR;
+
+	      return this.root_.querySelector(NATIVE_CONTROL_SELECTOR);
+	    }
+	  }], [{
+	    key: 'attachTo',
+	    value: function attachTo(root) {
+	      return new MDCCheckbox(root);
+	    }
+	  }]);
+
 	  function MDCCheckbox() {
+	    var _ref;
+
 	    _classCallCheck(this, MDCCheckbox);
 
-	    return _possibleConstructorReturn(this, (MDCCheckbox.__proto__ || Object.getPrototypeOf(MDCCheckbox)).apply(this, arguments));
+	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	      args[_key] = arguments[_key];
+	    }
+
+	    var _this = _possibleConstructorReturn(this, (_ref = MDCCheckbox.__proto__ || Object.getPrototypeOf(MDCCheckbox)).call.apply(_ref, [this].concat(args)));
+
+	    _this.ripple_ = _this.initRipple_();
+	    return _this;
 	  }
 
 	  _createClass(MDCCheckbox, [{
+	    key: 'initRipple_',
+	    value: function initRipple_() {
+	      var _this2 = this;
+
+	      var MATCHES = (0, _util.getMatchesProperty)(HTMLElement.prototype);
+	      var adapter = _extends(_ripple.MDCRipple.createAdapter(this), {
+	        isUnbounded: function isUnbounded() {
+	          return true;
+	        },
+	        isSurfaceActive: function isSurfaceActive() {
+	          return _this2.nativeCb_[MATCHES](':active');
+	        },
+	        registerInteractionHandler: function registerInteractionHandler(type, handler) {
+	          return _this2.nativeCb_.addEventListener(type, handler);
+	        },
+	        deregisterInteractionHandler: function deregisterInteractionHandler(type, handler) {
+	          return _this2.nativeCb_.removeEventListener(type, handler);
+	        },
+	        computeBoundingRect: function computeBoundingRect() {
+	          var _root_$getBoundingCli = _this2.root_.getBoundingClientRect(),
+	              left = _root_$getBoundingCli.left,
+	              top = _root_$getBoundingCli.top;
+
+	          var DIM = 40;
+	          return {
+	            top: top,
+	            left: left,
+	            right: left + DIM,
+	            bottom: top + DIM,
+	            width: DIM,
+	            height: DIM
+	          };
+	        }
+	      });
+	      var foundation = new _ripple.MDCRippleFoundation(adapter);
+	      return new _ripple.MDCRipple(this.root_, foundation);
+	    }
+	  }, {
 	    key: 'getDefaultFoundation',
 	    value: function getDefaultFoundation() {
-	      var _this2 = this;
+	      var _this3 = this;
 
 	      return new _foundation2.default({
 	        addClass: function addClass(className) {
-	          return _this2.root_.classList.add(className);
+	          return _this3.root_.classList.add(className);
 	        },
 	        removeClass: function removeClass(className) {
-	          return _this2.root_.classList.remove(className);
+	          return _this3.root_.classList.remove(className);
 	        },
 	        registerAnimationEndHandler: function registerAnimationEndHandler(handler) {
-	          return _this2.root_.addEventListener((0, _animation.getCorrectEventName)(window, 'animation'), handler);
+	          return _this3.root_.addEventListener((0, _animation.getCorrectEventName)(window, 'animationend'), handler);
 	        },
 	        deregisterAnimationEndHandler: function deregisterAnimationEndHandler(handler) {
-	          return _this2.root_.removeEventListener((0, _animation.getCorrectEventName)(window, 'animation'), handler);
+	          return _this3.root_.removeEventListener((0, _animation.getCorrectEventName)(window, 'animationend'), handler);
 	        },
 	        registerChangeHandler: function registerChangeHandler(handler) {
-	          return _this2.nativeCb_.addEventListener('change', handler);
+	          return _this3.nativeCb_.addEventListener('change', handler);
 	        },
 	        deregisterChangeHandler: function deregisterChangeHandler(handler) {
-	          return _this2.nativeCb_.removeEventListener('change', handler);
+	          return _this3.nativeCb_.removeEventListener('change', handler);
 	        },
 	        getNativeControl: function getNativeControl() {
-	          return _this2.nativeCb_;
+	          return _this3.nativeCb_;
 	        },
 	        forceLayout: function forceLayout() {
-	          return _this2.root_.offsetWidth;
+	          return _this3.root_.offsetWidth;
 	        },
 	        isAttachedToDOM: function isAttachedToDOM() {
-	          return Boolean(_this2.root_.parentNode);
+	          return Boolean(_this3.root_.parentNode);
 	        }
 	      });
 	    }
 	  }, {
-	    key: 'nativeCb_',
-	    get: function get() {
-	      var NATIVE_CONTROL_SELECTOR = _foundation2.default.strings.NATIVE_CONTROL_SELECTOR;
-
-	      return this.root_.querySelector(NATIVE_CONTROL_SELECTOR);
+	    key: 'destroy',
+	    value: function destroy() {
+	      this.ripple_.destroy();
+	      _get(MDCCheckbox.prototype.__proto__ || Object.getPrototypeOf(MDCCheckbox.prototype), 'destroy', this).call(this);
 	    }
 	  }, {
 	    key: 'checked',
@@ -524,11 +592,6 @@ return /******/ (function(modules) { // webpackBootstrap
 	    set: function set(disabled) {
 	      this.foundation_.setDisabled(disabled);
 	    }
-	  }], [{
-	    key: 'attachTo',
-	    value: function attachTo(root) {
-	      return new MDCCheckbox(root);
-	    }
 	  }]);
 
 	  return MDCCheckbox;
@@ -536,138 +599,6 @@ return /******/ (function(modules) { // webpackBootstrap
 
 /***/ },
 /* 5 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.getCorrectEventName = getCorrectEventName;
-	exports.getCorrectPropertyName = getCorrectPropertyName;
-	/**
-	 * Copyright 2016 Google Inc. All Rights Reserved.
-	 *
-	 * Licensed under the Apache License, Version 2.0 (the "License");
-	 * you may not use this file except in compliance with the License.
-	 * You may obtain a copy of the License at
-	 *
-	 *      http://www.apache.org/licenses/LICENSE-2.0
-	 *
-	 * Unless required by applicable law or agreed to in writing, software
-	 * distributed under the License is distributed on an "AS IS" BASIS,
-	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-	 * See the License for the specific language governing permissions and
-	 * limitations under the License.
-	 */
-
-	var eventTypeMap = {
-	  animationstart: {
-	    noPrefix: 'animationstart',
-	    webkitPrefix: 'webkitAnimationStart'
-	  },
-	  animationend: {
-	    noPrefix: 'animationend',
-	    webkitPrefix: 'webkitAnimationEnd'
-	  },
-	  animationiteration: {
-	    noPrefix: 'animationiteration',
-	    webkitPrefix: 'webkitAnimationIteration'
-	  },
-	  transitionend: {
-	    noPrefix: 'transitionend',
-	    webkitPrefix: 'webkitTransitionEnd'
-	  }
-	};
-
-	var cssPropertyMap = {
-	  animation: {
-	    noPrefix: 'animation',
-	    webkitPrefix: '-webkit-animation'
-	  },
-	  transform: {
-	    noPrefix: 'transform',
-	    webkitPrefix: '-webkit-transform'
-	  },
-	  transition: {
-	    noPrefix: 'transition',
-	    webkitPrefix: '-webkit-transition'
-	  }
-	};
-
-	function hasProperShape(windowObj) {
-	  return windowObj.document !== undefined && typeof windowObj.document.createElement === 'function';
-	}
-
-	function eventFoundInMaps(eventType) {
-	  return eventType in eventTypeMap || eventType in cssPropertyMap;
-	}
-
-	// If 'animation' or 'transition' exist as style property, webkit prefix isn't necessary. Since we are unable to
-	// see the event types on the element, we must rely on the corresponding style properties.
-	function getJavaScriptEventName(eventType, map, el) {
-	  switch (eventType) {
-	    case 'animationstart':
-	    case 'animationend':
-	    case 'animationiteration':
-	      return 'animation' in el.style ? map[eventType].noPrefix : map[eventType].webkitPrefix;
-	    case 'transitionend':
-	      return 'transition' in el.style ? map[eventType].noPrefix : map[eventType].webkitPrefix;
-	    default:
-	      return map[eventType].noPrefix;
-	  }
-	}
-
-	// Helper function to determine browser prefix for CSS3 animation events
-	// and property names
-	//
-	// Parameters:
-	// windowObject: Object -- Contains Document with a `createElement()` method
-	// eventType: string -- The type of animation
-	//
-	// returns the value of the event as a string, prefixed if necessary.
-	// If proper arguments are not supplied, this function will return
-	// the property or event type without webkit prefix.
-	//
-	function getAnimationName(windowObj, eventType) {
-	  if (!hasProperShape(windowObj) || !eventFoundInMaps(eventType)) {
-	    return eventType;
-	  }
-
-	  var map = eventType in eventTypeMap ? eventTypeMap : cssPropertyMap;
-	  var el = windowObj.document.createElement('div');
-	  var eventName = '';
-
-	  if (map === eventTypeMap) {
-	    eventName = getJavaScriptEventName(eventType, map, el);
-	  } else {
-	    eventName = map[eventType].noPrefix in el.style ? map[eventType].noPrefix : map[eventType].webkitPrefix;
-	  }
-
-	  return eventName;
-	}
-
-	// Public functions to access getAnimationName() for JavaScript events or CSS
-	// property names.
-	//
-	// Parameters:
-	// windowObject: Object -- Contains Document with a `createElement()` method
-	// eventType: string -- The type of animation
-	//
-	// returns the value of the event as a string, prefixed if necessary.
-	// If proper arguments are not supplied, this function will return
-	// the property or event type without webkit prefix.
-	//
-	function getCorrectEventName(windowObj, eventType) {
-	  return getAnimationName(windowObj, eventType);
-	}
-
-	function getCorrectPropertyName(windowObj, eventType) {
-	  return getAnimationName(windowObj, eventType);
-	}
-
-/***/ },
-/* 6 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -675,14 +606,19 @@ return /******/ (function(modules) { // webpackBootstrap
 	Object.defineProperty(exports, "__esModule", {
 	  value: true
 	});
-
-	var _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; };
+	exports.MDCRipple = exports.MDCRippleFoundation = undefined;
 
 	var _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; }; }();
 
 	var _base = __webpack_require__(1);
 
-	var _constants = __webpack_require__(7);
+	var _foundation = __webpack_require__(6);
+
+	var _foundation2 = _interopRequireDefault(_foundation);
+
+	var _util = __webpack_require__(9);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
@@ -704,238 +640,607 @@ return /******/ (function(modules) { // webpackBootstrap
 	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * limitations under the License.
 	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
 
-	var CB_PROTO_PROPS = ['checked', 'indeterminate'];
+	var MATCHES = (0, _util.getMatchesProperty)(HTMLElement.prototype);
 
-	var MDCCheckboxFoundation = function (_MDCFoundation) {
-	  _inherits(MDCCheckboxFoundation, _MDCFoundation);
+	exports.MDCRippleFoundation = _foundation2.default;
 
-	  _createClass(MDCCheckboxFoundation, null, [{
-	    key: 'cssClasses',
-	    get: function get() {
-	      return _constants.cssClasses;
+	var MDCRipple = exports.MDCRipple = function (_MDCComponent) {
+	  _inherits(MDCRipple, _MDCComponent);
+
+	  function MDCRipple() {
+	    _classCallCheck(this, MDCRipple);
+
+	    return _possibleConstructorReturn(this, (MDCRipple.__proto__ || Object.getPrototypeOf(MDCRipple)).apply(this, arguments));
+	  }
+
+	  _createClass(MDCRipple, [{
+	    key: 'getDefaultFoundation',
+	    value: function getDefaultFoundation() {
+	      return new _foundation2.default(MDCRipple.createAdapter(this));
 	    }
 	  }, {
-	    key: 'strings',
-	    get: function get() {
-	      return _constants.strings;
+	    key: 'initialSyncWithDOM',
+	    value: function initialSyncWithDOM() {
+	      this.unbounded = 'mdcRippleIsUnbounded' in this.root_.dataset;
 	    }
 	  }, {
-	    key: 'numbers',
+	    key: 'unbounded',
 	    get: function get() {
-	      return _constants.numbers;
+	      return this.unbounded_;
+	    },
+	    set: function set(unbounded) {
+	      var UNBOUNDED = _foundation2.default.cssClasses.UNBOUNDED;
+
+	      this.unbounded_ = Boolean(unbounded);
+	      if (this.unbounded_) {
+	        this.root_.classList.add(UNBOUNDED);
+	      } else {
+	        this.root_.classList.remove(UNBOUNDED);
+	      }
+	    }
+	  }], [{
+	    key: 'attachTo',
+	    value: function attachTo(root) {
+	      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+	          _ref$isUnbounded = _ref.isUnbounded,
+	          isUnbounded = _ref$isUnbounded === undefined ? undefined : _ref$isUnbounded;
+
+	      var ripple = new MDCRipple(root);
+	      // Only override unbounded behavior if option is explicitly specified
+	      if (isUnbounded !== undefined) {
+	        ripple.unbounded = isUnbounded;
+	      }
+	      return ripple;
+	    }
+	  }, {
+	    key: 'createAdapter',
+	    value: function createAdapter(instance) {
+	      return {
+	        browserSupportsCssVars: function browserSupportsCssVars() {
+	          return (0, _util.supportsCssVariables)(window);
+	        },
+	        isUnbounded: function isUnbounded() {
+	          return instance.unbounded;
+	        },
+	        isSurfaceActive: function isSurfaceActive() {
+	          return instance.root_[MATCHES](':active');
+	        },
+	        addClass: function addClass(className) {
+	          return instance.root_.classList.add(className);
+	        },
+	        removeClass: function removeClass(className) {
+	          return instance.root_.classList.remove(className);
+	        },
+	        registerInteractionHandler: function registerInteractionHandler(evtType, handler) {
+	          return instance.root_.addEventListener(evtType, handler);
+	        },
+	        deregisterInteractionHandler: function deregisterInteractionHandler(evtType, handler) {
+	          return instance.root_.removeEventListener(evtType, handler);
+	        },
+	        registerResizeHandler: function registerResizeHandler(handler) {
+	          return window.addEventListener('resize', handler);
+	        },
+	        deregisterResizeHandler: function deregisterResizeHandler(handler) {
+	          return window.removeEventListener('resize', handler);
+	        },
+	        updateCssVariable: function updateCssVariable(varName, value) {
+	          return instance.root_.style.setProperty(varName, value);
+	        },
+	        computeBoundingRect: function computeBoundingRect() {
+	          return instance.root_.getBoundingClientRect();
+	        },
+	        getWindowPageOffset: function getWindowPageOffset() {
+	          return { x: window.pageXOffset, y: window.pageYOffset };
+	        }
+	      };
+	    }
+	  }]);
+
+	  return MDCRipple;
+	}(_base.MDCComponent);
+
+/***/ },
+/* 6 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _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; };
+
+	var _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; }; }();
+
+	var _base = __webpack_require__(1);
+
+	var _animation = __webpack_require__(7);
+
+	var _constants = __webpack_require__(8);
+
+	var _util = __webpack_require__(9);
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(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; }
+
+	function _inherits(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; } /**
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Copyright 2016 Google Inc. All Rights Reserved.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Licensed under the Apache License, Version 2.0 (the "License");
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * you may not use this file except in compliance with the License.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * You may obtain a copy of the License at
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *      http://www.apache.org/licenses/LICENSE-2.0
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Unless required by applicable law or agreed to in writing, software
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * distributed under the License is distributed on an "AS IS" BASIS,
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * See the License for the specific language governing permissions and
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * limitations under the License.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
+
+	var DEACTIVATION_ACTIVATION_PAIRS = {
+	  mouseup: 'mousedown',
+	  pointerup: 'pointerdown',
+	  touchend: 'touchstart',
+	  keyup: 'keydown',
+	  blur: 'focus'
+	};
+
+	var MDCRippleFoundation = function (_MDCFoundation) {
+	  _inherits(MDCRippleFoundation, _MDCFoundation);
+
+	  _createClass(MDCRippleFoundation, [{
+	    key: 'isSupported_',
+
+
+	    // We compute this property so that we are not querying information about the client
+	    // until the point in time where the foundation requests it. This prevents scenarios where
+	    // client-side feature-detection may happen too early, such as when components are rendered on the server
+	    // and then initialized at mount time on the client.
+	    get: function get() {
+	      return this.adapter_.browserSupportsCssVars();
+	    }
+	  }], [{
+	    key: 'cssClasses',
+	    get: function get() {
+	      return _constants.cssClasses;
+	    }
+	  }, {
+	    key: 'strings',
+	    get: function get() {
+	      return _constants.strings;
+	    }
+	  }, {
+	    key: 'numbers',
+	    get: function get() {
+	      return _constants.numbers;
 	    }
 	  }, {
 	    key: 'defaultAdapter',
 	    get: function get() {
 	      return {
+	        browserSupportsCssVars: function browserSupportsCssVars() /* boolean - cached */{},
+	        isUnbounded: function isUnbounded() /* boolean */{},
+	        isSurfaceActive: function isSurfaceActive() /* boolean */{},
 	        addClass: function addClass() /* className: string */{},
 	        removeClass: function removeClass() /* className: string */{},
-	        registerAnimationEndHandler: function registerAnimationEndHandler() /* handler: EventListener */{},
-	        deregisterAnimationEndHandler: function deregisterAnimationEndHandler() /* handler: EventListener */{},
-	        registerChangeHandler: function registerChangeHandler() /* handler: EventListener */{},
-	        deregisterChangeHandler: function deregisterChangeHandler() /* handler: EventListener */{},
-	        getNativeControl: function getNativeControl() /* HTMLInputElement */{},
-	        forceLayout: function forceLayout() {},
-	        isAttachedToDOM: function isAttachedToDOM() /* boolean */{}
+	        registerInteractionHandler: function registerInteractionHandler() /* evtType: string, handler: EventListener */{},
+	        deregisterInteractionHandler: function deregisterInteractionHandler() /* evtType: string, handler: EventListener */{},
+	        registerResizeHandler: function registerResizeHandler() /* handler: EventListener */{},
+	        deregisterResizeHandler: function deregisterResizeHandler() /* handler: EventListener */{},
+	        updateCssVariable: function updateCssVariable() /* varName: string, value: string */{},
+	        computeBoundingRect: function computeBoundingRect() /* ClientRect */{},
+	        getWindowPageOffset: function getWindowPageOffset() /* {x: number, y: number} */{}
 	      };
 	    }
 	  }]);
 
-	  function MDCCheckboxFoundation(adapter) {
-	    _classCallCheck(this, MDCCheckboxFoundation);
+	  function MDCRippleFoundation(adapter) {
+	    _classCallCheck(this, MDCRippleFoundation);
 
-	    var _this = _possibleConstructorReturn(this, (MDCCheckboxFoundation.__proto__ || Object.getPrototypeOf(MDCCheckboxFoundation)).call(this, _extends(MDCCheckboxFoundation.defaultAdapter, adapter)));
+	    var _this = _possibleConstructorReturn(this, (MDCRippleFoundation.__proto__ || Object.getPrototypeOf(MDCRippleFoundation)).call(this, _extends(MDCRippleFoundation.defaultAdapter, adapter)));
 
-	    _this.currentCheckState_ = _constants.strings.TRANSITION_STATE_INIT;
-	    _this.currentAnimationClass_ = '';
-	    _this.animEndLatchTimer_ = 0;
-	    _this.animEndHandler_ = function () {
-	      clearTimeout(_this.animEndLatchTimer_);
-	      _this.animEndLatchTimer_ = setTimeout(function () {
-	        _this.adapter_.removeClass(_this.currentAnimationClass_);
-	        _this.adapter_.deregisterAnimationEndHandler(_this.animEndHandler_);
-	      }, _constants.numbers.ANIM_END_LATCH_MS);
+	    _this.layoutFrame_ = 0;
+	    _this.frame_ = { width: 0, height: 0 };
+	    _this.activationState_ = _this.defaultActivationState_();
+	    _this.xfDuration_ = 0;
+	    _this.initialSize_ = 0;
+	    _this.maxRadius_ = 0;
+	    _this.listenerInfos_ = [{ activate: 'touchstart', deactivate: 'touchend' }, { activate: 'pointerdown', deactivate: 'pointerup' }, { activate: 'mousedown', deactivate: 'mouseup' }, { activate: 'keydown', deactivate: 'keyup' }, { focus: 'focus', blur: 'blur' }];
+	    _this.listeners_ = {
+	      activate: function activate(e) {
+	        return _this.activate_(e);
+	      },
+	      deactivate: function deactivate(e) {
+	        return _this.deactivate_(e);
+	      },
+	      focus: function focus() {
+	        return requestAnimationFrame(function () {
+	          return _this.adapter_.addClass(MDCRippleFoundation.cssClasses.BG_ACTIVE);
+	        });
+	      },
+	      blur: function blur() {
+	        return requestAnimationFrame(function () {
+	          return _this.adapter_.removeClass(MDCRippleFoundation.cssClasses.BG_ACTIVE);
+	        });
+	      }
 	    };
-	    _this.changeHandler_ = function () {
-	      return _this.transitionCheckState_();
+	    _this.unboundedOpacityFadeTimer_ = 0;
+	    _this.resizeHandler_ = function () {
+	      return _this.layout();
+	    };
+	    _this.cancelBgBounded_ = function () {};
+	    _this.cancelFgBounded_ = function () {};
+	    _this.cancelFgUnbounded_ = function () {};
+	    _this.unboundedCoords_ = {
+	      left: 0,
+	      top: 0
 	    };
+	    _this.fgScale_ = 0;
 	    return _this;
 	  }
 
-	  _createClass(MDCCheckboxFoundation, [{
-	    key: 'init',
-	    value: function init() {
-	      this.adapter_.registerChangeHandler(this.changeHandler_);
-	      this.installPropertyChangeHooks_();
+	  _createClass(MDCRippleFoundation, [{
+	    key: 'defaultActivationState_',
+	    value: function defaultActivationState_() {
+	      return {
+	        isActivated: false,
+	        wasActivatedByPointer: false,
+	        wasElementMadeActive: false,
+	        activationStartTime: 0,
+	        activationEvent: null
+	      };
 	    }
 	  }, {
-	    key: 'destroy',
-	    value: function destroy() {
-	      this.adapter_.deregisterChangeHandler(this.changeHandler_);
-	      this.uninstallPropertyChangeHooks_();
+	    key: 'init',
+	    value: function init() {
+	      var _this2 = this;
+
+	      if (!this.isSupported_) {
+	        return;
+	      }
+	      this.addEventListeners_();
+
+	      var _MDCRippleFoundation$ = MDCRippleFoundation.cssClasses,
+	          ROOT = _MDCRippleFoundation$.ROOT,
+	          UNBOUNDED = _MDCRippleFoundation$.UNBOUNDED;
+
+	      requestAnimationFrame(function () {
+	        _this2.adapter_.addClass(ROOT);
+	        if (_this2.adapter_.isUnbounded()) {
+	          _this2.adapter_.addClass(UNBOUNDED);
+	        }
+	        _this2.layoutInternal_();
+	      });
 	    }
 	  }, {
-	    key: 'isChecked',
-	    value: function isChecked() {
-	      return this.getNativeControl_().checked;
-	    }
-	  }, {
-	    key: 'setChecked',
-	    value: function setChecked(checked) {
-	      this.getNativeControl_().checked = checked;
-	    }
-	  }, {
-	    key: 'isIndeterminate',
-	    value: function isIndeterminate() {
-	      return this.getNativeControl_().indeterminate;
-	    }
-	  }, {
-	    key: 'setIndeterminate',
-	    value: function setIndeterminate(indeterminate) {
-	      this.getNativeControl_().indeterminate = indeterminate;
-	    }
-	  }, {
-	    key: 'isDisabled',
-	    value: function isDisabled() {
-	      return this.getNativeControl_().disabled;
-	    }
-	  }, {
-	    key: 'setDisabled',
-	    value: function setDisabled(disabled) {
-	      this.getNativeControl_().disabled = disabled;
+	    key: 'addEventListeners_',
+	    value: function addEventListeners_() {
+	      var _this3 = this;
+
+	      this.listenerInfos_.forEach(function (info) {
+	        Object.keys(info).forEach(function (k) {
+	          _this3.adapter_.registerInteractionHandler(info[k], _this3.listeners_[k]);
+	        });
+	      });
+	      this.adapter_.registerResizeHandler(this.resizeHandler_);
 	    }
 	  }, {
-	    key: 'installPropertyChangeHooks_',
-	    value: function installPropertyChangeHooks_() {
-	      var _this2 = this;
+	    key: 'activate_',
+	    value: function activate_(e) {
+	      var _this4 = this;
 
-	      var nativeCb = this.getNativeControl_();
-	      var cbProto = Object.getPrototypeOf(nativeCb);
+	      var activationState = this.activationState_;
 
-	      CB_PROTO_PROPS.forEach(function (controlState) {
-	        var desc = Object.getOwnPropertyDescriptor(cbProto, controlState);
-	        // We have to check for this descriptor, since some browsers (Safari) don't support its return.
-	        // See: https://bugs.webkit.org/show_bug.cgi?id=49739
-	        if (validDescriptor(desc)) {
-	          Object.defineProperty(nativeCb, controlState, {
-	            get: desc.get,
-	            set: function set(state) {
-	              desc.set.call(nativeCb, state);
-	              _this2.transitionCheckState_();
-	            },
-	            configurable: desc.configurable,
-	            enumerable: desc.enumerable
-	          });
+	      if (activationState.isActivated) {
+	        return;
+	      }
+
+	      activationState.isActivated = true;
+	      activationState.activationEvent = e;
+	      activationState.wasActivatedByPointer = e.type === 'mousedown' || e.type === 'touchstart' || e.type === 'pointerdown';
+
+	      activationState.activationStartTime = Date.now();
+	      requestAnimationFrame(function () {
+	        // This needs to be wrapped in an rAF call b/c web browsers
+	        // report active states inconsistently when they're called within
+	        // event handling code:
+	        // - https://bugs.chromium.org/p/chromium/issues/detail?id=635971
+	        // - https://bugzilla.mozilla.org/show_bug.cgi?id=1293741
+	        activationState.wasElementMadeActive = e.type === 'keydown' ? _this4.adapter_.isSurfaceActive() : true;
+	        if (activationState.wasElementMadeActive) {
+	          _this4.animateActivation_();
+	        } else {
+	          // Reset activation state immediately if element was not made active.
+	          _this4.activationState_ = _this4.defaultActivationState_();
 	        }
 	      });
 	    }
 	  }, {
-	    key: 'uninstallPropertyChangeHooks_',
-	    value: function uninstallPropertyChangeHooks_() {
-	      var nativeCb = this.getNativeControl_();
-	      var cbProto = Object.getPrototypeOf(nativeCb);
+	    key: 'animateActivation_',
+	    value: function animateActivation_() {
+	      var _this5 = this;
 
-	      CB_PROTO_PROPS.forEach(function (controlState) {
-	        var desc = Object.getOwnPropertyDescriptor(cbProto, controlState);
-	        if (validDescriptor(desc)) {
-	          Object.defineProperty(nativeCb, controlState, desc);
-	        }
+	      var _MDCRippleFoundation$2 = MDCRippleFoundation.cssClasses,
+	          BG_ACTIVE = _MDCRippleFoundation$2.BG_ACTIVE,
+	          BG_BOUNDED_ACTIVE_FILL = _MDCRippleFoundation$2.BG_BOUNDED_ACTIVE_FILL,
+	          FG_UNBOUNDED_DEACTIVATION = _MDCRippleFoundation$2.FG_UNBOUNDED_DEACTIVATION,
+	          FG_BOUNDED_ACTIVE_FILL = _MDCRippleFoundation$2.FG_BOUNDED_ACTIVE_FILL;
+
+	      // If ripple is currently deactivating, cancel those animations.
+
+	      [BG_BOUNDED_ACTIVE_FILL, FG_UNBOUNDED_DEACTIVATION, FG_BOUNDED_ACTIVE_FILL].forEach(function (c) {
+	        return _this5.adapter_.removeClass(c);
 	      });
+	      this.cancelBgBounded_();
+	      this.cancelFgBounded_();
+	      this.cancelFgUnbounded_();
+	      if (this.unboundedOpacityFadeTimer_) {
+	        clearTimeout(this.unboundedOpacityFadeTimer_);
+	        this.unboundedOpacityFadeTimer_ = 0;
+	      }
+
+	      this.adapter_.addClass(BG_ACTIVE);
+	      if (this.adapter_.isUnbounded()) {
+	        this.animateUnboundedActivation_();
+	      }
 	    }
 	  }, {
-	    key: 'transitionCheckState_',
-	    value: function transitionCheckState_() {
-	      var nativeCb = this.adapter_.getNativeControl();
-	      if (!nativeCb) {
+	    key: 'animateUnboundedActivation_',
+	    value: function animateUnboundedActivation_() {
+	      var FG_UNBOUNDED_ACTIVATION = MDCRippleFoundation.cssClasses.FG_UNBOUNDED_ACTIVATION;
+
+	      this.adapter_.addClass(FG_UNBOUNDED_ACTIVATION);
+	    }
+	  }, {
+	    key: 'deactivate_',
+	    value: function deactivate_(e) {
+	      var _this6 = this;
+
+	      var activationState = this.activationState_;
+	      // This can happen in scenarios such as when you have a keyup event that blurs the element.
+
+	      if (!activationState.isActivated) {
 	        return;
 	      }
-	      var oldState = this.currentCheckState_;
-	      var newState = this.determineCheckState_(nativeCb);
-	      if (oldState === newState) {
-	        return;
+	      var actualActivationType = DEACTIVATION_ACTIVATION_PAIRS[e.type];
+	      var expectedActivationType = activationState.activationEvent.type;
+	      // NOTE: Pointer events are tricky - https://patrickhlauke.github.io/touch/tests/results/
+	      // Essentially, what we need to do here is decouple the deactivation UX from the actual
+	      // deactivation state itself. This way, touch/pointer events in sequence do not trample one
+	      // another.
+	      var needsDeactivationUX = actualActivationType === expectedActivationType;
+	      var needsActualDeactivation = needsDeactivationUX;
+	      if (activationState.wasActivatedByPointer) {
+	        needsActualDeactivation = e.type === 'mouseup';
 	      }
 
-	      // Check to ensure that there isn't a previously existing animation class, in case for example
-	      // the user interacted with the checkbox before the animation was finished.
-	      if (this.currentAnimationClass_.length > 0) {
-	        clearTimeout(this.animEndLatchTimer_);
-	        this.adapter_.forceLayout();
-	        this.adapter_.removeClass(this.currentAnimationClass_);
+	      var state = _extends({}, this.activationState_);
+	      if (needsDeactivationUX) {
+	        requestAnimationFrame(function () {
+	          return _this6.animateDeactivation_(e, state);
+	        });
 	      }
-
-	      this.currentAnimationClass_ = this.getTransitionAnimationClass_(oldState, newState);
-	      this.currentCheckState_ = newState;
-
-	      // Check for parentNode so that animations are only run when the element is attached
-	      // to the DOM.
-	      if (this.adapter_.isAttachedToDOM() && this.currentAnimationClass_.length > 0) {
-	        this.adapter_.addClass(this.currentAnimationClass_);
-	        this.adapter_.registerAnimationEndHandler(this.animEndHandler_);
+	      if (needsActualDeactivation) {
+	        this.activationState_ = this.defaultActivationState_();
 	      }
 	    }
 	  }, {
-	    key: 'determineCheckState_',
-	    value: function determineCheckState_(nativeCb) {
-	      var TRANSITION_STATE_INDETERMINATE = _constants.strings.TRANSITION_STATE_INDETERMINATE,
-	          TRANSITION_STATE_CHECKED = _constants.strings.TRANSITION_STATE_CHECKED,
-	          TRANSITION_STATE_UNCHECKED = _constants.strings.TRANSITION_STATE_UNCHECKED;
-
+	    key: 'animateDeactivation_',
+	    value: function animateDeactivation_(e, _ref) {
+	      var wasActivatedByPointer = _ref.wasActivatedByPointer,
+	          wasElementMadeActive = _ref.wasElementMadeActive,
+	          activationStartTime = _ref.activationStartTime;
+	      var BG_ACTIVE = MDCRippleFoundation.cssClasses.BG_ACTIVE;
 
-	      if (nativeCb.indeterminate) {
-	        return TRANSITION_STATE_INDETERMINATE;
+	      if (wasActivatedByPointer || wasElementMadeActive) {
+	        this.adapter_.removeClass(BG_ACTIVE);
+	        var isPointerEvent = e.type === 'touchend' || e.type === 'pointerup' || e.type === 'mouseup';
+	        if (this.adapter_.isUnbounded()) {
+	          this.animateUnboundedDeactivation_(this.getUnboundedDeactivationInfo_(activationStartTime));
+	        } else {
+	          this.animateBoundedDeactivation_(e, isPointerEvent);
+	        }
 	      }
-	      return nativeCb.checked ? TRANSITION_STATE_CHECKED : TRANSITION_STATE_UNCHECKED;
 	    }
 	  }, {
-	    key: 'getTransitionAnimationClass_',
-	    value: function getTransitionAnimationClass_(oldState, newState) {
-	      var TRANSITION_STATE_INIT = _constants.strings.TRANSITION_STATE_INIT,
-	          TRANSITION_STATE_CHECKED = _constants.strings.TRANSITION_STATE_CHECKED,
-	          TRANSITION_STATE_UNCHECKED = _constants.strings.TRANSITION_STATE_UNCHECKED;
-	      var _MDCCheckboxFoundatio = MDCCheckboxFoundation.cssClasses,
-	          ANIM_UNCHECKED_CHECKED = _MDCCheckboxFoundatio.ANIM_UNCHECKED_CHECKED,
-	          ANIM_UNCHECKED_INDETERMINATE = _MDCCheckboxFoundatio.ANIM_UNCHECKED_INDETERMINATE,
-	          ANIM_CHECKED_UNCHECKED = _MDCCheckboxFoundatio.ANIM_CHECKED_UNCHECKED,
-	          ANIM_CHECKED_INDETERMINATE = _MDCCheckboxFoundatio.ANIM_CHECKED_INDETERMINATE,
-	          ANIM_INDETERMINATE_CHECKED = _MDCCheckboxFoundatio.ANIM_INDETERMINATE_CHECKED,
-	          ANIM_INDETERMINATE_UNCHECKED = _MDCCheckboxFoundatio.ANIM_INDETERMINATE_UNCHECKED;
+	    key: 'animateUnboundedDeactivation_',
+	    value: function animateUnboundedDeactivation_(_ref2) {
+	      var _this7 = this;
 
+	      var opacityDuration = _ref2.opacityDuration,
+	          transformDuration = _ref2.transformDuration,
+	          approxCurScale = _ref2.approxCurScale;
+	      var _MDCRippleFoundation$3 = MDCRippleFoundation.cssClasses,
+	          FG_UNBOUNDED_ACTIVATION = _MDCRippleFoundation$3.FG_UNBOUNDED_ACTIVATION,
+	          FG_UNBOUNDED_DEACTIVATION = _MDCRippleFoundation$3.FG_UNBOUNDED_DEACTIVATION;
+	      var _MDCRippleFoundation$4 = MDCRippleFoundation.strings,
+	          VAR_FG_UNBOUNDED_OPACITY_DURATION = _MDCRippleFoundation$4.VAR_FG_UNBOUNDED_OPACITY_DURATION,
+	          VAR_FG_UNBOUNDED_TRANSFORM_DURATION = _MDCRippleFoundation$4.VAR_FG_UNBOUNDED_TRANSFORM_DURATION,
+	          VAR_FG_APPROX_XF = _MDCRippleFoundation$4.VAR_FG_APPROX_XF;
 
-	      switch (oldState) {
-	        case TRANSITION_STATE_INIT:
-	          if (newState === TRANSITION_STATE_UNCHECKED) {
-	            return '';
-	          }
-	        // fallthrough
-	        case TRANSITION_STATE_UNCHECKED:
-	          return newState === TRANSITION_STATE_CHECKED ? ANIM_UNCHECKED_CHECKED : ANIM_UNCHECKED_INDETERMINATE;
-	        case TRANSITION_STATE_CHECKED:
-	          return newState === TRANSITION_STATE_UNCHECKED ? ANIM_CHECKED_UNCHECKED : ANIM_CHECKED_INDETERMINATE;
-	        // TRANSITION_STATE_INDETERMINATE
-	        default:
-	          return newState === TRANSITION_STATE_CHECKED ? ANIM_INDETERMINATE_CHECKED : ANIM_INDETERMINATE_UNCHECKED;
-	      }
+	      this.adapter_.updateCssVariable(VAR_FG_APPROX_XF, 'scale(' + approxCurScale + ')');
+	      this.adapter_.updateCssVariable(VAR_FG_UNBOUNDED_OPACITY_DURATION, opacityDuration + 'ms');
+	      this.adapter_.updateCssVariable(VAR_FG_UNBOUNDED_TRANSFORM_DURATION, transformDuration + 'ms');
+	      this.adapter_.addClass(FG_UNBOUNDED_DEACTIVATION);
+	      this.adapter_.removeClass(FG_UNBOUNDED_ACTIVATION);
+	      // We use setTimeout here since we know how long the fade will take.
+	      this.unboundedOpacityFadeTimer_ = setTimeout(function () {
+	        _this7.adapter_.removeClass(FG_UNBOUNDED_DEACTIVATION);
+	      }, opacityDuration);
 	    }
 	  }, {
-	    key: 'getNativeControl_',
-	    value: function getNativeControl_() {
-	      return this.adapter_.getNativeControl() || {
-	        checked: false,
-	        indeterminate: false,
-	        disabled: false
-	      };
-	    }
-	  }]);
+	    key: 'getUnboundedDeactivationInfo_',
+	    value: function getUnboundedDeactivationInfo_(activationStartTime) {
+	      var msElapsed = Date.now() - activationStartTime;
+	      var _MDCRippleFoundation$5 = MDCRippleFoundation.numbers,
+	          FG_TRANSFORM_DELAY_MS = _MDCRippleFoundation$5.FG_TRANSFORM_DELAY_MS,
+	          OPACITY_DURATION_DIVISOR = _MDCRippleFoundation$5.OPACITY_DURATION_DIVISOR,
+	          ACTIVE_OPACITY_DURATION_MS = _MDCRippleFoundation$5.ACTIVE_OPACITY_DURATION_MS,
+	          UNBOUNDED_TRANSFORM_DURATION_MS = _MDCRippleFoundation$5.UNBOUNDED_TRANSFORM_DURATION_MS,
+	          MIN_OPACITY_DURATION_MS = _MDCRippleFoundation$5.MIN_OPACITY_DURATION_MS;
 
-	  return MDCCheckboxFoundation;
-	}(_base.MDCFoundation);
 
-	exports.default = MDCCheckboxFoundation;
+	      var approxCurScale = 0;
+	      if (msElapsed > FG_TRANSFORM_DELAY_MS) {
+	        var percentComplete = Math.min((msElapsed - FG_TRANSFORM_DELAY_MS) / this.xfDuration_, 1);
+	        approxCurScale = percentComplete * this.fgScale_;
+	      }
 
+	      var transformDuration = UNBOUNDED_TRANSFORM_DURATION_MS;
+	      var approxOpacity = Math.min(msElapsed / ACTIVE_OPACITY_DURATION_MS, 1);
+	      var opacityDuration = Math.max(MIN_OPACITY_DURATION_MS, 1000 * approxOpacity / OPACITY_DURATION_DIVISOR);
 
-	function validDescriptor(inputPropDesc) {
-	  return inputPropDesc && typeof inputPropDesc.set === 'function';
-	}
+	      return { transformDuration: transformDuration, opacityDuration: opacityDuration, approxCurScale: approxCurScale };
+	    }
+	  }, {
+	    key: 'animateBoundedDeactivation_',
+	    value: function animateBoundedDeactivation_(e, isPointerEvent) {
+	      var startPoint = void 0;
+	      if (isPointerEvent) {
+	        startPoint = (0, _util.getNormalizedEventCoords)(e, this.adapter_.getWindowPageOffset(), this.adapter_.computeBoundingRect());
+	      } else {
+	        startPoint = {
+	          x: this.frame_.width / 2,
+	          y: this.frame_.height / 2
+	        };
+	      }
+
+	      startPoint = {
+	        x: startPoint.x - this.initialSize_ / 2,
+	        y: startPoint.y - this.initialSize_ / 2
+	      };
+
+	      var endPoint = {
+	        x: this.frame_.width / 2 - this.initialSize_ / 2,
+	        y: this.frame_.height / 2 - this.initialSize_ / 2
+	      };
+
+	      var _MDCRippleFoundation$6 = MDCRippleFoundation.strings,
+	          VAR_FG_TRANSLATE_START = _MDCRippleFoundation$6.VAR_FG_TRANSLATE_START,
+	          VAR_FG_TRANSLATE_END = _MDCRippleFoundation$6.VAR_FG_TRANSLATE_END;
+	      var _MDCRippleFoundation$7 = MDCRippleFoundation.cssClasses,
+	          BG_BOUNDED_ACTIVE_FILL = _MDCRippleFoundation$7.BG_BOUNDED_ACTIVE_FILL,
+	          FG_BOUNDED_ACTIVE_FILL = _MDCRippleFoundation$7.FG_BOUNDED_ACTIVE_FILL;
+
+	      this.adapter_.updateCssVariable(VAR_FG_TRANSLATE_START, startPoint.x + 'px, ' + startPoint.y + 'px');
+	      this.adapter_.updateCssVariable(VAR_FG_TRANSLATE_END, endPoint.x + 'px, ' + endPoint.y + 'px');
+	      this.cancelBgBounded_ = (0, _util.animateWithClass)(this.adapter_, BG_BOUNDED_ACTIVE_FILL, (0, _animation.getCorrectEventName)(window, 'transitionend'));
+	      this.cancelFgBounded_ = (0, _util.animateWithClass)(this.adapter_, FG_BOUNDED_ACTIVE_FILL, (0, _animation.getCorrectEventName)(window, 'animationend'));
+	    }
+	  }, {
+	    key: 'destroy',
+	    value: function destroy() {
+	      var _this8 = this;
+
+	      if (!this.isSupported_) {
+	        return;
+	      }
+	      this.removeEventListeners_();
+
+	      var _MDCRippleFoundation$8 = MDCRippleFoundation.cssClasses,
+	          ROOT = _MDCRippleFoundation$8.ROOT,
+	          UNBOUNDED = _MDCRippleFoundation$8.UNBOUNDED;
+
+	      requestAnimationFrame(function () {
+	        _this8.adapter_.removeClass(ROOT);
+	        _this8.adapter_.removeClass(UNBOUNDED);
+	        _this8.removeCssVars_();
+	      });
+	    }
+	  }, {
+	    key: 'removeEventListeners_',
+	    value: function removeEventListeners_() {
+	      var _this9 = this;
+
+	      this.listenerInfos_.forEach(function (info) {
+	        Object.keys(info).forEach(function (k) {
+	          _this9.adapter_.deregisterInteractionHandler(info[k], _this9.listeners_[k]);
+	        });
+	      });
+	      this.adapter_.deregisterResizeHandler(this.resizeHandler_);
+	    }
+	  }, {
+	    key: 'removeCssVars_',
+	    value: function removeCssVars_() {
+	      var _this10 = this;
+
+	      var strings = MDCRippleFoundation.strings;
+
+	      Object.keys(strings).forEach(function (k) {
+	        if (k.indexOf('VAR_') === 0) {
+	          _this10.adapter_.updateCssVariable(strings[k], null);
+	        }
+	      });
+	    }
+	  }, {
+	    key: 'layout',
+	    value: function layout() {
+	      var _this11 = this;
+
+	      if (this.layoutFrame_) {
+	        cancelAnimationFrame(this.layoutFrame_);
+	      }
+	      this.layoutFrame_ = requestAnimationFrame(function () {
+	        _this11.layoutInternal_();
+	        _this11.layoutFrame_ = 0;
+	      });
+	    }
+	  }, {
+	    key: 'layoutInternal_',
+	    value: function layoutInternal_() {
+	      this.frame_ = this.adapter_.computeBoundingRect();
+
+	      var maxDim = Math.max(this.frame_.height, this.frame_.width);
+	      var surfaceDiameter = Math.sqrt(Math.pow(this.frame_.width, 2) + Math.pow(this.frame_.height, 2));
+
+	      // 60% of the largest dimension of the surface
+	      this.initialSize_ = maxDim * MDCRippleFoundation.numbers.INITIAL_ORIGIN_SCALE;
+
+	      // Diameter of the surface + 10px
+	      this.maxRadius_ = surfaceDiameter + MDCRippleFoundation.numbers.PADDING;
+	      this.fgScale_ = this.maxRadius_ / this.initialSize_;
+	      this.xfDuration_ = 1000 * Math.sqrt(this.maxRadius_ / 1024);
+	      this.updateLayoutCssVars_();
+	    }
+	  }, {
+	    key: 'updateLayoutCssVars_',
+	    value: function updateLayoutCssVars_() {
+	      var _MDCRippleFoundation$9 = MDCRippleFoundation.strings,
+	          VAR_SURFACE_WIDTH = _MDCRippleFoundation$9.VAR_SURFACE_WIDTH,
+	          VAR_SURFACE_HEIGHT = _MDCRippleFoundation$9.VAR_SURFACE_HEIGHT,
+	          VAR_FG_SIZE = _MDCRippleFoundation$9.VAR_FG_SIZE,
+	          VAR_FG_UNBOUNDED_TRANSFORM_DURATION = _MDCRippleFoundation$9.VAR_FG_UNBOUNDED_TRANSFORM_DURATION,
+	          VAR_LEFT = _MDCRippleFoundation$9.VAR_LEFT,
+	          VAR_TOP = _MDCRippleFoundation$9.VAR_TOP,
+	          VAR_FG_SCALE = _MDCRippleFoundation$9.VAR_FG_SCALE;
+
+
+	      this.adapter_.updateCssVariable(VAR_SURFACE_WIDTH, this.frame_.width + 'px');
+	      this.adapter_.updateCssVariable(VAR_SURFACE_HEIGHT, this.frame_.height + 'px');
+	      this.adapter_.updateCssVariable(VAR_FG_SIZE, this.initialSize_ + 'px');
+	      this.adapter_.updateCssVariable(VAR_FG_UNBOUNDED_TRANSFORM_DURATION, this.xfDuration_ + 'ms');
+	      this.adapter_.updateCssVariable(VAR_FG_SCALE, this.fgScale_);
+
+	      if (this.adapter_.isUnbounded()) {
+	        this.unboundedCoords_ = {
+	          left: Math.round(this.frame_.width / 2 - this.initialSize_ / 2),
+	          top: Math.round(this.frame_.height / 2 - this.initialSize_ / 2)
+	        };
+
+	        this.adapter_.updateCssVariable(VAR_LEFT, this.unboundedCoords_.left + 'px');
+	        this.adapter_.updateCssVariable(VAR_TOP, this.unboundedCoords_.top + 'px');
+	      }
+	    }
+	  }]);
+
+	  return MDCRippleFoundation;
+	}(_base.MDCFoundation);
+
+	exports.default = MDCRippleFoundation;
 
 /***/ },
 /* 7 */
@@ -946,6 +1251,8 @@ return /******/ (function(modules) { // webpackBootstrap
 	Object.defineProperty(exports, "__esModule", {
 	  value: true
 	});
+	exports.getCorrectEventName = getCorrectEventName;
+	exports.getCorrectPropertyName = getCorrectPropertyName;
 	/**
 	 * Copyright 2016 Google Inc. All Rights Reserved.
 	 *
@@ -962,367 +1269,260 @@ return /******/ (function(modules) { // webpackBootstrap
 	 * limitations under the License.
 	 */
 
-	var ROOT = 'mdc-checkbox';
-	var ANIM = ROOT + '--anim';
-
-	var cssClasses = exports.cssClasses = {
-	  ROOT: ROOT,
-	  CHECKED: ROOT + '--checked',
-	  INDETERMINATE: ROOT + '--indeterminate',
-	  ANIM_UNCHECKED_CHECKED: ANIM + '-unchecked-checked',
-	  ANIM_UNCHECKED_INDETERMINATE: ANIM + '-unchecked-indeterminate',
-	  ANIM_CHECKED_UNCHECKED: ANIM + '-checked-unchecked',
-	  ANIM_CHECKED_INDETERMINATE: ANIM + '-checked-indeterminate',
-	  ANIM_INDETERMINATE_CHECKED: ANIM + '-indeterminate-checked',
-	  ANIM_INDETERMINATE_UNCHECKED: ANIM + '-indeterminate-unchecked'
-	};
-
-	var strings = exports.strings = {
-	  NATIVE_CONTROL_SELECTOR: '.' + ROOT + '__native-control',
-	  TRANSITION_STATE_INIT: 'init',
-	  TRANSITION_STATE_CHECKED: 'checked',
-	  TRANSITION_STATE_UNCHECKED: 'unchecked',
-	  TRANSITION_STATE_INDETERMINATE: 'indeterminate'
+	var eventTypeMap = {
+	  animationstart: {
+	    noPrefix: 'animationstart',
+	    webkitPrefix: 'webkitAnimationStart'
+	  },
+	  animationend: {
+	    noPrefix: 'animationend',
+	    webkitPrefix: 'webkitAnimationEnd'
+	  },
+	  animationiteration: {
+	    noPrefix: 'animationiteration',
+	    webkitPrefix: 'webkitAnimationIteration'
+	  },
+	  transitionend: {
+	    noPrefix: 'transitionend',
+	    webkitPrefix: 'webkitTransitionEnd'
+	  }
 	};
 
-	var numbers = exports.numbers = {
-	  ANIM_END_LATCH_MS: 100
+	var cssPropertyMap = {
+	  animation: {
+	    noPrefix: 'animation',
+	    webkitPrefix: '-webkit-animation'
+	  },
+	  transform: {
+	    noPrefix: 'transform',
+	    webkitPrefix: '-webkit-transform'
+	  },
+	  transition: {
+	    noPrefix: 'transition',
+	    webkitPrefix: '-webkit-transition'
+	  }
 	};
 
-/***/ },
-/* 8 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.MDCIconToggle = exports.MDCIconToggleFoundation = undefined;
-
-	var _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; };
-
-	var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
-
-	var _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; }; }();
-
-	var _base = __webpack_require__(1);
-
-	var _ripple = __webpack_require__(9);
-
-	var _foundation = __webpack_require__(13);
-
-	var _foundation2 = _interopRequireDefault(_foundation);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-	function _possibleConstructorReturn(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; }
-
-	function _inherits(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; } /**
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Copyright 2016 Google Inc. All Rights Reserved.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Licensed under the Apache License, Version 2.0 (the "License");
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * you may not use this file except in compliance with the License.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * You may obtain a copy of the License at
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *      http://www.apache.org/licenses/LICENSE-2.0
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Unless required by applicable law or agreed to in writing, software
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * distributed under the License is distributed on an "AS IS" BASIS,
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * See the License for the specific language governing permissions and
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * limitations under the License.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
-
-	exports.MDCIconToggleFoundation = _foundation2.default;
-
-	var MDCIconToggle = exports.MDCIconToggle = function (_MDCComponent) {
-	  _inherits(MDCIconToggle, _MDCComponent);
-
-	  _createClass(MDCIconToggle, null, [{
-	    key: 'attachTo',
-	    value: function attachTo(root) {
-	      return new MDCIconToggle(root);
-	    }
-	  }]);
-
-	  function MDCIconToggle() {
-	    var _ref;
-
-	    _classCallCheck(this, MDCIconToggle);
-
-	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
-	      args[_key] = arguments[_key];
-	    }
+	function hasProperShape(windowObj) {
+	  return windowObj.document !== undefined && typeof windowObj.document.createElement === 'function';
+	}
 
-	    var _this = _possibleConstructorReturn(this, (_ref = MDCIconToggle.__proto__ || Object.getPrototypeOf(MDCIconToggle)).call.apply(_ref, [this].concat(args)));
+	function eventFoundInMaps(eventType) {
+	  return eventType in eventTypeMap || eventType in cssPropertyMap;
+	}
 
-	    _this.ripple_ = _this.initRipple_();
-	    return _this;
+	// If 'animation' or 'transition' exist as style property, webkit prefix isn't necessary. Since we are unable to
+	// see the event types on the element, we must rely on the corresponding style properties.
+	function getJavaScriptEventName(eventType, map, el) {
+	  switch (eventType) {
+	    case 'animationstart':
+	    case 'animationend':
+	    case 'animationiteration':
+	      return 'animation' in el.style ? map[eventType].noPrefix : map[eventType].webkitPrefix;
+	    case 'transitionend':
+	      return 'transition' in el.style ? map[eventType].noPrefix : map[eventType].webkitPrefix;
+	    default:
+	      return map[eventType].noPrefix;
 	  }
+	}
 
-	  _createClass(MDCIconToggle, [{
-	    key: 'initRipple_',
-	    value: function initRipple_() {
-	      var _this2 = this;
-
-	      var adapter = _extends(_ripple.MDCRipple.createAdapter(this), {
-	        isUnbounded: function isUnbounded() {
-	          return true;
-	        },
-	        isSurfaceActive: function isSurfaceActive() {
-	          return _this2.foundation_.isKeyboardActivated();
-	        },
-	        computeBoundingRect: function computeBoundingRect() {
-	          var dim = 48;
+	// Helper function to determine browser prefix for CSS3 animation events
+	// and property names
+	//
+	// Parameters:
+	// windowObject: Object -- Contains Document with a `createElement()` method
+	// eventType: string -- The type of animation
+	//
+	// returns the value of the event as a string, prefixed if necessary.
+	// If proper arguments are not supplied, this function will return
+	// the property or event type without webkit prefix.
+	//
+	function getAnimationName(windowObj, eventType) {
+	  if (!hasProperShape(windowObj) || !eventFoundInMaps(eventType)) {
+	    return eventType;
+	  }
 
-	          var _root_$getBoundingCli = _this2.root_.getBoundingClientRect(),
-	              left = _root_$getBoundingCli.left,
-	              top = _root_$getBoundingCli.top;
+	  var map = eventType in eventTypeMap ? eventTypeMap : cssPropertyMap;
+	  var el = windowObj.document.createElement('div');
+	  var eventName = '';
 
-	          return {
-	            left: left,
-	            top: top,
-	            width: dim,
-	            height: dim,
-	            right: left + dim,
-	            bottom: left + dim
-	          };
-	        }
-	      });
-	      var foundation = new _ripple.MDCRippleFoundation(adapter);
-	      return new _ripple.MDCRipple(this.root_, foundation);
-	    }
-	  }, {
-	    key: 'destroy',
-	    value: function destroy() {
-	      this.ripple_.destroy();
-	      _get(MDCIconToggle.prototype.__proto__ || Object.getPrototypeOf(MDCIconToggle.prototype), 'destroy', this).call(this);
-	    }
-	  }, {
-	    key: 'getDefaultFoundation',
-	    value: function getDefaultFoundation() {
-	      var _this3 = this;
+	  if (map === eventTypeMap) {
+	    eventName = getJavaScriptEventName(eventType, map, el);
+	  } else {
+	    eventName = map[eventType].noPrefix in el.style ? map[eventType].noPrefix : map[eventType].webkitPrefix;
+	  }
 
-	      return new _foundation2.default({
-	        addClass: function addClass(className) {
-	          return _this3.iconEl_.classList.add(className);
-	        },
-	        removeClass: function removeClass(className) {
-	          return _this3.iconEl_.classList.remove(className);
-	        },
-	        registerInteractionHandler: function registerInteractionHandler(type, handler) {
-	          return _this3.root_.addEventListener(type, handler);
-	        },
-	        deregisterInteractionHandler: function deregisterInteractionHandler(type, handler) {
-	          return _this3.root_.removeEventListener(type, handler);
-	        },
-	        setText: function setText(text) {
-	          _this3.iconEl_.textContent = text;
-	        },
-	        getTabIndex: function getTabIndex() {
-	          return (/* number */_this3.root_.tabIndex
-	          );
-	        },
-	        setTabIndex: function setTabIndex(tabIndex) {
-	          _this3.root_.tabIndex = tabIndex;
-	        },
-	        getAttr: function getAttr(name, value) {
-	          return _this3.root_.getAttribute(name, value);
-	        },
-	        setAttr: function setAttr(name, value) {
-	          return _this3.root_.setAttribute(name, value);
-	        },
-	        rmAttr: function rmAttr(name, value) {
-	          return _this3.root_.removeAttribute(name, value);
-	        },
-	        notifyChange: function notifyChange(evtData) {
-	          return _this3.emit('MDCIconToggle:change', evtData);
-	        }
-	      });
-	    }
-	  }, {
-	    key: 'initialSyncWithDOM',
-	    value: function initialSyncWithDOM() {
-	      this.on = this.root_.getAttribute(_foundation2.default.strings.ARIA_PRESSED) === 'true';
-	      this.disabled = this.root_.getAttribute(_foundation2.default.strings.ARIA_DISABLED) === 'true';
-	    }
-	  }, {
-	    key: 'refreshToggleData',
-	    value: function refreshToggleData() {
-	      this.foundation_.refreshToggleData();
-	    }
-	  }, {
-	    key: 'iconEl_',
-	    get: function get() {
-	      var sel = this.root_.dataset.iconInnerSelector;
+	  return eventName;
+	}
 
-	      return sel ? this.root_.querySelector(sel) : this.root_;
-	    }
-	  }, {
-	    key: 'on',
-	    get: function get() {
-	      return this.foundation_.isOn();
-	    },
-	    set: function set(isOn) {
-	      this.foundation_.toggle(isOn);
-	    }
-	  }, {
-	    key: 'disabled',
-	    get: function get() {
-	      return this.foundation_.isDisabled();
-	    },
-	    set: function set(isDisabled) {
-	      this.foundation_.setDisabled(isDisabled);
-	    }
-	  }]);
+	// Public functions to access getAnimationName() for JavaScript events or CSS
+	// property names.
+	//
+	// Parameters:
+	// windowObject: Object -- Contains Document with a `createElement()` method
+	// eventType: string -- The type of animation
+	//
+	// returns the value of the event as a string, prefixed if necessary.
+	// If proper arguments are not supplied, this function will return
+	// the property or event type without webkit prefix.
+	//
+	function getCorrectEventName(windowObj, eventType) {
+	  return getAnimationName(windowObj, eventType);
+	}
 
-	  return MDCIconToggle;
-	}(_base.MDCComponent);
+	function getCorrectPropertyName(windowObj, eventType) {
+	  return getAnimationName(windowObj, eventType);
+	}
 
 /***/ },
-/* 9 */
-/***/ function(module, exports, __webpack_require__) {
+/* 8 */
+/***/ function(module, exports) {
 
 	'use strict';
 
 	Object.defineProperty(exports, "__esModule", {
 	  value: true
 	});
-	exports.MDCRipple = exports.MDCRippleFoundation = undefined;
+	/**
+	 * Copyright 2016 Google Inc. All Rights Reserved.
+	 *
+	 * Licensed under the Apache License, Version 2.0 (the "License");
+	 * you may not use this file except in compliance with the License.
+	 * You may obtain a copy of the License at
+	 *
+	 *      http://www.apache.org/licenses/LICENSE-2.0
+	 *
+	 * Unless required by applicable law or agreed to in writing, software
+	 * distributed under the License is distributed on an "AS IS" BASIS,
+	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	 * See the License for the specific language governing permissions and
+	 * limitations under the License.
+	 */
 
-	var _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; }; }();
+	var ROOT = exports.ROOT = 'mdc-ripple';
+	var UPGRADED = exports.UPGRADED = ROOT + '-upgraded';
 
-	var _base = __webpack_require__(1);
+	var cssClasses = exports.cssClasses = {
+	  // Ripple is a special case where the "root" component is really a "mixin" of sorts,
+	  // given that it's an 'upgrade' to an existing component. That being said it is the root
+	  // CSS class that all other CSS classes derive from.
+	  ROOT: UPGRADED,
+	  UNBOUNDED: UPGRADED + '--unbounded',
+	  BG_ACTIVE: UPGRADED + '--background-active',
+	  BG_BOUNDED_ACTIVE_FILL: UPGRADED + '--background-bounded-active-fill',
+	  FG_BOUNDED_ACTIVE_FILL: UPGRADED + '--foreground-bounded-active-fill',
+	  FG_UNBOUNDED_ACTIVATION: UPGRADED + '--foreground-unbounded-activation',
+	  FG_UNBOUNDED_DEACTIVATION: UPGRADED + '--foreground-unbounded-deactivation'
+	};
 
-	var _foundation = __webpack_require__(10);
+	var strings = exports.strings = {
+	  VAR_SURFACE_WIDTH: '--' + ROOT + '-surface-width',
+	  VAR_SURFACE_HEIGHT: '--' + ROOT + '-surface-height',
+	  VAR_FG_SIZE: '--' + ROOT + '-fg-size',
+	  VAR_FG_UNBOUNDED_OPACITY_DURATION: '--' + ROOT + '-fg-unbounded-opacity-duration',
+	  VAR_FG_UNBOUNDED_TRANSFORM_DURATION: '--' + ROOT + '-fg-unbounded-transform-duration',
+	  VAR_LEFT: '--' + ROOT + '-left',
+	  VAR_TOP: '--' + ROOT + '-top',
+	  VAR_TRANSLATE_END: '--' + ROOT + '-translate-end',
+	  VAR_FG_APPROX_XF: '--' + ROOT + '-fg-approx-xf',
+	  VAR_FG_SCALE: '--' + ROOT + '-fg-scale',
+	  VAR_FG_TRANSLATE_START: '--' + ROOT + '-fg-translate-start',
+	  VAR_FG_TRANSLATE_END: '--' + ROOT + '-fg-translate-end'
+	};
 
-	var _foundation2 = _interopRequireDefault(_foundation);
+	var numbers = exports.numbers = {
+	  FG_TRANSFORM_DELAY_MS: 80,
+	  OPACITY_DURATION_DIVISOR: 3,
+	  ACTIVE_OPACITY_DURATION_MS: 110,
+	  MIN_OPACITY_DURATION_MS: 200,
+	  UNBOUNDED_TRANSFORM_DURATION_MS: 200,
+	  PADDING: 10,
+	  INITIAL_ORIGIN_SCALE: 0.6
+	};
 
-	var _util = __webpack_require__(12);
+/***/ },
+/* 9 */
+/***/ function(module, exports) {
 
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+	'use strict';
 
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.supportsCssVariables = supportsCssVariables;
+	exports.getMatchesProperty = getMatchesProperty;
+	exports.animateWithClass = animateWithClass;
+	exports.getNormalizedEventCoords = getNormalizedEventCoords;
+	/**
+	 * Copyright 2016 Google Inc. All Rights Reserved.
+	 *
+	 * Licensed under the Apache License, Version 2.0 (the "License");
+	 * you may not use this file except in compliance with the License.
+	 * You may obtain a copy of the License at
+	 *
+	 *      http://www.apache.org/licenses/LICENSE-2.0
+	 *
+	 * Unless required by applicable law or agreed to in writing, software
+	 * distributed under the License is distributed on an "AS IS" BASIS,
+	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	 * See the License for the specific language governing permissions and
+	 * limitations under the License.
+	 */
 
-	function _possibleConstructorReturn(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; }
+	function supportsCssVariables(windowObj) {
+	  var supportsFunctionPresent = windowObj.CSS && typeof windowObj.CSS.supports === 'function';
+	  if (!supportsFunctionPresent) {
+	    return;
+	  }
 
-	function _inherits(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; } /**
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Copyright 2016 Google Inc. All Rights Reserved.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Licensed under the Apache License, Version 2.0 (the "License");
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * you may not use this file except in compliance with the License.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * You may obtain a copy of the License at
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *      http://www.apache.org/licenses/LICENSE-2.0
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Unless required by applicable law or agreed to in writing, software
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * distributed under the License is distributed on an "AS IS" BASIS,
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * See the License for the specific language governing permissions and
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * limitations under the License.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
+	  var explicitlySupportsCssVars = windowObj.CSS.supports('--css-vars', 'yes');
+	  // See: https://bugs.webkit.org/show_bug.cgi?id=154669
+	  // See: README section on Safari
+	  var weAreFeatureDetectingSafari10plus = windowObj.CSS.supports('(--css-vars: yes)') && windowObj.CSS.supports('color', '#00000000');
+	  return explicitlySupportsCssVars || weAreFeatureDetectingSafari10plus;
+	}
 
-	var MATCHES = (0, _util.getMatchesProperty)(HTMLElement.prototype);
+	function getMatchesProperty(HTMLElementPrototype) {
+	  return ['webkitMatchesSelector', 'msMatchesSelector', 'matches'].filter(function (p) {
+	    return p in HTMLElementPrototype;
+	  }).pop();
+	}
 
-	exports.MDCRippleFoundation = _foundation2.default;
+	function animateWithClass(rippleAdapter, cls, endEvent) {
+	  var cancelled = false;
+	  var cancel = function cancel() {
+	    if (cancelled) {
+	      return;
+	    }
+	    cancelled = true;
+	    rippleAdapter.removeClass(cls);
+	    rippleAdapter.deregisterInteractionHandler(endEvent, cancel);
+	  };
+	  rippleAdapter.registerInteractionHandler(endEvent, cancel);
+	  rippleAdapter.addClass(cls);
+	  return cancel;
+	}
 
-	var MDCRipple = exports.MDCRipple = function (_MDCComponent) {
-	  _inherits(MDCRipple, _MDCComponent);
+	function getNormalizedEventCoords(ev, pageOffset, clientRect) {
+	  var x = pageOffset.x,
+	      y = pageOffset.y;
 
-	  function MDCRipple() {
-	    _classCallCheck(this, MDCRipple);
+	  var documentX = x + clientRect.left;
+	  var documentY = y + clientRect.top;
 
-	    return _possibleConstructorReturn(this, (MDCRipple.__proto__ || Object.getPrototypeOf(MDCRipple)).apply(this, arguments));
+	  var normalizedX = void 0;
+	  var normalizedY = void 0;
+	  // Determine touch point relative to the ripple container.
+	  if (ev.type === 'touchend') {
+	    normalizedX = ev.changedTouches[0].pageX - documentX;
+	    normalizedY = ev.changedTouches[0].pageY - documentY;
+	  } else {
+	    normalizedX = ev.pageX - documentX;
+	    normalizedY = ev.pageY - documentY;
 	  }
 
-	  _createClass(MDCRipple, [{
-	    key: 'getDefaultFoundation',
-	    value: function getDefaultFoundation() {
-	      return new _foundation2.default(MDCRipple.createAdapter(this));
-	    }
-	  }, {
-	    key: 'initialSyncWithDOM',
-	    value: function initialSyncWithDOM() {
-	      this.unbounded = 'mdcRippleIsUnbounded' in this.root_.dataset;
-	    }
-	  }, {
-	    key: 'unbounded',
-	    get: function get() {
-	      return this.unbounded_;
-	    },
-	    set: function set(unbounded) {
-	      var UNBOUNDED = _foundation2.default.cssClasses.UNBOUNDED;
-
-	      this.unbounded_ = Boolean(unbounded);
-	      if (this.unbounded_) {
-	        this.root_.classList.add(UNBOUNDED);
-	      } else {
-	        this.root_.classList.remove(UNBOUNDED);
-	      }
-	    }
-	  }], [{
-	    key: 'attachTo',
-	    value: function attachTo(root) {
-	      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-	          _ref$isUnbounded = _ref.isUnbounded,
-	          isUnbounded = _ref$isUnbounded === undefined ? undefined : _ref$isUnbounded;
-
-	      var ripple = new MDCRipple(root);
-	      // Only override unbounded behavior if option is explicitly specified
-	      if (isUnbounded !== undefined) {
-	        ripple.unbounded = isUnbounded;
-	      }
-	      return ripple;
-	    }
-	  }, {
-	    key: 'createAdapter',
-	    value: function createAdapter(instance) {
-	      return {
-	        browserSupportsCssVars: function browserSupportsCssVars() {
-	          return (0, _util.supportsCssVariables)(window);
-	        },
-	        isUnbounded: function isUnbounded() {
-	          return instance.unbounded;
-	        },
-	        isSurfaceActive: function isSurfaceActive() {
-	          return instance.root_[MATCHES](':active');
-	        },
-	        addClass: function addClass(className) {
-	          return instance.root_.classList.add(className);
-	        },
-	        removeClass: function removeClass(className) {
-	          return instance.root_.classList.remove(className);
-	        },
-	        registerInteractionHandler: function registerInteractionHandler(evtType, handler) {
-	          return instance.root_.addEventListener(evtType, handler);
-	        },
-	        deregisterInteractionHandler: function deregisterInteractionHandler(evtType, handler) {
-	          return instance.root_.removeEventListener(evtType, handler);
-	        },
-	        registerResizeHandler: function registerResizeHandler(handler) {
-	          return window.addEventListener('resize', handler);
-	        },
-	        deregisterResizeHandler: function deregisterResizeHandler(handler) {
-	          return window.removeEventListener('resize', handler);
-	        },
-	        updateCssVariable: function updateCssVariable(varName, value) {
-	          return instance.root_.style.setProperty(varName, value);
-	        },
-	        computeBoundingRect: function computeBoundingRect() {
-	          return instance.root_.getBoundingClientRect();
-	        },
-	        getWindowPageOffset: function getWindowPageOffset() {
-	          return { x: window.pageXOffset, y: window.pageYOffset };
-	        }
-	      };
-	    }
-	  }]);
-
-	  return MDCRipple;
-	}(_base.MDCComponent);
+	  return { x: normalizedX, y: normalizedY };
+	}
 
 /***/ },
 /* 10 */
@@ -1340,12 +1540,8 @@ return /******/ (function(modules) { // webpackBootstrap
 
 	var _base = __webpack_require__(1);
 
-	var _animation = __webpack_require__(5);
-
 	var _constants = __webpack_require__(11);
 
-	var _util = __webpack_require__(12);
-
 	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 	function _possibleConstructorReturn(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; }
@@ -1366,29 +1562,12 @@ return /******/ (function(modules) { // webpackBootstrap
 	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * limitations under the License.
 	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
 
-	var DEACTIVATION_ACTIVATION_PAIRS = {
-	  mouseup: 'mousedown',
-	  pointerup: 'pointerdown',
-	  touchend: 'touchstart',
-	  keyup: 'keydown',
-	  blur: 'focus'
-	};
-
-	var MDCRippleFoundation = function (_MDCFoundation) {
-	  _inherits(MDCRippleFoundation, _MDCFoundation);
-
-	  _createClass(MDCRippleFoundation, [{
-	    key: 'isSupported_',
+	var CB_PROTO_PROPS = ['checked', 'indeterminate'];
 
+	var MDCCheckboxFoundation = function (_MDCFoundation) {
+	  _inherits(MDCCheckboxFoundation, _MDCFoundation);
 
-	    // We compute this property so that we are not querying information about the client
-	    // until the point in time where the foundation requests it. This prevents scenarios where
-	    // client-side feature-detection may happen too early, such as when components are rendered on the server
-	    // and then initialized at mount time on the client.
-	    get: function get() {
-	      return this.adapter_.browserSupportsCssVars();
-	    }
-	  }], [{
+	  _createClass(MDCCheckboxFoundation, null, [{
 	    key: 'cssClasses',
 	    get: function get() {
 	      return _constants.cssClasses;
@@ -1407,490 +1586,217 @@ return /******/ (function(modules) { // webpackBootstrap
 	    key: 'defaultAdapter',
 	    get: function get() {
 	      return {
-	        browserSupportsCssVars: function browserSupportsCssVars() /* boolean - cached */{},
-	        isUnbounded: function isUnbounded() /* boolean */{},
-	        isSurfaceActive: function isSurfaceActive() /* boolean */{},
 	        addClass: function addClass() /* className: string */{},
 	        removeClass: function removeClass() /* className: string */{},
-	        registerInteractionHandler: function registerInteractionHandler() /* evtType: string, handler: EventListener */{},
-	        deregisterInteractionHandler: function deregisterInteractionHandler() /* evtType: string, handler: EventListener */{},
-	        registerResizeHandler: function registerResizeHandler() /* handler: EventListener */{},
-	        deregisterResizeHandler: function deregisterResizeHandler() /* handler: EventListener */{},
-	        updateCssVariable: function updateCssVariable() /* varName: string, value: string */{},
-	        computeBoundingRect: function computeBoundingRect() /* ClientRect */{},
-	        getWindowPageOffset: function getWindowPageOffset() /* {x: number, y: number} */{}
+	        registerAnimationEndHandler: function registerAnimationEndHandler() /* handler: EventListener */{},
+	        deregisterAnimationEndHandler: function deregisterAnimationEndHandler() /* handler: EventListener */{},
+	        registerChangeHandler: function registerChangeHandler() /* handler: EventListener */{},
+	        deregisterChangeHandler: function deregisterChangeHandler() /* handler: EventListener */{},
+	        getNativeControl: function getNativeControl() /* HTMLInputElement */{},
+	        forceLayout: function forceLayout() {},
+	        isAttachedToDOM: function isAttachedToDOM() /* boolean */{}
 	      };
 	    }
 	  }]);
 
-	  function MDCRippleFoundation(adapter) {
-	    _classCallCheck(this, MDCRippleFoundation);
+	  function MDCCheckboxFoundation(adapter) {
+	    _classCallCheck(this, MDCCheckboxFoundation);
 
-	    var _this = _possibleConstructorReturn(this, (MDCRippleFoundation.__proto__ || Object.getPrototypeOf(MDCRippleFoundation)).call(this, _extends(MDCRippleFoundation.defaultAdapter, adapter)));
+	    var _this = _possibleConstructorReturn(this, (MDCCheckboxFoundation.__proto__ || Object.getPrototypeOf(MDCCheckboxFoundation)).call(this, _extends(MDCCheckboxFoundation.defaultAdapter, adapter)));
 
-	    _this.layoutFrame_ = 0;
-	    _this.frame_ = { width: 0, height: 0 };
-	    _this.activationState_ = _this.defaultActivationState_();
-	    _this.xfDuration_ = 0;
-	    _this.maxRadius = 0;
-	    _this.listenerInfos_ = [{ activate: 'touchstart', deactivate: 'touchend' }, { activate: 'pointerdown', deactivate: 'pointerup' }, { activate: 'mousedown', deactivate: 'mouseup' }, { activate: 'keydown', deactivate: 'keyup' }, { focus: 'focus', blur: 'blur' }];
-	    _this.listeners_ = {
-	      activate: function activate(e) {
-	        return _this.activate_(e);
-	      },
-	      deactivate: function deactivate(e) {
-	        return _this.deactivate_(e);
-	      },
-	      focus: function focus() {
-	        return requestAnimationFrame(function () {
-	          return _this.adapter_.addClass(MDCRippleFoundation.cssClasses.BG_ACTIVE);
-	        });
-	      },
-	      blur: function blur() {
-	        return requestAnimationFrame(function () {
-	          return _this.adapter_.removeClass(MDCRippleFoundation.cssClasses.BG_ACTIVE);
-	        });
-	      }
-	    };
-	    _this.unboundedOpacityFadeTimer_ = 0;
-	    _this.resizeHandler_ = function () {
-	      return _this.layout();
+	    _this.currentCheckState_ = _constants.strings.TRANSITION_STATE_INIT;
+	    _this.currentAnimationClass_ = '';
+	    _this.animEndLatchTimer_ = 0;
+	    _this.animEndHandler_ = function () {
+	      clearTimeout(_this.animEndLatchTimer_);
+	      _this.animEndLatchTimer_ = setTimeout(function () {
+	        _this.adapter_.removeClass(_this.currentAnimationClass_);
+	        _this.adapter_.deregisterAnimationEndHandler(_this.animEndHandler_);
+	      }, _constants.numbers.ANIM_END_LATCH_MS);
 	    };
-	    _this.cancelBgBounded_ = function () {};
-	    _this.cancelFgBounded_ = function () {};
-	    _this.cancelFgUnbounded_ = function () {};
-	    _this.unboundedCoords_ = {
-	      left: 0,
-	      top: 0
+	    _this.changeHandler_ = function () {
+	      return _this.transitionCheckState_();
 	    };
 	    return _this;
 	  }
 
-	  _createClass(MDCRippleFoundation, [{
-	    key: 'defaultActivationState_',
-	    value: function defaultActivationState_() {
-	      return {
-	        isActivated: false,
-	        wasActivatedByPointer: false,
-	        wasElementMadeActive: false,
-	        activationStartTime: 0,
-	        activationEvent: null
-	      };
-	    }
-	  }, {
+	  _createClass(MDCCheckboxFoundation, [{
 	    key: 'init',
 	    value: function init() {
-	      var _this2 = this;
-
-	      if (!this.isSupported_) {
-	        return;
-	      }
-	      this.addEventListeners_();
-
-	      var _MDCRippleFoundation$ = MDCRippleFoundation.cssClasses,
-	          ROOT = _MDCRippleFoundation$.ROOT,
-	          UNBOUNDED = _MDCRippleFoundation$.UNBOUNDED;
-
-	      requestAnimationFrame(function () {
-	        _this2.adapter_.addClass(ROOT);
-	        if (_this2.adapter_.isUnbounded()) {
-	          _this2.adapter_.addClass(UNBOUNDED);
-	        }
-	        _this2.layoutInternal_();
-	      });
-	    }
-	  }, {
-	    key: 'addEventListeners_',
-	    value: function addEventListeners_() {
-	      var _this3 = this;
-
-	      this.listenerInfos_.forEach(function (info) {
-	        Object.keys(info).forEach(function (k) {
-	          _this3.adapter_.registerInteractionHandler(info[k], _this3.listeners_[k]);
-	        });
-	      });
-	      this.adapter_.registerResizeHandler(this.resizeHandler_);
-	    }
-	  }, {
-	    key: 'activate_',
-	    value: function activate_(e) {
-	      var _this4 = this;
-
-	      var activationState = this.activationState_;
-
-	      if (activationState.isActivated) {
-	        return;
-	      }
-
-	      activationState.isActivated = true;
-	      activationState.activationEvent = e;
-	      activationState.wasActivatedByPointer = e.type === 'mousedown' || e.type === 'touchstart' || e.type === 'pointerdown';
-
-	      activationState.activationStartTime = Date.now();
-	      requestAnimationFrame(function () {
-	        // This needs to be wrapped in an rAF call b/c web browsers
-	        // report active states inconsistently when they're called within
-	        // event handling code:
-	        // - https://bugs.chromium.org/p/chromium/issues/detail?id=635971
-	        // - https://bugzilla.mozilla.org/show_bug.cgi?id=1293741
-	        activationState.wasElementMadeActive = e.type === 'keydown' ? _this4.adapter_.isSurfaceActive() : true;
-	        if (activationState.wasElementMadeActive) {
-	          _this4.animateActivation_();
-	        } else {
-	          // Reset activation state immediately if element was not made active.
-	          _this4.activationState_ = _this4.defaultActivationState_();
-	        }
-	      });
-	    }
-	  }, {
-	    key: 'animateActivation_',
-	    value: function animateActivation_() {
-	      var _this5 = this;
-
-	      var _MDCRippleFoundation$2 = MDCRippleFoundation.cssClasses,
-	          BG_ACTIVE = _MDCRippleFoundation$2.BG_ACTIVE,
-	          BG_BOUNDED_ACTIVE_FILL = _MDCRippleFoundation$2.BG_BOUNDED_ACTIVE_FILL,
-	          FG_UNBOUNDED_DEACTIVATION = _MDCRippleFoundation$2.FG_UNBOUNDED_DEACTIVATION,
-	          FG_BOUNDED_ACTIVE_FILL = _MDCRippleFoundation$2.FG_BOUNDED_ACTIVE_FILL;
-
-	      // If ripple is currently deactivating, cancel those animations.
-
-	      [BG_BOUNDED_ACTIVE_FILL, FG_UNBOUNDED_DEACTIVATION, FG_BOUNDED_ACTIVE_FILL].forEach(function (c) {
-	        return _this5.adapter_.removeClass(c);
-	      });
-	      this.cancelBgBounded_();
-	      this.cancelFgBounded_();
-	      this.cancelFgUnbounded_();
-	      if (this.unboundedOpacityFadeTimer_) {
-	        clearTimeout(this.unboundedOpacityFadeTimer_);
-	        this.unboundedOpacityFadeTimer_ = 0;
-	      }
-
-	      this.adapter_.addClass(BG_ACTIVE);
-	      if (this.adapter_.isUnbounded()) {
-	        this.animateUnboundedActivation_();
-	      }
+	      this.adapter_.registerChangeHandler(this.changeHandler_);
+	      this.installPropertyChangeHooks_();
 	    }
 	  }, {
-	    key: 'animateUnboundedActivation_',
-	    value: function animateUnboundedActivation_() {
-	      var FG_UNBOUNDED_ACTIVATION = MDCRippleFoundation.cssClasses.FG_UNBOUNDED_ACTIVATION;
-
-	      var startPoint = void 0;
-	      if (this.activationState_.wasActivatedByPointer) {
-	        startPoint = (0, _util.getNormalizedEventCoords)(this.activationState_.activationEvent, this.adapter_.getWindowPageOffset(), this.adapter_.computeBoundingRect());
-	      } else {
-	        startPoint = {
-	          left: this.frame_.width / 2,
-	          top: this.frame_.height / 2
-	        };
-	      }
-	      var _startPoint = startPoint,
-	          left = _startPoint.left,
-	          top = _startPoint.top;
-	      var _MDCRippleFoundation$3 = MDCRippleFoundation.strings,
-	          VAR_XF_ORIGIN_X = _MDCRippleFoundation$3.VAR_XF_ORIGIN_X,
-	          VAR_XF_ORIGIN_Y = _MDCRippleFoundation$3.VAR_XF_ORIGIN_Y;
-
-	      this.adapter_.updateCssVariable(VAR_XF_ORIGIN_X, left - this.unboundedCoords_.left + 'px');
-	      this.adapter_.updateCssVariable(VAR_XF_ORIGIN_Y, top - this.unboundedCoords_.top + 'px');
-	      this.adapter_.addClass(FG_UNBOUNDED_ACTIVATION);
+	    key: 'destroy',
+	    value: function destroy() {
+	      this.adapter_.deregisterChangeHandler(this.changeHandler_);
+	      this.uninstallPropertyChangeHooks_();
 	    }
 	  }, {
-	    key: 'deactivate_',
-	    value: function deactivate_(e) {
-	      var _this6 = this;
-
-	      var activationState = this.activationState_;
-	      // This can happen in scenarios such as when you have a keyup event that blurs the element.
-
-	      if (!activationState.isActivated) {
-	        return;
-	      }
-	      var actualActivationType = DEACTIVATION_ACTIVATION_PAIRS[e.type];
-	      var expectedActivationType = activationState.activationEvent.type;
-	      // NOTE: Pointer events are tricky - https://patrickhlauke.github.io/touch/tests/results/
-	      // Essentially, what we need to do here is decouple the deactivation UX from the actual
-	      // deactivation state itself. This way, touch/pointer events in sequence do not trample one
-	      // another.
-	      var needsDeactivationUX = actualActivationType === expectedActivationType;
-	      var needsActualDeactivation = needsDeactivationUX;
-	      if (activationState.wasActivatedByPointer) {
-	        needsActualDeactivation = e.type === 'mouseup';
-	      }
-
-	      var state = _extends({}, this.activationState_);
-	      if (needsDeactivationUX) {
-	        requestAnimationFrame(function () {
-	          return _this6.animateDeactivation_(e, state);
-	        });
-	      }
-	      if (needsActualDeactivation) {
-	        this.activationState_ = this.defaultActivationState_();
-	      }
+	    key: 'isChecked',
+	    value: function isChecked() {
+	      return this.getNativeControl_().checked;
 	    }
 	  }, {
-	    key: 'animateDeactivation_',
-	    value: function animateDeactivation_(e, _ref) {
-	      var wasActivatedByPointer = _ref.wasActivatedByPointer,
-	          wasElementMadeActive = _ref.wasElementMadeActive,
-	          activationStartTime = _ref.activationStartTime;
-	      var BG_ACTIVE = MDCRippleFoundation.cssClasses.BG_ACTIVE;
-
-	      if (wasActivatedByPointer || wasElementMadeActive) {
-	        this.adapter_.removeClass(BG_ACTIVE);
-	        var isPointerEvent = e.type === 'touchend' || e.type === 'pointerup' || e.type === 'mouseup';
-	        if (this.adapter_.isUnbounded()) {
-	          this.animateUnboundedDeactivation_(this.getUnboundedDeactivationInfo_(activationStartTime));
-	        } else {
-	          this.animateBoundedDeactivation_(e, isPointerEvent);
-	        }
-	      }
+	    key: 'setChecked',
+	    value: function setChecked(checked) {
+	      this.getNativeControl_().checked = checked;
 	    }
 	  }, {
-	    key: 'animateUnboundedDeactivation_',
-	    value: function animateUnboundedDeactivation_(_ref2) {
-	      var _this7 = this;
-
-	      var opacityDuration = _ref2.opacityDuration,
-	          transformDuration = _ref2.transformDuration,
-	          approxCurScale = _ref2.approxCurScale;
-	      var _MDCRippleFoundation$4 = MDCRippleFoundation.cssClasses,
-	          FG_UNBOUNDED_ACTIVATION = _MDCRippleFoundation$4.FG_UNBOUNDED_ACTIVATION,
-	          FG_UNBOUNDED_DEACTIVATION = _MDCRippleFoundation$4.FG_UNBOUNDED_DEACTIVATION;
-	      var _MDCRippleFoundation$5 = MDCRippleFoundation.strings,
-	          VAR_FG_UNBOUNDED_OPACITY_DURATION = _MDCRippleFoundation$5.VAR_FG_UNBOUNDED_OPACITY_DURATION,
-	          VAR_FG_UNBOUNDED_TRANSFORM_DURATION = _MDCRippleFoundation$5.VAR_FG_UNBOUNDED_TRANSFORM_DURATION,
-	          VAR_FG_APPROX_XF = _MDCRippleFoundation$5.VAR_FG_APPROX_XF;
-
-	      this.adapter_.updateCssVariable(VAR_FG_APPROX_XF, 'scale(' + approxCurScale + ')');
-	      this.adapter_.updateCssVariable(VAR_FG_UNBOUNDED_OPACITY_DURATION, opacityDuration + 'ms');
-	      this.adapter_.updateCssVariable(VAR_FG_UNBOUNDED_TRANSFORM_DURATION, transformDuration + 'ms');
-	      this.adapter_.addClass(FG_UNBOUNDED_DEACTIVATION);
-	      this.adapter_.removeClass(FG_UNBOUNDED_ACTIVATION);
-	      // We use setTimeout here since we know how long the fade will take.
-	      this.unboundedOpacityFadeTimer_ = setTimeout(function () {
-	        _this7.adapter_.removeClass(FG_UNBOUNDED_DEACTIVATION);
-	      }, opacityDuration);
+	    key: 'isIndeterminate',
+	    value: function isIndeterminate() {
+	      return this.getNativeControl_().indeterminate;
 	    }
 	  }, {
-	    key: 'getUnboundedDeactivationInfo_',
-	    value: function getUnboundedDeactivationInfo_(activationStartTime) {
-	      var msElapsed = Date.now() - activationStartTime;
-	      var _MDCRippleFoundation$6 = MDCRippleFoundation.numbers,
-	          FG_TRANSFORM_DELAY_MS = _MDCRippleFoundation$6.FG_TRANSFORM_DELAY_MS,
-	          OPACITY_DURATION_DIVISOR = _MDCRippleFoundation$6.OPACITY_DURATION_DIVISOR,
-	          ACTIVE_OPACITY_DURATION_MS = _MDCRippleFoundation$6.ACTIVE_OPACITY_DURATION_MS,
-	          UNBOUNDED_TRANSFORM_DURATION_MS = _MDCRippleFoundation$6.UNBOUNDED_TRANSFORM_DURATION_MS,
-	          MIN_OPACITY_DURATION_MS = _MDCRippleFoundation$6.MIN_OPACITY_DURATION_MS;
-
-
-	      var approxCurScale = 0;
-	      if (msElapsed > FG_TRANSFORM_DELAY_MS) {
-	        approxCurScale = Math.min((msElapsed - FG_TRANSFORM_DELAY_MS) / this.xfDuration_, 1);
-	      }
-
-	      var transformDuration = UNBOUNDED_TRANSFORM_DURATION_MS;
-	      var approxOpacity = Math.min(msElapsed / ACTIVE_OPACITY_DURATION_MS, 1);
-	      var opacityDuration = Math.max(MIN_OPACITY_DURATION_MS, 1000 * approxOpacity / OPACITY_DURATION_DIVISOR);
-
-	      return { transformDuration: transformDuration, opacityDuration: opacityDuration, approxCurScale: approxCurScale };
+	    key: 'setIndeterminate',
+	    value: function setIndeterminate(indeterminate) {
+	      this.getNativeControl_().indeterminate = indeterminate;
 	    }
 	  }, {
-	    key: 'animateBoundedDeactivation_',
-	    value: function animateBoundedDeactivation_(e, isPointerEvent) {
-	      var startPoint = void 0;
-	      if (isPointerEvent) {
-	        startPoint = (0, _util.getNormalizedEventCoords)(e, this.adapter_.getWindowPageOffset(), this.adapter_.computeBoundingRect());
-	      } else {
-	        startPoint = {
-	          left: this.frame_.width / 2,
-	          top: this.frame_.height / 2
-	        };
-	      }
-	      var _startPoint2 = startPoint,
-	          left = _startPoint2.left,
-	          top = _startPoint2.top;
-	      var _MDCRippleFoundation$7 = MDCRippleFoundation.strings,
-	          VAR_LEFT = _MDCRippleFoundation$7.VAR_LEFT,
-	          VAR_TOP = _MDCRippleFoundation$7.VAR_TOP;
-	      var _MDCRippleFoundation$8 = MDCRippleFoundation.cssClasses,
-	          BG_BOUNDED_ACTIVE_FILL = _MDCRippleFoundation$8.BG_BOUNDED_ACTIVE_FILL,
-	          FG_BOUNDED_ACTIVE_FILL = _MDCRippleFoundation$8.FG_BOUNDED_ACTIVE_FILL;
-
-	      this.adapter_.updateCssVariable(VAR_LEFT, left + 'px');
-	      this.adapter_.updateCssVariable(VAR_TOP, top + 'px');
-	      this.cancelBgBounded_ = (0, _util.animateWithClass)(this.adapter_, BG_BOUNDED_ACTIVE_FILL, (0, _animation.getCorrectEventName)(window, 'transitionend'));
-	      this.cancelFgBounded_ = (0, _util.animateWithClass)(this.adapter_, FG_BOUNDED_ACTIVE_FILL, (0, _animation.getCorrectEventName)(window, 'animationend'));
+	    key: 'isDisabled',
+	    value: function isDisabled() {
+	      return this.getNativeControl_().disabled;
 	    }
 	  }, {
-	    key: 'destroy',
-	    value: function destroy() {
-	      var _this8 = this;
-
-	      if (!this.isSupported_) {
-	        return;
-	      }
-	      this.removeEventListeners_();
-
-	      var _MDCRippleFoundation$9 = MDCRippleFoundation.cssClasses,
-	          ROOT = _MDCRippleFoundation$9.ROOT,
-	          UNBOUNDED = _MDCRippleFoundation$9.UNBOUNDED;
-
-	      requestAnimationFrame(function () {
-	        _this8.adapter_.removeClass(ROOT);
-	        _this8.adapter_.removeClass(UNBOUNDED);
-	        _this8.removeCssVars_();
-	      });
+	    key: 'setDisabled',
+	    value: function setDisabled(disabled) {
+	      this.getNativeControl_().disabled = disabled;
 	    }
 	  }, {
-	    key: 'removeEventListeners_',
-	    value: function removeEventListeners_() {
-	      var _this9 = this;
+	    key: 'installPropertyChangeHooks_',
+	    value: function installPropertyChangeHooks_() {
+	      var _this2 = this;
 
-	      this.listenerInfos_.forEach(function (info) {
-	        Object.keys(info).forEach(function (k) {
-	          _this9.adapter_.deregisterInteractionHandler(info[k], _this9.listeners_[k]);
-	        });
+	      var nativeCb = this.getNativeControl_();
+	      var cbProto = Object.getPrototypeOf(nativeCb);
+
+	      CB_PROTO_PROPS.forEach(function (controlState) {
+	        var desc = Object.getOwnPropertyDescriptor(cbProto, controlState);
+	        // We have to check for this descriptor, since some browsers (Safari) don't support its return.
+	        // See: https://bugs.webkit.org/show_bug.cgi?id=49739
+	        if (validDescriptor(desc)) {
+	          Object.defineProperty(nativeCb, controlState, {
+	            get: desc.get,
+	            set: function set(state) {
+	              desc.set.call(nativeCb, state);
+	              _this2.transitionCheckState_();
+	            },
+	            configurable: desc.configurable,
+	            enumerable: desc.enumerable
+	          });
+	        }
 	      });
-	      this.adapter_.deregisterResizeHandler(this.resizeHandler_);
 	    }
 	  }, {
-	    key: 'removeCssVars_',
-	    value: function removeCssVars_() {
-	      var _this10 = this;
-
-	      var strings = MDCRippleFoundation.strings;
+	    key: 'uninstallPropertyChangeHooks_',
+	    value: function uninstallPropertyChangeHooks_() {
+	      var nativeCb = this.getNativeControl_();
+	      var cbProto = Object.getPrototypeOf(nativeCb);
 
-	      Object.keys(strings).forEach(function (k) {
-	        if (k.indexOf('VAR_') === 0) {
-	          _this10.adapter_.updateCssVariable(strings[k], null);
+	      CB_PROTO_PROPS.forEach(function (controlState) {
+	        var desc = Object.getOwnPropertyDescriptor(cbProto, controlState);
+	        if (validDescriptor(desc)) {
+	          Object.defineProperty(nativeCb, controlState, desc);
 	        }
 	      });
 	    }
 	  }, {
-	    key: 'layout',
-	    value: function layout() {
-	      var _this11 = this;
+	    key: 'transitionCheckState_',
+	    value: function transitionCheckState_() {
+	      var nativeCb = this.adapter_.getNativeControl();
+	      if (!nativeCb) {
+	        return;
+	      }
+	      var oldState = this.currentCheckState_;
+	      var newState = this.determineCheckState_(nativeCb);
+	      if (oldState === newState) {
+	        return;
+	      }
 
-	      if (this.layoutFrame_) {
-	        cancelAnimationFrame(this.layoutFrame_);
+	      // Check to ensure that there isn't a previously existing animation class, in case for example
+	      // the user interacted with the checkbox before the animation was finished.
+	      if (this.currentAnimationClass_.length > 0) {
+	        clearTimeout(this.animEndLatchTimer_);
+	        this.adapter_.forceLayout();
+	        this.adapter_.removeClass(this.currentAnimationClass_);
+	      }
+
+	      this.currentAnimationClass_ = this.getTransitionAnimationClass_(oldState, newState);
+	      this.currentCheckState_ = newState;
+
+	      // Check for parentNode so that animations are only run when the element is attached
+	      // to the DOM.
+	      if (this.adapter_.isAttachedToDOM() && this.currentAnimationClass_.length > 0) {
+	        this.adapter_.addClass(this.currentAnimationClass_);
+	        this.adapter_.registerAnimationEndHandler(this.animEndHandler_);
 	      }
-	      this.layoutFrame_ = requestAnimationFrame(function () {
-	        _this11.layoutInternal_();
-	        _this11.layoutFrame_ = 0;
-	      });
 	    }
 	  }, {
-	    key: 'layoutInternal_',
-	    value: function layoutInternal_() {
-	      this.frame_ = this.adapter_.computeBoundingRect();
+	    key: 'determineCheckState_',
+	    value: function determineCheckState_(nativeCb) {
+	      var TRANSITION_STATE_INDETERMINATE = _constants.strings.TRANSITION_STATE_INDETERMINATE,
+	          TRANSITION_STATE_CHECKED = _constants.strings.TRANSITION_STATE_CHECKED,
+	          TRANSITION_STATE_UNCHECKED = _constants.strings.TRANSITION_STATE_UNCHECKED;
 
-	      var maxDim = Math.max(this.frame_.height, this.frame_.width);
 
-	      // Sqrt(2) * square length == diameter
-	      this.maxRadius_ = Math.sqrt(2) * maxDim / 2;
-	      this.xfDuration_ = 1000 * Math.sqrt(this.maxRadius_ / 1024);
-	      this.updateLayoutCssVars_();
+	      if (nativeCb.indeterminate) {
+	        return TRANSITION_STATE_INDETERMINATE;
+	      }
+	      return nativeCb.checked ? TRANSITION_STATE_CHECKED : TRANSITION_STATE_UNCHECKED;
 	    }
 	  }, {
-	    key: 'updateLayoutCssVars_',
-	    value: function updateLayoutCssVars_() {
-	      var fgSize = this.maxRadius_ * 2;
-	      var _MDCRippleFoundation$10 = MDCRippleFoundation.strings,
-	          VAR_SURFACE_WIDTH = _MDCRippleFoundation$10.VAR_SURFACE_WIDTH,
-	          VAR_SURFACE_HEIGHT = _MDCRippleFoundation$10.VAR_SURFACE_HEIGHT,
-	          VAR_FG_SIZE = _MDCRippleFoundation$10.VAR_FG_SIZE,
-	          VAR_FG_UNBOUNDED_TRANSFORM_DURATION = _MDCRippleFoundation$10.VAR_FG_UNBOUNDED_TRANSFORM_DURATION,
-	          VAR_LEFT = _MDCRippleFoundation$10.VAR_LEFT,
-	          VAR_TOP = _MDCRippleFoundation$10.VAR_TOP;
-
+	    key: 'getTransitionAnimationClass_',
+	    value: function getTransitionAnimationClass_(oldState, newState) {
+	      var TRANSITION_STATE_INIT = _constants.strings.TRANSITION_STATE_INIT,
+	          TRANSITION_STATE_CHECKED = _constants.strings.TRANSITION_STATE_CHECKED,
+	          TRANSITION_STATE_UNCHECKED = _constants.strings.TRANSITION_STATE_UNCHECKED;
+	      var _MDCCheckboxFoundatio = MDCCheckboxFoundation.cssClasses,
+	          ANIM_UNCHECKED_CHECKED = _MDCCheckboxFoundatio.ANIM_UNCHECKED_CHECKED,
+	          ANIM_UNCHECKED_INDETERMINATE = _MDCCheckboxFoundatio.ANIM_UNCHECKED_INDETERMINATE,
+	          ANIM_CHECKED_UNCHECKED = _MDCCheckboxFoundatio.ANIM_CHECKED_UNCHECKED,
+	          ANIM_CHECKED_INDETERMINATE = _MDCCheckboxFoundatio.ANIM_CHECKED_INDETERMINATE,
+	          ANIM_INDETERMINATE_CHECKED = _MDCCheckboxFoundatio.ANIM_INDETERMINATE_CHECKED,
+	          ANIM_INDETERMINATE_UNCHECKED = _MDCCheckboxFoundatio.ANIM_INDETERMINATE_UNCHECKED;
 
-	      this.adapter_.updateCssVariable(VAR_SURFACE_WIDTH, this.frame_.width + 'px');
-	      this.adapter_.updateCssVariable(VAR_SURFACE_HEIGHT, this.frame_.height + 'px');
-	      this.adapter_.updateCssVariable(VAR_FG_SIZE, fgSize + 'px');
-	      this.adapter_.updateCssVariable(VAR_FG_UNBOUNDED_TRANSFORM_DURATION, this.xfDuration_ + 'ms');
 
-	      if (this.adapter_.isUnbounded()) {
-	        this.unboundedCoords_ = {
-	          left: Math.round(-(fgSize / 2) + this.frame_.width / 2),
-	          top: Math.round(-(fgSize / 2) + this.frame_.height / 2)
-	        };
-	        this.adapter_.updateCssVariable(VAR_LEFT, this.unboundedCoords_.left + 'px');
-	        this.adapter_.updateCssVariable(VAR_TOP, this.unboundedCoords_.top + 'px');
+	      switch (oldState) {
+	        case TRANSITION_STATE_INIT:
+	          if (newState === TRANSITION_STATE_UNCHECKED) {
+	            return '';
+	          }
+	        // fallthrough
+	        case TRANSITION_STATE_UNCHECKED:
+	          return newState === TRANSITION_STATE_CHECKED ? ANIM_UNCHECKED_CHECKED : ANIM_UNCHECKED_INDETERMINATE;
+	        case TRANSITION_STATE_CHECKED:
+	          return newState === TRANSITION_STATE_UNCHECKED ? ANIM_CHECKED_UNCHECKED : ANIM_CHECKED_INDETERMINATE;
+	        // TRANSITION_STATE_INDETERMINATE
+	        default:
+	          return newState === TRANSITION_STATE_CHECKED ? ANIM_INDETERMINATE_CHECKED : ANIM_INDETERMINATE_UNCHECKED;
 	      }
 	    }
+	  }, {
+	    key: 'getNativeControl_',
+	    value: function getNativeControl_() {
+	      return this.adapter_.getNativeControl() || {
+	        checked: false,
+	        indeterminate: false,
+	        disabled: false
+	      };
+	    }
 	  }]);
 
-	  return MDCRippleFoundation;
+	  return MDCCheckboxFoundation;
 	}(_base.MDCFoundation);
 
-	exports.default = MDCRippleFoundation;
-
-/***/ },
-/* 11 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	/**
-	 * Copyright 2016 Google Inc. All Rights Reserved.
-	 *
-	 * Licensed under the Apache License, Version 2.0 (the "License");
-	 * you may not use this file except in compliance with the License.
-	 * You may obtain a copy of the License at
-	 *
-	 *      http://www.apache.org/licenses/LICENSE-2.0
-	 *
-	 * Unless required by applicable law or agreed to in writing, software
-	 * distributed under the License is distributed on an "AS IS" BASIS,
-	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-	 * See the License for the specific language governing permissions and
-	 * limitations under the License.
-	 */
-
-	var ROOT = exports.ROOT = 'mdc-ripple';
-	var UPGRADED = exports.UPGRADED = ROOT + '-upgraded';
-
-	var cssClasses = exports.cssClasses = {
-	  // Ripple is a special case where the "root" component is really a "mixin" of sorts,
-	  // given that it's an 'upgrade' to an existing component. That being said it is the root
-	  // CSS class that all other CSS classes derive from.
-	  ROOT: UPGRADED,
-	  UNBOUNDED: UPGRADED + '--unbounded',
-	  BG_ACTIVE: UPGRADED + '--background-active',
-	  BG_BOUNDED_ACTIVE_FILL: UPGRADED + '--background-bounded-active-fill',
-	  FG_BOUNDED_ACTIVE_FILL: UPGRADED + '--foreground-bounded-active-fill',
-	  FG_UNBOUNDED_ACTIVATION: UPGRADED + '--foreground-unbounded-activation',
-	  FG_UNBOUNDED_DEACTIVATION: UPGRADED + '--foreground-unbounded-deactivation'
-	};
-
-	var strings = exports.strings = {
-	  VAR_SURFACE_WIDTH: '--' + ROOT + '-surface-width',
-	  VAR_SURFACE_HEIGHT: '--' + ROOT + '-surface-height',
-	  VAR_FG_SIZE: '--' + ROOT + '-fg-size',
-	  VAR_FG_UNBOUNDED_OPACITY_DURATION: '--' + ROOT + '-fg-unbounded-opacity-duration',
-	  VAR_FG_UNBOUNDED_TRANSFORM_DURATION: '--' + ROOT + '-fg-unbounded-transform-duration',
-	  VAR_LEFT: '--' + ROOT + '-left',
-	  VAR_TOP: '--' + ROOT + '-top',
-	  VAR_XF_ORIGIN_X: '--' + ROOT + '-xfo-x',
-	  VAR_XF_ORIGIN_Y: '--' + ROOT + '-xfo-y',
-	  VAR_FG_APPROX_XF: '--' + ROOT + '-fg-approx-xf'
-	};
-
-	var numbers = exports.numbers = {
-	  FG_TRANSFORM_DELAY_MS: 80,
-	  OPACITY_DURATION_DIVISOR: 3,
-	  ACTIVE_OPACITY_DURATION_MS: 110,
-	  MIN_OPACITY_DURATION_MS: 200,
-	  UNBOUNDED_TRANSFORM_DURATION_MS: 200
-	};
-
+	exports.default = MDCCheckboxFoundation;
+
+
+	function validDescriptor(inputPropDesc) {
+	  return inputPropDesc && typeof inputPropDesc.set === 'function';
+	}
+
 /***/ },
-/* 12 */
+/* 11 */
 /***/ function(module, exports) {
 
 	'use strict';
@@ -1898,10 +1804,6 @@ return /******/ (function(modules) { // webpackBootstrap
 	Object.defineProperty(exports, "__esModule", {
 	  value: true
 	});
-	exports.supportsCssVariables = supportsCssVariables;
-	exports.getMatchesProperty = getMatchesProperty;
-	exports.animateWithClass = animateWithClass;
-	exports.getNormalizedEventCoords = getNormalizedEventCoords;
 	/**
 	 * Copyright 2016 Google Inc. All Rights Reserved.
 	 *
@@ -1918,60 +1820,225 @@ return /******/ (function(modules) { // webpackBootstrap
 	 * limitations under the License.
 	 */
 
-	function supportsCssVariables(windowObj) {
-	  var supportsFunctionPresent = windowObj.CSS && typeof windowObj.CSS.supports === 'function';
-	  if (!supportsFunctionPresent) {
-	    return;
-	  }
+	var ROOT = 'mdc-checkbox';
+	var ANIM = ROOT + '--anim';
 
-	  var explicitlySupportsCssVars = windowObj.CSS.supports('--css-vars', 'yes');
-	  // See: https://bugs.webkit.org/show_bug.cgi?id=154669
-	  // See: README section on Safari
-	  var weAreFeatureDetectingSafari10plus = windowObj.CSS.supports('(--css-vars: yes)') && windowObj.CSS.supports('color', '#00000000');
-	  return explicitlySupportsCssVars || weAreFeatureDetectingSafari10plus;
-	}
+	var cssClasses = exports.cssClasses = {
+	  ROOT: ROOT,
+	  CHECKED: ROOT + '--checked',
+	  INDETERMINATE: ROOT + '--indeterminate',
+	  ANIM_UNCHECKED_CHECKED: ANIM + '-unchecked-checked',
+	  ANIM_UNCHECKED_INDETERMINATE: ANIM + '-unchecked-indeterminate',
+	  ANIM_CHECKED_UNCHECKED: ANIM + '-checked-unchecked',
+	  ANIM_CHECKED_INDETERMINATE: ANIM + '-checked-indeterminate',
+	  ANIM_INDETERMINATE_CHECKED: ANIM + '-indeterminate-checked',
+	  ANIM_INDETERMINATE_UNCHECKED: ANIM + '-indeterminate-unchecked'
+	};
 
-	function getMatchesProperty(HTMLElementPrototype) {
-	  return ['webkitMatchesSelector', 'msMatchesSelector', 'matches'].filter(function (p) {
-	    return p in HTMLElementPrototype;
-	  }).pop();
-	}
+	var strings = exports.strings = {
+	  NATIVE_CONTROL_SELECTOR: '.' + ROOT + '__native-control',
+	  TRANSITION_STATE_INIT: 'init',
+	  TRANSITION_STATE_CHECKED: 'checked',
+	  TRANSITION_STATE_UNCHECKED: 'unchecked',
+	  TRANSITION_STATE_INDETERMINATE: 'indeterminate'
+	};
 
-	function animateWithClass(rippleAdapter, cls, endEvent) {
-	  var cancelled = false;
-	  var cancel = function cancel() {
-	    if (cancelled) {
-	      return;
+	var numbers = exports.numbers = {
+	  ANIM_END_LATCH_MS: 100
+	};
+
+/***/ },
+/* 12 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.MDCIconToggle = exports.MDCIconToggleFoundation = undefined;
+
+	var _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; };
+
+	var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+	var _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; }; }();
+
+	var _base = __webpack_require__(1);
+
+	var _ripple = __webpack_require__(5);
+
+	var _foundation = __webpack_require__(13);
+
+	var _foundation2 = _interopRequireDefault(_foundation);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(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; }
+
+	function _inherits(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; } /**
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Copyright 2016 Google Inc. All Rights Reserved.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Licensed under the Apache License, Version 2.0 (the "License");
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * you may not use this file except in compliance with the License.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * You may obtain a copy of the License at
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *      http://www.apache.org/licenses/LICENSE-2.0
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Unless required by applicable law or agreed to in writing, software
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * distributed under the License is distributed on an "AS IS" BASIS,
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * See the License for the specific language governing permissions and
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * limitations under the License.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
+
+	exports.MDCIconToggleFoundation = _foundation2.default;
+
+	var MDCIconToggle = exports.MDCIconToggle = function (_MDCComponent) {
+	  _inherits(MDCIconToggle, _MDCComponent);
+
+	  _createClass(MDCIconToggle, null, [{
+	    key: 'attachTo',
+	    value: function attachTo(root) {
+	      return new MDCIconToggle(root);
 	    }
-	    cancelled = true;
-	    rippleAdapter.removeClass(cls);
-	    rippleAdapter.deregisterInteractionHandler(endEvent, cancel);
-	  };
-	  rippleAdapter.registerInteractionHandler(endEvent, cancel);
-	  rippleAdapter.addClass(cls);
-	  return cancel;
-	}
+	  }]);
 
-	function getNormalizedEventCoords(ev, pageOffset, clientRect) {
-	  var x = pageOffset.x,
-	      y = pageOffset.y;
+	  function MDCIconToggle() {
+	    var _ref;
+
+	    _classCallCheck(this, MDCIconToggle);
 
-	  var documentLeft = x + clientRect.left;
-	  var documentTop = y + clientRect.top;
+	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	      args[_key] = arguments[_key];
+	    }
 
-	  var normalizedLeft = void 0;
-	  var normalizedTop = void 0;
-	  // Determine touch point relative to the ripple container.
-	  if (ev.type === 'touchend') {
-	    normalizedLeft = ev.changedTouches[0].pageX - documentLeft;
-	    normalizedTop = ev.changedTouches[0].pageY - documentTop;
-	  } else {
-	    normalizedLeft = ev.pageX - documentLeft;
-	    normalizedTop = ev.pageY - documentTop;
+	    var _this = _possibleConstructorReturn(this, (_ref = MDCIconToggle.__proto__ || Object.getPrototypeOf(MDCIconToggle)).call.apply(_ref, [this].concat(args)));
+
+	    _this.ripple_ = _this.initRipple_();
+	    return _this;
 	  }
 
-	  return { left: normalizedLeft, top: normalizedTop };
-	}
+	  _createClass(MDCIconToggle, [{
+	    key: 'initRipple_',
+	    value: function initRipple_() {
+	      var _this2 = this;
+
+	      var adapter = _extends(_ripple.MDCRipple.createAdapter(this), {
+	        isUnbounded: function isUnbounded() {
+	          return true;
+	        },
+	        isSurfaceActive: function isSurfaceActive() {
+	          return _this2.foundation_.isKeyboardActivated();
+	        },
+	        computeBoundingRect: function computeBoundingRect() {
+	          var dim = 48;
+
+	          var _root_$getBoundingCli = _this2.root_.getBoundingClientRect(),
+	              left = _root_$getBoundingCli.left,
+	              top = _root_$getBoundingCli.top;
+
+	          return {
+	            left: left,
+	            top: top,
+	            width: dim,
+	            height: dim,
+	            right: left + dim,
+	            bottom: left + dim
+	          };
+	        }
+	      });
+	      var foundation = new _ripple.MDCRippleFoundation(adapter);
+	      return new _ripple.MDCRipple(this.root_, foundation);
+	    }
+	  }, {
+	    key: 'destroy',
+	    value: function destroy() {
+	      this.ripple_.destroy();
+	      _get(MDCIconToggle.prototype.__proto__ || Object.getPrototypeOf(MDCIconToggle.prototype), 'destroy', this).call(this);
+	    }
+	  }, {
+	    key: 'getDefaultFoundation',
+	    value: function getDefaultFoundation() {
+	      var _this3 = this;
+
+	      return new _foundation2.default({
+	        addClass: function addClass(className) {
+	          return _this3.iconEl_.classList.add(className);
+	        },
+	        removeClass: function removeClass(className) {
+	          return _this3.iconEl_.classList.remove(className);
+	        },
+	        registerInteractionHandler: function registerInteractionHandler(type, handler) {
+	          return _this3.root_.addEventListener(type, handler);
+	        },
+	        deregisterInteractionHandler: function deregisterInteractionHandler(type, handler) {
+	          return _this3.root_.removeEventListener(type, handler);
+	        },
+	        setText: function setText(text) {
+	          _this3.iconEl_.textContent = text;
+	        },
+	        getTabIndex: function getTabIndex() {
+	          return (/* number */_this3.root_.tabIndex
+	          );
+	        },
+	        setTabIndex: function setTabIndex(tabIndex) {
+	          _this3.root_.tabIndex = tabIndex;
+	        },
+	        getAttr: function getAttr(name, value) {
+	          return _this3.root_.getAttribute(name, value);
+	        },
+	        setAttr: function setAttr(name, value) {
+	          return _this3.root_.setAttribute(name, value);
+	        },
+	        rmAttr: function rmAttr(name) {
+	          return _this3.root_.removeAttribute(name);
+	        },
+	        notifyChange: function notifyChange(evtData) {
+	          return _this3.emit('MDCIconToggle:change', evtData);
+	        }
+	      });
+	    }
+	  }, {
+	    key: 'initialSyncWithDOM',
+	    value: function initialSyncWithDOM() {
+	      this.on = this.root_.getAttribute(_foundation2.default.strings.ARIA_PRESSED) === 'true';
+	      this.disabled = this.root_.getAttribute(_foundation2.default.strings.ARIA_DISABLED) === 'true';
+	    }
+	  }, {
+	    key: 'refreshToggleData',
+	    value: function refreshToggleData() {
+	      this.foundation_.refreshToggleData();
+	    }
+	  }, {
+	    key: 'iconEl_',
+	    get: function get() {
+	      var sel = this.root_.dataset.iconInnerSelector;
+
+	      return sel ? this.root_.querySelector(sel) : this.root_;
+	    }
+	  }, {
+	    key: 'on',
+	    get: function get() {
+	      return this.foundation_.isOn();
+	    },
+	    set: function set(isOn) {
+	      this.foundation_.toggle(isOn);
+	    }
+	  }, {
+	    key: 'disabled',
+	    get: function get() {
+	      return this.foundation_.isDisabled();
+	    },
+	    set: function set(isDisabled) {
+	      this.foundation_.setDisabled(isDisabled);
+	    }
+	  }]);
+
+	  return MDCIconToggle;
+	}(_base.MDCComponent);
 
 /***/ },
 /* 13 */
@@ -2236,7 +2303,7 @@ return /******/ (function(modules) { // webpackBootstrap
 
 	var _base = __webpack_require__(1);
 
-	var _ripple = __webpack_require__(9);
+	var _ripple = __webpack_require__(5);
 
 	var _foundation = __webpack_require__(15);
 
@@ -3454,7 +3521,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	        registerInputKeydownHandler: function registerInputKeydownHandler() /* handler: EventListener */{},
 	        deregisterInputKeydownHandler: function deregisterInputKeydownHandler() /* handler: EventListener */{},
 	        setHelptextAttr: function setHelptextAttr() /* name: string, value: string */{},
-	        removeHelptextAttr: function removeHelptextAttr() /* name: string, value: string */{},
+	        removeHelptextAttr: function removeHelptextAttr() /* name: string */{},
 	        getNativeInput: function getNativeInput() {
 	          return (/* HTMLInputElement */{}
 	          );
@@ -3636,7 +3703,7 @@ return /******/ (function(modules) { // webpackBootstrap
 
 	var _foundation2 = _interopRequireDefault(_foundation);
 
-	var _animation = __webpack_require__(5);
+	var _animation = __webpack_require__(7);
 
 	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }