text: /* */ 
  "format cjs";
  /**
   * @license
   * 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.
   */
  
  import MDCComponent from '@material/base/component';
  import MDCRippleAdapter from './adapter';
  import MDCRippleFoundation from './foundation';
  import * as util from './util';
  
  /**
   * @extends MDCComponent<!MDCRippleFoundation>
   */
  class MDCRipple extends MDCComponent {
    /** @param {...?} args */
    constructor(...args) {
      super(...args);
  
      /** @type {boolean} */
      this.disabled = false;
  
      /** @private {boolean} */
      this.unbounded_;
    }
  
    /**
     * @param {!Element} root
     * @param {{isUnbounded: (boolean|undefined)}=} options
     * @return {!MDCRipple}
     */
    static attachTo(root, {isUnbounded = undefined} = {}) {
      const ripple = new MDCRipple(root);
      // Only override unbounded behavior if option is explicitly specified
      if (isUnbounded !== undefined) {
        ripple.unbounded = /** @type {boolean} */ (isUnbounded);
      }
      return ripple;
    }
  
    /**
     * @param {!RippleCapableSurface} instance
     * @return {!MDCRippleAdapter}
     */
    static createAdapter(instance) {
      const MATCHES = util.getMatchesProperty(HTMLElement.prototype);
  
      return {
        browserSupportsCssVars: () => util.supportsCssVariables(window),
        isUnbounded: () => instance.unbounded,
        isSurfaceActive: () => instance.root_[MATCHES](':active'),
        isSurfaceDisabled: () => instance.disabled,
        addClass: (className) => instance.root_.classList.add(className),
        removeClass: (className) => instance.root_.classList.remove(className),
        containsEventTarget: (target) => instance.root_.contains(target),
        registerInteractionHandler: (evtType, handler) =>
          instance.root_.addEventListener(evtType, handler, util.applyPassive()),
        deregisterInteractionHandler: (evtType, handler) =>
          instance.root_.removeEventListener(evtType, handler, util.applyPassive()),
        registerDocumentInteractionHandler: (evtType, handler) =>
          document.documentElement.addEventListener(evtType, handler, util.applyPassive()),
        deregisterDocumentInteractionHandler: (evtType, handler) =>
          document.documentElement.removeEventListener(evtType, handler, util.applyPassive()),
        registerResizeHandler: (handler) => window.addEventListener('resize', handler),
        deregisterResizeHandler: (handler) => window.removeEventListener('resize', handler),
        updateCssVariable: (varName, value) => instance.root_.style.setProperty(varName, value),
        computeBoundingRect: () => instance.root_.getBoundingClientRect(),
        getWindowPageOffset: () => ({x: window.pageXOffset, y: window.pageYOffset}),
      };
    }
  
    /** @return {boolean} */
    get unbounded() {
      return this.unbounded_;
    }
  
    /** @param {boolean} unbounded */
    set unbounded(unbounded) {
      this.unbounded_ = Boolean(unbounded);
      this.setUnbounded_();
    }
  
    /**
     * Closure Compiler throws an access control error when directly accessing a
     * protected or private property inside a getter/setter, like unbounded above.
     * By accessing the protected property inside a method, we solve that problem.
     * That's why this function exists.
     * @private
     */
    setUnbounded_() {
      this.foundation_.setUnbounded(this.unbounded_);
    }
  
    activate() {
      this.foundation_.activate();
    }
  
    deactivate() {
      this.foundation_.deactivate();
    }
  
    layout() {
      this.foundation_.layout();
    }
  
    /** @return {!MDCRippleFoundation} */
    getDefaultFoundation() {
      return new MDCRippleFoundation(MDCRipple.createAdapter(this));
    }
  
    initialSyncWithDOM() {
      this.unbounded = 'mdcRippleIsUnbounded' in this.root_.dataset;
    }
  }
  
  /**
   * See Material Design spec for more details on when to use ripples.
   * https://material.io/guidelines/motion/choreography.html#choreography-creation
   * @record
   */
  class RippleCapableSurface {}
  
  /** @protected {!Element} */
  RippleCapableSurface.prototype.root_;
  
  /**
   * Whether or not the ripple bleeds out of the bounds of the element.
   * @type {boolean|undefined}
   */
  RippleCapableSurface.prototype.unbounded;
  
  /**
   * Whether or not the ripple is attached to a disabled component.
   * @type {boolean|undefined}
   */
  RippleCapableSurface.prototype.disabled;
  
  export {MDCRipple, MDCRippleFoundation, RippleCapableSurface, util};
  