text: define(["exports", "../../tslib/tslib.es6.js", "../base/component.js", "../dom/events.js", "../dom/ponyfill.js", "./foundation.js", "./util.js"], function (_exports, _tslibEs, _component, _events, _ponyfill, _foundation, util) {
    "use strict";
  
    Object.defineProperty(_exports, "__esModule", {
      value: true
    });
    _exports.MDCRipple = void 0;
    util = babelHelpers.interopRequireWildcard(util);
  
    /**
     * @license
     * Copyright 2016 Google Inc.
     *
     * Permission is hereby granted, free of charge, to any person obtaining a copy
     * of this software and associated documentation files (the "Software"), to deal
     * in the Software without restriction, including without limitation the rights
     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     * copies of the Software, and to permit persons to whom the Software is
     * furnished to do so, subject to the following conditions:
     *
     * The above copyright notice and this permission notice shall be included in
     * all copies or substantial portions of the Software.
     *
     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     * THE SOFTWARE.
     */
    var MDCRipple =
    /** @class */
    function (_super) {
      (0, _tslibEs.__extends)(MDCRipple, _super);
  
      function MDCRipple() {
        var _this = _super !== null && _super.apply(this, arguments) || this;
  
        _this.disabled = false;
        return _this;
      }
  
      MDCRipple.attachTo = function (root, opts) {
        if (opts === void 0) {
          opts = {
            isUnbounded: undefined
          };
        }
  
        var ripple = new MDCRipple(root); // Only override unbounded behavior if option is explicitly specified
  
        if (opts.isUnbounded !== undefined) {
          ripple.unbounded = opts.isUnbounded;
        }
  
        return ripple;
      };
  
      MDCRipple.createAdapter = function (instance) {
        return {
          addClass: function addClass(className) {
            return instance.root.classList.add(className);
          },
          browserSupportsCssVars: function browserSupportsCssVars() {
            return util.supportsCssVariables(window);
          },
          computeBoundingRect: function computeBoundingRect() {
            return instance.root.getBoundingClientRect();
          },
          containsEventTarget: function containsEventTarget(target) {
            return instance.root.contains(target);
          },
          deregisterDocumentInteractionHandler: function deregisterDocumentInteractionHandler(evtType, handler) {
            return document.documentElement.removeEventListener(evtType, handler, (0, _events.applyPassive)());
          },
          deregisterInteractionHandler: function deregisterInteractionHandler(evtType, handler) {
            return instance.root.removeEventListener(evtType, handler, (0, _events.applyPassive)());
          },
          deregisterResizeHandler: function deregisterResizeHandler(handler) {
            return window.removeEventListener('resize', handler);
          },
          getWindowPageOffset: function getWindowPageOffset() {
            return {
              x: window.pageXOffset,
              y: window.pageYOffset
            };
          },
          isSurfaceActive: function isSurfaceActive() {
            return (0, _ponyfill.matches)(instance.root, ':active');
          },
          isSurfaceDisabled: function isSurfaceDisabled() {
            return Boolean(instance.disabled);
          },
          isUnbounded: function isUnbounded() {
            return Boolean(instance.unbounded);
          },
          registerDocumentInteractionHandler: function registerDocumentInteractionHandler(evtType, handler) {
            return document.documentElement.addEventListener(evtType, handler, (0, _events.applyPassive)());
          },
          registerInteractionHandler: function registerInteractionHandler(evtType, handler) {
            return instance.root.addEventListener(evtType, handler, (0, _events.applyPassive)());
          },
          registerResizeHandler: function registerResizeHandler(handler) {
            return window.addEventListener('resize', handler);
          },
          removeClass: function removeClass(className) {
            return instance.root.classList.remove(className);
          },
          updateCssVariable: function updateCssVariable(varName, value) {
            return instance.root.style.setProperty(varName, value);
          }
        };
      };
  
      Object.defineProperty(MDCRipple.prototype, "unbounded", {
        get: function get() {
          return Boolean(this.unbounded_);
        },
        set: function set(unbounded) {
          this.unbounded_ = Boolean(unbounded);
          this.setUnbounded_();
        },
        enumerable: true,
        configurable: true
      });
  
      MDCRipple.prototype.activate = function () {
        this.foundation.activate();
      };
  
      MDCRipple.prototype.deactivate = function () {
        this.foundation.deactivate();
      };
  
      MDCRipple.prototype.layout = function () {
        this.foundation.layout();
      };
  
      MDCRipple.prototype.getDefaultFoundation = function () {
        return new _foundation.MDCRippleFoundation(MDCRipple.createAdapter(this));
      };
  
      MDCRipple.prototype.initialSyncWithDOM = function () {
        var root = this.root;
        this.unbounded = 'mdcRippleIsUnbounded' in root.dataset;
      };
      /**
       * 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.
       */
  
  
      MDCRipple.prototype.setUnbounded_ = function () {
        this.foundation.setUnbounded(Boolean(this.unbounded_));
      };
  
      return MDCRipple;
    }(_component.MDCComponent);
  
    _exports.MDCRipple = MDCRipple;
  });