{"version":3,"sources":["webpack://mdc/webpack/universalModuleDefinition","webpack://mdc/webpack/bootstrap","webpack://mdc/./packages/material-components-web/index.ts","webpack://mdc/./packages/mdc-animation/util.ts","webpack://mdc/./packages/mdc-auto-init/constants.ts","webpack://mdc/./packages/mdc-auto-init/index.ts","webpack://mdc/./packages/mdc-base/component.ts","webpack://mdc/./packages/mdc-base/foundation.ts","webpack://mdc/./packages/mdc-base/index.ts","webpack://mdc/./packages/mdc-checkbox/component.ts","webpack://mdc/./packages/mdc-checkbox/constants.ts","webpack://mdc/./packages/mdc-checkbox/foundation.ts","webpack://mdc/./packages/mdc-checkbox/index.ts","webpack://mdc/./packages/mdc-chips/chip-set/component.ts","webpack://mdc/./packages/mdc-chips/chip-set/constants.ts","webpack://mdc/./packages/mdc-chips/chip-set/foundation.ts","webpack://mdc/./packages/mdc-chips/chip-set/index.ts","webpack://mdc/./packages/mdc-chips/chip/component.ts","webpack://mdc/./packages/mdc-chips/chip/constants.ts","webpack://mdc/./packages/mdc-chips/chip/foundation.ts","webpack://mdc/./packages/mdc-chips/chip/index.ts","webpack://mdc/./packages/mdc-chips/index.ts","webpack://mdc/./packages/mdc-data-table/component.ts","webpack://mdc/./packages/mdc-data-table/constants.ts","webpack://mdc/./packages/mdc-data-table/foundation.ts","webpack://mdc/./packages/mdc-data-table/index.ts","webpack://mdc/./packages/mdc-dialog/component.ts","webpack://mdc/./packages/mdc-dialog/constants.ts","webpack://mdc/./packages/mdc-dialog/foundation.ts","webpack://mdc/./packages/mdc-dialog/index.ts","webpack://mdc/./packages/mdc-dialog/node_modules/focus-trap/index.js","webpack://mdc/./packages/mdc-dialog/node_modules/tabbable/index.js","webpack://mdc/./packages/mdc-dialog/node_modules/xtend/immutable.js","webpack://mdc/./packages/mdc-dialog/util.ts","webpack://mdc/./packages/mdc-dom/events.ts","webpack://mdc/./packages/mdc-dom/index.ts","webpack://mdc/./packages/mdc-dom/ponyfill.ts","webpack://mdc/./packages/mdc-drawer/component.ts","webpack://mdc/./packages/mdc-drawer/constants.ts","webpack://mdc/./packages/mdc-drawer/dismissible/foundation.ts","webpack://mdc/./packages/mdc-drawer/index.ts","webpack://mdc/./packages/mdc-drawer/modal/foundation.ts","webpack://mdc/./packages/mdc-drawer/node_modules/focus-trap/index.js","webpack://mdc/./packages/mdc-drawer/node_modules/tabbable/index.js","webpack://mdc/./packages/mdc-drawer/node_modules/xtend/immutable.js","webpack://mdc/./packages/mdc-drawer/util.ts","webpack://mdc/./packages/mdc-floating-label/component.ts","webpack://mdc/./packages/mdc-floating-label/constants.ts","webpack://mdc/./packages/mdc-floating-label/foundation.ts","webpack://mdc/./packages/mdc-floating-label/index.ts","webpack://mdc/./packages/mdc-form-field/component.ts","webpack://mdc/./packages/mdc-form-field/constants.ts","webpack://mdc/./packages/mdc-form-field/foundation.ts","webpack://mdc/./packages/mdc-form-field/index.ts","webpack://mdc/./packages/mdc-grid-list/component.ts","webpack://mdc/./packages/mdc-grid-list/constants.ts","webpack://mdc/./packages/mdc-grid-list/foundation.ts","webpack://mdc/./packages/mdc-grid-list/index.ts","webpack://mdc/./packages/mdc-icon-button/component.ts","webpack://mdc/./packages/mdc-icon-button/constants.ts","webpack://mdc/./packages/mdc-icon-button/foundation.ts","webpack://mdc/./packages/mdc-icon-button/index.ts","webpack://mdc/./packages/mdc-line-ripple/component.ts","webpack://mdc/./packages/mdc-line-ripple/constants.ts","webpack://mdc/./packages/mdc-line-ripple/foundation.ts","webpack://mdc/./packages/mdc-line-ripple/index.ts","webpack://mdc/./packages/mdc-linear-progress/component.ts","webpack://mdc/./packages/mdc-linear-progress/constants.ts","webpack://mdc/./packages/mdc-linear-progress/foundation.ts","webpack://mdc/./packages/mdc-linear-progress/index.ts","webpack://mdc/./packages/mdc-list/component.ts","webpack://mdc/./packages/mdc-list/constants.ts","webpack://mdc/./packages/mdc-list/foundation.ts","webpack://mdc/./packages/mdc-list/index.ts","webpack://mdc/./packages/mdc-menu-surface/component.ts","webpack://mdc/./packages/mdc-menu-surface/constants.ts","webpack://mdc/./packages/mdc-menu-surface/foundation.ts","webpack://mdc/./packages/mdc-menu-surface/index.ts","webpack://mdc/./packages/mdc-menu-surface/util.ts","webpack://mdc/./packages/mdc-menu/component.ts","webpack://mdc/./packages/mdc-menu/constants.ts","webpack://mdc/./packages/mdc-menu/foundation.ts","webpack://mdc/./packages/mdc-menu/index.ts","webpack://mdc/./packages/mdc-notched-outline/component.ts","webpack://mdc/./packages/mdc-notched-outline/constants.ts","webpack://mdc/./packages/mdc-notched-outline/foundation.ts","webpack://mdc/./packages/mdc-notched-outline/index.ts","webpack://mdc/./packages/mdc-radio/component.ts","webpack://mdc/./packages/mdc-radio/constants.ts","webpack://mdc/./packages/mdc-radio/foundation.ts","webpack://mdc/./packages/mdc-radio/index.ts","webpack://mdc/./packages/mdc-ripple/component.ts","webpack://mdc/./packages/mdc-ripple/constants.ts","webpack://mdc/./packages/mdc-ripple/foundation.ts","webpack://mdc/./packages/mdc-ripple/index.ts","webpack://mdc/./packages/mdc-ripple/util.ts","webpack://mdc/./packages/mdc-select/component.ts","webpack://mdc/./packages/mdc-select/constants.ts","webpack://mdc/./packages/mdc-select/foundation.ts","webpack://mdc/./packages/mdc-select/helper-text/component.ts","webpack://mdc/./packages/mdc-select/helper-text/constants.ts","webpack://mdc/./packages/mdc-select/helper-text/foundation.ts","webpack://mdc/./packages/mdc-select/helper-text/index.ts","webpack://mdc/./packages/mdc-select/icon/component.ts","webpack://mdc/./packages/mdc-select/icon/constants.ts","webpack://mdc/./packages/mdc-select/icon/foundation.ts","webpack://mdc/./packages/mdc-select/icon/index.ts","webpack://mdc/./packages/mdc-select/index.ts","webpack://mdc/./packages/mdc-slider/component.ts","webpack://mdc/./packages/mdc-slider/constants.ts","webpack://mdc/./packages/mdc-slider/foundation.ts","webpack://mdc/./packages/mdc-slider/index.ts","webpack://mdc/./packages/mdc-snackbar/component.ts","webpack://mdc/./packages/mdc-snackbar/constants.ts","webpack://mdc/./packages/mdc-snackbar/foundation.ts","webpack://mdc/./packages/mdc-snackbar/index.ts","webpack://mdc/./packages/mdc-snackbar/util.ts","webpack://mdc/./packages/mdc-switch/component.ts","webpack://mdc/./packages/mdc-switch/constants.ts","webpack://mdc/./packages/mdc-switch/foundation.ts","webpack://mdc/./packages/mdc-switch/index.ts","webpack://mdc/./packages/mdc-tab-bar/component.ts","webpack://mdc/./packages/mdc-tab-bar/constants.ts","webpack://mdc/./packages/mdc-tab-bar/foundation.ts","webpack://mdc/./packages/mdc-tab-bar/index.ts","webpack://mdc/./packages/mdc-tab-indicator/component.ts","webpack://mdc/./packages/mdc-tab-indicator/constants.ts","webpack://mdc/./packages/mdc-tab-indicator/fading-foundation.ts","webpack://mdc/./packages/mdc-tab-indicator/foundation.ts","webpack://mdc/./packages/mdc-tab-indicator/index.ts","webpack://mdc/./packages/mdc-tab-indicator/sliding-foundation.ts","webpack://mdc/./packages/mdc-tab-scroller/component.ts","webpack://mdc/./packages/mdc-tab-scroller/constants.ts","webpack://mdc/./packages/mdc-tab-scroller/foundation.ts","webpack://mdc/./packages/mdc-tab-scroller/index.ts","webpack://mdc/./packages/mdc-tab-scroller/rtl-default-scroller.ts","webpack://mdc/./packages/mdc-tab-scroller/rtl-negative-scroller.ts","webpack://mdc/./packages/mdc-tab-scroller/rtl-reverse-scroller.ts","webpack://mdc/./packages/mdc-tab-scroller/rtl-scroller.ts","webpack://mdc/./packages/mdc-tab-scroller/util.ts","webpack://mdc/./packages/mdc-tab/component.ts","webpack://mdc/./packages/mdc-tab/constants.ts","webpack://mdc/./packages/mdc-tab/foundation.ts","webpack://mdc/./packages/mdc-tab/index.ts","webpack://mdc/./packages/mdc-textfield/character-counter/component.ts","webpack://mdc/./packages/mdc-textfield/character-counter/constants.ts","webpack://mdc/./packages/mdc-textfield/character-counter/foundation.ts","webpack://mdc/./packages/mdc-textfield/character-counter/index.ts","webpack://mdc/./packages/mdc-textfield/component.ts","webpack://mdc/./packages/mdc-textfield/constants.ts","webpack://mdc/./packages/mdc-textfield/foundation.ts","webpack://mdc/./packages/mdc-textfield/helper-text/component.ts","webpack://mdc/./packages/mdc-textfield/helper-text/constants.ts","webpack://mdc/./packages/mdc-textfield/helper-text/foundation.ts","webpack://mdc/./packages/mdc-textfield/helper-text/index.ts","webpack://mdc/./packages/mdc-textfield/icon/component.ts","webpack://mdc/./packages/mdc-textfield/icon/constants.ts","webpack://mdc/./packages/mdc-textfield/icon/foundation.ts","webpack://mdc/./packages/mdc-textfield/icon/index.ts","webpack://mdc/./packages/mdc-textfield/index.ts","webpack://mdc/./packages/mdc-top-app-bar/component.ts","webpack://mdc/./packages/mdc-top-app-bar/constants.ts","webpack://mdc/./packages/mdc-top-app-bar/fixed/foundation.ts","webpack://mdc/./packages/mdc-top-app-bar/foundation.ts","webpack://mdc/./packages/mdc-top-app-bar/index.ts","webpack://mdc/./packages/mdc-top-app-bar/short/foundation.ts","webpack://mdc/./packages/mdc-top-app-bar/standard/foundation.ts"],"names":[],"mappings":"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iBAAS,SAAkB;AAC3B,iBAAmB,qBAAqB;AAEhD;AAAC;AAEO,kCAAwB,2BAAhC;AACgF;AAC1E,aAAS,SAAY,YAAC,YAAU,WAAa;AACjD,YAAQ,KAAS,SAAsB,uBAAE;AACnC,iBAAS,SAAS,SAAC,YAAU,WAAa;AAElD;AAAC;AACH,WAAC;AAAA,EAlPwC,aAkPxC;AAlPY,8BAAmB;AAoPiF;AACjH,kBAAmC,oB;;;;;;;;;;;;;AC3PhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,4CAA+B;AAEvB,eAAI;AAEZ,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,4D;;;;;;;;;;;AC7B7B,eAAe,mBAAO,CAAC,sEAAU;AACjC,YAAY,mBAAO,CAAC,oEAAO;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;;AAEL;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;AC9TA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,aAAa,uBAAuB;AACpC;;AAEA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA;AACA,sBAAsB,gBAAgB;AACtC;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;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ACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;;AAEL;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;AC9TA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,aAAa,uBAAuB;AACpC;;AAEA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA;AACA,sBAAsB,gBAAgB;AACtC;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,iBAAiB,kBAAkB;AACnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACxJA;;AAEA;;AAEA;AACA;;AAEA,mBAAmB,sBAAsB;AACzC;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;;;;;;;;;;;;ACGG;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uDAA0E;AAO1E,SAAuC,wBACb,WAC+E;AAArG;AAAA,2BAA8C,aAAuD;;AAEvG,4BAAiC;AACR,iCAAM;AACZ,2BAAO;AACZ,sBAAW;AACA,iCAE3B;AANqC,KAAZ;AAMxB;AAVD,kCAUC,wB;;;;;;;;;;;;;ACnBE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,uCAAwD;AAIxD;AAAsC,gCAAwC;AAA9E;mEAu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","file":"material-components-web.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"mdc\"] = factory();\n\telse\n\t\troot[\"mdc\"] = factory();\n})(this, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./packages/material-components-web/index.ts\");\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport autoInit from '@material/auto-init/index';\nimport * as base from '@material/base/index';\nimport * as checkbox from '@material/checkbox/index';\nimport * as chips from '@material/chips/index';\nimport * as dataTable from '@material/data-table/index';\nimport * as dialog from '@material/dialog/index';\nimport * as dom from '@material/dom/index';\nimport * as drawer from '@material/drawer/index';\nimport * as floatingLabel from '@material/floating-label/index';\nimport * as formField from '@material/form-field/index';\nimport * as gridList from '@material/grid-list/index';\nimport * as iconButton from '@material/icon-button/index';\nimport * as lineRipple from '@material/line-ripple/index';\nimport * as linearProgress from '@material/linear-progress/index';\nimport * as list from '@material/list/index';\nimport * as menuSurface from '@material/menu-surface/index';\nimport * as menu from '@material/menu/index';\nimport * as notchedOutline from '@material/notched-outline/index';\nimport * as radio from '@material/radio/index';\nimport * as ripple from '@material/ripple/index';\nimport * as select from '@material/select/index';\nimport * as slider from '@material/slider/index';\nimport * as snackbar from '@material/snackbar/index';\nimport * as switchControl from '@material/switch/index';\nimport * as tabBar from '@material/tab-bar/index';\nimport * as tabIndicator from '@material/tab-indicator/index';\nimport * as tabScroller from '@material/tab-scroller/index';\nimport * as tab from '@material/tab/index';\nimport * as textField from '@material/textfield/index';\nimport * as topAppBar from '@material/top-app-bar/index';\n\n// Register all components\nautoInit.register('MDCCheckbox', checkbox.MDCCheckbox);\nautoInit.register('MDCChip', chips.MDCChip);\nautoInit.register('MDCChipSet', chips.MDCChipSet);\nautoInit.register('MDCDataTable', dataTable.MDCDataTable);\nautoInit.register('MDCDialog', dialog.MDCDialog);\nautoInit.register('MDCDrawer', drawer.MDCDrawer);\nautoInit.register('MDCFloatingLabel', floatingLabel.MDCFloatingLabel);\nautoInit.register('MDCFormField', formField.MDCFormField);\nautoInit.register('MDCGridList', gridList.MDCGridList);\nautoInit.register('MDCIconButtonToggle', iconButton.MDCIconButtonToggle);\nautoInit.register('MDCLineRipple', lineRipple.MDCLineRipple);\nautoInit.register('MDCLinearProgress', linearProgress.MDCLinearProgress);\nautoInit.register('MDCList', list.MDCList);\nautoInit.register('MDCMenu', menu.MDCMenu);\nautoInit.register('MDCMenuSurface', menuSurface.MDCMenuSurface);\nautoInit.register('MDCNotchedOutline', notchedOutline.MDCNotchedOutline);\nautoInit.register('MDCRadio', radio.MDCRadio);\nautoInit.register('MDCRipple', ripple.MDCRipple);\nautoInit.register('MDCSelect', select.MDCSelect);\nautoInit.register('MDCSlider', slider.MDCSlider);\nautoInit.register('MDCSnackbar', snackbar.MDCSnackbar);\nautoInit.register('MDCSwitch', switchControl.MDCSwitch);\nautoInit.register('MDCTabBar', tabBar.MDCTabBar);\nautoInit.register('MDCTextField', textField.MDCTextField);\nautoInit.register('MDCTopAppBar', topAppBar.MDCTopAppBar);\n\n// Export all components.\nexport {\n  autoInit,\n  base,\n  checkbox,\n  chips,\n  dataTable,\n  dialog,\n  dom,\n  drawer,\n  floatingLabel,\n  formField,\n  gridList,\n  iconButton,\n  lineRipple,\n  linearProgress,\n  list,\n  menu,\n  menuSurface,\n  notchedOutline,\n  radio,\n  ripple,\n  select,\n  slider,\n  snackbar,\n  switchControl,\n  tab,\n  tabBar,\n  tabIndicator,\n  tabScroller,\n  textField,\n  topAppBar,\n};\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {\n  CssVendorPropertyMap, JsVendorPropertyMap,\n  PrefixedCssPropertyName, PrefixedJsEventType,\n  StandardCssPropertyName, StandardJsEventType,\n} from './types';\n\nconst cssPropertyNameMap: CssVendorPropertyMap = {\n  animation: {\n    prefixed: '-webkit-animation',\n    standard: 'animation',\n  },\n  transform: {\n    prefixed: '-webkit-transform',\n    standard: 'transform',\n  },\n  transition: {\n    prefixed: '-webkit-transition',\n    standard: 'transition',\n  },\n};\n\nconst jsEventTypeMap: JsVendorPropertyMap = {\n  animationend: {\n    cssProperty: 'animation',\n    prefixed: 'webkitAnimationEnd',\n    standard: 'animationend',\n  },\n  animationiteration: {\n    cssProperty: 'animation',\n    prefixed: 'webkitAnimationIteration',\n    standard: 'animationiteration',\n  },\n  animationstart: {\n    cssProperty: 'animation',\n    prefixed: 'webkitAnimationStart',\n    standard: 'animationstart',\n  },\n  transitionend: {\n    cssProperty: 'transition',\n    prefixed: 'webkitTransitionEnd',\n    standard: 'transitionend',\n  },\n};\n\nfunction isWindow(windowObj: Window): boolean {\n  return Boolean(windowObj.document) && typeof windowObj.document.createElement === 'function';\n}\n\nexport function getCorrectPropertyName(windowObj: Window, cssProperty: StandardCssPropertyName):\n    StandardCssPropertyName | PrefixedCssPropertyName {\n  if (isWindow(windowObj) && cssProperty in cssPropertyNameMap) {\n    const el = windowObj.document.createElement('div');\n    const {standard, prefixed} = cssPropertyNameMap[cssProperty];\n    const isStandard = standard in el.style;\n    return isStandard ? standard : prefixed;\n  }\n  return cssProperty;\n}\n\nexport function getCorrectEventName(windowObj: Window, eventType: StandardJsEventType):\n    StandardJsEventType | PrefixedJsEventType {\n  if (isWindow(windowObj) && eventType in jsEventTypeMap) {\n    const el = windowObj.document.createElement('div');\n    const {standard, prefixed, cssProperty} = jsEventTypeMap[eventType];\n    const isStandard = cssProperty in el.style;\n    return isStandard ? standard : prefixed;\n  }\n  return eventType;\n}\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport const strings = {\n  AUTO_INIT_ATTR: 'data-mdc-auto-init',\n  AUTO_INIT_STATE_ATTR: 'data-mdc-auto-init-state',\n  INITIALIZED_STATE: 'initialized',\n};\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n// tslint:disable:only-arrow-functions\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCFoundation} from '@material/base/foundation';\n\nimport {strings} from './constants';\n\nconst {AUTO_INIT_ATTR, AUTO_INIT_STATE_ATTR, INITIALIZED_STATE} = strings;\n\nexport interface MDCAttachable {\n  new<F extends MDCFoundation>(root: Element, foundation?: F, ...args: Array<unknown>): MDCComponent<F>;\n\n  // Static method.\n  attachTo<F extends MDCFoundation>(root: Element): MDCComponent<F>;\n}\n\ninterface InternalComponentRegistry {\n  [key: string]: MDCAttachable;\n}\n\nconst registry: InternalComponentRegistry = {};\n\nconst CONSOLE_WARN = console.warn.bind(console); // tslint:disable-line:no-console\n\nfunction emit<T extends object>(evtType: string, evtData: T, shouldBubble = false) {\n  let evt;\n  if (typeof CustomEvent === 'function') {\n    evt = new CustomEvent<T>(evtType, {\n      bubbles: shouldBubble,\n      detail: evtData,\n    });\n  } else {\n    evt = document.createEvent('CustomEvent');\n    evt.initCustomEvent(evtType, shouldBubble, false, evtData);\n  }\n\n  document.dispatchEvent(evt);\n}\n\n/* istanbul ignore next: optional argument is not a branch statement */\n/**\n * Auto-initializes all MDC components on a page.\n */\nexport function mdcAutoInit(root = document) {\n  const components = [];\n  let nodes: Element[] = [].slice.call(root.querySelectorAll(`[${AUTO_INIT_ATTR}]`));\n  nodes = nodes.filter((node) => node.getAttribute(AUTO_INIT_STATE_ATTR) !== INITIALIZED_STATE);\n\n  for (const node of nodes) {\n    const ctorName = node.getAttribute(AUTO_INIT_ATTR);\n    if (!ctorName) {\n      throw new Error('(mdc-auto-init) Constructor name must be given.');\n    }\n\n    const Constructor = registry[ctorName]; // tslint:disable-line:variable-name\n    if (typeof Constructor !== 'function') {\n      throw new Error(\n          `(mdc-auto-init) Could not find constructor in registry for ${ctorName}`);\n    }\n\n    // TODO: Should we make an eslint rule for an attachTo() static method?\n    // See https://github.com/Microsoft/TypeScript/issues/14600 for discussion of static interface support in TS\n    const component = Constructor.attachTo(node);\n    Object.defineProperty(node, ctorName, {\n      configurable: true,\n      enumerable: false,\n      value: component,\n      writable: false,\n    });\n    components.push(component);\n    node.setAttribute(AUTO_INIT_STATE_ATTR, INITIALIZED_STATE);\n  }\n\n  emit('MDCAutoInit:End', {});\n  return components;\n}\n\n// Constructor is PascalCased because it is a direct reference to a class, rather than an instance of a class.\n// tslint:disable-next-line:variable-name\nmdcAutoInit.register = function(componentName: string, Constructor: MDCAttachable, warn = CONSOLE_WARN) {\n  if (typeof Constructor !== 'function') {\n    throw new Error(`(mdc-auto-init) Invalid Constructor value: ${Constructor}. Expected function.`);\n  }\n  const registryValue = registry[componentName];\n  if (registryValue) {\n    warn(`(mdc-auto-init) Overriding registration for ${componentName} with ${Constructor}. Was: ${registryValue}`);\n  }\n  registry[componentName] = Constructor;\n};\n\nmdcAutoInit.deregister = function(componentName: string) {\n  delete registry[componentName];\n};\n\nmdcAutoInit.deregisterAll = function() {\n  const keys = Object.keys(registry) as string[];\n  keys.forEach(this.deregister, this);\n};\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default mdcAutoInit;\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from './foundation';\nimport {CustomEventListener, EventType, SpecificEventListener} from './types';\n\nexport class MDCComponent<FoundationType extends MDCFoundation> {\n  static attachTo(root: Element): MDCComponent<MDCFoundation<{}>> {\n    // Subclasses which extend MDCBase should provide an attachTo() method that takes a root element and\n    // returns an instantiated component with its root set to that element. Also note that in the cases of\n    // subclasses, an explicit foundation class will not have to be passed in; it will simply be initialized\n    // from getDefaultFoundation().\n    return new MDCComponent(root, new MDCFoundation({}));\n  }\n\n  protected root_: Element;\n  protected foundation_: FoundationType;\n\n  constructor(\n      root: Element,\n      foundation?: FoundationType,\n      ...args: Array<unknown>\n  ) {\n    this.root_ = root;\n    this.initialize(...args);\n    // Note that we initialize foundation here and not within the constructor's default param so that\n    // this.root_ is defined and can be used within the foundation class.\n    this.foundation_ = foundation === undefined ? this.getDefaultFoundation() : foundation;\n    this.foundation_.init();\n    this.initialSyncWithDOM();\n  }\n\n  /* istanbul ignore next: method param only exists for typing purposes; it does not need to be unit tested */\n  initialize(..._args: Array<unknown>) {\n    // Subclasses can override this to do any additional setup work that would be considered part of a\n    // \"constructor\". Essentially, it is a hook into the parent constructor before the foundation is\n    // initialized. Any additional arguments besides root and foundation will be passed in here.\n  }\n\n  getDefaultFoundation(): FoundationType {\n    // Subclasses must override this method to return a properly configured foundation class for the\n    // component.\n    throw new Error('Subclasses must override getDefaultFoundation to return a properly configured ' +\n        'foundation class');\n  }\n\n  initialSyncWithDOM() {\n    // Subclasses should override this method if they need to perform work to synchronize with a host DOM\n    // object. An example of this would be a form control wrapper that needs to synchronize its internal state\n    // to some property or attribute of the host DOM. Please note: this is *not* the place to perform DOM\n    // reads/writes that would cause layout / paint, as this is called synchronously from within the constructor.\n  }\n\n  destroy() {\n    // Subclasses may implement this method to release any resources / deregister any listeners they have\n    // attached. An example of this might be deregistering a resize event from the window object.\n    this.foundation_.destroy();\n  }\n\n  /**\n   * Wrapper method to add an event listener to the component's root element. This is most useful when\n   * listening for custom events.\n   */\n  listen<K extends EventType>(\n    evtType: K, handler: SpecificEventListener<K>, options?: AddEventListenerOptions | boolean): void;\n  listen<E extends Event>(\n    evtType: string, handler: CustomEventListener<E>, options?: AddEventListenerOptions | boolean): void;\n  listen(evtType: string, handler: EventListener, options?: AddEventListenerOptions | boolean) {\n    this.root_.addEventListener(evtType, handler, options);\n  }\n\n  /**\n   * Wrapper method to remove an event listener to the component's root element. This is most useful when\n   * unlistening for custom events.\n   */\n  unlisten<K extends EventType>(\n    evtType: K, handler: SpecificEventListener<K>, options?: AddEventListenerOptions | boolean): void;\n  unlisten<E extends Event>(\n    evtType: string, handler: CustomEventListener<E>, options?: AddEventListenerOptions | boolean): void;\n  unlisten(evtType: string, handler: EventListener, options?: AddEventListenerOptions | boolean) {\n    this.root_.removeEventListener(evtType, handler, options);\n  }\n\n  /**\n   * Fires a cross-browser-compatible custom event from the component root of the given type, with the given data.\n   */\n  emit<T extends object>(evtType: string, evtData: T, shouldBubble = false) {\n    let evt: CustomEvent<T>;\n    if (typeof CustomEvent === 'function') {\n      evt = new CustomEvent<T>(evtType, {\n        bubbles: shouldBubble,\n        detail: evtData,\n      });\n    } else {\n      evt = document.createEvent('CustomEvent');\n      evt.initCustomEvent(evtType, shouldBubble, false, evtData);\n    }\n\n    this.root_.dispatchEvent(evt);\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCComponent;\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport class MDCFoundation<AdapterType extends {} = {}> {\n  static get cssClasses(): { [key: string]: string } {\n    // Classes extending MDCFoundation should implement this method to return an object which exports every\n    // CSS class the foundation class needs as a property. e.g. {ACTIVE: 'mdc-component--active'}\n    return {};\n  }\n\n  static get strings(): { [key: string]: string } {\n    // Classes extending MDCFoundation should implement this method to return an object which exports all\n    // semantic strings as constants. e.g. {ARIA_ROLE: 'tablist'}\n    return {};\n  }\n\n  static get numbers(): { [key: string]: number } {\n    // Classes extending MDCFoundation should implement this method to return an object which exports all\n    // of its semantic numbers as constants. e.g. {ANIMATION_DELAY_MS: 350}\n    return {};\n  }\n\n  static get defaultAdapter(): {} {\n    // Classes extending MDCFoundation may choose to implement this getter in order to provide a convenient\n    // way of viewing the necessary methods of an adapter. In the future, this could also be used for adapter\n    // validation.\n    return {};\n  }\n\n  protected adapter_: AdapterType;\n\n  constructor(adapter: AdapterType = {} as AdapterType) {\n    this.adapter_ = adapter;\n  }\n\n  init() {\n    // Subclasses should override this method to perform initialization routines (registering events, etc.)\n  }\n\n  destroy() {\n    // Subclasses should override this method to perform de-initialization routines (de-registering events, etc.)\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './component';\nexport * from './foundation';\nexport * from './types';\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {getCorrectEventName} from '@material/animation/util';\nimport {MDCComponent} from '@material/base/component';\nimport {applyPassive} from '@material/dom/events';\nimport {matches} from '@material/dom/ponyfill';\nimport {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\nimport {MDCCheckboxAdapter} from './adapter';\nimport {MDCCheckboxFoundation} from './foundation';\n\n/**\n * This type is needed for compatibility with Closure Compiler.\n */\ntype PropertyDescriptorGetter = (() => unknown) | undefined;\n\nconst CB_PROTO_PROPS = ['checked', 'indeterminate'];\n\nexport type MDCCheckboxFactory = (el: Element, foundation?: MDCCheckboxFoundation) => MDCCheckbox;\n\nexport class MDCCheckbox extends MDCComponent<MDCCheckboxFoundation> implements MDCRippleCapableSurface {\n  static attachTo(root: Element) {\n    return new MDCCheckbox(root);\n  }\n\n  get ripple(): MDCRipple {\n    return this.ripple_;\n  }\n\n  get checked(): boolean {\n    return this.nativeControl_.checked;\n  }\n\n  set checked(checked: boolean) {\n    this.nativeControl_.checked = checked;\n  }\n\n  get indeterminate(): boolean {\n    return this.nativeControl_.indeterminate;\n  }\n\n  set indeterminate(indeterminate: boolean) {\n    this.nativeControl_.indeterminate = indeterminate;\n  }\n\n  get disabled(): boolean {\n    return this.nativeControl_.disabled;\n  }\n\n  set disabled(disabled: boolean) {\n    this.foundation_.setDisabled(disabled);\n  }\n\n  get value(): string {\n    return this.nativeControl_.value;\n  }\n\n  set value(value: string) {\n    this.nativeControl_.value = value;\n  }\n\n  // Public visibility for this property is required by MDCRippleCapableSurface.\n  root_!: Element; // assigned in MDCComponent constructor\n\n  private readonly ripple_: MDCRipple = this.createRipple_();\n  private handleChange_!: EventListener; // assigned in initialSyncWithDOM()\n  private handleAnimationEnd_!: EventListener; // assigned in initialSyncWithDOM()\n\n  initialSyncWithDOM() {\n    this.handleChange_ = () => this.foundation_.handleChange();\n    this.handleAnimationEnd_ = () => this.foundation_.handleAnimationEnd();\n    this.nativeControl_.addEventListener('change', this.handleChange_);\n    this.listen(getCorrectEventName(window, 'animationend'), this.handleAnimationEnd_);\n    this.installPropertyChangeHooks_();\n  }\n\n  destroy() {\n    this.ripple_.destroy();\n    this.nativeControl_.removeEventListener('change', this.handleChange_);\n    this.unlisten(getCorrectEventName(window, 'animationend'), this.handleAnimationEnd_);\n    this.uninstallPropertyChangeHooks_();\n    super.destroy();\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCCheckboxAdapter = {\n      addClass: (className) => this.root_.classList.add(className),\n      forceLayout: () => (this.root_ as HTMLElement).offsetWidth,\n      hasNativeControl: () => !!this.nativeControl_,\n      isAttachedToDOM: () => Boolean(this.root_.parentNode),\n      isChecked: () => this.checked,\n      isIndeterminate: () => this.indeterminate,\n      removeClass: (className) => this.root_.classList.remove(className),\n      removeNativeControlAttr: (attr) => this.nativeControl_.removeAttribute(attr),\n      setNativeControlAttr: (attr, value) => this.nativeControl_.setAttribute(attr, value),\n      setNativeControlDisabled: (disabled) => this.nativeControl_.disabled = disabled,\n    };\n    return new MDCCheckboxFoundation(adapter);\n  }\n\n  private createRipple_(): MDCRipple {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCRippleAdapter = {\n      ...MDCRipple.createAdapter(this),\n      deregisterInteractionHandler: (evtType, handler) => this.nativeControl_.removeEventListener(\n        evtType, handler, applyPassive()),\n      isSurfaceActive: () => matches(this.nativeControl_, ':active'),\n      isUnbounded: () => true,\n      registerInteractionHandler: (evtType, handler) => this.nativeControl_.addEventListener(\n        evtType, handler, applyPassive()),\n    };\n    return new MDCRipple(this.root_, new MDCRippleFoundation(adapter));\n  }\n\n  private installPropertyChangeHooks_() {\n    const nativeCb = this.nativeControl_;\n    const cbProto = Object.getPrototypeOf(nativeCb);\n\n    CB_PROTO_PROPS.forEach((controlState) => {\n      const desc = Object.getOwnPropertyDescriptor(cbProto, controlState);\n      // We have to check for this descriptor, since some browsers (Safari) don't support its return.\n      // See: https://bugs.webkit.org/show_bug.cgi?id=49739\n      if (!validDescriptor(desc)) {\n        return;\n      }\n\n      // Type cast is needed for compatibility with Closure Compiler.\n      const nativeGetter = (desc as {get: PropertyDescriptorGetter}).get;\n\n      const nativeCbDesc = {\n        configurable: desc.configurable,\n        enumerable: desc.enumerable,\n        get: nativeGetter,\n        set: (state: boolean) => {\n          desc.set!.call(nativeCb, state);\n          this.foundation_.handleChange();\n        },\n      };\n      Object.defineProperty(nativeCb, controlState, nativeCbDesc);\n    });\n  }\n\n  private uninstallPropertyChangeHooks_() {\n    const nativeCb = this.nativeControl_;\n    const cbProto = Object.getPrototypeOf(nativeCb);\n\n    CB_PROTO_PROPS.forEach((controlState) => {\n      const desc = Object.getOwnPropertyDescriptor(cbProto, controlState);\n      if (!validDescriptor(desc)) {\n        return;\n      }\n      Object.defineProperty(nativeCb, controlState, desc);\n    });\n  }\n\n  private get nativeControl_(): HTMLInputElement {\n    const {NATIVE_CONTROL_SELECTOR} = MDCCheckboxFoundation.strings;\n    const el = this.root_.querySelector<HTMLInputElement>(NATIVE_CONTROL_SELECTOR);\n    if (!el) {\n      throw new Error(`Checkbox component requires a ${NATIVE_CONTROL_SELECTOR} element`);\n    }\n    return el;\n  }\n}\n\nfunction validDescriptor(inputPropDesc: PropertyDescriptor | undefined): inputPropDesc is PropertyDescriptor {\n  return !!inputPropDesc && typeof inputPropDesc.set === 'function';\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport const cssClasses = {\n  ANIM_CHECKED_INDETERMINATE: 'mdc-checkbox--anim-checked-indeterminate',\n  ANIM_CHECKED_UNCHECKED: 'mdc-checkbox--anim-checked-unchecked',\n  ANIM_INDETERMINATE_CHECKED: 'mdc-checkbox--anim-indeterminate-checked',\n  ANIM_INDETERMINATE_UNCHECKED: 'mdc-checkbox--anim-indeterminate-unchecked',\n  ANIM_UNCHECKED_CHECKED: 'mdc-checkbox--anim-unchecked-checked',\n  ANIM_UNCHECKED_INDETERMINATE: 'mdc-checkbox--anim-unchecked-indeterminate',\n  BACKGROUND: 'mdc-checkbox__background',\n  CHECKED: 'mdc-checkbox--checked',\n  CHECKMARK: 'mdc-checkbox__checkmark',\n  CHECKMARK_PATH: 'mdc-checkbox__checkmark-path',\n  DISABLED: 'mdc-checkbox--disabled',\n  INDETERMINATE: 'mdc-checkbox--indeterminate',\n  MIXEDMARK: 'mdc-checkbox__mixedmark',\n  NATIVE_CONTROL: 'mdc-checkbox__native-control',\n  ROOT: 'mdc-checkbox',\n  SELECTED: 'mdc-checkbox--selected',\n  UPGRADED: 'mdc-checkbox--upgraded',\n};\n\nexport const strings = {\n  ARIA_CHECKED_ATTR: 'aria-checked',\n  ARIA_CHECKED_INDETERMINATE_VALUE: 'mixed',\n  NATIVE_CONTROL_SELECTOR: '.mdc-checkbox__native-control',\n  TRANSITION_STATE_CHECKED: 'checked',\n  TRANSITION_STATE_INDETERMINATE: 'indeterminate',\n  TRANSITION_STATE_INIT: 'init',\n  TRANSITION_STATE_UNCHECKED: 'unchecked',\n};\n\nexport const numbers = {\n  ANIM_END_LATCH_MS: 250,\n};\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCCheckboxAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\nexport class MDCCheckboxFoundation extends MDCFoundation<MDCCheckboxAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get numbers() {\n    return numbers;\n  }\n\n  static get defaultAdapter(): MDCCheckboxAdapter {\n    return {\n      addClass: () => undefined,\n      forceLayout: () => undefined,\n      hasNativeControl: () => false,\n      isAttachedToDOM: () => false,\n      isChecked: () => false,\n      isIndeterminate: () => false,\n      removeClass: () => undefined,\n      removeNativeControlAttr: () => undefined,\n      setNativeControlAttr: () => undefined,\n      setNativeControlDisabled: () => undefined,\n    };\n  }\n\n  private currentCheckState_ = strings.TRANSITION_STATE_INIT;\n  private currentAnimationClass_ = '';\n  private animEndLatchTimer_ = 0;\n  private enableAnimationEndHandler_ = false;\n\n  constructor(adapter?: Partial<MDCCheckboxAdapter>) {\n    super({...MDCCheckboxFoundation.defaultAdapter, ...adapter});\n  }\n\n  init() {\n    this.currentCheckState_ = this.determineCheckState_();\n    this.updateAriaChecked_();\n    this.adapter_.addClass(cssClasses.UPGRADED);\n  }\n\n  destroy() {\n    clearTimeout(this.animEndLatchTimer_);\n  }\n\n  setDisabled(disabled: boolean) {\n    this.adapter_.setNativeControlDisabled(disabled);\n    if (disabled) {\n      this.adapter_.addClass(cssClasses.DISABLED);\n    } else {\n      this.adapter_.removeClass(cssClasses.DISABLED);\n    }\n  }\n\n  /**\n   * Handles the animationend event for the checkbox\n   */\n  handleAnimationEnd() {\n    if (!this.enableAnimationEndHandler_) {\n      return;\n    }\n\n    clearTimeout(this.animEndLatchTimer_);\n\n    this.animEndLatchTimer_ = setTimeout(() => {\n      this.adapter_.removeClass(this.currentAnimationClass_);\n      this.enableAnimationEndHandler_ = false;\n    }, numbers.ANIM_END_LATCH_MS);\n  }\n\n  /**\n   * Handles the change event for the checkbox\n   */\n  handleChange() {\n    this.transitionCheckState_();\n  }\n\n  private transitionCheckState_() {\n    if (!this.adapter_.hasNativeControl()) {\n      return;\n    }\n    const oldState = this.currentCheckState_;\n    const newState = this.determineCheckState_();\n\n    if (oldState === newState) {\n      return;\n    }\n\n    this.updateAriaChecked_();\n\n    const {TRANSITION_STATE_UNCHECKED} = strings;\n    const {SELECTED} = cssClasses;\n    if (newState === TRANSITION_STATE_UNCHECKED) {\n      this.adapter_.removeClass(SELECTED);\n    } else {\n      this.adapter_.addClass(SELECTED);\n    }\n\n    // Check to ensure that there isn't a previously existing animation class, in case for example\n    // the user interacted with the checkbox before the animation was finished.\n    if (this.currentAnimationClass_.length > 0) {\n      clearTimeout(this.animEndLatchTimer_);\n      this.adapter_.forceLayout();\n      this.adapter_.removeClass(this.currentAnimationClass_);\n    }\n\n    this.currentAnimationClass_ = this.getTransitionAnimationClass_(oldState, newState);\n    this.currentCheckState_ = newState;\n\n    // Check for parentNode so that animations are only run when the element is attached\n    // to the DOM.\n    if (this.adapter_.isAttachedToDOM() && this.currentAnimationClass_.length > 0) {\n      this.adapter_.addClass(this.currentAnimationClass_);\n      this.enableAnimationEndHandler_ = true;\n    }\n  }\n\n  private determineCheckState_(): string {\n    const {\n      TRANSITION_STATE_INDETERMINATE,\n      TRANSITION_STATE_CHECKED,\n      TRANSITION_STATE_UNCHECKED,\n    } = strings;\n\n    if (this.adapter_.isIndeterminate()) {\n      return TRANSITION_STATE_INDETERMINATE;\n    }\n    return this.adapter_.isChecked() ? TRANSITION_STATE_CHECKED : TRANSITION_STATE_UNCHECKED;\n  }\n\n  private getTransitionAnimationClass_(oldState: string, newState: string): string {\n    const {\n      TRANSITION_STATE_INIT,\n      TRANSITION_STATE_CHECKED,\n      TRANSITION_STATE_UNCHECKED,\n    } = strings;\n\n    const {\n      ANIM_UNCHECKED_CHECKED,\n      ANIM_UNCHECKED_INDETERMINATE,\n      ANIM_CHECKED_UNCHECKED,\n      ANIM_CHECKED_INDETERMINATE,\n      ANIM_INDETERMINATE_CHECKED,\n      ANIM_INDETERMINATE_UNCHECKED,\n    } = MDCCheckboxFoundation.cssClasses;\n\n    switch (oldState) {\n      case TRANSITION_STATE_INIT:\n        if (newState === TRANSITION_STATE_UNCHECKED) {\n          return '';\n        }\n        return newState === TRANSITION_STATE_CHECKED ? ANIM_INDETERMINATE_CHECKED : ANIM_INDETERMINATE_UNCHECKED;\n      case TRANSITION_STATE_UNCHECKED:\n        return newState === TRANSITION_STATE_CHECKED ? ANIM_UNCHECKED_CHECKED : ANIM_UNCHECKED_INDETERMINATE;\n      case TRANSITION_STATE_CHECKED:\n        return newState === TRANSITION_STATE_UNCHECKED ? ANIM_CHECKED_UNCHECKED : ANIM_CHECKED_INDETERMINATE;\n      default: // TRANSITION_STATE_INDETERMINATE\n        return newState === TRANSITION_STATE_CHECKED ? ANIM_INDETERMINATE_CHECKED : ANIM_INDETERMINATE_UNCHECKED;\n    }\n  }\n\n  private updateAriaChecked_() {\n    // Ensure aria-checked is set to mixed if checkbox is in indeterminate state.\n    if (this.adapter_.isIndeterminate()) {\n      this.adapter_.setNativeControlAttr(\n          strings.ARIA_CHECKED_ATTR, strings.ARIA_CHECKED_INDETERMINATE_VALUE);\n    } else {\n      // The on/off state does not need to keep track of aria-checked, since\n      // the screenreader uses the checked property on the checkbox element.\n      this.adapter_.removeNativeControlAttr(strings.ARIA_CHECKED_ATTR);\n    }\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCCheckboxFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCChip, MDCChipFactory} from '../chip/component';\nimport {MDCChipFoundation} from '../chip/foundation';\nimport {MDCChipInteractionEvent, MDCChipRemovalEvent, MDCChipSelectionEvent} from '../chip/types';\nimport {MDCChipSetAdapter} from './adapter';\nimport {MDCChipSetFoundation} from './foundation';\n\nconst {INTERACTION_EVENT, SELECTION_EVENT, REMOVAL_EVENT} = MDCChipFoundation.strings;\nconst {CHIP_SELECTOR} = MDCChipSetFoundation.strings;\n\nlet idCounter = 0;\n\nexport class MDCChipSet extends MDCComponent<MDCChipSetFoundation> {\n  static attachTo(root: Element) {\n    return new MDCChipSet(root);\n  }\n\n  get chips(): ReadonlyArray<MDCChip> {\n    return this.chips_.slice();\n  }\n\n  /**\n   * @return An array of the IDs of all selected chips.\n   */\n  get selectedChipIds(): ReadonlyArray<string> {\n    return this.foundation_.getSelectedChipIds();\n  }\n\n  private chips_!: MDCChip[]; // assigned in initialize()\n  private chipFactory_!: (el: Element) => MDCChip; // assigned in initialize()\n  private handleChipInteraction_!: (evt: MDCChipInteractionEvent) => void; // assigned in initialSyncWithDOM()\n  private handleChipSelection_!: (evt: MDCChipSelectionEvent) => void; // assigned in initialSyncWithDOM()\n  private handleChipRemoval_!: (evt: MDCChipRemovalEvent) => void; // assigned in initialSyncWithDOM()\n\n  /**\n   * @param chipFactory A function which creates a new MDCChip.\n   */\n  initialize(chipFactory: MDCChipFactory = (el) => new MDCChip(el)) {\n    this.chipFactory_ = chipFactory;\n    this.chips_ = this.instantiateChips_(this.chipFactory_);\n  }\n\n  initialSyncWithDOM() {\n    this.chips_.forEach((chip) => {\n      if (chip.id && chip.selected) {\n        this.foundation_.select(chip.id);\n      }\n    });\n\n    this.handleChipInteraction_ = (evt) => this.foundation_.handleChipInteraction(evt.detail.chipId);\n    this.handleChipSelection_ = (evt) => this.foundation_.handleChipSelection(evt.detail.chipId, evt.detail.selected);\n    this.handleChipRemoval_ = (evt) => this.foundation_.handleChipRemoval(evt.detail.chipId);\n    this.listen(INTERACTION_EVENT, this.handleChipInteraction_);\n    this.listen(SELECTION_EVENT, this.handleChipSelection_);\n    this.listen(REMOVAL_EVENT, this.handleChipRemoval_);\n  }\n\n  destroy() {\n    this.chips_.forEach((chip) => {\n      chip.destroy();\n    });\n\n    this.unlisten(INTERACTION_EVENT, this.handleChipInteraction_);\n    this.unlisten(SELECTION_EVENT, this.handleChipSelection_);\n    this.unlisten(REMOVAL_EVENT, this.handleChipRemoval_);\n\n    super.destroy();\n  }\n\n  /**\n   * Adds a new chip object to the chip set from the given chip element.\n   */\n  addChip(chipEl: Element) {\n    chipEl.id = chipEl.id || `mdc-chip-${++idCounter}`;\n    this.chips_.push(this.chipFactory_(chipEl));\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCChipSetAdapter = {\n      hasClass: (className) => this.root_.classList.contains(className),\n      removeChip: (chipId) => {\n        const index = this.findChipIndex_(chipId);\n        if (index >= 0) {\n          this.chips_[index].destroy();\n          this.chips_.splice(index, 1);\n        }\n      },\n      setSelected: (chipId, selected) => {\n        const index = this.findChipIndex_(chipId);\n        if (index >= 0) {\n          this.chips_[index].selected = selected;\n        }\n      },\n    };\n    return new MDCChipSetFoundation(adapter);\n  }\n\n  /**\n   * Instantiates chip components on all of the chip set's child chip elements.\n   */\n  private instantiateChips_(chipFactory: MDCChipFactory): MDCChip[] {\n    const chipElements: Element[] =\n        [].slice.call(this.root_.querySelectorAll(CHIP_SELECTOR));\n    return chipElements.map((el) => {\n      el.id = el.id || `mdc-chip-${++idCounter}`;\n      return chipFactory(el);\n    });\n  }\n\n  /**\n   * Returns the index of the chip with the given id, or -1 if the chip does not exist.\n   */\n  private findChipIndex_(chipId: string): number {\n    for (let i = 0; i < this.chips_.length; i++) {\n      if (this.chips_[i].id === chipId) {\n        return i;\n      }\n    }\n    return -1;\n  }\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport const strings = {\n  CHIP_SELECTOR: '.mdc-chip',\n};\n\nexport const cssClasses = {\n  CHOICE: 'mdc-chip-set--choice',\n  FILTER: 'mdc-chip-set--filter',\n};\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCChipSetAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCChipSetFoundation extends MDCFoundation<MDCChipSetAdapter> {\n  static get strings() {\n    return strings;\n  }\n\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get defaultAdapter(): MDCChipSetAdapter {\n    return {\n      hasClass: () => false,\n      removeChip: () => undefined,\n      setSelected: () => undefined,\n    };\n  }\n\n  /**\n   * The ids of the selected chips in the set. Only used for choice chip set or filter chip set.\n   */\n  private selectedChipIds_: string[] = [];\n\n  constructor(adapter?: Partial<MDCChipSetAdapter>) {\n    super({...MDCChipSetFoundation.defaultAdapter, ...adapter});\n  }\n\n  /**\n   * Returns an array of the IDs of all selected chips.\n   */\n  getSelectedChipIds(): ReadonlyArray<string> {\n    return this.selectedChipIds_.slice();\n  }\n\n  /**\n   * Selects the chip with the given id. Deselects all other chips if the chip set is of the choice variant.\n   */\n  select(chipId: string) {\n    if (this.selectedChipIds_.indexOf(chipId) >= 0) {\n      return;\n    }\n\n    if (this.adapter_.hasClass(cssClasses.CHOICE) && this.selectedChipIds_.length > 0) {\n      const previouslySelectedChip = this.selectedChipIds_[0];\n      this.selectedChipIds_.length = 0;\n      this.adapter_.setSelected(previouslySelectedChip, false);\n    }\n    this.selectedChipIds_.push(chipId);\n    this.adapter_.setSelected(chipId, true);\n  }\n\n  /**\n   * Handles a chip interaction event\n   */\n  handleChipInteraction(chipId: string) {\n    if (this.adapter_.hasClass(cssClasses.CHOICE) || this.adapter_.hasClass(cssClasses.FILTER)) {\n      this.toggleSelect_(chipId);\n    }\n  }\n\n  /**\n   * Handles a chip selection event, used to handle discrepancy when selection state is set directly on the Chip.\n   */\n  handleChipSelection(chipId: string, selected: boolean) {\n    const chipIsSelected = this.selectedChipIds_.indexOf(chipId) >= 0;\n    if (selected && !chipIsSelected) {\n      this.select(chipId);\n    } else if (!selected && chipIsSelected) {\n      this.deselect_(chipId);\n    }\n  }\n\n  /**\n   * Handles the event when a chip is removed.\n   */\n  handleChipRemoval(chipId: string) {\n    this.deselect_(chipId);\n    this.adapter_.removeChip(chipId);\n  }\n\n  /**\n   * Deselects the chip with the given id.\n   */\n  private deselect_(chipId: string) {\n    const index = this.selectedChipIds_.indexOf(chipId);\n    if (index >= 0) {\n      this.selectedChipIds_.splice(index, 1);\n      this.adapter_.setSelected(chipId, false);\n    }\n  }\n\n  /**\n   * Toggles selection of the chip with the given id.\n   */\n  private toggleSelect_(chipId: string) {\n    if (this.selectedChipIds_.indexOf(chipId) >= 0) {\n      this.deselect_(chipId);\n    } else {\n      this.select(chipId);\n    }\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCChipSetFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport {cssClasses as chipSetCssClasses, strings as chipSetStrings} from './constants';\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple, MDCRippleFactory} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\nimport {MDCChipAdapter} from './adapter';\nimport {strings} from './constants';\nimport {MDCChipFoundation} from './foundation';\nimport {MDCChipInteractionEventDetail, MDCChipRemovalEventDetail, MDCChipSelectionEventDetail} from './types';\n\ntype InteractionType = 'click' | 'keydown';\n\nconst INTERACTION_EVENTS: InteractionType[] = ['click', 'keydown'];\n\nexport type MDCChipFactory = (el: Element, foundation?: MDCChipFoundation) => MDCChip;\n\nexport class MDCChip extends MDCComponent<MDCChipFoundation> implements MDCRippleCapableSurface {\n  /**\n   * @return Whether the chip is selected.\n   */\n  get selected(): boolean {\n    return this.foundation_.isSelected();\n  }\n\n  /**\n   * Sets selected state on the chip.\n   */\n  set selected(selected: boolean) {\n    this.foundation_.setSelected(selected);\n  }\n\n  /**\n   * @return Whether a trailing icon click should trigger exit/removal of the chip.\n   */\n  get shouldRemoveOnTrailingIconClick(): boolean {\n    return this.foundation_.getShouldRemoveOnTrailingIconClick();\n  }\n\n  /**\n   * Sets whether a trailing icon click should trigger exit/removal of the chip.\n   */\n  set shouldRemoveOnTrailingIconClick(shouldRemove: boolean) {\n    this.foundation_.setShouldRemoveOnTrailingIconClick(shouldRemove);\n  }\n\n  get ripple(): MDCRipple {\n    return this.ripple_;\n  }\n\n  get id(): string {\n    return this.root_.id;\n  }\n\n  static attachTo(root: Element) {\n    return new MDCChip(root);\n  }\n\n  // Public visibility for this property is required by MDCRippleCapableSurface.\n  root_!: HTMLElement; // assigned in MDCComponent constructor\n\n  private leadingIcon_!: Element | null; // assigned in initialize()\n  private trailingIcon_!: Element | null; // assigned in initialize()\n  private checkmark_!: Element | null; // assigned in initialize()\n  private ripple_!: MDCRipple; // assigned in initialize()\n\n  private handleInteraction_!: SpecificEventListener<InteractionType>; // assigned in initialSyncWithDOM()\n  private handleTransitionEnd_!: SpecificEventListener<'transitionend'>; // assigned in initialSyncWithDOM()\n  private handleTrailingIconInteraction_!: SpecificEventListener<InteractionType>; // assigned in initialSyncWithDOM()\n\n  initialize(rippleFactory: MDCRippleFactory = (el, foundation) => new MDCRipple(el, foundation)) {\n    this.leadingIcon_ = this.root_.querySelector(strings.LEADING_ICON_SELECTOR);\n    this.trailingIcon_ = this.root_.querySelector(strings.TRAILING_ICON_SELECTOR);\n    this.checkmark_ = this.root_.querySelector(strings.CHECKMARK_SELECTOR);\n\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const rippleAdapter: MDCRippleAdapter = {\n      ...MDCRipple.createAdapter(this),\n      computeBoundingRect: () => this.foundation_.getDimensions(),\n    };\n    this.ripple_ = rippleFactory(this.root_, new MDCRippleFoundation(rippleAdapter));\n  }\n\n  initialSyncWithDOM() {\n    this.handleInteraction_ = (evt: MouseEvent | KeyboardEvent) => this.foundation_.handleInteraction(evt);\n    this.handleTransitionEnd_ = (evt: TransitionEvent) => this.foundation_.handleTransitionEnd(evt);\n    this.handleTrailingIconInteraction_ = (evt: MouseEvent | KeyboardEvent) =>\n        this.foundation_.handleTrailingIconInteraction(evt);\n\n    INTERACTION_EVENTS.forEach((evtType) => {\n      this.listen(evtType, this.handleInteraction_);\n    });\n    this.listen('transitionend', this.handleTransitionEnd_);\n\n    if (this.trailingIcon_) {\n      INTERACTION_EVENTS.forEach((evtType) => {\n        this.trailingIcon_!.addEventListener(evtType, this.handleTrailingIconInteraction_ as EventListener);\n      });\n    }\n  }\n\n  destroy() {\n    this.ripple_.destroy();\n\n    INTERACTION_EVENTS.forEach((evtType) => {\n      this.unlisten(evtType, this.handleInteraction_);\n    });\n    this.unlisten('transitionend', this.handleTransitionEnd_);\n\n    if (this.trailingIcon_) {\n      INTERACTION_EVENTS.forEach((evtType) => {\n        this.trailingIcon_!.removeEventListener(evtType, this.handleTrailingIconInteraction_ as EventListener);\n      });\n    }\n\n    super.destroy();\n  }\n\n  /**\n   * Begins the exit animation which leads to removal of the chip.\n   */\n  beginExit() {\n    this.foundation_.beginExit();\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCChipAdapter = {\n      addClass: (className) => this.root_.classList.add(className),\n      addClassToLeadingIcon: (className) => {\n        if (this.leadingIcon_) {\n          this.leadingIcon_.classList.add(className);\n        }\n      },\n      eventTargetHasClass: (target, className) => target ? (target as Element).classList.contains(className) : false,\n      getCheckmarkBoundingClientRect: () => this.checkmark_ ? this.checkmark_.getBoundingClientRect() : null,\n      getComputedStyleValue: (propertyName) => window.getComputedStyle(this.root_).getPropertyValue(propertyName),\n      getRootBoundingClientRect: () => this.root_.getBoundingClientRect(),\n      hasClass: (className) => this.root_.classList.contains(className),\n      hasLeadingIcon: () => !!this.leadingIcon_,\n      notifyInteraction: () => this.emit<MDCChipInteractionEventDetail>(\n          strings.INTERACTION_EVENT, {chipId: this.id}, true /* shouldBubble */),\n      notifyRemoval: () => this.emit<MDCChipRemovalEventDetail>(\n          strings.REMOVAL_EVENT, {chipId: this.id, root: this.root_}, true /* shouldBubble */),\n      notifySelection: (selected) => this.emit<MDCChipSelectionEventDetail>(\n          strings.SELECTION_EVENT, {chipId: this.id, selected}, true /* shouldBubble */),\n      notifyTrailingIconInteraction: () => this.emit<MDCChipInteractionEventDetail>(\n          strings.TRAILING_ICON_INTERACTION_EVENT, {chipId: this.id}, true /* shouldBubble */),\n      removeClass: (className) => this.root_.classList.remove(className),\n      removeClassFromLeadingIcon: (className) => {\n        if (this.leadingIcon_) {\n          this.leadingIcon_.classList.remove(className);\n        }\n      },\n      setAttr: (attr, value) => this.root_.setAttribute(attr, value),\n      setStyleProperty: (propertyName, value) => this.root_.style.setProperty(propertyName, value),\n    };\n    return new MDCChipFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport const strings = {\n  ARIA_CHECKED: 'aria-checked',\n  CHECKMARK_SELECTOR: '.mdc-chip__checkmark',\n  ENTRY_ANIMATION_NAME: 'mdc-chip-entry',\n  INTERACTION_EVENT: 'MDCChip:interaction',\n  LEADING_ICON_SELECTOR: '.mdc-chip__icon--leading',\n  REMOVAL_EVENT: 'MDCChip:removal',\n  SELECTION_EVENT: 'MDCChip:selection',\n  TRAILING_ICON_INTERACTION_EVENT: 'MDCChip:trailingIconInteraction',\n  TRAILING_ICON_SELECTOR: '.mdc-chip__icon--trailing',\n};\n\nexport const cssClasses = {\n  CHECKMARK: 'mdc-chip__checkmark',\n  CHIP_EXIT: 'mdc-chip--exit',\n  HIDDEN_LEADING_ICON: 'mdc-chip__icon--leading-hidden',\n  LEADING_ICON: 'mdc-chip__icon--leading',\n  SELECTED: 'mdc-chip--selected',\n  TRAILING_ICON: 'mdc-chip__icon--trailing',\n};\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCChipAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nconst emptyClientRect = {\n  bottom: 0,\n  height: 0,\n  left: 0,\n  right: 0,\n  top: 0,\n  width: 0,\n};\n\nexport class MDCChipFoundation extends MDCFoundation<MDCChipAdapter> {\n  static get strings() {\n    return strings;\n  }\n\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get defaultAdapter(): MDCChipAdapter {\n    return {\n      addClass: () => undefined,\n      addClassToLeadingIcon: () => undefined,\n      eventTargetHasClass: () => false,\n      getCheckmarkBoundingClientRect: () => emptyClientRect,\n      getComputedStyleValue: () => '',\n      getRootBoundingClientRect: () => emptyClientRect,\n      hasClass: () => false,\n      hasLeadingIcon: () => false,\n      notifyInteraction: () => undefined,\n      notifyRemoval: () => undefined,\n      notifySelection: () => undefined,\n      notifyTrailingIconInteraction: () => undefined,\n      removeClass: () => undefined,\n      removeClassFromLeadingIcon: () => undefined,\n      setAttr: () => undefined,\n      setStyleProperty: () => undefined,\n    };\n  }\n\n  /**\n   * Whether a trailing icon click should immediately trigger exit/removal of the chip.\n   */\n  private shouldRemoveOnTrailingIconClick_ = true;\n\n  constructor(adapter?: Partial<MDCChipAdapter>) {\n    super({...MDCChipFoundation.defaultAdapter, ...adapter});\n  }\n\n  isSelected() {\n    return this.adapter_.hasClass(cssClasses.SELECTED);\n  }\n\n  setSelected(selected: boolean) {\n    if (selected) {\n      this.adapter_.addClass(cssClasses.SELECTED);\n      this.adapter_.setAttr(strings.ARIA_CHECKED, 'true');\n    } else {\n      this.adapter_.removeClass(cssClasses.SELECTED);\n      this.adapter_.setAttr(strings.ARIA_CHECKED, 'false');\n    }\n    this.adapter_.notifySelection(selected);\n  }\n\n  getShouldRemoveOnTrailingIconClick() {\n    return this.shouldRemoveOnTrailingIconClick_;\n  }\n\n  setShouldRemoveOnTrailingIconClick(shouldRemove: boolean) {\n    this.shouldRemoveOnTrailingIconClick_ = shouldRemove;\n  }\n\n  getDimensions(): ClientRect {\n    const getRootRect = () => this.adapter_.getRootBoundingClientRect();\n    const getCheckmarkRect = () => this.adapter_.getCheckmarkBoundingClientRect();\n\n    // When a chip has a checkmark and not a leading icon, the bounding rect changes in size depending on the current\n    // size of the checkmark.\n    if (!this.adapter_.hasLeadingIcon()) {\n      const checkmarkRect = getCheckmarkRect();\n      if (checkmarkRect) {\n        const rootRect = getRootRect();\n        // Checkmark is a square, meaning the client rect's width and height are identical once the animation completes.\n        // However, the checkbox is initially hidden by setting the width to 0.\n        // To account for an initial width of 0, we use the checkbox's height instead (which equals the end-state width)\n        // when adding it to the root client rect's width.\n        return {\n          bottom: rootRect.bottom,\n          height: rootRect.height,\n          left: rootRect.left,\n          right: rootRect.right,\n          top: rootRect.top,\n          width: rootRect.width + checkmarkRect.height,\n        };\n      }\n    }\n\n    return getRootRect();\n  }\n\n  /**\n   * Begins the exit animation which leads to removal of the chip.\n   */\n  beginExit() {\n    this.adapter_.addClass(cssClasses.CHIP_EXIT);\n  }\n\n  /**\n   * Handles an interaction event on the root element.\n   */\n  handleInteraction(evt: MouseEvent | KeyboardEvent) {\n    const isEnter = (evt as KeyboardEvent).key === 'Enter' || (evt as KeyboardEvent).keyCode === 13;\n    if (evt.type === 'click' || isEnter) {\n      this.adapter_.notifyInteraction();\n    }\n  }\n\n  /**\n   * Handles a transition end event on the root element.\n   */\n  handleTransitionEnd(evt: TransitionEvent) {\n    // Handle transition end event on the chip when it is about to be removed.\n    if (this.adapter_.eventTargetHasClass(evt.target, cssClasses.CHIP_EXIT)) {\n      if (evt.propertyName === 'width') {\n        this.adapter_.notifyRemoval();\n      } else if (evt.propertyName === 'opacity') {\n        // See: https://css-tricks.com/using-css-transitions-auto-dimensions/#article-header-id-5\n        const chipWidth = this.adapter_.getComputedStyleValue('width');\n\n        // On the next frame (once we get the computed width), explicitly set the chip's width\n        // to its current pixel width, so we aren't transitioning out of 'auto'.\n        requestAnimationFrame(() => {\n          this.adapter_.setStyleProperty('width', chipWidth);\n\n          // To mitigate jitter, start transitioning padding and margin before width.\n          this.adapter_.setStyleProperty('padding', '0');\n          this.adapter_.setStyleProperty('margin', '0');\n\n          // On the next frame (once width is explicitly set), transition width to 0.\n          requestAnimationFrame(() => {\n            this.adapter_.setStyleProperty('width', '0');\n          });\n        });\n      }\n      return;\n    }\n\n    // Handle a transition end event on the leading icon or checkmark, since the transition end event bubbles.\n    if (evt.propertyName !== 'opacity') {\n      return;\n    }\n    if (this.adapter_.eventTargetHasClass(evt.target, cssClasses.LEADING_ICON) &&\n        this.adapter_.hasClass(cssClasses.SELECTED)) {\n      this.adapter_.addClassToLeadingIcon(cssClasses.HIDDEN_LEADING_ICON);\n    } else if (this.adapter_.eventTargetHasClass(evt.target, cssClasses.CHECKMARK) &&\n        !this.adapter_.hasClass(cssClasses.SELECTED)) {\n      this.adapter_.removeClassFromLeadingIcon(cssClasses.HIDDEN_LEADING_ICON);\n    }\n  }\n\n  /**\n   * Handles an interaction event on the trailing icon element. This is used to\n   * prevent the ripple from activating on interaction with the trailing icon.\n   */\n  handleTrailingIconInteraction(evt: MouseEvent | KeyboardEvent) {\n    const isEnter = (evt as KeyboardEvent).key === 'Enter' || (evt as KeyboardEvent).keyCode === 13;\n    evt.stopPropagation();\n    if (evt.type === 'click' || isEnter) {\n      this.adapter_.notifyTrailingIconInteraction();\n      if (this.shouldRemoveOnTrailingIconClick_) {\n        this.beginExit();\n      }\n    }\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCChipFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport * from './types';\nexport {cssClasses as chipCssClasses, strings as chipStrings} from './constants';\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './chip/index';\nexport * from './chip-set/index';\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCCheckbox, MDCCheckboxFactory} from '@material/checkbox/component';\nimport {closest} from '@material/dom/ponyfill';\nimport {MDCDataTableAdapter} from './adapter';\nimport {cssClasses, events, strings} from './constants';\nimport {MDCDataTableFoundation} from './foundation';\nimport {MDCDataTableRowSelectionChangedEventDetail} from './types';\n\nexport class MDCDataTable extends MDCComponent<MDCDataTableFoundation> {\n  static attachTo(root: Element): MDCDataTable {\n    return new MDCDataTable(root);\n  }\n\n  private headerRowCheckbox_!: MDCCheckbox;\n  private rowCheckboxList_!: MDCCheckbox[];\n  private checkboxFactory_!: MDCCheckboxFactory;\n  private headerRow_!: HTMLElement;\n  private content_!: HTMLElement;\n  private handleHeaderRowCheckboxChange_!: SpecificEventListener<'change'>;\n  private handleRowCheckboxChange_!: SpecificEventListener<'change'>;\n\n  initialize(checkboxFactory: MDCCheckboxFactory = (el: Element) => new MDCCheckbox(el)) {\n    this.checkboxFactory_ = checkboxFactory;\n  }\n\n  initialSyncWithDOM() {\n    this.headerRow_ = this.root_.querySelector(`.${cssClasses.HEADER_ROW}`) as HTMLElement;\n    this.handleHeaderRowCheckboxChange_ = () => this.foundation_.handleHeaderRowCheckboxChange();\n    this.headerRow_.addEventListener('change', this.handleHeaderRowCheckboxChange_);\n\n    this.content_ = this.root_.querySelector(`.${cssClasses.CONTENT}`) as HTMLElement;\n    this.handleRowCheckboxChange_ = (event) => this.foundation_.handleRowCheckboxChange(event);\n    this.content_.addEventListener('change', this.handleRowCheckboxChange_);\n\n    this.layout();\n  }\n\n  /**\n   * Re-initializes header row checkbox and row checkboxes when selectable rows are added or removed from table.\n   */\n  layout() {\n    this.foundation_.layout();\n  }\n\n  /**\n   * @return Returns array of row elements.\n   */\n  getRows(): Element[] {\n    return this.foundation_.getRows();\n  }\n\n  /**\n   * @return Returns array of selected row ids.\n   */\n  getSelectedRowIds(): Array<string|null> {\n    return this.foundation_.getSelectedRowIds();\n  }\n\n  /**\n   * Sets selected row ids. Overwrites previously selected rows.\n   * @param rowIds Array of row ids that needs to be selected.\n   */\n  setSelectedRowIds(rowIds: string[]) {\n    this.foundation_.setSelectedRowIds(rowIds);\n  }\n\n  destroy() {\n    this.headerRow_.removeEventListener('change', this.handleHeaderRowCheckboxChange_);\n    this.content_.removeEventListener('change', this.handleRowCheckboxChange_);\n\n    this.headerRowCheckbox_.destroy();\n    this.rowCheckboxList_.forEach((checkbox) => checkbox.destroy());\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCDataTableAdapter = {\n      addClassAtRowIndex: (rowIndex: number, className: string) => this.getRows()[rowIndex].classList.add(className),\n      getRowCount: () => this.getRows().length,\n      getRowElements: () => [].slice.call(this.root_.querySelectorAll(strings.ROW_SELECTOR)),\n      getRowIdAtIndex: (rowIndex: number) => this.getRows()[rowIndex].getAttribute(strings.DATA_ROW_ID_ATTR),\n      getRowIndexByChildElement: (el: Element) => {\n        return this.getRows().indexOf((closest(el, strings.ROW_SELECTOR) as HTMLElement));\n      },\n      getSelectedRowCount: () => this.root_.querySelectorAll(strings.ROW_SELECTED_SELECTOR).length,\n      isCheckboxAtRowIndexChecked: (rowIndex: number) => this.rowCheckboxList_[rowIndex].checked,\n      isHeaderRowCheckboxChecked: () => this.headerRowCheckbox_.checked,\n      isRowsSelectable: () => !!this.root_.querySelector(strings.ROW_CHECKBOX_SELECTOR),\n      notifyRowSelectionChanged: (data: MDCDataTableRowSelectionChangedEventDetail) => {\n        this.emit(events.ROW_SELECTION_CHANGED, {\n          row: this.getRowByIndex_(data.rowIndex),\n          rowId: this.getRowIdByIndex_(data.rowIndex),\n          rowIndex: data.rowIndex,\n          selected: data.selected,\n        },\n        /** shouldBubble */ true);\n      },\n      notifySelectedAll: () => this.emit(events.SELECTED_ALL, {}, /** shouldBubble */ true),\n      notifyUnselectedAll: () => this.emit(events.UNSELECTED_ALL, {}, /** shouldBubble */ true),\n      registerHeaderRowCheckbox: () => {\n        if (this.headerRowCheckbox_) {\n          this.headerRowCheckbox_.destroy();\n        }\n\n        const checkboxEl = (this.root_.querySelector(strings.HEADER_ROW_CHECKBOX_SELECTOR) as HTMLElement);\n        this.headerRowCheckbox_ = this.checkboxFactory_(checkboxEl);\n      },\n      registerRowCheckboxes: () => {\n        if (this.rowCheckboxList_) {\n          this.rowCheckboxList_.forEach((checkbox) => checkbox.destroy());\n        }\n\n        this.rowCheckboxList_ = [];\n        this.getRows().forEach((rowEl) => {\n          const checkbox = this.checkboxFactory_((rowEl.querySelector(strings.ROW_CHECKBOX_SELECTOR) as HTMLElement));\n          this.rowCheckboxList_.push(checkbox);\n        });\n      },\n      removeClassAtRowIndex: (rowIndex: number, className: string) => {\n        this.getRows()[rowIndex].classList.remove(className);\n      },\n      setAttributeAtRowIndex: (rowIndex: number, attr: string, value: string) => {\n        this.getRows()[rowIndex].setAttribute(attr, value);\n      },\n      setHeaderRowCheckboxChecked: (checked: boolean) => {\n        this.headerRowCheckbox_.checked = checked;\n      },\n      setHeaderRowCheckboxIndeterminate: (indeterminate: boolean) => {\n        this.headerRowCheckbox_.indeterminate = indeterminate;\n      },\n      setRowCheckboxCheckedAtIndex: (rowIndex: number, checked: boolean) => {\n        this.rowCheckboxList_[rowIndex].checked = checked;\n      },\n    };\n    return new MDCDataTableFoundation(adapter);\n  }\n\n  private getRowByIndex_(index: number): Element {\n    return this.getRows()[index];\n  }\n\n  private getRowIdByIndex_(index: number): string | null {\n    return this.getRowByIndex_(index).getAttribute(strings.DATA_ROW_ID_ATTR);\n  }\n}\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport const cssClasses = {\n  CELL: 'mdc-data-table__cell',\n  CELL_NUMERIC: 'mdc-data-table__cell--numeric',\n  CONTENT: 'mdc-data-table__content',\n  HEADER_ROW: 'mdc-data-table__header-row',\n  HEADER_ROW_CHECKBOX: 'mdc-data-table__header-row-checkbox',\n  ROOT: 'mdc-data-table',\n  ROW: 'mdc-data-table__row',\n  ROW_CHECKBOX: 'mdc-data-table__row-checkbox',\n  ROW_SELECTED: 'mdc-data-table__row--selected',\n};\n\nexport const strings = {\n  ARIA_SELECTED: 'aria-selected',\n  DATA_ROW_ID_ATTR: 'data-row-id',\n  HEADER_ROW_CHECKBOX_SELECTOR: `.${cssClasses.HEADER_ROW_CHECKBOX}`,\n  ROW_CHECKBOX_SELECTOR: `.${cssClasses.ROW_CHECKBOX}`,\n  ROW_SELECTED_SELECTOR: `.${cssClasses.ROW_SELECTED}`,\n  ROW_SELECTOR: `.${cssClasses.ROW}`,\n};\n\nexport const events = {\n  ROW_SELECTION_CHANGED: 'MDCDataTable:rowSelectionChanged',\n  SELECTED_ALL: 'MDCDataTable:selectedAll',\n  UNSELECTED_ALL: 'MDCDataTable:unselectedAll',\n};\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCDataTableAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCDataTableFoundation extends MDCFoundation<MDCDataTableAdapter> {\n  static get defaultAdapter(): MDCDataTableAdapter {\n    return {\n      addClassAtRowIndex: () => undefined,\n      getRowCount: () => 0,\n      getRowElements: () => [],\n      getRowIdAtIndex: () => '',\n      getRowIndexByChildElement: () => 0,\n      getSelectedRowCount: () => 0,\n      isCheckboxAtRowIndexChecked: () => false,\n      isHeaderRowCheckboxChecked: () => false,\n      isRowsSelectable: () => false,\n      notifyRowSelectionChanged: () => undefined,\n      notifySelectedAll: () => undefined,\n      notifyUnselectedAll: () => undefined,\n      registerHeaderRowCheckbox: () => undefined,\n      registerRowCheckboxes: () => undefined,\n      removeClassAtRowIndex: () => undefined,\n      setAttributeAtRowIndex: () => undefined,\n      setHeaderRowCheckboxChecked: () => undefined,\n      setHeaderRowCheckboxIndeterminate: () => undefined,\n      setRowCheckboxCheckedAtIndex: () => undefined,\n    };\n  }\n\n  constructor(adapter?: Partial<MDCDataTableAdapter>) {\n    super({...MDCDataTableFoundation.defaultAdapter, ...adapter});\n  }\n\n  /**\n   * Re-initializes header row checkbox and row checkboxes when selectable rows are added or removed from table.\n   * Use this if registering checkbox is synchronous.\n   */\n  layout() {\n    if (this.adapter_.isRowsSelectable()) {\n      this.adapter_.registerHeaderRowCheckbox();\n      this.adapter_.registerRowCheckboxes();\n\n      this.setHeaderRowCheckboxState_();\n    }\n  }\n\n  /**\n   * Re-initializes header row checkbox and row checkboxes when selectable rows are added or removed from table.\n   * Use this if registering checkbox is asynchronous.\n   */\n  async layoutAsync(): Promise<void> {\n    if (this.adapter_.isRowsSelectable()) {\n      await this.adapter_.registerHeaderRowCheckbox();\n      await this.adapter_.registerRowCheckboxes();\n\n      this.setHeaderRowCheckboxState_();\n    }\n  }\n\n  /**\n   * @return Returns array of row elements.\n   */\n  getRows(): Element[] {\n    return this.adapter_.getRowElements();\n  }\n\n  /**\n   * Sets selected row ids. Overwrites previously selected rows.\n   * @param rowIds Array of row ids that needs to be selected.\n   */\n  setSelectedRowIds(rowIds: string[]) {\n    for (let rowIndex = 0; rowIndex < this.adapter_.getRowCount(); rowIndex++) {\n      const rowId = this.adapter_.getRowIdAtIndex(rowIndex);\n\n      let isSelected = false;\n      if (rowId && rowIds.indexOf(rowId) >= 0) {\n        isSelected = true;\n      }\n\n      this.adapter_.setRowCheckboxCheckedAtIndex(rowIndex, isSelected);\n      this.selectRowAtIndex_(rowIndex, isSelected);\n    }\n\n    this.setHeaderRowCheckboxState_();\n  }\n\n  /**\n   * @return Returns array of selected row ids.\n   */\n  getSelectedRowIds(): Array<string|null> {\n    const selectedRowIds: Array<string|null> = [];\n    for (let rowIndex = 0; rowIndex < this.adapter_.getRowCount(); rowIndex++) {\n      if (this.adapter_.isCheckboxAtRowIndexChecked(rowIndex)) {\n        selectedRowIds.push(this.adapter_.getRowIdAtIndex(rowIndex));\n      }\n    }\n\n    return selectedRowIds;\n  }\n\n  /**\n   * Handles header row checkbox change event.\n   */\n  handleHeaderRowCheckboxChange() {\n    const isHeaderChecked = this.adapter_.isHeaderRowCheckboxChecked();\n\n    for (let rowIndex = 0; rowIndex < this.adapter_.getRowCount(); rowIndex++) {\n      this.adapter_.setRowCheckboxCheckedAtIndex(rowIndex, isHeaderChecked);\n      this.selectRowAtIndex_(rowIndex, isHeaderChecked);\n    }\n\n    if (isHeaderChecked) {\n      this.adapter_.notifySelectedAll();\n    } else {\n      this.adapter_.notifyUnselectedAll();\n    }\n  }\n\n  /**\n   * Handles change event originated from row checkboxes.\n   */\n  handleRowCheckboxChange(event: Event) {\n    const rowIndex = this.adapter_.getRowIndexByChildElement(event.target as HTMLInputElement);\n\n    if (rowIndex === -1) {\n      return;\n    }\n\n    const selected = this.adapter_.isCheckboxAtRowIndexChecked(rowIndex);\n\n    this.selectRowAtIndex_(rowIndex, selected);\n    this.setHeaderRowCheckboxState_();\n\n    const rowId = this.adapter_.getRowIdAtIndex(rowIndex);\n    this.adapter_.notifyRowSelectionChanged({rowId, rowIndex, selected});\n  }\n\n  /**\n   * Updates header row checkbox state based on number of rows selected.\n   */\n  private setHeaderRowCheckboxState_() {\n    if (this.adapter_.getSelectedRowCount() === this.adapter_.getRowCount()) {\n      this.adapter_.setHeaderRowCheckboxChecked(true);\n      this.adapter_.setHeaderRowCheckboxIndeterminate(false);\n    } else if (this.adapter_.getSelectedRowCount() === 0) {\n      this.adapter_.setHeaderRowCheckboxIndeterminate(false);\n      this.adapter_.setHeaderRowCheckboxChecked(false);\n    } else {\n      this.adapter_.setHeaderRowCheckboxIndeterminate(true);\n      this.adapter_.setHeaderRowCheckboxChecked(false);\n    }\n  }\n\n  /**\n   * Sets the attributes of row element based on selection state.\n   */\n  private selectRowAtIndex_(rowIndex: number, selected: boolean) {\n    if (selected) {\n      this.adapter_.addClassAtRowIndex(rowIndex, cssClasses.ROW_SELECTED);\n      this.adapter_.setAttributeAtRowIndex(rowIndex, strings.ARIA_SELECTED, 'true');\n    } else {\n      this.adapter_.removeClassAtRowIndex(rowIndex, cssClasses.ROW_SELECTED);\n      this.adapter_.setAttributeAtRowIndex(rowIndex, strings.ARIA_SELECTED, 'false');\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport * from './constants';\nexport * from './types';\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {closest, matches} from '@material/dom/ponyfill';\nimport {MDCRipple} from '@material/ripple/component';\nimport {FocusTrap} from 'focus-trap';\nimport {MDCDialogAdapter} from './adapter';\nimport {MDCDialogFoundation} from './foundation';\nimport {MDCDialogCloseEventDetail} from './types';\nimport * as util from './util';\nimport {MDCDialogFocusTrapFactory} from './util';\n\nconst {strings} = MDCDialogFoundation;\n\nexport class MDCDialog extends MDCComponent<MDCDialogFoundation> {\n  get isOpen() {\n    return this.foundation_.isOpen();\n  }\n\n  get escapeKeyAction() {\n    return this.foundation_.getEscapeKeyAction();\n  }\n\n  set escapeKeyAction(action) {\n    this.foundation_.setEscapeKeyAction(action);\n  }\n\n  get scrimClickAction() {\n    return this.foundation_.getScrimClickAction();\n  }\n\n  set scrimClickAction(action) {\n    this.foundation_.setScrimClickAction(action);\n  }\n\n  get autoStackButtons() {\n    return this.foundation_.getAutoStackButtons();\n  }\n\n  set autoStackButtons(autoStack) {\n    this.foundation_.setAutoStackButtons(autoStack);\n  }\n\n  static attachTo(root: Element) {\n    return new MDCDialog(root);\n  }\n\n  private buttonRipples_!: MDCRipple[]; // assigned in initialize()\n  private buttons_!: HTMLElement[]; // assigned in initialize()\n  private container_!: HTMLElement; // assigned in initialize()\n  private content_!: HTMLElement | null; // assigned in initialize()\n  private defaultButton_!: HTMLElement | null; // assigned in initialize()\n\n  private focusTrap_!: FocusTrap; // assigned in initialSyncWithDOM()\n  private focusTrapFactory_?: MDCDialogFocusTrapFactory; // assigned in initialize()\n\n  private handleClick_!: SpecificEventListener<'click'>; // assigned in initialSyncWithDOM()\n  private handleKeydown_!: SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n  private handleDocumentKeydown_!: SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n  private handleLayout_!: EventListener; // assigned in initialSyncWithDOM()\n  private handleOpening_!: EventListener; // assigned in initialSyncWithDOM()\n  private handleClosing_!: () => void; // assigned in initialSyncWithDOM()\n\n  initialize(\n      focusTrapFactory?: MDCDialogFocusTrapFactory,\n  ) {\n    const container = this.root_.querySelector<HTMLElement>(strings.CONTAINER_SELECTOR);\n    if (!container) {\n      throw new Error(`Dialog component requires a ${strings.CONTAINER_SELECTOR} container element`);\n    }\n    this.container_ = container;\n    this.content_ = this.root_.querySelector<HTMLElement>(strings.CONTENT_SELECTOR);\n    this.buttons_ = [].slice.call(this.root_.querySelectorAll<HTMLElement>(strings.BUTTON_SELECTOR));\n    this.defaultButton_ = this.root_.querySelector<HTMLElement>(`[${strings.BUTTON_DEFAULT_ATTRIBUTE}]`);\n    this.focusTrapFactory_ = focusTrapFactory;\n    this.buttonRipples_ = [];\n\n    for (const buttonEl of this.buttons_) {\n      this.buttonRipples_.push(new MDCRipple(buttonEl));\n    }\n  }\n\n  initialSyncWithDOM() {\n    this.focusTrap_ = util.createFocusTrapInstance(\n        this.container_, this.focusTrapFactory_, this.getInitialFocusEl_() || undefined);\n\n    this.handleClick_ = this.foundation_.handleClick.bind(this.foundation_);\n    this.handleKeydown_ = this.foundation_.handleKeydown.bind(this.foundation_);\n    this.handleDocumentKeydown_ = this.foundation_.handleDocumentKeydown.bind(this.foundation_);\n    this.handleLayout_ = this.layout.bind(this);\n\n    const LAYOUT_EVENTS = ['resize', 'orientationchange'];\n    this.handleOpening_ = () => {\n      LAYOUT_EVENTS.forEach((evtType) => window.addEventListener(evtType, this.handleLayout_));\n      document.addEventListener('keydown', this.handleDocumentKeydown_);\n    };\n    this.handleClosing_ = () => {\n      LAYOUT_EVENTS.forEach((evtType) => window.removeEventListener(evtType, this.handleLayout_));\n      document.removeEventListener('keydown', this.handleDocumentKeydown_);\n    };\n\n    this.listen('click', this.handleClick_);\n    this.listen('keydown', this.handleKeydown_);\n    this.listen(strings.OPENING_EVENT, this.handleOpening_);\n    this.listen(strings.CLOSING_EVENT, this.handleClosing_);\n  }\n\n  destroy() {\n    this.unlisten('click', this.handleClick_);\n    this.unlisten('keydown', this.handleKeydown_);\n    this.unlisten(strings.OPENING_EVENT, this.handleOpening_);\n    this.unlisten(strings.CLOSING_EVENT, this.handleClosing_);\n    this.handleClosing_();\n\n    this.buttonRipples_.forEach((ripple) => ripple.destroy());\n    super.destroy();\n  }\n\n  layout() {\n    this.foundation_.layout();\n  }\n\n  open() {\n    this.foundation_.open();\n  }\n\n  close(action = '') {\n    this.foundation_.close(action);\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCDialogAdapter = {\n      addBodyClass: (className) => document.body.classList.add(className),\n      addClass: (className) => this.root_.classList.add(className),\n      areButtonsStacked: () => util.areTopsMisaligned(this.buttons_),\n      clickDefaultButton: () => this.defaultButton_ && this.defaultButton_.click(),\n      eventTargetMatches: (target, selector) => target ? matches(target as Element, selector) : false,\n      getActionFromEvent: (evt: Event) => {\n        if (!evt.target) {\n          return '';\n        }\n        const element = closest(evt.target as Element, `[${strings.ACTION_ATTRIBUTE}]`);\n        return element && element.getAttribute(strings.ACTION_ATTRIBUTE);\n      },\n      getInitialFocusEl: () => this.getInitialFocusEl_(),\n      hasClass: (className) => this.root_.classList.contains(className),\n      isContentScrollable: () => util.isScrollable(this.content_),\n      notifyClosed: (action) => this.emit<MDCDialogCloseEventDetail>(strings.CLOSED_EVENT, action ? {action} : {}),\n      notifyClosing: (action) => this.emit<MDCDialogCloseEventDetail>(strings.CLOSING_EVENT, action ? {action} : {}),\n      notifyOpened: () => this.emit(strings.OPENED_EVENT, {}),\n      notifyOpening: () => this.emit(strings.OPENING_EVENT, {}),\n      releaseFocus: () => this.focusTrap_.deactivate(),\n      removeBodyClass: (className) => document.body.classList.remove(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      reverseButtons: () => {\n        this.buttons_.reverse();\n        this.buttons_.forEach((button) => {\n          button.parentElement!.appendChild(button);\n        });\n      },\n      trapFocus: () => this.focusTrap_.activate(),\n    };\n    return new MDCDialogFoundation(adapter);\n  }\n\n  private getInitialFocusEl_(): HTMLElement|null {\n    return document.querySelector(`[${strings.INITIAL_FOCUS_ATTRIBUTE}]`);\n  }\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport const cssClasses = {\n  CLOSING: 'mdc-dialog--closing',\n  OPEN: 'mdc-dialog--open',\n  OPENING: 'mdc-dialog--opening',\n  SCROLLABLE: 'mdc-dialog--scrollable',\n  SCROLL_LOCK: 'mdc-dialog-scroll-lock',\n  STACKED: 'mdc-dialog--stacked',\n};\n\nexport const strings = {\n  ACTION_ATTRIBUTE: 'data-mdc-dialog-action',\n  BUTTON_DEFAULT_ATTRIBUTE: 'data-mdc-dialog-button-default',\n  BUTTON_SELECTOR: '.mdc-dialog__button',\n  CLOSED_EVENT: 'MDCDialog:closed',\n  CLOSE_ACTION: 'close',\n  CLOSING_EVENT: 'MDCDialog:closing',\n  CONTAINER_SELECTOR: '.mdc-dialog__container',\n  CONTENT_SELECTOR: '.mdc-dialog__content',\n  DESTROY_ACTION: 'destroy',\n  INITIAL_FOCUS_ATTRIBUTE: 'data-mdc-dialog-initial-focus',\n  OPENED_EVENT: 'MDCDialog:opened',\n  OPENING_EVENT: 'MDCDialog:opening',\n  SCRIM_SELECTOR: '.mdc-dialog__scrim',\n  SUPPRESS_DEFAULT_PRESS_SELECTOR: [\n    'textarea',\n    '.mdc-menu .mdc-list-item',\n  ].join(', '),\n  SURFACE_SELECTOR: '.mdc-dialog__surface',\n};\n\nexport const numbers = {\n  DIALOG_ANIMATION_CLOSE_TIME_MS: 75,\n  DIALOG_ANIMATION_OPEN_TIME_MS: 150,\n};\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCDialogAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\nexport class MDCDialogFoundation extends MDCFoundation<MDCDialogAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get numbers() {\n    return numbers;\n  }\n\n  static get defaultAdapter(): MDCDialogAdapter {\n    return {\n      addBodyClass: () => undefined,\n      addClass: () => undefined,\n      areButtonsStacked: () => false,\n      clickDefaultButton: () => undefined,\n      eventTargetMatches: () => false,\n      getActionFromEvent: () => '',\n      getInitialFocusEl: () => null,\n      hasClass: () => false,\n      isContentScrollable: () => false,\n      notifyClosed: () => undefined,\n      notifyClosing: () => undefined,\n      notifyOpened: () => undefined,\n      notifyOpening: () => undefined,\n      releaseFocus: () => undefined,\n      removeBodyClass: () => undefined,\n      removeClass: () => undefined,\n      reverseButtons: () => undefined,\n      trapFocus: () => undefined,\n    };\n  }\n\n  private isOpen_ = false;\n  private animationFrame_ = 0;\n  private animationTimer_ = 0;\n  private layoutFrame_ = 0;\n  private escapeKeyAction_ = strings.CLOSE_ACTION;\n  private scrimClickAction_ = strings.CLOSE_ACTION;\n  private autoStackButtons_ = true;\n  private areButtonsStacked_ = false;\n\n  constructor(adapter?: Partial<MDCDialogAdapter>) {\n    super({...MDCDialogFoundation.defaultAdapter, ...adapter});\n  }\n\n  init() {\n    if (this.adapter_.hasClass(cssClasses.STACKED)) {\n      this.setAutoStackButtons(false);\n    }\n  }\n\n  destroy() {\n    if (this.isOpen_) {\n      this.close(strings.DESTROY_ACTION);\n    }\n\n    if (this.animationTimer_) {\n      clearTimeout(this.animationTimer_);\n      this.handleAnimationTimerEnd_();\n    }\n\n    if (this.layoutFrame_) {\n      cancelAnimationFrame(this.layoutFrame_);\n      this.layoutFrame_ = 0;\n    }\n  }\n\n  open() {\n    this.isOpen_ = true;\n    this.adapter_.notifyOpening();\n    this.adapter_.addClass(cssClasses.OPENING);\n\n    // Wait a frame once display is no longer \"none\", to establish basis for animation\n    this.runNextAnimationFrame_(() => {\n      this.adapter_.addClass(cssClasses.OPEN);\n      this.adapter_.addBodyClass(cssClasses.SCROLL_LOCK);\n\n      this.layout();\n\n      this.animationTimer_ = setTimeout(() => {\n        this.handleAnimationTimerEnd_();\n        this.adapter_.trapFocus(this.adapter_.getInitialFocusEl());\n        this.adapter_.notifyOpened();\n      }, numbers.DIALOG_ANIMATION_OPEN_TIME_MS);\n    });\n  }\n\n  close(action = '') {\n    if (!this.isOpen_) {\n      // Avoid redundant close calls (and events), e.g. from keydown on elements that inherently emit click\n      return;\n    }\n\n    this.isOpen_ = false;\n    this.adapter_.notifyClosing(action);\n    this.adapter_.addClass(cssClasses.CLOSING);\n    this.adapter_.removeClass(cssClasses.OPEN);\n    this.adapter_.removeBodyClass(cssClasses.SCROLL_LOCK);\n\n    cancelAnimationFrame(this.animationFrame_);\n    this.animationFrame_ = 0;\n\n    clearTimeout(this.animationTimer_);\n    this.animationTimer_ = setTimeout(() => {\n      this.adapter_.releaseFocus();\n      this.handleAnimationTimerEnd_();\n      this.adapter_.notifyClosed(action);\n    }, numbers.DIALOG_ANIMATION_CLOSE_TIME_MS);\n  }\n\n  isOpen() {\n    return this.isOpen_;\n  }\n\n  getEscapeKeyAction(): string {\n    return this.escapeKeyAction_;\n  }\n\n  setEscapeKeyAction(action: string) {\n    this.escapeKeyAction_ = action;\n  }\n\n  getScrimClickAction(): string {\n    return this.scrimClickAction_;\n  }\n\n  setScrimClickAction(action: string) {\n    this.scrimClickAction_ = action;\n  }\n\n  getAutoStackButtons(): boolean {\n    return this.autoStackButtons_;\n  }\n\n  setAutoStackButtons(autoStack: boolean) {\n    this.autoStackButtons_ = autoStack;\n  }\n\n  layout() {\n    if (this.layoutFrame_) {\n      cancelAnimationFrame(this.layoutFrame_);\n    }\n    this.layoutFrame_ = requestAnimationFrame(() => {\n      this.layoutInternal_();\n      this.layoutFrame_ = 0;\n    });\n  }\n\n  /** Handles click on the dialog root element. */\n  handleClick(evt: MouseEvent) {\n    const isScrim = this.adapter_.eventTargetMatches(evt.target, strings.SCRIM_SELECTOR);\n    // Check for scrim click first since it doesn't require querying ancestors.\n    if (isScrim && this.scrimClickAction_ !== '') {\n      this.close(this.scrimClickAction_);\n    } else {\n      const action = this.adapter_.getActionFromEvent(evt);\n      if (action) {\n        this.close(action);\n      }\n    }\n  }\n\n  /** Handles keydown on the dialog root element. */\n  handleKeydown(evt: KeyboardEvent) {\n    const isEnter = evt.key === 'Enter' || evt.keyCode === 13;\n    if (!isEnter) {\n      return;\n    }\n    const action = this.adapter_.getActionFromEvent(evt);\n    if (action) {\n      // Action button callback is handled in `handleClick`,\n      // since space/enter keydowns on buttons trigger click events.\n      return;\n    }\n\n    const isDefault = !this.adapter_.eventTargetMatches(\n        evt.target, strings.SUPPRESS_DEFAULT_PRESS_SELECTOR);\n    if (isEnter && isDefault) {\n      this.adapter_.clickDefaultButton();\n    }\n  }\n\n  /** Handles keydown on the document. */\n  handleDocumentKeydown(evt: KeyboardEvent) {\n    const isEscape = evt.key === 'Escape' || evt.keyCode === 27;\n    if (isEscape && this.escapeKeyAction_ !== '') {\n      this.close(this.escapeKeyAction_);\n    }\n  }\n\n  private layoutInternal_() {\n    if (this.autoStackButtons_) {\n      this.detectStackedButtons_();\n    }\n    this.detectScrollableContent_();\n  }\n\n  private handleAnimationTimerEnd_() {\n    this.animationTimer_ = 0;\n    this.adapter_.removeClass(cssClasses.OPENING);\n    this.adapter_.removeClass(cssClasses.CLOSING);\n  }\n\n  /**\n   * Runs the given logic on the next animation frame, using setTimeout to factor in Firefox reflow behavior.\n   */\n  private runNextAnimationFrame_(callback: () => void) {\n    cancelAnimationFrame(this.animationFrame_);\n    this.animationFrame_ = requestAnimationFrame(() => {\n      this.animationFrame_ = 0;\n      clearTimeout(this.animationTimer_);\n      this.animationTimer_ = setTimeout(callback, 0);\n    });\n  }\n\n  private detectStackedButtons_() {\n    // Remove the class first to let us measure the buttons' natural positions.\n    this.adapter_.removeClass(cssClasses.STACKED);\n\n    const areButtonsStacked = this.adapter_.areButtonsStacked();\n\n    if (areButtonsStacked) {\n      this.adapter_.addClass(cssClasses.STACKED);\n    }\n\n    if (areButtonsStacked !== this.areButtonsStacked_) {\n      this.adapter_.reverseButtons();\n      this.areButtonsStacked_ = areButtonsStacked;\n    }\n  }\n\n  private detectScrollableContent_() {\n    // Remove the class first to let us measure the natural height of the content.\n    this.adapter_.removeClass(cssClasses.SCROLLABLE);\n    if (this.adapter_.isContentScrollable()) {\n      this.adapter_.addClass(cssClasses.SCROLLABLE);\n    }\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCDialogFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport * as util from './util';\n\nexport {util};\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","var tabbable = require('tabbable');\nvar xtend = require('xtend');\n\nvar activeFocusTraps = (function() {\n  var trapQueue = [];\n  return {\n    activateTrap: function(trap) {\n      if (trapQueue.length > 0) {\n        var activeTrap = trapQueue[trapQueue.length - 1];\n        if (activeTrap !== trap) {\n          activeTrap.pause();\n        }\n      }\n\n      var trapIndex = trapQueue.indexOf(trap);\n      if (trapIndex === -1) {\n        trapQueue.push(trap);\n      } else {\n        // move this existing trap to the front of the queue\n        trapQueue.splice(trapIndex, 1);\n        trapQueue.push(trap);\n      }\n    },\n\n    deactivateTrap: function(trap) {\n      var trapIndex = trapQueue.indexOf(trap);\n      if (trapIndex !== -1) {\n        trapQueue.splice(trapIndex, 1);\n      }\n\n      if (trapQueue.length > 0) {\n        trapQueue[trapQueue.length - 1].unpause();\n      }\n    }\n  };\n})();\n\nfunction focusTrap(element, userOptions) {\n  var doc = document;\n  var container =\n    typeof element === 'string' ? doc.querySelector(element) : element;\n\n  var config = xtend(\n    {\n      returnFocusOnDeactivate: true,\n      escapeDeactivates: true\n    },\n    userOptions\n  );\n\n  var state = {\n    firstTabbableNode: null,\n    lastTabbableNode: null,\n    nodeFocusedBeforeActivation: null,\n    mostRecentlyFocusedNode: null,\n    active: false,\n    paused: false\n  };\n\n  var trap = {\n    activate: activate,\n    deactivate: deactivate,\n    pause: pause,\n    unpause: unpause\n  };\n\n  return trap;\n\n  function activate(activateOptions) {\n    if (state.active) return;\n\n    updateTabbableNodes();\n\n    state.active = true;\n    state.paused = false;\n    state.nodeFocusedBeforeActivation = doc.activeElement;\n\n    var onActivate =\n      activateOptions && activateOptions.onActivate\n        ? activateOptions.onActivate\n        : config.onActivate;\n    if (onActivate) {\n      onActivate();\n    }\n\n    addListeners();\n    return trap;\n  }\n\n  function deactivate(deactivateOptions) {\n    if (!state.active) return;\n\n    removeListeners();\n    state.active = false;\n    state.paused = false;\n\n    activeFocusTraps.deactivateTrap(trap);\n\n    var onDeactivate =\n      deactivateOptions && deactivateOptions.onDeactivate !== undefined\n        ? deactivateOptions.onDeactivate\n        : config.onDeactivate;\n    if (onDeactivate) {\n      onDeactivate();\n    }\n\n    var returnFocus =\n      deactivateOptions && deactivateOptions.returnFocus !== undefined\n        ? deactivateOptions.returnFocus\n        : config.returnFocusOnDeactivate;\n    if (returnFocus) {\n      delay(function() {\n        tryFocus(state.nodeFocusedBeforeActivation);\n      });\n    }\n\n    return trap;\n  }\n\n  function pause() {\n    if (state.paused || !state.active) return;\n    state.paused = true;\n    removeListeners();\n  }\n\n  function unpause() {\n    if (!state.paused || !state.active) return;\n    state.paused = false;\n    updateTabbableNodes();\n    addListeners();\n  }\n\n  function addListeners() {\n    if (!state.active) return;\n\n    // There can be only one listening focus trap at a time\n    activeFocusTraps.activateTrap(trap);\n\n    // Delay ensures that the focused element doesn't capture the event\n    // that caused the focus trap activation.\n    delay(function() {\n      tryFocus(getInitialFocusNode());\n    });\n    doc.addEventListener('focusin', checkFocusIn, true);\n    doc.addEventListener('mousedown', checkPointerDown, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('touchstart', checkPointerDown, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('click', checkClick, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('keydown', checkKey, {\n      capture: true,\n      passive: false\n    });\n\n    return trap;\n  }\n\n  function removeListeners() {\n    if (!state.active) return;\n\n    doc.removeEventListener('focusin', checkFocusIn, true);\n    doc.removeEventListener('mousedown', checkPointerDown, true);\n    doc.removeEventListener('touchstart', checkPointerDown, true);\n    doc.removeEventListener('click', checkClick, true);\n    doc.removeEventListener('keydown', checkKey, true);\n\n    return trap;\n  }\n\n  function getNodeForOption(optionName) {\n    var optionValue = config[optionName];\n    var node = optionValue;\n    if (!optionValue) {\n      return null;\n    }\n    if (typeof optionValue === 'string') {\n      node = doc.querySelector(optionValue);\n      if (!node) {\n        throw new Error('`' + optionName + '` refers to no known node');\n      }\n    }\n    if (typeof optionValue === 'function') {\n      node = optionValue();\n      if (!node) {\n        throw new Error('`' + optionName + '` did not return a node');\n      }\n    }\n    return node;\n  }\n\n  function getInitialFocusNode() {\n    var node;\n    if (getNodeForOption('initialFocus') !== null) {\n      node = getNodeForOption('initialFocus');\n    } else if (container.contains(doc.activeElement)) {\n      node = doc.activeElement;\n    } else {\n      node = state.firstTabbableNode || getNodeForOption('fallbackFocus');\n    }\n\n    if (!node) {\n      throw new Error(\n        \"You can't have a focus-trap without at least one focusable element\"\n      );\n    }\n\n    return node;\n  }\n\n  // This needs to be done on mousedown and touchstart instead of click\n  // so that it precedes the focus event.\n  function checkPointerDown(e) {\n    if (container.contains(e.target)) return;\n    if (config.clickOutsideDeactivates) {\n      deactivate({\n        returnFocus: !tabbable.isFocusable(e.target)\n      });\n    } else {\n      e.preventDefault();\n    }\n  }\n\n  // In case focus escapes the trap for some strange reason, pull it back in.\n  function checkFocusIn(e) {\n    // In Firefox when you Tab out of an iframe the Document is briefly focused.\n    if (container.contains(e.target) || e.target instanceof Document) {\n      return;\n    }\n    e.stopImmediatePropagation();\n    tryFocus(state.mostRecentlyFocusedNode || getInitialFocusNode());\n  }\n\n  function checkKey(e) {\n    if (config.escapeDeactivates !== false && isEscapeEvent(e)) {\n      e.preventDefault();\n      deactivate();\n      return;\n    }\n    if (isTabEvent(e)) {\n      checkTab(e);\n      return;\n    }\n  }\n\n  // Hijack Tab events on the first and last focusable nodes of the trap,\n  // in order to prevent focus from escaping. If it escapes for even a\n  // moment it can end up scrolling the page and causing confusion so we\n  // kind of need to capture the action at the keydown phase.\n  function checkTab(e) {\n    updateTabbableNodes();\n    if (e.shiftKey && e.target === state.firstTabbableNode) {\n      e.preventDefault();\n      tryFocus(state.lastTabbableNode);\n      return;\n    }\n    if (!e.shiftKey && e.target === state.lastTabbableNode) {\n      e.preventDefault();\n      tryFocus(state.firstTabbableNode);\n      return;\n    }\n  }\n\n  function checkClick(e) {\n    if (config.clickOutsideDeactivates) return;\n    if (container.contains(e.target)) return;\n    e.preventDefault();\n    e.stopImmediatePropagation();\n  }\n\n  function updateTabbableNodes() {\n    var tabbableNodes = tabbable(container);\n    state.firstTabbableNode = tabbableNodes[0] || getInitialFocusNode();\n    state.lastTabbableNode =\n      tabbableNodes[tabbableNodes.length - 1] || getInitialFocusNode();\n  }\n\n  function tryFocus(node) {\n    if (node === doc.activeElement) return;\n    if (!node || !node.focus) {\n      tryFocus(getInitialFocusNode());\n      return;\n    }\n\n    node.focus();\n    state.mostRecentlyFocusedNode = node;\n    if (isSelectableInput(node)) {\n      node.select();\n    }\n  }\n}\n\nfunction isSelectableInput(node) {\n  return (\n    node.tagName &&\n    node.tagName.toLowerCase() === 'input' &&\n    typeof node.select === 'function'\n  );\n}\n\nfunction isEscapeEvent(e) {\n  return e.key === 'Escape' || e.key === 'Esc' || e.keyCode === 27;\n}\n\nfunction isTabEvent(e) {\n  return e.key === 'Tab' || e.keyCode === 9;\n}\n\nfunction delay(fn) {\n  return setTimeout(fn, 0);\n}\n\nmodule.exports = focusTrap;\n","var candidateSelectors = [\n  'input',\n  'select',\n  'textarea',\n  'a[href]',\n  'button',\n  '[tabindex]',\n  'audio[controls]',\n  'video[controls]',\n  '[contenteditable]:not([contenteditable=\"false\"])',\n];\nvar candidateSelector = candidateSelectors.join(',');\n\nvar matches = typeof Element === 'undefined'\n  ? function () {}\n  : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;\n\nfunction tabbable(el, options) {\n  options = options || {};\n\n  var regularTabbables = [];\n  var orderedTabbables = [];\n\n  var candidates = el.querySelectorAll(candidateSelector);\n\n  if (options.includeContainer) {\n    if (matches.call(el, candidateSelector)) {\n      candidates = Array.prototype.slice.apply(candidates);\n      candidates.unshift(el);\n    }\n  }\n\n  var i, candidate, candidateTabindex;\n  for (i = 0; i < candidates.length; i++) {\n    candidate = candidates[i];\n\n    if (!isNodeMatchingSelectorTabbable(candidate)) continue;\n\n    candidateTabindex = getTabindex(candidate);\n    if (candidateTabindex === 0) {\n      regularTabbables.push(candidate);\n    } else {\n      orderedTabbables.push({\n        documentOrder: i,\n        tabIndex: candidateTabindex,\n        node: candidate,\n      });\n    }\n  }\n\n  var tabbableNodes = orderedTabbables\n    .sort(sortOrderedTabbables)\n    .map(function(a) { return a.node })\n    .concat(regularTabbables);\n\n  return tabbableNodes;\n}\n\ntabbable.isTabbable = isTabbable;\ntabbable.isFocusable = isFocusable;\n\nfunction isNodeMatchingSelectorTabbable(node) {\n  if (\n    !isNodeMatchingSelectorFocusable(node)\n    || isNonTabbableRadio(node)\n    || getTabindex(node) < 0\n  ) {\n    return false;\n  }\n  return true;\n}\n\nfunction isTabbable(node) {\n  if (!node) throw new Error('No node provided');\n  if (matches.call(node, candidateSelector) === false) return false;\n  return isNodeMatchingSelectorTabbable(node);\n}\n\nfunction isNodeMatchingSelectorFocusable(node) {\n  if (\n    node.disabled\n    || isHiddenInput(node)\n    || isHidden(node)\n  ) {\n    return false;\n  }\n  return true;\n}\n\nvar focusableCandidateSelector = candidateSelectors.concat('iframe').join(',');\nfunction isFocusable(node) {\n  if (!node) throw new Error('No node provided');\n  if (matches.call(node, focusableCandidateSelector) === false) return false;\n  return isNodeMatchingSelectorFocusable(node);\n}\n\nfunction getTabindex(node) {\n  var tabindexAttr = parseInt(node.getAttribute('tabindex'), 10);\n  if (!isNaN(tabindexAttr)) return tabindexAttr;\n  // Browsers do not return `tabIndex` correctly for contentEditable nodes;\n  // so if they don't have a tabindex attribute specifically set, assume it's 0.\n  if (isContentEditable(node)) return 0;\n  return node.tabIndex;\n}\n\nfunction sortOrderedTabbables(a, b) {\n  return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;\n}\n\nfunction isContentEditable(node) {\n  return node.contentEditable === 'true';\n}\n\nfunction isInput(node) {\n  return node.tagName === 'INPUT';\n}\n\nfunction isHiddenInput(node) {\n  return isInput(node) && node.type === 'hidden';\n}\n\nfunction isRadio(node) {\n  return isInput(node) && node.type === 'radio';\n}\n\nfunction isNonTabbableRadio(node) {\n  return isRadio(node) && !isTabbableRadio(node);\n}\n\nfunction getCheckedRadio(nodes) {\n  for (var i = 0; i < nodes.length; i++) {\n    if (nodes[i].checked) {\n      return nodes[i];\n    }\n  }\n}\n\nfunction isTabbableRadio(node) {\n  if (!node.name) return true;\n  // This won't account for the edge case where you have radio groups with the same\n  // in separate forms on the same page.\n  var radioSet = node.ownerDocument.querySelectorAll('input[type=\"radio\"][name=\"' + node.name + '\"]');\n  var checked = getCheckedRadio(radioSet);\n  return !checked || checked === node;\n}\n\nfunction isHidden(node) {\n  // offsetParent being null will allow detecting cases where an element is invisible or inside an invisible element,\n  // as long as the element does not use position: fixed. For them, their visibility has to be checked directly as well.\n  return node.offsetParent === null || getComputedStyle(node).visibility === 'hidden';\n}\n\nmodule.exports = tabbable;\n","module.exports = extend\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n    var target = {}\n\n    for (var i = 0; i < arguments.length; i++) {\n        var source = arguments[i]\n\n        for (var key in source) {\n            if (hasOwnProperty.call(source, key)) {\n                target[key] = source[key]\n            }\n        }\n    }\n\n    return target\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {default as createFocusTrap, FocusTarget, FocusTrap, Options} from 'focus-trap';\n\nexport type MDCDialogFocusTrapFactory = (\n    element: HTMLElement | string,\n    userOptions?: Options,\n) => FocusTrap;\n\nexport function createFocusTrapInstance(\n    surfaceEl: HTMLElement,\n    focusTrapFactory: MDCDialogFocusTrapFactory = createFocusTrap as unknown as MDCDialogFocusTrapFactory,\n    initialFocusEl?: FocusTarget,\n): FocusTrap {\n  return focusTrapFactory(surfaceEl, {\n    clickOutsideDeactivates: true, // Allow handling of scrim clicks.\n    escapeDeactivates: false, // Foundation handles ESC key.\n    initialFocus: initialFocusEl,\n  });\n}\n\nexport function isScrollable(el: HTMLElement | null): boolean {\n  return el ? el.scrollHeight > el.offsetHeight : false;\n}\n\nexport function areTopsMisaligned(els: HTMLElement[]): boolean {\n  const tops = new Set();\n  [].forEach.call(els, (el: HTMLElement) => tops.add(el.offsetTop));\n  return tops.size > 1;\n}\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n/**\n * Stores result from applyPassive to avoid redundant processing to detect\n * passive event listener support.\n */\nlet supportsPassive_: boolean | undefined;\n\n/**\n * Determine whether the current browser supports passive event listeners, and\n * if so, use them.\n */\nexport function applyPassive(globalObj: Window = window, forceRefresh = false):\n    boolean | EventListenerOptions {\n  if (supportsPassive_ === undefined || forceRefresh) {\n    let isSupported = false;\n    try {\n      globalObj.document.addEventListener('test', () => undefined, {\n        get passive() {\n          isSupported = true;\n          return isSupported;\n        },\n      });\n    } catch (e) {\n    } // tslint:disable-line:no-empty cannot throw error due to tests. tslint also disables console.log.\n\n    supportsPassive_ = isSupported;\n  }\n\n  return supportsPassive_ ? {passive: true} as EventListenerOptions : false;\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport * as events from './events';\nimport * as ponyfill from './ponyfill';\n\nexport {events, ponyfill};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n/**\n * @fileoverview A \"ponyfill\" is a polyfill that doesn't modify the global prototype chain.\n * This makes ponyfills safer than traditional polyfills, especially for libraries like MDC.\n */\n\nexport function closest(element: Element, selector: string): Element | null {\n  if (element.closest) {\n    return element.closest(selector);\n  }\n\n  let el: Element | null = element;\n  while (el) {\n    if (matches(el, selector)) {\n      return el;\n    }\n    el = el.parentElement;\n  }\n  return null;\n}\n\nexport function matches(element: Element, selector: string): boolean {\n  const nativeMatches = element.matches\n      || element.webkitMatchesSelector\n      || element.msMatchesSelector;\n  return nativeMatches.call(element, selector);\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCList, MDCListFactory} from '@material/list/component';\nimport {MDCListFoundation} from '@material/list/foundation';\nimport {default as createFocusTrap, FocusTrap} from 'focus-trap';\nimport {MDCDrawerAdapter} from './adapter';\nimport {MDCDismissibleDrawerFoundation} from './dismissible/foundation';\nimport {MDCModalDrawerFoundation} from './modal/foundation';\nimport * as util from './util';\nimport {MDCDrawerFocusTrapFactory} from './util';\n\nconst {cssClasses, strings} = MDCDismissibleDrawerFoundation;\n\n/**\n * @events `MDCDrawer:closed {}` Emits when the navigation drawer has closed.\n * @events `MDCDrawer:opened {}` Emits when the navigation drawer has opened.\n */\nexport class MDCDrawer extends MDCComponent<MDCDismissibleDrawerFoundation> {\n  static attachTo(root: Element): MDCDrawer {\n    return new MDCDrawer(root);\n  }\n\n  /**\n   * @return boolean Proxies to the foundation's `open`/`close` methods.\n   * Also returns true if drawer is in the open position.\n   */\n  get open(): boolean {\n    return this.foundation_.isOpen();\n  }\n\n  /**\n   * Toggles the drawer open and closed.\n   */\n  set open(isOpen: boolean) {\n    if (isOpen) {\n      this.foundation_.open();\n    } else {\n      this.foundation_.close();\n    }\n  }\n\n  private previousFocus_?: Element | null;\n  private scrim_!: HTMLElement | null; // assigned in initialSyncWithDOM()\n  private list_?: MDCList; // assigned in initialize()\n\n  private focusTrap_?: FocusTrap; // assigned in initialSyncWithDOM()\n  private focusTrapFactory_!: MDCDrawerFocusTrapFactory; // assigned in initialize()\n\n  private handleScrimClick_?: SpecificEventListener<'click'>; // initialized in initialSyncWithDOM()\n  private handleKeydown_!: SpecificEventListener<'keydown'>; // initialized in initialSyncWithDOM()\n  private handleTransitionEnd_!: SpecificEventListener<'transitionend'>; // initialized in initialSyncWithDOM()\n\n  get list(): MDCList | undefined {\n    return this.list_;\n  }\n\n  initialize(\n      focusTrapFactory: MDCDrawerFocusTrapFactory = createFocusTrap as unknown as MDCDrawerFocusTrapFactory,\n      listFactory: MDCListFactory = (el) => new MDCList(el),\n  ) {\n    const listEl = this.root_.querySelector(`.${MDCListFoundation.cssClasses.ROOT}`);\n    if (listEl) {\n      this.list_ = listFactory(listEl);\n      this.list_.wrapFocus = true;\n    }\n    this.focusTrapFactory_ = focusTrapFactory;\n  }\n\n  initialSyncWithDOM() {\n    const {MODAL} = cssClasses;\n    const {SCRIM_SELECTOR} = strings;\n\n    this.scrim_ = (this.root_.parentNode as Element).querySelector<HTMLElement>(SCRIM_SELECTOR);\n\n    if (this.scrim_ && this.root_.classList.contains(MODAL)) {\n      this.handleScrimClick_ = () => (this.foundation_ as MDCModalDrawerFoundation).handleScrimClick();\n      this.scrim_.addEventListener('click', this.handleScrimClick_);\n      this.focusTrap_ = util.createFocusTrapInstance(this.root_ as HTMLElement, this.focusTrapFactory_);\n    }\n\n    this.handleKeydown_ = (evt) => this.foundation_.handleKeydown(evt);\n    this.handleTransitionEnd_ = (evt) => this.foundation_.handleTransitionEnd(evt);\n\n    this.listen('keydown', this.handleKeydown_);\n    this.listen('transitionend', this.handleTransitionEnd_);\n  }\n\n  destroy() {\n    this.unlisten('keydown', this.handleKeydown_);\n    this.unlisten('transitionend', this.handleTransitionEnd_);\n\n    if (this.list_) {\n      this.list_.destroy();\n    }\n\n    const {MODAL} = cssClasses;\n    if (this.scrim_ && this.handleScrimClick_ && this.root_.classList.contains(MODAL)) {\n      this.scrim_.removeEventListener('click', this.handleScrimClick_);\n      // Ensure drawer is closed to hide scrim and release focus\n      this.open = false;\n    }\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCDrawerAdapter = {\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      hasClass: (className) => this.root_.classList.contains(className),\n      elementHasClass: (element, className) => element.classList.contains(className),\n      saveFocus: () => this.previousFocus_ = document.activeElement,\n      restoreFocus: () => {\n        const previousFocus = this.previousFocus_ as HTMLOrSVGElement | null;\n        if (previousFocus && previousFocus.focus && this.root_.contains(document.activeElement)) {\n          previousFocus.focus();\n        }\n      },\n      focusActiveNavigationItem: () => {\n        const activeNavItemEl =\n            this.root_.querySelector<HTMLElement>(`.${MDCListFoundation.cssClasses.LIST_ITEM_ACTIVATED_CLASS}`);\n        if (activeNavItemEl) {\n          activeNavItemEl.focus();\n        }\n      },\n      notifyClose: () => this.emit(strings.CLOSE_EVENT, {}, true /* shouldBubble */),\n      notifyOpen: () => this.emit(strings.OPEN_EVENT, {}, true /* shouldBubble */),\n      trapFocus: () => this.focusTrap_!.activate(),\n      releaseFocus: () => this.focusTrap_!.deactivate(),\n    };\n    // tslint:enable:object-literal-sort-keys\n\n    const {DISMISSIBLE, MODAL} = cssClasses;\n    if (this.root_.classList.contains(DISMISSIBLE)) {\n      return new MDCDismissibleDrawerFoundation(adapter);\n    } else if (this.root_.classList.contains(MODAL)) {\n      return new MDCModalDrawerFoundation(adapter);\n    } else {\n      throw new Error(\n          `MDCDrawer: Failed to instantiate component. Supported variants are ${DISMISSIBLE} and ${MODAL}.`);\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n  ANIMATE: 'mdc-drawer--animate',\n  CLOSING: 'mdc-drawer--closing',\n  DISMISSIBLE: 'mdc-drawer--dismissible',\n  MODAL: 'mdc-drawer--modal',\n  OPEN: 'mdc-drawer--open',\n  OPENING: 'mdc-drawer--opening',\n  ROOT: 'mdc-drawer',\n};\n\nconst strings = {\n  APP_CONTENT_SELECTOR: '.mdc-drawer-app-content',\n  CLOSE_EVENT: 'MDCDrawer:closed',\n  OPEN_EVENT: 'MDCDrawer:opened',\n  SCRIM_SELECTOR: '.mdc-drawer-scrim',\n};\n\nexport {cssClasses, strings};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCDrawerAdapter} from '../adapter';\nimport {cssClasses, strings} from '../constants';\n\nexport class MDCDismissibleDrawerFoundation extends MDCFoundation<MDCDrawerAdapter> {\n  static get strings() {\n    return strings;\n  }\n\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get defaultAdapter(): MDCDrawerAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      hasClass: () => false,\n      elementHasClass: () => false,\n      notifyClose: () => undefined,\n      notifyOpen: () => undefined,\n      saveFocus: () => undefined,\n      restoreFocus: () => undefined,\n      focusActiveNavigationItem: () => undefined,\n      trapFocus: () => undefined,\n      releaseFocus: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private animationFrame_ = 0;\n  private animationTimer_ = 0;\n\n  constructor(adapter?: Partial<MDCDrawerAdapter>) {\n    super({...MDCDismissibleDrawerFoundation.defaultAdapter, ...adapter});\n  }\n\n  destroy() {\n    if (this.animationFrame_) {\n      cancelAnimationFrame(this.animationFrame_);\n    }\n    if (this.animationTimer_) {\n      clearTimeout(this.animationTimer_);\n    }\n  }\n\n  /**\n   * Opens the drawer from the closed state.\n   */\n  open() {\n    if (this.isOpen() || this.isOpening() || this.isClosing()) {\n      return;\n    }\n\n    this.adapter_.addClass(cssClasses.OPEN);\n    this.adapter_.addClass(cssClasses.ANIMATE);\n\n    // Wait a frame once display is no longer \"none\", to establish basis for animation\n    this.runNextAnimationFrame_(() => {\n      this.adapter_.addClass(cssClasses.OPENING);\n    });\n\n    this.adapter_.saveFocus();\n  }\n\n  /**\n   * Closes the drawer from the open state.\n   */\n  close() {\n    if (!this.isOpen() || this.isOpening() || this.isClosing()) {\n      return;\n    }\n\n    this.adapter_.addClass(cssClasses.CLOSING);\n  }\n\n  /**\n   * Returns true if the drawer is in the open position.\n   * @return true if drawer is in open state.\n   */\n  isOpen(): boolean {\n    return this.adapter_.hasClass(cssClasses.OPEN);\n  }\n\n  /**\n   * Returns true if the drawer is animating open.\n   * @return true if drawer is animating open.\n   */\n  isOpening(): boolean {\n    return this.adapter_.hasClass(cssClasses.OPENING) || this.adapter_.hasClass(cssClasses.ANIMATE);\n  }\n\n  /**\n   * Returns true if the drawer is animating closed.\n   * @return true if drawer is animating closed.\n   */\n  isClosing(): boolean {\n    return this.adapter_.hasClass(cssClasses.CLOSING);\n  }\n\n  /**\n   * Keydown handler to close drawer when key is escape.\n   */\n  handleKeydown(evt: KeyboardEvent) {\n    const {keyCode, key} = evt;\n    const isEscape = key === 'Escape' || keyCode === 27;\n    if (isEscape) {\n      this.close();\n    }\n  }\n\n  /**\n   * Handles the `transitionend` event when the drawer finishes opening/closing.\n   */\n  handleTransitionEnd(evt: TransitionEvent) {\n    const {OPENING, CLOSING, OPEN, ANIMATE, ROOT} = cssClasses;\n\n    // In Edge, transitionend on ripple pseudo-elements yields a target without classList, so check for Element first.\n    const isRootElement = this.isElement_(evt.target) && this.adapter_.elementHasClass(evt.target, ROOT);\n    if (!isRootElement) {\n      return;\n    }\n\n    if (this.isClosing()) {\n      this.adapter_.removeClass(OPEN);\n      this.closed_();\n      this.adapter_.restoreFocus();\n      this.adapter_.notifyClose();\n    } else {\n      this.adapter_.focusActiveNavigationItem();\n      this.opened_();\n      this.adapter_.notifyOpen();\n    }\n\n    this.adapter_.removeClass(ANIMATE);\n    this.adapter_.removeClass(OPENING);\n    this.adapter_.removeClass(CLOSING);\n  }\n\n  /**\n   * Extension point for when drawer finishes open animation.\n   */\n  protected opened_() {} // tslint:disable-line:no-empty\n\n  /**\n   * Extension point for when drawer finishes close animation.\n   */\n  protected closed_() {} // tslint:disable-line:no-empty\n\n  /**\n   * Runs the given logic on the next animation frame, using setTimeout to factor in Firefox reflow behavior.\n   */\n  private runNextAnimationFrame_(callback: () => void) {\n    cancelAnimationFrame(this.animationFrame_);\n    this.animationFrame_ = requestAnimationFrame(() => {\n      this.animationFrame_ = 0;\n      clearTimeout(this.animationTimer_);\n      this.animationTimer_ = setTimeout(callback, 0);\n    });\n  }\n\n  private isElement_(element: unknown): element is Element {\n    // In Edge, transitionend on ripple pseudo-elements yields a target without classList.\n    return Boolean((element as Element).classList);\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCDismissibleDrawerFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport * as util from './util';\n\nexport {util};\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './dismissible/foundation';\nexport * from './modal/foundation';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCDismissibleDrawerFoundation} from '../dismissible/foundation';\n\n/* istanbul ignore next: subclass is not a branch statement */\nexport class MDCModalDrawerFoundation extends MDCDismissibleDrawerFoundation {\n  /**\n   * Handles click event on scrim.\n   */\n  handleScrimClick() {\n    this.close();\n  }\n\n  /**\n   * Called when drawer finishes open animation.\n   */\n  protected opened_() {\n    this.adapter_.trapFocus();\n  }\n\n  /**\n   * Called when drawer finishes close animation.\n   */\n  protected closed_() {\n    this.adapter_.releaseFocus();\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCModalDrawerFoundation;\n","var tabbable = require('tabbable');\nvar xtend = require('xtend');\n\nvar activeFocusTraps = (function() {\n  var trapQueue = [];\n  return {\n    activateTrap: function(trap) {\n      if (trapQueue.length > 0) {\n        var activeTrap = trapQueue[trapQueue.length - 1];\n        if (activeTrap !== trap) {\n          activeTrap.pause();\n        }\n      }\n\n      var trapIndex = trapQueue.indexOf(trap);\n      if (trapIndex === -1) {\n        trapQueue.push(trap);\n      } else {\n        // move this existing trap to the front of the queue\n        trapQueue.splice(trapIndex, 1);\n        trapQueue.push(trap);\n      }\n    },\n\n    deactivateTrap: function(trap) {\n      var trapIndex = trapQueue.indexOf(trap);\n      if (trapIndex !== -1) {\n        trapQueue.splice(trapIndex, 1);\n      }\n\n      if (trapQueue.length > 0) {\n        trapQueue[trapQueue.length - 1].unpause();\n      }\n    }\n  };\n})();\n\nfunction focusTrap(element, userOptions) {\n  var doc = document;\n  var container =\n    typeof element === 'string' ? doc.querySelector(element) : element;\n\n  var config = xtend(\n    {\n      returnFocusOnDeactivate: true,\n      escapeDeactivates: true\n    },\n    userOptions\n  );\n\n  var state = {\n    firstTabbableNode: null,\n    lastTabbableNode: null,\n    nodeFocusedBeforeActivation: null,\n    mostRecentlyFocusedNode: null,\n    active: false,\n    paused: false\n  };\n\n  var trap = {\n    activate: activate,\n    deactivate: deactivate,\n    pause: pause,\n    unpause: unpause\n  };\n\n  return trap;\n\n  function activate(activateOptions) {\n    if (state.active) return;\n\n    updateTabbableNodes();\n\n    state.active = true;\n    state.paused = false;\n    state.nodeFocusedBeforeActivation = doc.activeElement;\n\n    var onActivate =\n      activateOptions && activateOptions.onActivate\n        ? activateOptions.onActivate\n        : config.onActivate;\n    if (onActivate) {\n      onActivate();\n    }\n\n    addListeners();\n    return trap;\n  }\n\n  function deactivate(deactivateOptions) {\n    if (!state.active) return;\n\n    removeListeners();\n    state.active = false;\n    state.paused = false;\n\n    activeFocusTraps.deactivateTrap(trap);\n\n    var onDeactivate =\n      deactivateOptions && deactivateOptions.onDeactivate !== undefined\n        ? deactivateOptions.onDeactivate\n        : config.onDeactivate;\n    if (onDeactivate) {\n      onDeactivate();\n    }\n\n    var returnFocus =\n      deactivateOptions && deactivateOptions.returnFocus !== undefined\n        ? deactivateOptions.returnFocus\n        : config.returnFocusOnDeactivate;\n    if (returnFocus) {\n      delay(function() {\n        tryFocus(state.nodeFocusedBeforeActivation);\n      });\n    }\n\n    return trap;\n  }\n\n  function pause() {\n    if (state.paused || !state.active) return;\n    state.paused = true;\n    removeListeners();\n  }\n\n  function unpause() {\n    if (!state.paused || !state.active) return;\n    state.paused = false;\n    updateTabbableNodes();\n    addListeners();\n  }\n\n  function addListeners() {\n    if (!state.active) return;\n\n    // There can be only one listening focus trap at a time\n    activeFocusTraps.activateTrap(trap);\n\n    // Delay ensures that the focused element doesn't capture the event\n    // that caused the focus trap activation.\n    delay(function() {\n      tryFocus(getInitialFocusNode());\n    });\n    doc.addEventListener('focusin', checkFocusIn, true);\n    doc.addEventListener('mousedown', checkPointerDown, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('touchstart', checkPointerDown, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('click', checkClick, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('keydown', checkKey, {\n      capture: true,\n      passive: false\n    });\n\n    return trap;\n  }\n\n  function removeListeners() {\n    if (!state.active) return;\n\n    doc.removeEventListener('focusin', checkFocusIn, true);\n    doc.removeEventListener('mousedown', checkPointerDown, true);\n    doc.removeEventListener('touchstart', checkPointerDown, true);\n    doc.removeEventListener('click', checkClick, true);\n    doc.removeEventListener('keydown', checkKey, true);\n\n    return trap;\n  }\n\n  function getNodeForOption(optionName) {\n    var optionValue = config[optionName];\n    var node = optionValue;\n    if (!optionValue) {\n      return null;\n    }\n    if (typeof optionValue === 'string') {\n      node = doc.querySelector(optionValue);\n      if (!node) {\n        throw new Error('`' + optionName + '` refers to no known node');\n      }\n    }\n    if (typeof optionValue === 'function') {\n      node = optionValue();\n      if (!node) {\n        throw new Error('`' + optionName + '` did not return a node');\n      }\n    }\n    return node;\n  }\n\n  function getInitialFocusNode() {\n    var node;\n    if (getNodeForOption('initialFocus') !== null) {\n      node = getNodeForOption('initialFocus');\n    } else if (container.contains(doc.activeElement)) {\n      node = doc.activeElement;\n    } else {\n      node = state.firstTabbableNode || getNodeForOption('fallbackFocus');\n    }\n\n    if (!node) {\n      throw new Error(\n        \"You can't have a focus-trap without at least one focusable element\"\n      );\n    }\n\n    return node;\n  }\n\n  // This needs to be done on mousedown and touchstart instead of click\n  // so that it precedes the focus event.\n  function checkPointerDown(e) {\n    if (container.contains(e.target)) return;\n    if (config.clickOutsideDeactivates) {\n      deactivate({\n        returnFocus: !tabbable.isFocusable(e.target)\n      });\n    } else {\n      e.preventDefault();\n    }\n  }\n\n  // In case focus escapes the trap for some strange reason, pull it back in.\n  function checkFocusIn(e) {\n    // In Firefox when you Tab out of an iframe the Document is briefly focused.\n    if (container.contains(e.target) || e.target instanceof Document) {\n      return;\n    }\n    e.stopImmediatePropagation();\n    tryFocus(state.mostRecentlyFocusedNode || getInitialFocusNode());\n  }\n\n  function checkKey(e) {\n    if (config.escapeDeactivates !== false && isEscapeEvent(e)) {\n      e.preventDefault();\n      deactivate();\n      return;\n    }\n    if (isTabEvent(e)) {\n      checkTab(e);\n      return;\n    }\n  }\n\n  // Hijack Tab events on the first and last focusable nodes of the trap,\n  // in order to prevent focus from escaping. If it escapes for even a\n  // moment it can end up scrolling the page and causing confusion so we\n  // kind of need to capture the action at the keydown phase.\n  function checkTab(e) {\n    updateTabbableNodes();\n    if (e.shiftKey && e.target === state.firstTabbableNode) {\n      e.preventDefault();\n      tryFocus(state.lastTabbableNode);\n      return;\n    }\n    if (!e.shiftKey && e.target === state.lastTabbableNode) {\n      e.preventDefault();\n      tryFocus(state.firstTabbableNode);\n      return;\n    }\n  }\n\n  function checkClick(e) {\n    if (config.clickOutsideDeactivates) return;\n    if (container.contains(e.target)) return;\n    e.preventDefault();\n    e.stopImmediatePropagation();\n  }\n\n  function updateTabbableNodes() {\n    var tabbableNodes = tabbable(container);\n    state.firstTabbableNode = tabbableNodes[0] || getInitialFocusNode();\n    state.lastTabbableNode =\n      tabbableNodes[tabbableNodes.length - 1] || getInitialFocusNode();\n  }\n\n  function tryFocus(node) {\n    if (node === doc.activeElement) return;\n    if (!node || !node.focus) {\n      tryFocus(getInitialFocusNode());\n      return;\n    }\n\n    node.focus();\n    state.mostRecentlyFocusedNode = node;\n    if (isSelectableInput(node)) {\n      node.select();\n    }\n  }\n}\n\nfunction isSelectableInput(node) {\n  return (\n    node.tagName &&\n    node.tagName.toLowerCase() === 'input' &&\n    typeof node.select === 'function'\n  );\n}\n\nfunction isEscapeEvent(e) {\n  return e.key === 'Escape' || e.key === 'Esc' || e.keyCode === 27;\n}\n\nfunction isTabEvent(e) {\n  return e.key === 'Tab' || e.keyCode === 9;\n}\n\nfunction delay(fn) {\n  return setTimeout(fn, 0);\n}\n\nmodule.exports = focusTrap;\n","var candidateSelectors = [\n  'input',\n  'select',\n  'textarea',\n  'a[href]',\n  'button',\n  '[tabindex]',\n  'audio[controls]',\n  'video[controls]',\n  '[contenteditable]:not([contenteditable=\"false\"])',\n];\nvar candidateSelector = candidateSelectors.join(',');\n\nvar matches = typeof Element === 'undefined'\n  ? function () {}\n  : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;\n\nfunction tabbable(el, options) {\n  options = options || {};\n\n  var regularTabbables = [];\n  var orderedTabbables = [];\n\n  var candidates = el.querySelectorAll(candidateSelector);\n\n  if (options.includeContainer) {\n    if (matches.call(el, candidateSelector)) {\n      candidates = Array.prototype.slice.apply(candidates);\n      candidates.unshift(el);\n    }\n  }\n\n  var i, candidate, candidateTabindex;\n  for (i = 0; i < candidates.length; i++) {\n    candidate = candidates[i];\n\n    if (!isNodeMatchingSelectorTabbable(candidate)) continue;\n\n    candidateTabindex = getTabindex(candidate);\n    if (candidateTabindex === 0) {\n      regularTabbables.push(candidate);\n    } else {\n      orderedTabbables.push({\n        documentOrder: i,\n        tabIndex: candidateTabindex,\n        node: candidate,\n      });\n    }\n  }\n\n  var tabbableNodes = orderedTabbables\n    .sort(sortOrderedTabbables)\n    .map(function(a) { return a.node })\n    .concat(regularTabbables);\n\n  return tabbableNodes;\n}\n\ntabbable.isTabbable = isTabbable;\ntabbable.isFocusable = isFocusable;\n\nfunction isNodeMatchingSelectorTabbable(node) {\n  if (\n    !isNodeMatchingSelectorFocusable(node)\n    || isNonTabbableRadio(node)\n    || getTabindex(node) < 0\n  ) {\n    return false;\n  }\n  return true;\n}\n\nfunction isTabbable(node) {\n  if (!node) throw new Error('No node provided');\n  if (matches.call(node, candidateSelector) === false) return false;\n  return isNodeMatchingSelectorTabbable(node);\n}\n\nfunction isNodeMatchingSelectorFocusable(node) {\n  if (\n    node.disabled\n    || isHiddenInput(node)\n    || isHidden(node)\n  ) {\n    return false;\n  }\n  return true;\n}\n\nvar focusableCandidateSelector = candidateSelectors.concat('iframe').join(',');\nfunction isFocusable(node) {\n  if (!node) throw new Error('No node provided');\n  if (matches.call(node, focusableCandidateSelector) === false) return false;\n  return isNodeMatchingSelectorFocusable(node);\n}\n\nfunction getTabindex(node) {\n  var tabindexAttr = parseInt(node.getAttribute('tabindex'), 10);\n  if (!isNaN(tabindexAttr)) return tabindexAttr;\n  // Browsers do not return `tabIndex` correctly for contentEditable nodes;\n  // so if they don't have a tabindex attribute specifically set, assume it's 0.\n  if (isContentEditable(node)) return 0;\n  return node.tabIndex;\n}\n\nfunction sortOrderedTabbables(a, b) {\n  return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;\n}\n\nfunction isContentEditable(node) {\n  return node.contentEditable === 'true';\n}\n\nfunction isInput(node) {\n  return node.tagName === 'INPUT';\n}\n\nfunction isHiddenInput(node) {\n  return isInput(node) && node.type === 'hidden';\n}\n\nfunction isRadio(node) {\n  return isInput(node) && node.type === 'radio';\n}\n\nfunction isNonTabbableRadio(node) {\n  return isRadio(node) && !isTabbableRadio(node);\n}\n\nfunction getCheckedRadio(nodes) {\n  for (var i = 0; i < nodes.length; i++) {\n    if (nodes[i].checked) {\n      return nodes[i];\n    }\n  }\n}\n\nfunction isTabbableRadio(node) {\n  if (!node.name) return true;\n  // This won't account for the edge case where you have radio groups with the same\n  // in separate forms on the same page.\n  var radioSet = node.ownerDocument.querySelectorAll('input[type=\"radio\"][name=\"' + node.name + '\"]');\n  var checked = getCheckedRadio(radioSet);\n  return !checked || checked === node;\n}\n\nfunction isHidden(node) {\n  // offsetParent being null will allow detecting cases where an element is invisible or inside an invisible element,\n  // as long as the element does not use position: fixed. For them, their visibility has to be checked directly as well.\n  return node.offsetParent === null || getComputedStyle(node).visibility === 'hidden';\n}\n\nmodule.exports = tabbable;\n","module.exports = extend\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n    var target = {}\n\n    for (var i = 0; i < arguments.length; i++) {\n        var source = arguments[i]\n\n        for (var key in source) {\n            if (hasOwnProperty.call(source, key)) {\n                target[key] = source[key]\n            }\n        }\n    }\n\n    return target\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {default as createFocusTrap, FocusTrap, Options} from 'focus-trap';\n\nexport type MDCDrawerFocusTrapFactory = (\n    element: HTMLElement | string,\n    userOptions?: Options,\n) => FocusTrap;\n\nexport function createFocusTrapInstance(\n    surfaceEl: HTMLElement,\n    focusTrapFactory: MDCDrawerFocusTrapFactory = createFocusTrap as unknown as MDCDrawerFocusTrapFactory,\n): FocusTrap {\n  return focusTrapFactory(surfaceEl, {\n    clickOutsideDeactivates: true, // Allow handling of scrim clicks.\n    escapeDeactivates: false, // Foundation handles ESC key.\n    initialFocus: undefined, // Component handles focusing on active nav item.\n    returnFocusOnDeactivate: false, // Component handles restoring focus.\n  });\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCFloatingLabelAdapter} from './adapter';\nimport {MDCFloatingLabelFoundation} from './foundation';\n\nexport type MDCFloatingLabelFactory = (el: Element, foundation?: MDCFloatingLabelFoundation) => MDCFloatingLabel;\n\nexport class MDCFloatingLabel extends MDCComponent<MDCFloatingLabelFoundation> {\n  static attachTo(root: Element): MDCFloatingLabel {\n    return new MDCFloatingLabel(root);\n  }\n\n  /**\n   * Styles the label to produce the label shake for errors.\n   * @param shouldShake If true, shakes the label by adding a CSS class; otherwise, stops shaking by removing the class.\n   */\n  shake(shouldShake: boolean) {\n    this.foundation_.shake(shouldShake);\n  }\n\n  /**\n   * Styles the label to float/dock.\n   * @param shouldFloat If true, floats the label by adding a CSS class; otherwise, docks it by removing the class.\n   */\n  float(shouldFloat: boolean) {\n    this.foundation_.float(shouldFloat);\n  }\n\n  getWidth(): number {\n    return this.foundation_.getWidth();\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCFloatingLabelAdapter = {\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      getWidth: () => this.root_.scrollWidth,\n      registerInteractionHandler: (evtType, handler) => this.listen(evtType, handler),\n      deregisterInteractionHandler: (evtType, handler) => this.unlisten(evtType, handler),\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCFloatingLabelFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport const cssClasses = {\n  LABEL_FLOAT_ABOVE: 'mdc-floating-label--float-above',\n  LABEL_SHAKE: 'mdc-floating-label--shake',\n  ROOT: 'mdc-floating-label',\n};\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCFloatingLabelAdapter} from './adapter';\nimport {cssClasses} from './constants';\n\nexport class MDCFloatingLabelFoundation extends MDCFoundation<MDCFloatingLabelAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  /**\n   * See {@link MDCFloatingLabelAdapter} for typing information on parameters and return types.\n   */\n  static get defaultAdapter(): MDCFloatingLabelAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      getWidth: () => 0,\n      registerInteractionHandler: () => undefined,\n      deregisterInteractionHandler: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private readonly shakeAnimationEndHandler_: SpecificEventListener<'animationend'>;\n\n  constructor(adapter?: Partial<MDCFloatingLabelAdapter>) {\n    super({...MDCFloatingLabelFoundation.defaultAdapter, ...adapter});\n\n    this.shakeAnimationEndHandler_ = () => this.handleShakeAnimationEnd_();\n  }\n\n  init() {\n    this.adapter_.registerInteractionHandler('animationend', this.shakeAnimationEndHandler_);\n  }\n\n  destroy() {\n    this.adapter_.deregisterInteractionHandler('animationend', this.shakeAnimationEndHandler_);\n  }\n\n  /**\n   * Returns the width of the label element.\n   */\n  getWidth(): number {\n    return this.adapter_.getWidth();\n  }\n\n  /**\n   * Styles the label to produce a shake animation to indicate an error.\n   * @param shouldShake If true, adds the shake CSS class; otherwise, removes shake class.\n   */\n  shake(shouldShake: boolean) {\n    const {LABEL_SHAKE} = MDCFloatingLabelFoundation.cssClasses;\n    if (shouldShake) {\n      this.adapter_.addClass(LABEL_SHAKE);\n    } else {\n      this.adapter_.removeClass(LABEL_SHAKE);\n    }\n  }\n\n  /**\n   * Styles the label to float or dock.\n   * @param shouldFloat If true, adds the float CSS class; otherwise, removes float and shake classes to dock the label.\n   */\n  float(shouldFloat: boolean) {\n    const {LABEL_FLOAT_ABOVE, LABEL_SHAKE} = MDCFloatingLabelFoundation.cssClasses;\n    if (shouldFloat) {\n      this.adapter_.addClass(LABEL_FLOAT_ABOVE);\n    } else {\n      this.adapter_.removeClass(LABEL_FLOAT_ABOVE);\n      this.adapter_.removeClass(LABEL_SHAKE);\n    }\n  }\n\n  private handleShakeAnimationEnd_() {\n    const {LABEL_SHAKE} = MDCFloatingLabelFoundation.cssClasses;\n    this.adapter_.removeClass(LABEL_SHAKE);\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCFloatingLabelFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCRipple} from '@material/ripple/component';\nimport {MDCFormFieldAdapter} from './adapter';\nimport {MDCFormFieldFoundation} from './foundation';\n\nexport interface MDCFormFieldInput {\n  readonly ripple: MDCRipple | undefined;\n}\n\nexport class MDCFormField extends MDCComponent<MDCFormFieldFoundation> {\n  static attachTo(root: HTMLElement) {\n    return new MDCFormField(root);\n  }\n\n  private input_?: MDCFormFieldInput;\n\n  set input(input: MDCFormFieldInput | undefined) {\n    this.input_ = input;\n  }\n\n  get input(): MDCFormFieldInput | undefined {\n    return this.input_;\n  }\n\n  private get label_(): Element | null {\n    const {LABEL_SELECTOR} = MDCFormFieldFoundation.strings;\n    return this.root_.querySelector(LABEL_SELECTOR);\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCFormFieldAdapter = {\n      activateInputRipple: () => {\n        if (this.input_ && this.input_.ripple) {\n          this.input_.ripple.activate();\n        }\n      },\n      deactivateInputRipple: () => {\n        if (this.input_ && this.input_.ripple) {\n          this.input_.ripple.deactivate();\n        }\n      },\n      deregisterInteractionHandler: (evtType, handler) => {\n        if (this.label_) {\n          (this.label_ as HTMLElement).removeEventListener(evtType, handler);\n        }\n      },\n      registerInteractionHandler: (evtType, handler) => {\n        if (this.label_) {\n          (this.label_ as HTMLElement).addEventListener(evtType, handler);\n        }\n      },\n    };\n    return new MDCFormFieldFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport const cssClasses = {\n  ROOT: 'mdc-form-field',\n};\n\nexport const strings = {\n  LABEL_SELECTOR: '.mdc-form-field > label',\n};\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCFormFieldAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCFormFieldFoundation extends MDCFoundation<MDCFormFieldAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get defaultAdapter(): MDCFormFieldAdapter {\n    return {\n      activateInputRipple: () => undefined,\n      deactivateInputRipple: () => undefined,\n      deregisterInteractionHandler: () => undefined,\n      registerInteractionHandler: () => undefined,\n    };\n  }\n\n  private readonly clickHandler_: () => void;\n\n  constructor(adapter?: Partial<MDCFormFieldAdapter>) {\n    super({...MDCFormFieldFoundation.defaultAdapter, ...adapter});\n\n    this.clickHandler_ = () => this.handleClick_();\n  }\n\n  init() {\n    this.adapter_.registerInteractionHandler('click', this.clickHandler_);\n  }\n\n  destroy() {\n    this.adapter_.deregisterInteractionHandler('click', this.clickHandler_);\n  }\n\n  private handleClick_() {\n    this.adapter_.activateInputRipple();\n    requestAnimationFrame(() => this.adapter_.deactivateInputRipple());\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCFormFieldFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCGridListAdapter} from './adapter';\nimport {MDCGridListFoundation} from './foundation';\n\nexport class MDCGridList extends MDCComponent<MDCGridListFoundation> {\n  static attachTo(root: Element) {\n    return new MDCGridList(root);\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCGridListAdapter = {\n      deregisterResizeHandler: (handler) => window.removeEventListener('resize', handler),\n      getNumberOfTiles: () => {\n        return this.root_.querySelectorAll(MDCGridListFoundation.strings.TILE_SELECTOR).length;\n      },\n      getOffsetWidth: () => (this.root_ as HTMLElement).offsetWidth,\n      getOffsetWidthForTileAtIndex: (index) => {\n        const tileEl = this.root_.querySelectorAll<HTMLElement>(MDCGridListFoundation.strings.TILE_SELECTOR)[index];\n        return tileEl.offsetWidth;\n      },\n      registerResizeHandler: (handler) => window.addEventListener('resize', handler),\n      setStyleForTilesElement: (property, value) => {\n        const tilesEl = this.root_.querySelector<HTMLElement>(MDCGridListFoundation.strings.TILES_SELECTOR);\n        tilesEl!.style[property] = value;\n      },\n    };\n    return new MDCGridListFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport const strings = {\n  TILES_SELECTOR: '.mdc-grid-list__tiles',\n  TILE_SELECTOR: '.mdc-grid-tile',\n};\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCGridListAdapter} from './adapter';\nimport {strings} from './constants';\n\nexport class MDCGridListFoundation extends MDCFoundation<MDCGridListAdapter> {\n  static get strings() {\n    return strings;\n  }\n\n  static get defaultAdapter(): MDCGridListAdapter {\n    return {\n      deregisterResizeHandler: () => undefined,\n      getNumberOfTiles: () => 0,\n      getOffsetWidth: () => 0,\n      getOffsetWidthForTileAtIndex: () => 0,\n      registerResizeHandler: () => undefined,\n      setStyleForTilesElement: () => undefined,\n    };\n  }\n\n  private readonly resizeHandler_: EventListener;\n  private resizeFrame_ = 0;\n\n  /* istanbul ignore next: optional argument is not a branch statement */\n  constructor(adapter?: Partial<MDCGridListAdapter>) {\n    super({...MDCGridListFoundation.defaultAdapter, ...adapter});\n\n    this.resizeHandler_ = this.alignCenter.bind(this);\n  }\n\n  init() {\n    this.alignCenter();\n    this.adapter_.registerResizeHandler(this.resizeHandler_);\n  }\n\n  destroy() {\n    this.adapter_.deregisterResizeHandler(this.resizeHandler_);\n  }\n\n  alignCenter() {\n    cancelAnimationFrame(this.resizeFrame_);\n    this.resizeFrame_ = requestAnimationFrame(() => {\n      this.alignCenter_();\n      this.resizeFrame_ = 0;\n    });\n  }\n\n  private alignCenter_() {\n    if (this.adapter_.getNumberOfTiles() === 0) {\n      return;\n    }\n    const gridWidth = this.adapter_.getOffsetWidth();\n    const itemWidth = this.adapter_.getOffsetWidthForTileAtIndex(0);\n    const tilesWidth = itemWidth * Math.floor(gridWidth / itemWidth);\n    this.adapter_.setStyleForTilesElement('width', `${tilesWidth}px`);\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCGridListFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCRipple} from '@material/ripple/component';\nimport {MDCIconButtonToggleAdapter} from './adapter';\nimport {MDCIconButtonToggleFoundation} from './foundation';\nimport {MDCIconButtonToggleEventDetail} from './types';\n\nconst {strings} = MDCIconButtonToggleFoundation;\n\nexport class MDCIconButtonToggle extends MDCComponent<MDCIconButtonToggleFoundation> {\n  static attachTo(root: HTMLElement) {\n    return new MDCIconButtonToggle(root);\n  }\n\n  protected root_!: HTMLElement; // assigned in MDCComponent constructor\n\n  private readonly ripple_: MDCRipple = this.createRipple_();\n  private handleClick_!: SpecificEventListener<'click'>; // assigned in initialSyncWithDOM()\n\n  initialSyncWithDOM() {\n    this.handleClick_ = () => this.foundation_.handleClick();\n    this.listen('click', this.handleClick_);\n  }\n\n  destroy() {\n    this.unlisten('click', this.handleClick_);\n    this.ripple_.destroy();\n    super.destroy();\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCIconButtonToggleAdapter = {\n      addClass: (className) => this.root_.classList.add(className),\n      hasClass: (className) => this.root_.classList.contains(className),\n      notifyChange: (evtData) => this.emit<MDCIconButtonToggleEventDetail>(strings.CHANGE_EVENT, evtData),\n      removeClass: (className) => this.root_.classList.remove(className),\n      setAttr: (attrName, attrValue) => this.root_.setAttribute(attrName, attrValue),\n    };\n    return new MDCIconButtonToggleFoundation(adapter);\n  }\n\n  get ripple(): MDCRipple {\n    return this.ripple_;\n  }\n\n  get on(): boolean {\n    return this.foundation_.isOn();\n  }\n\n  set on(isOn: boolean) {\n    this.foundation_.toggle(isOn);\n  }\n\n  private createRipple_(): MDCRipple {\n    const ripple = new MDCRipple(this.root_);\n    ripple.unbounded = true;\n    return ripple;\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport const cssClasses = {\n  ICON_BUTTON_ON: 'mdc-icon-button--on',\n  ROOT: 'mdc-icon-button',\n};\n\nexport const strings = {\n  ARIA_PRESSED: 'aria-pressed',\n  CHANGE_EVENT: 'MDCIconButtonToggle:change',\n};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCIconButtonToggleAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCIconButtonToggleFoundation extends MDCFoundation<MDCIconButtonToggleAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get defaultAdapter(): MDCIconButtonToggleAdapter {\n    return {\n      addClass: () => undefined,\n      hasClass: () => false,\n      notifyChange: () => undefined,\n      removeClass: () => undefined,\n      setAttr: () => undefined,\n    };\n  }\n\n  constructor(adapter?: Partial<MDCIconButtonToggleAdapter>) {\n    super({...MDCIconButtonToggleFoundation.defaultAdapter, ...adapter});\n  }\n\n  init() {\n    this.adapter_.setAttr(strings.ARIA_PRESSED, `${this.isOn()}`);\n  }\n\n  handleClick() {\n    this.toggle();\n    this.adapter_.notifyChange({isOn: this.isOn()});\n  }\n\n  isOn(): boolean {\n    return this.adapter_.hasClass(cssClasses.ICON_BUTTON_ON);\n  }\n\n  toggle(isOn: boolean = !this.isOn()) {\n    if (isOn) {\n      this.adapter_.addClass(cssClasses.ICON_BUTTON_ON);\n    } else {\n      this.adapter_.removeClass(cssClasses.ICON_BUTTON_ON);\n    }\n\n    this.adapter_.setAttr(strings.ARIA_PRESSED, `${isOn}`);\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCIconButtonToggleFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCLineRippleAdapter} from './adapter';\nimport {MDCLineRippleFoundation} from './foundation';\n\nexport type MDCLineRippleFactory = (el: Element, foundation?: MDCLineRippleFoundation) => MDCLineRipple;\n\nexport class MDCLineRipple extends MDCComponent<MDCLineRippleFoundation> {\n  static attachTo(root: Element): MDCLineRipple {\n    return new MDCLineRipple(root);\n  }\n\n  /**\n   * Activates the line ripple\n   */\n  activate() {\n    this.foundation_.activate();\n  }\n\n  /**\n   * Deactivates the line ripple\n   */\n  deactivate() {\n    this.foundation_.deactivate();\n  }\n\n  /**\n   * Sets the transform origin given a user's click location.\n   * The `rippleCenter` is the x-coordinate of the middle of the ripple.\n   */\n  setRippleCenter(xCoordinate: number) {\n    this.foundation_.setRippleCenter(xCoordinate);\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCLineRippleAdapter = {\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      hasClass: (className) => this.root_.classList.contains(className),\n      setStyle: (propertyName, value) => (this.root_ as HTMLElement).style.setProperty(propertyName, value),\n      registerEventHandler: (evtType, handler) => this.listen(evtType, handler),\n      deregisterEventHandler: (evtType, handler) => this.unlisten(evtType, handler),\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCLineRippleFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n  LINE_RIPPLE_ACTIVE: 'mdc-line-ripple--active',\n  LINE_RIPPLE_DEACTIVATING: 'mdc-line-ripple--deactivating',\n};\n\nexport {cssClasses};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCLineRippleAdapter} from './adapter';\nimport {cssClasses} from './constants';\n\nexport class MDCLineRippleFoundation extends MDCFoundation<MDCLineRippleAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  /**\n   * See {@link MDCLineRippleAdapter} for typing information on parameters and return types.\n   */\n  static get defaultAdapter(): MDCLineRippleAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      hasClass: () => false,\n      setStyle: () => undefined,\n      registerEventHandler: () => undefined,\n      deregisterEventHandler: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private readonly transitionEndHandler_: SpecificEventListener<'transitionend'>;\n\n  constructor(adapter?: Partial<MDCLineRippleAdapter>) {\n    super({...MDCLineRippleFoundation.defaultAdapter, ...adapter});\n\n    this.transitionEndHandler_ = (evt) => this.handleTransitionEnd(evt);\n  }\n\n  init() {\n    this.adapter_.registerEventHandler('transitionend', this.transitionEndHandler_);\n  }\n\n  destroy() {\n    this.adapter_.deregisterEventHandler('transitionend', this.transitionEndHandler_);\n  }\n\n  activate() {\n    this.adapter_.removeClass(cssClasses.LINE_RIPPLE_DEACTIVATING);\n    this.adapter_.addClass(cssClasses.LINE_RIPPLE_ACTIVE);\n  }\n\n  setRippleCenter(xCoordinate: number) {\n    this.adapter_.setStyle('transform-origin', `${xCoordinate}px center`);\n  }\n\n  deactivate() {\n    this.adapter_.addClass(cssClasses.LINE_RIPPLE_DEACTIVATING);\n  }\n\n  handleTransitionEnd(evt: TransitionEvent) {\n    // Wait for the line ripple to be either transparent or opaque\n    // before emitting the animation end event\n    const isDeactivating = this.adapter_.hasClass(cssClasses.LINE_RIPPLE_DEACTIVATING);\n\n    if (evt.propertyName === 'opacity') {\n      if (isDeactivating) {\n        this.adapter_.removeClass(cssClasses.LINE_RIPPLE_ACTIVE);\n        this.adapter_.removeClass(cssClasses.LINE_RIPPLE_DEACTIVATING);\n      }\n    }\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCLineRippleFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCLinearProgressAdapter} from './adapter';\nimport {MDCLinearProgressFoundation} from './foundation';\n\nexport class MDCLinearProgress extends MDCComponent<MDCLinearProgressFoundation> {\n  static attachTo(root: Element) {\n    return new MDCLinearProgress(root);\n  }\n\n  set determinate(value: boolean) {\n    this.foundation_.setDeterminate(value);\n  }\n\n  set progress(value: number) {\n    this.foundation_.setProgress(value);\n  }\n\n  set buffer(value: number) {\n    this.foundation_.setBuffer(value);\n  }\n\n  set reverse(value: boolean) {\n    this.foundation_.setReverse(value);\n  }\n\n  open() {\n    this.foundation_.open();\n  }\n\n  close() {\n    this.foundation_.close();\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCLinearProgressAdapter = {\n      addClass: (className: string) => this.root_.classList.add(className),\n      getBuffer: () => this.root_.querySelector(MDCLinearProgressFoundation.strings.BUFFER_SELECTOR),\n      getPrimaryBar: () => this.root_.querySelector(MDCLinearProgressFoundation.strings.PRIMARY_BAR_SELECTOR),\n      hasClass: (className: string) => this.root_.classList.contains(className),\n      removeClass: (className: string) => this.root_.classList.remove(className),\n      setStyle: (el: HTMLElement, styleProperty: string, value: string) => el.style.setProperty(styleProperty, value),\n    };\n    return new MDCLinearProgressFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport const cssClasses = {\n  CLOSED_CLASS: 'mdc-linear-progress--closed',\n  INDETERMINATE_CLASS: 'mdc-linear-progress--indeterminate',\n  REVERSED_CLASS: 'mdc-linear-progress--reversed',\n};\n\nexport const strings = {\n  BUFFER_SELECTOR: '.mdc-linear-progress__buffer',\n  PRIMARY_BAR_SELECTOR: '.mdc-linear-progress__primary-bar',\n};\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {getCorrectPropertyName} from '@material/animation/util';\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCLinearProgressAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCLinearProgressFoundation extends MDCFoundation<MDCLinearProgressAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get defaultAdapter(): MDCLinearProgressAdapter {\n    return {\n      addClass: () => undefined,\n      getBuffer: () => null,\n      getPrimaryBar: () => null,\n      hasClass: () => false,\n      removeClass: () => undefined,\n      setStyle: () => undefined,\n    };\n  }\n\n  private isDeterminate_!: boolean;\n  private isReversed_!: boolean;\n  private progress_!: number;\n\n  constructor(adapter?: Partial<MDCLinearProgressAdapter>) {\n    super({...MDCLinearProgressFoundation.defaultAdapter, ...adapter});\n  }\n\n  init() {\n    this.isDeterminate_ = !this.adapter_.hasClass(cssClasses.INDETERMINATE_CLASS);\n    this.isReversed_ = this.adapter_.hasClass(cssClasses.REVERSED_CLASS);\n    this.progress_ = 0;\n  }\n\n  setDeterminate(isDeterminate: boolean) {\n    this.isDeterminate_ = isDeterminate;\n    if (this.isDeterminate_) {\n      this.adapter_.removeClass(cssClasses.INDETERMINATE_CLASS);\n      this.setScale_(this.adapter_.getPrimaryBar(), this.progress_);\n    } else {\n      this.adapter_.addClass(cssClasses.INDETERMINATE_CLASS);\n      this.setScale_(this.adapter_.getPrimaryBar(), 1);\n      this.setScale_(this.adapter_.getBuffer(), 1);\n    }\n  }\n\n  setProgress(value: number) {\n    this.progress_ = value;\n    if (this.isDeterminate_) {\n      this.setScale_(this.adapter_.getPrimaryBar(), value);\n    }\n  }\n\n  setBuffer(value: number) {\n    if (this.isDeterminate_) {\n      this.setScale_(this.adapter_.getBuffer(), value);\n    }\n  }\n\n  setReverse(isReversed: boolean) {\n    this.isReversed_ = isReversed;\n    if (this.isReversed_) {\n      this.adapter_.addClass(cssClasses.REVERSED_CLASS);\n    } else {\n      this.adapter_.removeClass(cssClasses.REVERSED_CLASS);\n    }\n  }\n\n  open() {\n    this.adapter_.removeClass(cssClasses.CLOSED_CLASS);\n  }\n\n  close() {\n    this.adapter_.addClass(cssClasses.CLOSED_CLASS);\n  }\n\n  private setScale_(el: HTMLElement | null, scaleValue: number) {\n    if (!el) {\n      return;\n    }\n    const value = `scaleX(${scaleValue})`;\n    this.adapter_.setStyle(el, getCorrectPropertyName(window, 'transform'), value);\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCLinearProgressFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {closest, matches} from '@material/dom/ponyfill';\nimport {MDCListAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCListFoundation} from './foundation';\nimport {MDCListActionEventDetail, MDCListIndex} from './types';\n\nexport type MDCListFactory = (el: Element, foundation?: MDCListFoundation) => MDCList;\n\nexport class MDCList extends MDCComponent<MDCListFoundation> {\n  set vertical(value: boolean) {\n    this.foundation_.setVerticalOrientation(value);\n  }\n\n  get listElements(): Element[] {\n    return [].slice.call(this.root_.querySelectorAll(`.${cssClasses.LIST_ITEM_CLASS}`));\n  }\n\n  set wrapFocus(value: boolean) {\n    this.foundation_.setWrapFocus(value);\n  }\n\n  set singleSelection(isSingleSelectionList: boolean) {\n    this.foundation_.setSingleSelection(isSingleSelectionList);\n  }\n\n  get selectedIndex(): MDCListIndex {\n    return this.foundation_.getSelectedIndex();\n  }\n\n  set selectedIndex(index: MDCListIndex) {\n    this.foundation_.setSelectedIndex(index);\n  }\n\n  static attachTo(root: Element) {\n    return new MDCList(root);\n  }\n\n  private handleKeydown_!: SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n  private handleClick_!: SpecificEventListener<'click'>; // assigned in initialSyncWithDOM()\n  private focusInEventListener_!: SpecificEventListener<'focus'>; // assigned in initialSyncWithDOM()\n  private focusOutEventListener_!: SpecificEventListener<'focus'>; // assigned in initialSyncWithDOM()\n\n  initialSyncWithDOM() {\n    this.handleClick_ = this.handleClickEvent_.bind(this);\n    this.handleKeydown_ = this.handleKeydownEvent_.bind(this);\n    this.focusInEventListener_ = this.handleFocusInEvent_.bind(this);\n    this.focusOutEventListener_ = this.handleFocusOutEvent_.bind(this);\n    this.listen('keydown', this.handleKeydown_);\n    this.listen('click', this.handleClick_);\n    this.listen('focusin', this.focusInEventListener_);\n    this.listen('focusout', this.focusOutEventListener_);\n    this.layout();\n    this.initializeListType();\n  }\n\n  destroy() {\n    this.unlisten('keydown', this.handleKeydown_);\n    this.unlisten('click', this.handleClick_);\n    this.unlisten('focusin', this.focusInEventListener_);\n    this.unlisten('focusout', this.focusOutEventListener_);\n  }\n\n  layout() {\n    const direction = this.root_.getAttribute(strings.ARIA_ORIENTATION);\n    this.vertical = direction !== strings.ARIA_ORIENTATION_HORIZONTAL;\n\n    // List items need to have at least tabindex=-1 to be focusable.\n    [].slice.call(this.root_.querySelectorAll('.mdc-list-item:not([tabindex])'))\n        .forEach((el: Element) => {\n          el.setAttribute('tabindex', '-1');\n        });\n\n    // Child button/a elements are not tabbable until the list item is focused.\n    [].slice.call(this.root_.querySelectorAll(strings.FOCUSABLE_CHILD_ELEMENTS))\n        .forEach((el: Element) => el.setAttribute('tabindex', '-1'));\n\n    this.foundation_.layout();\n  }\n\n  /**\n   * Initialize selectedIndex value based on pre-selected checkbox list items, single selection or radio.\n   */\n  initializeListType() {\n    const checkboxListItems = this.root_.querySelectorAll(strings.ARIA_ROLE_CHECKBOX_SELECTOR);\n    const singleSelectedListItem = this.root_.querySelector(`\n      .${cssClasses.LIST_ITEM_ACTIVATED_CLASS},\n      .${cssClasses.LIST_ITEM_SELECTED_CLASS}\n    `);\n    const radioSelectedListItem = this.root_.querySelector(strings.ARIA_CHECKED_RADIO_SELECTOR);\n\n    if (checkboxListItems.length) {\n      const preselectedItems = this.root_.querySelectorAll(strings.ARIA_CHECKED_CHECKBOX_SELECTOR);\n      this.selectedIndex =\n          [].map.call(preselectedItems, (listItem: Element) => this.listElements.indexOf(listItem)) as number[];\n    } else if (singleSelectedListItem) {\n      if (singleSelectedListItem.classList.contains(cssClasses.LIST_ITEM_ACTIVATED_CLASS)) {\n        this.foundation_.setUseActivatedClass(true);\n      }\n\n      this.singleSelection = true;\n      this.selectedIndex = this.listElements.indexOf(singleSelectedListItem);\n    } else if (radioSelectedListItem) {\n      this.selectedIndex = this.listElements.indexOf(radioSelectedListItem);\n    }\n  }\n\n  /**\n   * Updates the list item at itemIndex to the desired isEnabled state.\n   * @param itemIndex Index of the list item\n   * @param isEnabled Sets the list item to enabled or disabled.\n   */\n  setEnabled(itemIndex: number, isEnabled: boolean) {\n    this.foundation_.setEnabled(itemIndex, isEnabled);\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCListAdapter = {\n      addClassForElementIndex: (index, className) => {\n        const element = this.listElements[index];\n        if (element) {\n          element.classList.add(className);\n        }\n      },\n      focusItemAtIndex: (index) => {\n        const element = this.listElements[index] as HTMLElement | undefined;\n        if (element) {\n          element.focus();\n        }\n      },\n      getAttributeForElementIndex: (index, attr) => this.listElements[index].getAttribute(attr),\n      getFocusedElementIndex: () => this.listElements.indexOf(document.activeElement!),\n      getListItemCount: () => this.listElements.length,\n      hasCheckboxAtIndex: (index) => {\n        const listItem = this.listElements[index];\n        return !!listItem.querySelector(strings.CHECKBOX_SELECTOR);\n      },\n      hasRadioAtIndex: (index) => {\n        const listItem = this.listElements[index];\n        return !!listItem.querySelector(strings.RADIO_SELECTOR);\n      },\n      isCheckboxCheckedAtIndex: (index) => {\n        const listItem = this.listElements[index];\n        const toggleEl = listItem.querySelector<HTMLInputElement>(strings.CHECKBOX_SELECTOR);\n        return toggleEl!.checked;\n      },\n      isFocusInsideList: () => {\n        return this.root_.contains(document.activeElement);\n      },\n      isRootFocused: () => document.activeElement === this.root_,\n      notifyAction: (index) => {\n        this.emit<MDCListActionEventDetail>(strings.ACTION_EVENT, {index}, /** shouldBubble */ true);\n      },\n      removeClassForElementIndex: (index, className) => {\n        const element = this.listElements[index];\n        if (element) {\n          element.classList.remove(className);\n        }\n      },\n      setAttributeForElementIndex: (index, attr, value) => {\n        const element = this.listElements[index];\n        if (element) {\n          element.setAttribute(attr, value);\n        }\n      },\n      setCheckedCheckboxOrRadioAtIndex: (index, isChecked) => {\n        const listItem = this.listElements[index];\n        const toggleEl = listItem.querySelector<HTMLInputElement>(strings.CHECKBOX_RADIO_SELECTOR);\n        toggleEl!.checked = isChecked;\n\n        const event = document.createEvent('Event');\n        event.initEvent('change', true, true);\n        toggleEl!.dispatchEvent(event);\n      },\n      setTabIndexForListItemChildren: (listItemIndex, tabIndexValue) => {\n        const element = this.listElements[listItemIndex];\n        const listItemChildren: Element[] =\n            [].slice.call(element.querySelectorAll(strings.CHILD_ELEMENTS_TO_TOGGLE_TABINDEX));\n        listItemChildren.forEach((el) => el.setAttribute('tabindex', tabIndexValue));\n      },\n    };\n    return new MDCListFoundation(adapter);\n  }\n\n  /**\n   * Used to figure out which list item this event is targetting. Or returns -1 if\n   * there is no list item\n   */\n  private getListItemIndex_(evt: Event) {\n    const eventTarget = evt.target as Element;\n    const nearestParent = closest(eventTarget, `.${cssClasses.LIST_ITEM_CLASS}, .${cssClasses.ROOT}`);\n\n    // Get the index of the element if it is a list item.\n    if (nearestParent && matches(nearestParent, `.${cssClasses.LIST_ITEM_CLASS}`)) {\n      return this.listElements.indexOf(nearestParent);\n    }\n\n    return -1;\n  }\n\n  /**\n   * Used to figure out which element was clicked before sending the event to the foundation.\n   */\n  private handleFocusInEvent_(evt: FocusEvent) {\n    const index = this.getListItemIndex_(evt);\n    this.foundation_.handleFocusIn(evt, index);\n  }\n\n  /**\n   * Used to figure out which element was clicked before sending the event to the foundation.\n   */\n  private handleFocusOutEvent_(evt: FocusEvent) {\n    const index = this.getListItemIndex_(evt);\n    this.foundation_.handleFocusOut(evt, index);\n  }\n\n  /**\n   * Used to figure out which element was focused when keydown event occurred before sending the event to the\n   * foundation.\n   */\n  private handleKeydownEvent_(evt: KeyboardEvent) {\n    const index = this.getListItemIndex_(evt);\n    const target = evt.target as Element;\n    this.foundation_.handleKeydown(evt, target.classList.contains(cssClasses.LIST_ITEM_CLASS), index);\n  }\n\n  /**\n   * Used to figure out which element was clicked before sending the event to the foundation.\n   */\n  private handleClickEvent_(evt: MouseEvent) {\n    const index = this.getListItemIndex_(evt);\n    const target = evt.target as Element;\n\n    // Toggle the checkbox only if it's not the target of the event, or the checkbox will have 2 change events.\n    const toggleCheckbox = !matches(target, strings.CHECKBOX_RADIO_SELECTOR);\n    this.foundation_.handleClick(index, toggleCheckbox);\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n  LIST_ITEM_ACTIVATED_CLASS: 'mdc-list-item--activated',\n  LIST_ITEM_CLASS: 'mdc-list-item',\n  LIST_ITEM_DISABLED_CLASS: 'mdc-list-item--disabled',\n  LIST_ITEM_SELECTED_CLASS: 'mdc-list-item--selected',\n  ROOT: 'mdc-list',\n};\n\nconst strings = {\n  ACTION_EVENT: 'MDCList:action',\n  ARIA_CHECKED: 'aria-checked',\n  ARIA_CHECKED_CHECKBOX_SELECTOR: '[role=\"checkbox\"][aria-checked=\"true\"]',\n  ARIA_CHECKED_RADIO_SELECTOR: '[role=\"radio\"][aria-checked=\"true\"]',\n  ARIA_CURRENT: 'aria-current',\n  ARIA_DISABLED: 'aria-disabled',\n  ARIA_ORIENTATION: 'aria-orientation',\n  ARIA_ORIENTATION_HORIZONTAL: 'horizontal',\n  ARIA_ROLE_CHECKBOX_SELECTOR: '[role=\"checkbox\"]',\n  ARIA_SELECTED: 'aria-selected',\n  CHECKBOX_RADIO_SELECTOR: 'input[type=\"checkbox\"]:not(:disabled), input[type=\"radio\"]:not(:disabled)',\n  CHECKBOX_SELECTOR: 'input[type=\"checkbox\"]:not(:disabled)',\n  CHILD_ELEMENTS_TO_TOGGLE_TABINDEX: `\n    .${cssClasses.LIST_ITEM_CLASS} button:not(:disabled),\n    .${cssClasses.LIST_ITEM_CLASS} a\n  `,\n  FOCUSABLE_CHILD_ELEMENTS: `\n    .${cssClasses.LIST_ITEM_CLASS} button:not(:disabled),\n    .${cssClasses.LIST_ITEM_CLASS} a,\n    .${cssClasses.LIST_ITEM_CLASS} input[type=\"radio\"]:not(:disabled),\n    .${cssClasses.LIST_ITEM_CLASS} input[type=\"checkbox\"]:not(:disabled)\n  `,\n  RADIO_SELECTOR: 'input[type=\"radio\"]:not(:disabled)',\n};\n\nconst numbers = {\n  UNSET_INDEX: -1,\n};\n\nexport {strings, cssClasses, numbers};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCListAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\nimport {MDCListIndex} from './types';\n\nconst ELEMENTS_KEY_ALLOWED_IN = ['input', 'button', 'textarea', 'select'];\n\nfunction isNumberArray(selectedIndex: MDCListIndex): selectedIndex is number[] {\n  return selectedIndex instanceof Array;\n}\n\nexport class MDCListFoundation extends MDCFoundation<MDCListAdapter> {\n  static get strings() {\n    return strings;\n  }\n\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get numbers() {\n    return numbers;\n  }\n\n  static get defaultAdapter(): MDCListAdapter {\n    return {\n      addClassForElementIndex: () => undefined,\n      focusItemAtIndex: () => undefined,\n      getAttributeForElementIndex: () => null,\n      getFocusedElementIndex: () => 0,\n      getListItemCount: () => 0,\n      hasCheckboxAtIndex: () => false,\n      hasRadioAtIndex: () => false,\n      isCheckboxCheckedAtIndex: () => false,\n      isFocusInsideList: () => false,\n      isRootFocused: () => false,\n      notifyAction: () => undefined,\n      removeClassForElementIndex: () => undefined,\n      setAttributeForElementIndex: () => undefined,\n      setCheckedCheckboxOrRadioAtIndex: () => undefined,\n      setTabIndexForListItemChildren: () => undefined,\n    };\n  }\n\n  private wrapFocus_ = false;\n  private isVertical_ = true;\n  private isSingleSelectionList_ = false;\n  private selectedIndex_: MDCListIndex = numbers.UNSET_INDEX;\n  private focusedItemIndex_ = numbers.UNSET_INDEX;\n  private useActivatedClass_ = false;\n  private ariaCurrentAttrValue_: string | null = null;\n  private isCheckboxList_ = false;\n  private isRadioList_ = false;\n\n  constructor(adapter?: Partial<MDCListAdapter>) {\n    super({...MDCListFoundation.defaultAdapter, ...adapter});\n  }\n\n  layout() {\n    if (this.adapter_.getListItemCount() === 0) {\n      return;\n    }\n\n    if (this.adapter_.hasCheckboxAtIndex(0)) {\n      this.isCheckboxList_ = true;\n    } else if (this.adapter_.hasRadioAtIndex(0)) {\n      this.isRadioList_ = true;\n    }\n  }\n\n  /**\n   * Sets the private wrapFocus_ variable.\n   */\n  setWrapFocus(value: boolean) {\n    this.wrapFocus_ = value;\n  }\n\n  /**\n   * Sets the isVertical_ private variable.\n   */\n  setVerticalOrientation(value: boolean) {\n    this.isVertical_ = value;\n  }\n\n  /**\n   * Sets the isSingleSelectionList_ private variable.\n   */\n  setSingleSelection(value: boolean) {\n    this.isSingleSelectionList_ = value;\n  }\n\n  /**\n   * Sets the useActivatedClass_ private variable.\n   */\n  setUseActivatedClass(useActivated: boolean) {\n    this.useActivatedClass_ = useActivated;\n  }\n\n  getSelectedIndex(): MDCListIndex {\n    return this.selectedIndex_;\n  }\n\n  setSelectedIndex(index: MDCListIndex) {\n    if (!this.isIndexValid_(index)) {\n      return;\n    }\n\n    if (this.isCheckboxList_) {\n      this.setCheckboxAtIndex_(index as number[]);\n    } else if (this.isRadioList_) {\n      this.setRadioAtIndex_(index as number);\n    } else {\n      this.setSingleSelectionAtIndex_(index as number);\n    }\n  }\n\n  /**\n   * Focus in handler for the list items.\n   */\n  handleFocusIn(_: FocusEvent, listItemIndex: number) {\n    if (listItemIndex >= 0) {\n      this.adapter_.setTabIndexForListItemChildren(listItemIndex, '0');\n    }\n  }\n\n  /**\n   * Focus out handler for the list items.\n   */\n  handleFocusOut(_: FocusEvent, listItemIndex: number) {\n    if (listItemIndex >= 0) {\n      this.adapter_.setTabIndexForListItemChildren(listItemIndex, '-1');\n    }\n\n    /**\n     * Between Focusout & Focusin some browsers do not have focus on any element. Setting a delay to wait till the focus\n     * is moved to next element.\n     */\n    setTimeout(() => {\n      if (!this.adapter_.isFocusInsideList()) {\n        this.setTabindexToFirstSelectedItem_();\n      }\n    }, 0);\n  }\n\n  /**\n   * Key handler for the list.\n   */\n  handleKeydown(evt: KeyboardEvent, isRootListItem: boolean, listItemIndex: number) {\n    const isArrowLeft = evt.key === 'ArrowLeft' || evt.keyCode === 37;\n    const isArrowUp = evt.key === 'ArrowUp' || evt.keyCode === 38;\n    const isArrowRight = evt.key === 'ArrowRight' || evt.keyCode === 39;\n    const isArrowDown = evt.key === 'ArrowDown' || evt.keyCode === 40;\n    const isHome = evt.key === 'Home' || evt.keyCode === 36;\n    const isEnd = evt.key === 'End' || evt.keyCode === 35;\n    const isEnter = evt.key === 'Enter' || evt.keyCode === 13;\n    const isSpace = evt.key === 'Space' || evt.keyCode === 32;\n\n    if (this.adapter_.isRootFocused()) {\n      if (isArrowUp || isEnd) {\n        evt.preventDefault();\n        this.focusLastElement();\n      } else if (isArrowDown || isHome) {\n        evt.preventDefault();\n        this.focusFirstElement();\n      }\n\n      return;\n    }\n\n    let currentIndex = this.adapter_.getFocusedElementIndex();\n    if (currentIndex === -1) {\n      currentIndex = listItemIndex;\n      if (currentIndex < 0) {\n        // If this event doesn't have a mdc-list-item ancestor from the\n        // current list (not from a sublist), return early.\n        return;\n      }\n    }\n\n    let nextIndex;\n    if ((this.isVertical_ && isArrowDown) || (!this.isVertical_ && isArrowRight)) {\n      this.preventDefaultEvent_(evt);\n      nextIndex = this.focusNextElement(currentIndex);\n    } else if ((this.isVertical_ && isArrowUp) || (!this.isVertical_ && isArrowLeft)) {\n      this.preventDefaultEvent_(evt);\n      nextIndex = this.focusPrevElement(currentIndex);\n    } else if (isHome) {\n      this.preventDefaultEvent_(evt);\n      nextIndex = this.focusFirstElement();\n    } else if (isEnd) {\n      this.preventDefaultEvent_(evt);\n      nextIndex = this.focusLastElement();\n    } else if (isEnter || isSpace) {\n      if (isRootListItem) {\n        // Return early if enter key is pressed on anchor element which triggers synthetic MouseEvent event.\n        const target = evt.target as Element | null;\n        if (target && target.tagName === 'A' && isEnter) {\n          return;\n        }\n        this.preventDefaultEvent_(evt);\n\n        if (this.isSelectableList_()) {\n          this.setSelectedIndexOnAction_(currentIndex);\n        }\n\n        this.adapter_.notifyAction(currentIndex);\n      }\n    }\n\n    this.focusedItemIndex_ = currentIndex;\n\n    if (nextIndex !== undefined) {\n      this.setTabindexAtIndex_(nextIndex);\n      this.focusedItemIndex_ = nextIndex;\n    }\n  }\n\n  /**\n   * Click handler for the list.\n   */\n  handleClick(index: number, toggleCheckbox: boolean) {\n    if (index === numbers.UNSET_INDEX) {\n      return;\n    }\n\n    if (this.isSelectableList_()) {\n      this.setSelectedIndexOnAction_(index, toggleCheckbox);\n    }\n\n    this.adapter_.notifyAction(index);\n\n    this.setTabindexAtIndex_(index);\n    this.focusedItemIndex_ = index;\n  }\n\n  /**\n   * Focuses the next element on the list.\n   */\n  focusNextElement(index: number) {\n    const count = this.adapter_.getListItemCount();\n    let nextIndex = index + 1;\n    if (nextIndex >= count) {\n      if (this.wrapFocus_) {\n        nextIndex = 0;\n      } else {\n        // Return early because last item is already focused.\n        return index;\n      }\n    }\n    this.adapter_.focusItemAtIndex(nextIndex);\n\n    return nextIndex;\n  }\n\n  /**\n   * Focuses the previous element on the list.\n   */\n  focusPrevElement(index: number) {\n    let prevIndex = index - 1;\n    if (prevIndex < 0) {\n      if (this.wrapFocus_) {\n        prevIndex = this.adapter_.getListItemCount() - 1;\n      } else {\n        // Return early because first item is already focused.\n        return index;\n      }\n    }\n    this.adapter_.focusItemAtIndex(prevIndex);\n\n    return prevIndex;\n  }\n\n  focusFirstElement() {\n    this.adapter_.focusItemAtIndex(0);\n    return 0;\n  }\n\n  focusLastElement() {\n    const lastIndex = this.adapter_.getListItemCount() - 1;\n    this.adapter_.focusItemAtIndex(lastIndex);\n    return lastIndex;\n  }\n\n  /**\n   * @param itemIndex Index of the list item\n   * @param isEnabled Sets the list item to enabled or disabled.\n   */\n  setEnabled(itemIndex: number, isEnabled: boolean): void {\n    if (!this.isIndexValid_(itemIndex)) {\n      return;\n    }\n\n    if (isEnabled) {\n      this.adapter_.removeClassForElementIndex(itemIndex, cssClasses.LIST_ITEM_DISABLED_CLASS);\n      this.adapter_.setAttributeForElementIndex(itemIndex, strings.ARIA_DISABLED, 'false');\n    } else {\n      this.adapter_.addClassForElementIndex(itemIndex, cssClasses.LIST_ITEM_DISABLED_CLASS);\n      this.adapter_.setAttributeForElementIndex(itemIndex, strings.ARIA_DISABLED, 'true');\n    }\n  }\n\n  /**\n   * Ensures that preventDefault is only called if the containing element doesn't\n   * consume the event, and it will cause an unintended scroll.\n   */\n  private preventDefaultEvent_(evt: KeyboardEvent) {\n    const target = evt.target as Element;\n    const tagName = `${target.tagName}`.toLowerCase();\n    if (ELEMENTS_KEY_ALLOWED_IN.indexOf(tagName) === -1) {\n      evt.preventDefault();\n    }\n  }\n\n  private setSingleSelectionAtIndex_(index: number) {\n    if (this.selectedIndex_ === index) {\n      return;\n    }\n\n    let selectedClassName = cssClasses.LIST_ITEM_SELECTED_CLASS;\n    if (this.useActivatedClass_) {\n      selectedClassName = cssClasses.LIST_ITEM_ACTIVATED_CLASS;\n    }\n\n    if (this.selectedIndex_ !== numbers.UNSET_INDEX) {\n      this.adapter_.removeClassForElementIndex(this.selectedIndex_ as number, selectedClassName);\n    }\n    this.adapter_.addClassForElementIndex(index, selectedClassName);\n    this.setAriaForSingleSelectionAtIndex_(index);\n\n    this.selectedIndex_ = index;\n  }\n\n  /**\n   * Sets aria attribute for single selection at given index.\n   */\n  private setAriaForSingleSelectionAtIndex_(index: number) {\n    // Detect the presence of aria-current and get the value only during list initialization when it is in unset state.\n    if (this.selectedIndex_ === numbers.UNSET_INDEX) {\n      this.ariaCurrentAttrValue_ =\n            this.adapter_.getAttributeForElementIndex(index, strings.ARIA_CURRENT);\n    }\n\n    const isAriaCurrent = this.ariaCurrentAttrValue_ !== null;\n    const ariaAttribute = isAriaCurrent ? strings.ARIA_CURRENT : strings.ARIA_SELECTED;\n\n    if (this.selectedIndex_ !== numbers.UNSET_INDEX) {\n      this.adapter_.setAttributeForElementIndex(this.selectedIndex_ as number, ariaAttribute, 'false');\n    }\n\n    const ariaAttributeValue = isAriaCurrent ? this.ariaCurrentAttrValue_ : 'true';\n    this.adapter_.setAttributeForElementIndex(index, ariaAttribute, ariaAttributeValue as string);\n  }\n\n  /**\n   * Toggles radio at give index. Radio doesn't change the checked state if it is already checked.\n   */\n  private setRadioAtIndex_(index: number) {\n    this.adapter_.setCheckedCheckboxOrRadioAtIndex(index, true);\n\n    if (this.selectedIndex_ !== numbers.UNSET_INDEX) {\n      this.adapter_.setAttributeForElementIndex(this.selectedIndex_ as number, strings.ARIA_CHECKED, 'false');\n    }\n\n    this.adapter_.setAttributeForElementIndex(index, strings.ARIA_CHECKED, 'true');\n\n    this.selectedIndex_ = index;\n  }\n\n  private setCheckboxAtIndex_(index: number[]) {\n    for (let i = 0; i < this.adapter_.getListItemCount(); i++) {\n      let isChecked = false;\n      if (index.indexOf(i) >= 0) {\n        isChecked = true;\n      }\n\n      this.adapter_.setCheckedCheckboxOrRadioAtIndex(i, isChecked);\n      this.adapter_.setAttributeForElementIndex(i, strings.ARIA_CHECKED, isChecked ? 'true' : 'false');\n    }\n\n    this.selectedIndex_ = index;\n  }\n\n  private setTabindexAtIndex_(index: number) {\n    if (this.focusedItemIndex_ === numbers.UNSET_INDEX && index !== 0) {\n      // If no list item was selected set first list item's tabindex to -1.\n      // Generally, tabindex is set to 0 on first list item of list that has no preselected items.\n      this.adapter_.setAttributeForElementIndex(0, 'tabindex', '-1');\n    } else if (this.focusedItemIndex_ >= 0 && this.focusedItemIndex_ !== index) {\n      this.adapter_.setAttributeForElementIndex(this.focusedItemIndex_, 'tabindex', '-1');\n    }\n\n    this.adapter_.setAttributeForElementIndex(index, 'tabindex', '0');\n  }\n\n  /**\n   * @return Return true if it is single selectin list, checkbox list or radio list.\n   */\n  private isSelectableList_() {\n    return this.isSingleSelectionList_ || this.isCheckboxList_ || this.isRadioList_;\n  }\n\n  private setTabindexToFirstSelectedItem_() {\n    let targetIndex = 0;\n\n    if (this.isSelectableList_()) {\n      if (typeof this.selectedIndex_ === 'number' && this.selectedIndex_ !== numbers.UNSET_INDEX) {\n        targetIndex = this.selectedIndex_;\n      } else if (isNumberArray(this.selectedIndex_) && this.selectedIndex_.length > 0) {\n        targetIndex = this.selectedIndex_.reduce((currentIndex, minIndex) => Math.min(currentIndex, minIndex));\n      }\n    }\n\n    this.setTabindexAtIndex_(targetIndex);\n  }\n\n  private isIndexValid_(index: MDCListIndex) {\n    if (index instanceof Array) {\n      if (!this.isCheckboxList_) {\n        throw new Error('MDCListFoundation: Array of index is only supported for checkbox based list');\n      }\n\n      if (index.length === 0) {\n        return true;\n      } else {\n        return index.some((i) => this.isIndexInRange_(i));\n      }\n    } else if (typeof index === 'number') {\n      if (this.isCheckboxList_) {\n        throw new Error('MDCListFoundation: Expected array of index for checkbox based list but got number: ' + index);\n      }\n      return this.isIndexInRange_(index);\n    } else {\n      return false;\n    }\n  }\n\n  private isIndexInRange_(index: number) {\n    const listSize = this.adapter_.getListItemCount();\n    return index >= 0 && index < listSize;\n  }\n\n  private setSelectedIndexOnAction_(index: number, toggleCheckbox = true) {\n    if (this.isCheckboxList_) {\n      this.toggleCheckboxAtIndex_(index, toggleCheckbox);\n    } else {\n      this.setSelectedIndex(index);\n    }\n  }\n\n  private toggleCheckboxAtIndex_(index: number, toggleCheckbox: boolean) {\n    let isChecked = this.adapter_.isCheckboxCheckedAtIndex(index);\n\n    if (toggleCheckbox) {\n      isChecked = !isChecked;\n      this.adapter_.setCheckedCheckboxOrRadioAtIndex(index, isChecked);\n    }\n\n    this.adapter_.setAttributeForElementIndex(index, strings.ARIA_CHECKED, isChecked ? 'true' : 'false');\n\n    // If none of the checkbox items are selected and selectedIndex is not initialized then provide a default value.\n    let selectedIndexes = this.selectedIndex_ === numbers.UNSET_INDEX ? [] : (this.selectedIndex_ as number[]).slice();\n\n    if (isChecked) {\n      selectedIndexes.push(index);\n    } else {\n      selectedIndexes = selectedIndexes.filter((i) => i !== index);\n    }\n\n    this.selectedIndex_ = selectedIndexes;\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCListFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCMenuSurfaceAdapter} from './adapter';\nimport {Corner, cssClasses, strings} from './constants';\nimport {MDCMenuSurfaceFoundation} from './foundation';\nimport {MDCMenuDistance} from './types';\nimport * as util from './util';\n\ntype RegisterFunction = () => void;\n\nexport type MDCMenuSurfaceFactory = (el: Element, foundation?: MDCMenuSurfaceFoundation) => MDCMenuSurface;\n\nexport class MDCMenuSurface extends MDCComponent<MDCMenuSurfaceFoundation> {\n  static attachTo(root: Element): MDCMenuSurface {\n    return new MDCMenuSurface(root);\n  }\n\n  anchorElement!: Element | null; // assigned in initialSyncWithDOM()\n\n  protected root_!: HTMLElement; // assigned in MDCComponent constructor\n\n  private previousFocus_?: HTMLElement | SVGElement | null;\n\n  private handleKeydown_!: SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n  private handleBodyClick_!: SpecificEventListener<'click'>; // assigned in initialSyncWithDOM()\n\n  private registerBodyClickListener_!: RegisterFunction; // assigned in initialSyncWithDOM()\n  private deregisterBodyClickListener_!: RegisterFunction; // assigned in initialSyncWithDOM()\n\n  initialSyncWithDOM() {\n    const parentEl = this.root_.parentElement;\n    this.anchorElement = parentEl && parentEl.classList.contains(cssClasses.ANCHOR) ? parentEl : null;\n\n    if (this.root_.classList.contains(cssClasses.FIXED)) {\n      this.setFixedPosition(true);\n    }\n\n    this.handleKeydown_ = (evt) => this.foundation_.handleKeydown(evt);\n    this.handleBodyClick_ = (evt) => this.foundation_.handleBodyClick(evt);\n\n    this.registerBodyClickListener_ = () => document.body.addEventListener('click', this.handleBodyClick_);\n    this.deregisterBodyClickListener_ = () => document.body.removeEventListener('click', this.handleBodyClick_);\n\n    this.listen('keydown', this.handleKeydown_);\n    this.listen(strings.OPENED_EVENT, this.registerBodyClickListener_);\n    this.listen(strings.CLOSED_EVENT, this.deregisterBodyClickListener_);\n  }\n\n  destroy() {\n    this.unlisten('keydown', this.handleKeydown_);\n    this.unlisten(strings.OPENED_EVENT, this.registerBodyClickListener_);\n    this.unlisten(strings.CLOSED_EVENT, this.deregisterBodyClickListener_);\n    super.destroy();\n  }\n\n  isOpen(): boolean {\n    return this.foundation_.isOpen();\n  }\n\n  open() {\n    this.foundation_.open();\n  }\n\n  close(skipRestoreFocus = false) {\n    this.foundation_.close(skipRestoreFocus);\n  }\n\n  set quickOpen(quickOpen: boolean) {\n    this.foundation_.setQuickOpen(quickOpen);\n  }\n\n  /**\n   * Removes the menu-surface from it's current location and appends it to the\n   * body to overcome any overflow:hidden issues.\n   */\n  hoistMenuToBody() {\n    document.body.appendChild(this.root_);\n    this.setIsHoisted(true);\n  }\n\n  /** Sets the foundation to use page offsets for an positioning when the menu is hoisted to the body. */\n  setIsHoisted(isHoisted: boolean) {\n    this.foundation_.setIsHoisted(isHoisted);\n  }\n\n  /** Sets the element that the menu-surface is anchored to. */\n  setMenuSurfaceAnchorElement(element: Element) {\n    this.anchorElement = element;\n  }\n\n  /** Sets the menu-surface to position: fixed. */\n  setFixedPosition(isFixed: boolean) {\n    if (isFixed) {\n      this.root_.classList.add(cssClasses.FIXED);\n    } else {\n      this.root_.classList.remove(cssClasses.FIXED);\n    }\n\n    this.foundation_.setFixedPosition(isFixed);\n  }\n\n  /** Sets the absolute x/y position to position based on. Requires the menu to be hoisted. */\n  setAbsolutePosition(x: number, y: number) {\n    this.foundation_.setAbsolutePosition(x, y);\n    this.setIsHoisted(true);\n  }\n\n  /**\n   * @param corner Default anchor corner alignment of top-left surface corner.\n   */\n  setAnchorCorner(corner: Corner) {\n    this.foundation_.setAnchorCorner(corner);\n  }\n\n  setAnchorMargin(margin: Partial<MDCMenuDistance>) {\n    this.foundation_.setAnchorMargin(margin);\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCMenuSurfaceAdapter = {\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      hasClass: (className) => this.root_.classList.contains(className),\n      hasAnchor: () => !!this.anchorElement,\n      notifyClose: () => this.emit(MDCMenuSurfaceFoundation.strings.CLOSED_EVENT, {}),\n      notifyOpen: () => this.emit(MDCMenuSurfaceFoundation.strings.OPENED_EVENT, {}),\n      isElementInContainer: (el) => this.root_.contains(el),\n      isRtl: () => getComputedStyle(this.root_).getPropertyValue('direction') === 'rtl',\n      setTransformOrigin: (origin) => {\n        const propertyName = `${util.getTransformPropertyName(window)}-origin`;\n        this.root_.style.setProperty(propertyName, origin);\n      },\n\n      isFocused: () => document.activeElement === this.root_,\n      saveFocus: () => {\n        this.previousFocus_ = document.activeElement as HTMLElement | SVGElement | null;\n      },\n      restoreFocus: () => {\n        if (this.root_.contains(document.activeElement)) {\n          if (this.previousFocus_ && this.previousFocus_.focus) {\n            this.previousFocus_.focus();\n          }\n        }\n      },\n\n      getInnerDimensions: () => {\n        return {width: this.root_.offsetWidth, height: this.root_.offsetHeight};\n      },\n      getAnchorDimensions: () => this.anchorElement ? this.anchorElement.getBoundingClientRect() : null,\n      getWindowDimensions: () => {\n        return {width: window.innerWidth, height: window.innerHeight};\n      },\n      getBodyDimensions: () => {\n        return {width: document.body.clientWidth, height: document.body.clientHeight};\n      },\n      getWindowScroll: () => {\n        return {x: window.pageXOffset, y: window.pageYOffset};\n      },\n      setPosition: (position) => {\n        this.root_.style.left = 'left' in position ? `${position.left}px` : '';\n        this.root_.style.right = 'right' in position ? `${position.right}px` : '';\n        this.root_.style.top = 'top' in position ? `${position.top}px` : '';\n        this.root_.style.bottom = 'bottom' in position ? `${position.bottom}px` : '';\n      },\n      setMaxHeight: (height) => {\n        this.root_.style.maxHeight = height;\n      },\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCMenuSurfaceFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n  ANCHOR: 'mdc-menu-surface--anchor',\n  ANIMATING_CLOSED: 'mdc-menu-surface--animating-closed',\n  ANIMATING_OPEN: 'mdc-menu-surface--animating-open',\n  FIXED: 'mdc-menu-surface--fixed',\n  OPEN: 'mdc-menu-surface--open',\n  ROOT: 'mdc-menu-surface',\n};\n\n// tslint:disable:object-literal-sort-keys\nconst strings = {\n  CLOSED_EVENT: 'MDCMenuSurface:closed',\n  OPENED_EVENT: 'MDCMenuSurface:opened',\n  FOCUSABLE_ELEMENTS: [\n    'button:not(:disabled)', '[href]:not([aria-disabled=\"true\"])', 'input:not(:disabled)',\n    'select:not(:disabled)', 'textarea:not(:disabled)', '[tabindex]:not([tabindex=\"-1\"]):not([aria-disabled=\"true\"])',\n  ].join(', '),\n};\n// tslint:enable:object-literal-sort-keys\n\nconst numbers = {\n  /** Total duration of menu-surface open animation. */\n  TRANSITION_OPEN_DURATION: 120,\n\n  /** Total duration of menu-surface close animation. */\n  TRANSITION_CLOSE_DURATION: 75,\n\n  /** Margin left to the edge of the viewport when menu-surface is at maximum possible height. */\n  MARGIN_TO_EDGE: 32,\n\n  /** Ratio of anchor width to menu-surface width for switching from corner positioning to center positioning. */\n  ANCHOR_TO_MENU_SURFACE_WIDTH_RATIO: 0.67,\n};\n\n/**\n * Enum for bits in the {@see Corner) bitmap.\n */\nenum CornerBit {\n  BOTTOM = 1,\n  CENTER = 2,\n  RIGHT = 4,\n  FLIP_RTL = 8,\n}\n\n/**\n * Enum for representing an element corner for positioning the menu-surface.\n *\n * The START constants map to LEFT if element directionality is left\n * to right and RIGHT if the directionality is right to left.\n * Likewise END maps to RIGHT or LEFT depending on the directionality.\n */\nenum Corner {\n  TOP_LEFT = 0,\n  TOP_RIGHT = CornerBit.RIGHT,\n  BOTTOM_LEFT = CornerBit.BOTTOM,\n  BOTTOM_RIGHT = CornerBit.BOTTOM | CornerBit.RIGHT, // tslint:disable-line:no-bitwise\n  TOP_START = CornerBit.FLIP_RTL,\n  TOP_END = CornerBit.FLIP_RTL | CornerBit.RIGHT, // tslint:disable-line:no-bitwise\n  BOTTOM_START = CornerBit.BOTTOM | CornerBit.FLIP_RTL, // tslint:disable-line:no-bitwise\n  BOTTOM_END = CornerBit.BOTTOM | CornerBit.RIGHT | CornerBit.FLIP_RTL, // tslint:disable-line:no-bitwise\n}\n\nexport {cssClasses, strings, numbers, CornerBit, Corner};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCMenuSurfaceAdapter} from './adapter';\nimport {Corner, CornerBit, cssClasses, numbers, strings} from './constants';\nimport {MDCMenuDimensions, MDCMenuDistance, MDCMenuPoint} from './types';\n\ninterface AutoLayoutMeasurements {\n  anchorSize: MDCMenuDimensions;\n  bodySize: MDCMenuDimensions;\n  surfaceSize: MDCMenuDimensions;\n  viewportDistance: MDCMenuDistance;\n  viewportSize: MDCMenuDimensions;\n  windowScroll: MDCMenuPoint;\n}\n\nexport class MDCMenuSurfaceFoundation extends MDCFoundation<MDCMenuSurfaceAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get numbers() {\n    return numbers;\n  }\n\n  static get Corner() {\n    return Corner;\n  }\n\n  /**\n   * @see {@link MDCMenuSurfaceAdapter} for typing information on parameters and return types.\n   */\n  static get defaultAdapter(): MDCMenuSurfaceAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      hasClass: () => false,\n      hasAnchor: () => false,\n\n      isElementInContainer: () => false,\n      isFocused: () => false,\n      isRtl: () => false,\n\n      getInnerDimensions: () => ({height: 0, width: 0}),\n      getAnchorDimensions: () => null,\n      getWindowDimensions: () => ({height: 0, width: 0}),\n      getBodyDimensions: () => ({height: 0, width: 0}),\n      getWindowScroll: () => ({x: 0, y: 0}),\n      setPosition: () => undefined,\n      setMaxHeight: () => undefined,\n      setTransformOrigin: () => undefined,\n\n      saveFocus: () => undefined,\n      restoreFocus: () => undefined,\n\n      notifyClose: () => undefined,\n      notifyOpen: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private isOpen_ = false;\n  private isQuickOpen_ = false;\n  private isHoistedElement_ = false;\n  private isFixedPosition_ = false;\n\n  private openAnimationEndTimerId_ = 0;\n  private closeAnimationEndTimerId_ = 0;\n  private animationRequestId_ = 0;\n\n  private anchorCorner_: Corner = Corner.TOP_START;\n  private anchorMargin_: MDCMenuDistance = {top: 0, right: 0, bottom: 0, left: 0};\n  private position_: MDCMenuPoint = {x: 0, y: 0};\n\n  private dimensions_!: MDCMenuDimensions; // assigned in open()\n  private measurements_!: AutoLayoutMeasurements; // assigned in open()\n\n  constructor(adapter?: Partial<MDCMenuSurfaceAdapter>) {\n    super({...MDCMenuSurfaceFoundation.defaultAdapter, ...adapter});\n  }\n\n  init() {\n    const {ROOT, OPEN} = MDCMenuSurfaceFoundation.cssClasses;\n\n    if (!this.adapter_.hasClass(ROOT)) {\n      throw new Error(`${ROOT} class required in root element.`);\n    }\n\n    if (this.adapter_.hasClass(OPEN)) {\n      this.isOpen_ = true;\n    }\n  }\n\n  destroy() {\n    clearTimeout(this.openAnimationEndTimerId_);\n    clearTimeout(this.closeAnimationEndTimerId_);\n    // Cancel any currently running animations.\n    cancelAnimationFrame(this.animationRequestId_);\n  }\n\n  /**\n   * @param corner Default anchor corner alignment of top-left menu surface corner.\n   */\n  setAnchorCorner(corner: Corner) {\n    this.anchorCorner_ = corner;\n  }\n\n  /**\n   * @param margin Set of margin values from anchor.\n   */\n  setAnchorMargin(margin: Partial<MDCMenuDistance>) {\n    this.anchorMargin_.top = margin.top || 0;\n    this.anchorMargin_.right = margin.right || 0;\n    this.anchorMargin_.bottom = margin.bottom || 0;\n    this.anchorMargin_.left = margin.left || 0;\n  }\n\n  /** Used to indicate if the menu-surface is hoisted to the body. */\n  setIsHoisted(isHoisted: boolean) {\n    this.isHoistedElement_ = isHoisted;\n  }\n\n  /** Used to set the menu-surface calculations based on a fixed position menu. */\n  setFixedPosition(isFixedPosition: boolean) {\n    this.isFixedPosition_ = isFixedPosition;\n  }\n\n  /** Sets the menu-surface position on the page. */\n  setAbsolutePosition(x: number, y: number) {\n    this.position_.x = this.isFinite_(x) ? x : 0;\n    this.position_.y = this.isFinite_(y) ? y : 0;\n  }\n\n  setQuickOpen(quickOpen: boolean) {\n    this.isQuickOpen_ = quickOpen;\n  }\n\n  isOpen() {\n    return this.isOpen_;\n  }\n\n  /**\n   * Open the menu surface.\n   */\n  open() {\n    this.adapter_.saveFocus();\n\n    if (!this.isQuickOpen_) {\n      this.adapter_.addClass(MDCMenuSurfaceFoundation.cssClasses.ANIMATING_OPEN);\n    }\n\n    this.animationRequestId_ = requestAnimationFrame(() => {\n      this.adapter_.addClass(MDCMenuSurfaceFoundation.cssClasses.OPEN);\n      this.dimensions_ = this.adapter_.getInnerDimensions();\n      this.autoPosition_();\n      if (this.isQuickOpen_) {\n        this.adapter_.notifyOpen();\n      } else {\n        this.openAnimationEndTimerId_ = setTimeout(() => {\n          this.openAnimationEndTimerId_ = 0;\n          this.adapter_.removeClass(MDCMenuSurfaceFoundation.cssClasses.ANIMATING_OPEN);\n          this.adapter_.notifyOpen();\n        }, numbers.TRANSITION_OPEN_DURATION);\n      }\n    });\n\n    this.isOpen_ = true;\n  }\n\n  /**\n   * Closes the menu surface.\n   */\n  close(skipRestoreFocus = false) {\n    if (!this.isQuickOpen_) {\n      this.adapter_.addClass(MDCMenuSurfaceFoundation.cssClasses.ANIMATING_CLOSED);\n    }\n\n    requestAnimationFrame(() => {\n      this.adapter_.removeClass(MDCMenuSurfaceFoundation.cssClasses.OPEN);\n      if (this.isQuickOpen_) {\n        this.adapter_.notifyClose();\n      } else {\n        this.closeAnimationEndTimerId_ = setTimeout(() => {\n          this.closeAnimationEndTimerId_ = 0;\n          this.adapter_.removeClass(MDCMenuSurfaceFoundation.cssClasses.ANIMATING_CLOSED);\n          this.adapter_.notifyClose();\n        }, numbers.TRANSITION_CLOSE_DURATION);\n      }\n    });\n\n    this.isOpen_ = false;\n    if (!skipRestoreFocus) {\n      this.maybeRestoreFocus_();\n    }\n  }\n\n  /** Handle clicks and close if not within menu-surface element. */\n  handleBodyClick(evt: MouseEvent) {\n    const el = evt.target as Element;\n    if (this.adapter_.isElementInContainer(el)) {\n      return;\n    }\n    this.close();\n  }\n\n  /** Handle keys that close the surface. */\n  handleKeydown(evt: KeyboardEvent) {\n    const {keyCode, key} = evt;\n\n    const isEscape = key === 'Escape' || keyCode === 27;\n    if (isEscape) {\n      this.close();\n    }\n  }\n\n  private autoPosition_() {\n    // Compute measurements for autoposition methods reuse.\n    this.measurements_ = this.getAutoLayoutMeasurements_();\n\n    const corner = this.getOriginCorner_();\n    const maxMenuSurfaceHeight = this.getMenuSurfaceMaxHeight_(corner);\n    const verticalAlignment = this.hasBit_(corner, CornerBit.BOTTOM) ? 'bottom' : 'top';\n    let horizontalAlignment = this.hasBit_(corner, CornerBit.RIGHT) ? 'right' : 'left';\n    const horizontalOffset = this.getHorizontalOriginOffset_(corner);\n    const verticalOffset = this.getVerticalOriginOffset_(corner);\n    const {anchorSize, surfaceSize} = this.measurements_;\n\n    const position: Partial<MDCMenuDistance> = {\n      [horizontalAlignment]: horizontalOffset,\n      [verticalAlignment]: verticalOffset,\n    };\n\n    // Center align when anchor width is comparable or greater than menu surface, otherwise keep corner.\n    if (anchorSize.width / surfaceSize.width > numbers.ANCHOR_TO_MENU_SURFACE_WIDTH_RATIO) {\n      horizontalAlignment = 'center';\n    }\n\n    // If the menu-surface has been hoisted to the body, it's no longer relative to the anchor element\n    if (this.isHoistedElement_ || this.isFixedPosition_) {\n      this.adjustPositionForHoistedElement_(position);\n    }\n\n    this.adapter_.setTransformOrigin(`${horizontalAlignment} ${verticalAlignment}`);\n    this.adapter_.setPosition(position);\n    this.adapter_.setMaxHeight(maxMenuSurfaceHeight ? maxMenuSurfaceHeight + 'px' : '');\n  }\n\n  /**\n   * @return Measurements used to position menu surface popup.\n   */\n  private getAutoLayoutMeasurements_(): AutoLayoutMeasurements {\n    let anchorRect = this.adapter_.getAnchorDimensions();\n    const bodySize = this.adapter_.getBodyDimensions();\n    const viewportSize = this.adapter_.getWindowDimensions();\n    const windowScroll = this.adapter_.getWindowScroll();\n\n    if (!anchorRect) {\n      // tslint:disable:object-literal-sort-keys Positional properties are more readable when they're grouped together\n      anchorRect = {\n        top: this.position_.y,\n        right: this.position_.x,\n        bottom: this.position_.y,\n        left: this.position_.x,\n        width: 0,\n        height: 0,\n      };\n      // tslint:enable:object-literal-sort-keys\n    }\n\n    return {\n      anchorSize: anchorRect,\n      bodySize,\n      surfaceSize: this.dimensions_,\n      viewportDistance: {\n        // tslint:disable:object-literal-sort-keys Positional properties are more readable when they're grouped together\n        top: anchorRect.top,\n        right: viewportSize.width - anchorRect.right,\n        bottom: viewportSize.height - anchorRect.bottom,\n        left: anchorRect.left,\n        // tslint:enable:object-literal-sort-keys\n      },\n      viewportSize,\n      windowScroll,\n    };\n  }\n\n  /**\n   * Computes the corner of the anchor from which to animate and position the menu surface.\n   */\n  private getOriginCorner_(): Corner {\n    // Defaults: open from the top left.\n    let corner = Corner.TOP_LEFT;\n\n    const {viewportDistance, anchorSize, surfaceSize} = this.measurements_;\n\n    const isBottomAligned = this.hasBit_(this.anchorCorner_, CornerBit.BOTTOM);\n    const availableTop = isBottomAligned ? viewportDistance.top + anchorSize.height + this.anchorMargin_.bottom\n        : viewportDistance.top + this.anchorMargin_.top;\n    const availableBottom = isBottomAligned ? viewportDistance.bottom - this.anchorMargin_.bottom\n        : viewportDistance.bottom + anchorSize.height - this.anchorMargin_.top;\n\n    const topOverflow = surfaceSize.height - availableTop;\n    const bottomOverflow = surfaceSize.height - availableBottom;\n    if (bottomOverflow > 0 && topOverflow < bottomOverflow) {\n      corner = this.setBit_(corner, CornerBit.BOTTOM);\n    }\n\n    const isRtl = this.adapter_.isRtl();\n    const isFlipRtl = this.hasBit_(this.anchorCorner_, CornerBit.FLIP_RTL);\n    const avoidHorizontalOverlap = this.hasBit_(this.anchorCorner_, CornerBit.RIGHT);\n    const isAlignedRight = (avoidHorizontalOverlap && !isRtl) ||\n        (!avoidHorizontalOverlap && isFlipRtl && isRtl);\n    const availableLeft = isAlignedRight ? viewportDistance.left + anchorSize.width + this.anchorMargin_.right :\n        viewportDistance.left + this.anchorMargin_.left;\n    const availableRight = isAlignedRight ? viewportDistance.right - this.anchorMargin_.right :\n        viewportDistance.right + anchorSize.width - this.anchorMargin_.left;\n\n    const leftOverflow = surfaceSize.width - availableLeft;\n    const rightOverflow = surfaceSize.width - availableRight;\n\n    if ((leftOverflow < 0 && isAlignedRight && isRtl) ||\n        (avoidHorizontalOverlap && !isAlignedRight && leftOverflow < 0) ||\n        (rightOverflow > 0 && leftOverflow < rightOverflow)) {\n      corner = this.setBit_(corner, CornerBit.RIGHT);\n    }\n\n    return corner;\n  }\n\n  /**\n   * @param corner Origin corner of the menu surface.\n   * @return Maximum height of the menu surface, based on available space. 0 indicates should not be set.\n   */\n  private getMenuSurfaceMaxHeight_(corner: Corner): number {\n    const {viewportDistance} = this.measurements_;\n\n    let maxHeight = 0;\n    const isBottomAligned = this.hasBit_(corner, CornerBit.BOTTOM);\n    const isBottomAnchored = this.hasBit_(this.anchorCorner_, CornerBit.BOTTOM);\n    const {MARGIN_TO_EDGE} = MDCMenuSurfaceFoundation.numbers;\n\n    // When maximum height is not specified, it is handled from CSS.\n    if (isBottomAligned) {\n      maxHeight = viewportDistance.top + this.anchorMargin_.top - MARGIN_TO_EDGE;\n      if (!isBottomAnchored) {\n        maxHeight += this.measurements_.anchorSize.height;\n      }\n    } else {\n      maxHeight =\n          viewportDistance.bottom - this.anchorMargin_.bottom + this.measurements_.anchorSize.height - MARGIN_TO_EDGE;\n      if (isBottomAnchored) {\n        maxHeight -= this.measurements_.anchorSize.height;\n      }\n    }\n\n    return maxHeight;\n  }\n\n  /**\n   * @param corner Origin corner of the menu surface.\n   * @return Horizontal offset of menu surface origin corner from corresponding anchor corner.\n   */\n  private getHorizontalOriginOffset_(corner: Corner): number {\n    const {anchorSize} = this.measurements_;\n\n    // isRightAligned corresponds to using the 'right' property on the surface.\n    const isRightAligned = this.hasBit_(corner, CornerBit.RIGHT);\n    const avoidHorizontalOverlap = this.hasBit_(this.anchorCorner_, CornerBit.RIGHT);\n\n    if (isRightAligned) {\n      const rightOffset =\n          avoidHorizontalOverlap ? anchorSize.width - this.anchorMargin_.left : this.anchorMargin_.right;\n\n      // For hoisted or fixed elements, adjust the offset by the difference between viewport width and body width so\n      // when we calculate the right value (`adjustPositionForHoistedElement_`) based on the element position,\n      // the right property is correct.\n      if (this.isHoistedElement_ || this.isFixedPosition_) {\n        return rightOffset - (this.measurements_.viewportSize.width - this.measurements_.bodySize.width);\n      }\n\n      return rightOffset;\n    }\n\n    return avoidHorizontalOverlap ? anchorSize.width - this.anchorMargin_.right : this.anchorMargin_.left;\n  }\n\n  /**\n   * @param corner Origin corner of the menu surface.\n   * @return Vertical offset of menu surface origin corner from corresponding anchor corner.\n   */\n  private getVerticalOriginOffset_(corner: Corner): number {\n    const {anchorSize} = this.measurements_;\n    const isBottomAligned = this.hasBit_(corner, CornerBit.BOTTOM);\n    const avoidVerticalOverlap = this.hasBit_(this.anchorCorner_, CornerBit.BOTTOM);\n\n    let y = 0;\n    if (isBottomAligned) {\n      y = avoidVerticalOverlap ? anchorSize.height - this.anchorMargin_.top : -this.anchorMargin_.bottom;\n    } else {\n      y = avoidVerticalOverlap ? (anchorSize.height + this.anchorMargin_.bottom) : this.anchorMargin_.top;\n    }\n    return y;\n  }\n\n  /** Calculates the offsets for positioning the menu-surface when the menu-surface has been hoisted to the body. */\n  private adjustPositionForHoistedElement_(position: Partial<MDCMenuDistance>) {\n    const {windowScroll, viewportDistance} = this.measurements_;\n\n    const props = Object.keys(position) as Array<keyof Partial<MDCMenuDistance>>;\n\n    for (const prop of props) {\n      let value = position[prop] || 0;\n\n      // Hoisted surfaces need to have the anchor elements location on the page added to the\n      // position properties for proper alignment on the body.\n      value += viewportDistance[prop];\n\n      // Surfaces that are absolutely positioned need to have additional calculations for scroll\n      // and bottom positioning.\n      if (!this.isFixedPosition_) {\n        if (prop === 'top') {\n          value += windowScroll.y;\n        } else if (prop === 'bottom') {\n          value -= windowScroll.y;\n        } else if (prop === 'left') {\n          value += windowScroll.x;\n        } else { // prop === 'right'\n          value -= windowScroll.x;\n        }\n      }\n\n      position[prop] = value;\n    }\n  }\n\n  /**\n   * The last focused element when the menu surface was opened should regain focus, if the user is\n   * focused on or within the menu surface when it is closed.\n   */\n  private maybeRestoreFocus_() {\n    const isRootFocused = this.adapter_.isFocused();\n    const childHasFocus = document.activeElement && this.adapter_.isElementInContainer(document.activeElement);\n    if (isRootFocused || childHasFocus) {\n      this.adapter_.restoreFocus();\n    }\n  }\n\n  private hasBit_(corner: Corner, bit: CornerBit): boolean {\n    return Boolean(corner & bit); // tslint:disable-line:no-bitwise\n  }\n\n  private setBit_(corner: Corner, bit: CornerBit): Corner {\n    return corner | bit; // tslint:disable-line:no-bitwise\n  }\n\n  /**\n   * isFinite that doesn't force conversion to number type.\n   * Equivalent to Number.isFinite in ES2015, which is not supported in IE.\n   */\n  private isFinite_(num: number): boolean {\n    return typeof num === 'number' && isFinite(num);\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCMenuSurfaceFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport * as util from './util';\n\nexport {Corner, CornerBit} from './constants';\nexport {util};\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\ntype CssTransformPropertyName = ('transform' | 'webkitTransform');\n\nlet cachedCssTransformPropertyName_: CssTransformPropertyName | undefined;\n\n/**\n * Returns the name of the correct transform property to use on the current browser.\n */\nfunction getTransformPropertyName(globalObj: Window, forceRefresh = false): CssTransformPropertyName {\n  if (cachedCssTransformPropertyName_ === undefined || forceRefresh) {\n    const el = globalObj.document.createElement('div');\n    cachedCssTransformPropertyName_ = 'transform' in el.style ? 'transform' : 'webkitTransform';\n  }\n  return cachedCssTransformPropertyName_;\n}\n\nexport {getTransformPropertyName};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {CustomEventListener, SpecificEventListener} from '@material/base/types';\nimport {closest} from '@material/dom/ponyfill';\nimport {MDCList, MDCListFactory} from '@material/list/component';\nimport {MDCListFoundation} from '@material/list/foundation';\nimport {MDCListActionEvent} from '@material/list/types';\nimport {MDCMenuSurface, MDCMenuSurfaceFactory} from '@material/menu-surface/component';\nimport {Corner} from '@material/menu-surface/constants';\nimport {MDCMenuSurfaceFoundation} from '@material/menu-surface/foundation';\nimport {MDCMenuDistance} from '@material/menu-surface/types';\nimport {MDCMenuAdapter} from './adapter';\nimport {cssClasses, DefaultFocusState, strings} from './constants';\nimport {MDCMenuFoundation} from './foundation';\nimport {MDCMenuItemComponentEventDetail} from './types';\n\nexport type MDCMenuFactory = (el: Element, foundation?: MDCMenuFoundation) => MDCMenu;\n\nexport class MDCMenu extends MDCComponent<MDCMenuFoundation> {\n  static attachTo(root: Element) {\n    return new MDCMenu(root);\n  }\n\n  private menuSurfaceFactory_!: MDCMenuSurfaceFactory; // assigned in initialize()\n  private listFactory_!: MDCListFactory; // assigned in initialize()\n\n  private menuSurface_!: MDCMenuSurface; // assigned in initialSyncWithDOM()\n  private list_!: MDCList | null; // assigned in initialSyncWithDOM()\n\n  private handleKeydown_!: SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n  private handleItemAction_!: CustomEventListener<MDCListActionEvent>; // assigned in initialSyncWithDOM()\n  private handleMenuSurfaceOpened_!: EventListener; // assigned in initialSyncWithDOM()\n\n  initialize(\n      menuSurfaceFactory: MDCMenuSurfaceFactory = (el) => new MDCMenuSurface(el),\n      listFactory: MDCListFactory = (el) => new MDCList(el)) {\n    this.menuSurfaceFactory_ = menuSurfaceFactory;\n    this.listFactory_ = listFactory;\n  }\n\n  initialSyncWithDOM() {\n    this.menuSurface_ = this.menuSurfaceFactory_(this.root_);\n\n    const list = this.root_.querySelector(strings.LIST_SELECTOR);\n    if (list) {\n      this.list_ = this.listFactory_(list);\n      this.list_.wrapFocus = true;\n    } else {\n      this.list_ = null;\n    }\n\n    this.handleKeydown_ = (evt) => this.foundation_.handleKeydown(evt);\n    this.handleItemAction_ = (evt) => this.foundation_.handleItemAction(this.items[evt.detail.index]);\n    this.handleMenuSurfaceOpened_ = () => this.foundation_.handleMenuSurfaceOpened();\n\n    this.menuSurface_.listen(MDCMenuSurfaceFoundation.strings.OPENED_EVENT, this.handleMenuSurfaceOpened_);\n    this.listen('keydown', this.handleKeydown_);\n    this.listen(MDCListFoundation.strings.ACTION_EVENT, this.handleItemAction_);\n  }\n\n  destroy() {\n    if (this.list_) {\n      this.list_.destroy();\n    }\n\n    this.menuSurface_.destroy();\n    this.menuSurface_.unlisten(MDCMenuSurfaceFoundation.strings.OPENED_EVENT, this.handleMenuSurfaceOpened_);\n    this.unlisten('keydown', this.handleKeydown_);\n    this.unlisten(MDCListFoundation.strings.ACTION_EVENT, this.handleItemAction_);\n    super.destroy();\n  }\n\n  get open(): boolean {\n    return this.menuSurface_.isOpen();\n  }\n\n  set open(value: boolean) {\n    if (value) {\n      this.menuSurface_.open();\n    } else {\n      this.menuSurface_.close();\n    }\n  }\n\n  get wrapFocus(): boolean {\n    return this.list_ ? this.list_.wrapFocus : false;\n  }\n\n  set wrapFocus(value: boolean) {\n    if (this.list_) {\n      this.list_.wrapFocus = value;\n    }\n  }\n\n  /**\n   * Return the items within the menu. Note that this only contains the set of elements within\n   * the items container that are proper list items, and not supplemental / presentational DOM\n   * elements.\n   */\n  get items(): Element[] {\n    return this.list_ ? this.list_.listElements : [];\n  }\n\n  set quickOpen(quickOpen: boolean) {\n    this.menuSurface_.quickOpen = quickOpen;\n  }\n\n  /**\n   * Sets default focus state where the menu should focus every time when menu\n   * is opened. Focuses the list root (`DefaultFocusState.LIST_ROOT`) element by\n   * default.\n   * @param focusState Default focus state.\n   */\n  setDefaultFocusState(focusState: DefaultFocusState) {\n    this.foundation_.setDefaultFocusState(focusState);\n  }\n\n  /**\n   * @param corner Default anchor corner alignment of top-left menu corner.\n   */\n  setAnchorCorner(corner: Corner) {\n    this.menuSurface_.setAnchorCorner(corner);\n  }\n\n  setAnchorMargin(margin: Partial<MDCMenuDistance>) {\n    this.menuSurface_.setAnchorMargin(margin);\n  }\n\n  /**\n   * Sets the list item as the selected row at the specified index.\n   * @param index Index of list item within menu.\n   */\n  setSelectedIndex(index: number) {\n    this.foundation_.setSelectedIndex(index);\n  }\n\n  /**\n   * Sets the enabled state to isEnabled for the menu item at the given index.\n   * @param index Index of the menu item\n   * @param isEnabled The desired enabled state of the menu item.\n   */\n  setEnabled(index: number, isEnabled: boolean): void {\n    this.foundation_.setEnabled(index, isEnabled);\n  }\n\n  /**\n   * @return The item within the menu at the index specified.\n   */\n  getOptionByIndex(index: number): Element | null {\n    const items = this.items;\n\n    if (index < items.length) {\n      return this.items[index];\n    } else {\n      return null;\n    }\n  }\n\n  setFixedPosition(isFixed: boolean) {\n    this.menuSurface_.setFixedPosition(isFixed);\n  }\n\n  hoistMenuToBody() {\n    this.menuSurface_.hoistMenuToBody();\n  }\n\n  setIsHoisted(isHoisted: boolean) {\n    this.menuSurface_.setIsHoisted(isHoisted);\n  }\n\n  setAbsolutePosition(x: number, y: number) {\n    this.menuSurface_.setAbsolutePosition(x, y);\n  }\n\n  /**\n   * Sets the element that the menu-surface is anchored to.\n   */\n  setAnchorElement(element: Element) {\n    this.menuSurface_.anchorElement = element;\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCMenuAdapter = {\n      addClassToElementAtIndex: (index, className) => {\n        const list = this.items;\n        list[index].classList.add(className);\n      },\n      removeClassFromElementAtIndex: (index, className) => {\n        const list = this.items;\n        list[index].classList.remove(className);\n      },\n      addAttributeToElementAtIndex: (index, attr, value) => {\n        const list = this.items;\n        list[index].setAttribute(attr, value);\n      },\n      removeAttributeFromElementAtIndex: (index, attr) => {\n        const list = this.items;\n        list[index].removeAttribute(attr);\n      },\n      elementContainsClass: (element, className) => element.classList.contains(className),\n      closeSurface: (skipRestoreFocus: boolean) => this.menuSurface_.close(skipRestoreFocus),\n      getElementIndex: (element) => this.items.indexOf(element),\n      notifySelected: (evtData) => this.emit<MDCMenuItemComponentEventDetail>(strings.SELECTED_EVENT, {\n        index: evtData.index,\n        item: this.items[evtData.index],\n      }),\n      getMenuItemCount: () => this.items.length,\n      focusItemAtIndex: (index) => (this.items[index] as HTMLElement).focus(),\n      focusListRoot: () => (this.root_.querySelector(strings.LIST_SELECTOR) as HTMLElement).focus(),\n      isSelectableItemAtIndex: (index) => !!closest(this.items[index], `.${cssClasses.MENU_SELECTION_GROUP}`),\n      getSelectedSiblingOfItemAtIndex: (index) => {\n        const selectionGroupEl = closest(this.items[index], `.${cssClasses.MENU_SELECTION_GROUP}`) as HTMLElement;\n        const selectedItemEl = selectionGroupEl.querySelector(`.${cssClasses.MENU_SELECTED_LIST_ITEM}`);\n        return selectedItemEl ? this.items.indexOf(selectedItemEl) : -1;\n      },\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCMenuFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n  MENU_SELECTED_LIST_ITEM: 'mdc-menu-item--selected',\n  MENU_SELECTION_GROUP: 'mdc-menu__selection-group',\n  ROOT: 'mdc-menu',\n};\n\nconst strings = {\n  ARIA_CHECKED_ATTR: 'aria-checked',\n  ARIA_DISABLED_ATTR: 'aria-disabled',\n  CHECKBOX_SELECTOR: 'input[type=\"checkbox\"]',\n  LIST_SELECTOR: '.mdc-list',\n  SELECTED_EVENT: 'MDCMenu:selected',\n};\n\nconst numbers = {\n  FOCUS_ROOT_INDEX: -1,\n};\n\nenum DefaultFocusState {\n  NONE = 0,\n  LIST_ROOT = 1,\n  FIRST_ITEM = 2,\n  LAST_ITEM = 3,\n}\n\nexport {cssClasses, strings, numbers, DefaultFocusState};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {cssClasses as listCssClasses} from '@material/list/constants';\nimport {MDCMenuSurfaceFoundation} from '@material/menu-surface/foundation';\nimport {MDCMenuAdapter} from './adapter';\nimport {cssClasses, DefaultFocusState, numbers, strings} from './constants';\n\nexport class MDCMenuFoundation extends MDCFoundation<MDCMenuAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get numbers() {\n    return numbers;\n  }\n\n  private closeAnimationEndTimerId_ = 0;\n  private defaultFocusState_ = DefaultFocusState.LIST_ROOT;\n\n  /**\n   * @see {@link MDCMenuAdapter} for typing information on parameters and return types.\n   */\n  static get defaultAdapter(): MDCMenuAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClassToElementAtIndex: () => undefined,\n      removeClassFromElementAtIndex: () => undefined,\n      addAttributeToElementAtIndex: () => undefined,\n      removeAttributeFromElementAtIndex: () => undefined,\n      elementContainsClass: () => false,\n      closeSurface: () => undefined,\n      getElementIndex: () => -1,\n      notifySelected: () => undefined,\n      getMenuItemCount: () => 0,\n      focusItemAtIndex: () => undefined,\n      focusListRoot: () => undefined,\n      getSelectedSiblingOfItemAtIndex: () => -1,\n      isSelectableItemAtIndex: () => false,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  constructor(adapter?: Partial<MDCMenuAdapter>) {\n    super({...MDCMenuFoundation.defaultAdapter, ...adapter});\n  }\n\n  destroy() {\n    if (this.closeAnimationEndTimerId_) {\n      clearTimeout(this.closeAnimationEndTimerId_);\n    }\n\n    this.adapter_.closeSurface();\n  }\n\n  handleKeydown(evt: KeyboardEvent) {\n    const {key, keyCode} = evt;\n    const isTab = key === 'Tab' || keyCode === 9;\n\n    if (isTab) {\n      this.adapter_.closeSurface(/** skipRestoreFocus */ true);\n    }\n  }\n\n  handleItemAction(listItem: Element) {\n    const index = this.adapter_.getElementIndex(listItem);\n    if (index < 0) {\n      return;\n    }\n\n    this.adapter_.notifySelected({index});\n    this.adapter_.closeSurface();\n\n    // Wait for the menu to close before adding/removing classes that affect styles.\n    this.closeAnimationEndTimerId_ = setTimeout(() => {\n      // Recompute the index in case the menu contents have changed.\n      const recomputedIndex = this.adapter_.getElementIndex(listItem);\n      if (this.adapter_.isSelectableItemAtIndex(recomputedIndex)) {\n        this.setSelectedIndex(recomputedIndex);\n      }\n    }, MDCMenuSurfaceFoundation.numbers.TRANSITION_CLOSE_DURATION);\n  }\n\n  handleMenuSurfaceOpened() {\n    switch (this.defaultFocusState_) {\n      case DefaultFocusState.FIRST_ITEM:\n        this.adapter_.focusItemAtIndex(0);\n        break;\n      case DefaultFocusState.LAST_ITEM:\n        this.adapter_.focusItemAtIndex(this.adapter_.getMenuItemCount() - 1);\n        break;\n      case DefaultFocusState.NONE:\n        // Do nothing.\n        break;\n      default:\n        this.adapter_.focusListRoot();\n        break;\n    }\n  }\n\n  /**\n   * Sets default focus state where the menu should focus every time when menu\n   * is opened. Focuses the list root (`DefaultFocusState.LIST_ROOT`) element by\n   * default.\n   */\n  setDefaultFocusState(focusState: DefaultFocusState) {\n    this.defaultFocusState_ = focusState;\n  }\n\n  /**\n   * Selects the list item at `index` within the menu.\n   * @param index Index of list item within the menu.\n   */\n  setSelectedIndex(index: number) {\n    this.validatedIndex_(index);\n\n    if (!this.adapter_.isSelectableItemAtIndex(index)) {\n      throw new Error('MDCMenuFoundation: No selection group at specified index.');\n    }\n\n    const prevSelectedIndex = this.adapter_.getSelectedSiblingOfItemAtIndex(index);\n    if (prevSelectedIndex >= 0) {\n      this.adapter_.removeAttributeFromElementAtIndex(prevSelectedIndex, strings.ARIA_CHECKED_ATTR);\n      this.adapter_.removeClassFromElementAtIndex(prevSelectedIndex, cssClasses.MENU_SELECTED_LIST_ITEM);\n    }\n\n    this.adapter_.addClassToElementAtIndex(index, cssClasses.MENU_SELECTED_LIST_ITEM);\n    this.adapter_.addAttributeToElementAtIndex(index, strings.ARIA_CHECKED_ATTR, 'true');\n  }\n\n  /**\n   * Sets the enabled state to isEnabled for the menu item at the given index.\n   * @param index Index of the menu item\n   * @param isEnabled The desired enabled state of the menu item.\n   */\n  setEnabled(index: number, isEnabled: boolean): void {\n    this.validatedIndex_(index);\n\n    if (isEnabled) {\n      this.adapter_.removeClassFromElementAtIndex(index, listCssClasses.LIST_ITEM_DISABLED_CLASS);\n      this.adapter_.addAttributeToElementAtIndex(index, strings.ARIA_DISABLED_ATTR, 'false');\n    } else {\n      this.adapter_.addClassToElementAtIndex(index, listCssClasses.LIST_ITEM_DISABLED_CLASS);\n      this.adapter_.addAttributeToElementAtIndex(index, strings.ARIA_DISABLED_ATTR, 'true');\n    }\n  }\n\n  private validatedIndex_(index: number): void {\n    const menuSize = this.adapter_.getMenuItemCount();\n    const isIndexInRange = index >= 0 && index < menuSize;\n\n    if (!isIndexInRange) {\n      throw new Error('MDCMenuFoundation: No list item at specified index.');\n    }\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCMenuFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport {Corner} from '@material/menu-surface/constants'; // for backward compatibility\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCFloatingLabelFoundation} from '@material/floating-label/foundation';\nimport {MDCNotchedOutlineAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCNotchedOutlineFoundation} from './foundation';\n\nexport type MDCNotchedOutlineFactory = (el: Element, foundation?: MDCNotchedOutlineFoundation) => MDCNotchedOutline;\n\nexport class MDCNotchedOutline extends MDCComponent<MDCNotchedOutlineFoundation> {\n  static attachTo(root: Element): MDCNotchedOutline {\n    return new MDCNotchedOutline(root);\n  }\n\n  private notchElement_!: HTMLElement; // assigned in initialSyncWithDOM()\n\n  initialSyncWithDOM() {\n    this.notchElement_ = this.root_.querySelector<HTMLElement>(strings.NOTCH_ELEMENT_SELECTOR)!;\n\n    const label = this.root_.querySelector<HTMLElement>('.' + MDCFloatingLabelFoundation.cssClasses.ROOT);\n    if (label) {\n      label.style.transitionDuration = '0s';\n      this.root_.classList.add(cssClasses.OUTLINE_UPGRADED);\n      requestAnimationFrame(() => {\n        label.style.transitionDuration = '';\n      });\n    } else {\n      this.root_.classList.add(cssClasses.NO_LABEL);\n    }\n  }\n\n  /**\n   * Updates classes and styles to open the notch to the specified width.\n   * @param notchWidth The notch width in the outline.\n   */\n  notch(notchWidth: number) {\n    this.foundation_.notch(notchWidth);\n  }\n\n  /**\n   * Updates classes and styles to close the notch.\n   */\n  closeNotch() {\n    this.foundation_.closeNotch();\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCNotchedOutlineAdapter = {\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      setNotchWidthProperty: (width) => this.notchElement_.style.setProperty('width', width + 'px'),\n      removeNotchWidthProperty: () => this.notchElement_.style.removeProperty('width'),\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCNotchedOutlineFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst strings = {\n  NOTCH_ELEMENT_SELECTOR: '.mdc-notched-outline__notch',\n};\n\nconst numbers = {\n  // This should stay in sync with $mdc-notched-outline-padding * 2.\n  NOTCH_ELEMENT_PADDING: 8,\n};\n\nconst cssClasses = {\n  NO_LABEL: 'mdc-notched-outline--no-label',\n  OUTLINE_NOTCHED: 'mdc-notched-outline--notched',\n  OUTLINE_UPGRADED: 'mdc-notched-outline--upgraded',\n};\n\nexport {cssClasses, numbers, strings};\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCNotchedOutlineAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\nexport class MDCNotchedOutlineFoundation extends MDCFoundation<MDCNotchedOutlineAdapter> {\n  static get strings() {\n    return strings;\n  }\n\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get numbers() {\n    return numbers;\n  }\n\n  /**\n   * See {@link MDCNotchedOutlineAdapter} for typing information on parameters and return types.\n   */\n  static get defaultAdapter(): MDCNotchedOutlineAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      setNotchWidthProperty: () => undefined,\n      removeNotchWidthProperty: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  constructor(adapter?: Partial<MDCNotchedOutlineAdapter>) {\n    super({...MDCNotchedOutlineFoundation.defaultAdapter, ...adapter});\n  }\n\n  /**\n   * Adds the outline notched selector and updates the notch width calculated based off of notchWidth.\n   */\n  notch(notchWidth: number) {\n    const {OUTLINE_NOTCHED} = MDCNotchedOutlineFoundation.cssClasses;\n\n    if (notchWidth > 0) {\n      notchWidth += numbers.NOTCH_ELEMENT_PADDING; // Add padding from left/right.\n    }\n\n    this.adapter_.setNotchWidthProperty(notchWidth);\n    this.adapter_.addClass(OUTLINE_NOTCHED);\n  }\n\n  /**\n   * Removes notched outline selector to close the notch in the outline.\n   */\n  closeNotch() {\n    const {OUTLINE_NOTCHED} = MDCNotchedOutlineFoundation.cssClasses;\n    this.adapter_.removeClass(OUTLINE_NOTCHED);\n    this.adapter_.removeNotchWidthProperty();\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCNotchedOutlineFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {applyPassive} from '@material/dom/events';\nimport {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\nimport {MDCRadioAdapter} from './adapter';\nimport {MDCRadioFoundation} from './foundation';\n\nexport class MDCRadio extends MDCComponent<MDCRadioFoundation> implements MDCRippleCapableSurface {\n  static attachTo(root: Element) {\n    return new MDCRadio(root);\n  }\n\n  get checked(): boolean {\n    return this.nativeControl_.checked;\n  }\n\n  set checked(checked: boolean) {\n    this.nativeControl_.checked = checked;\n  }\n\n  get disabled() {\n    return this.nativeControl_.disabled;\n  }\n\n  set disabled(disabled: boolean) {\n    this.foundation_.setDisabled(disabled);\n  }\n\n  get value() {\n    return this.nativeControl_.value;\n  }\n\n  set value(value: string) {\n    this.nativeControl_.value = value;\n  }\n\n  get ripple(): MDCRipple {\n    return this.ripple_;\n  }\n\n  // Public visibility for this property is required by MDCRippleCapableSurface.\n  root_!: Element; // assigned in MDCComponent constructor\n\n  private readonly ripple_: MDCRipple = this.createRipple_();\n\n  destroy() {\n    this.ripple_.destroy();\n    super.destroy();\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCRadioAdapter = {\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      setNativeControlDisabled: (disabled) => this.nativeControl_.disabled = disabled,\n    };\n    return new MDCRadioFoundation(adapter);\n  }\n\n  private createRipple_(): MDCRipple {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCRippleAdapter = {\n      ...MDCRipple.createAdapter(this),\n      registerInteractionHandler: (evtType, handler) => this.nativeControl_.addEventListener(\n        evtType, handler, applyPassive()),\n      deregisterInteractionHandler: (evtType, handler) => this.nativeControl_.removeEventListener(\n        evtType, handler, applyPassive()),\n      // Radio buttons technically go \"active\" whenever there is *any* keyboard interaction.\n      // This is not the UI we desire.\n      isSurfaceActive: () => false,\n      isUnbounded: () => true,\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCRipple(this.root_, new MDCRippleFoundation(adapter));\n  }\n\n  private get nativeControl_(): HTMLInputElement {\n    const {NATIVE_CONTROL_SELECTOR} = MDCRadioFoundation.strings;\n    const el = this.root_.querySelector<HTMLInputElement>(NATIVE_CONTROL_SELECTOR);\n    if (!el) {\n      throw new Error(`Radio component requires a ${NATIVE_CONTROL_SELECTOR} element`);\n    }\n    return el;\n  }\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst strings = {\n  NATIVE_CONTROL_SELECTOR: '.mdc-radio__native-control',\n};\n\nconst cssClasses = {\n  DISABLED: 'mdc-radio--disabled',\n  ROOT: 'mdc-radio',\n};\n\nexport {strings, cssClasses};\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCRadioAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCRadioFoundation extends MDCFoundation<MDCRadioAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get defaultAdapter(): MDCRadioAdapter {\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      setNativeControlDisabled: () => undefined,\n    };\n  }\n\n  constructor(adapter?: Partial<MDCRadioAdapter>) {\n    super({...MDCRadioFoundation.defaultAdapter, ...adapter});\n  }\n\n  setDisabled(disabled: boolean) {\n    const {DISABLED} = MDCRadioFoundation.cssClasses;\n    this.adapter_.setNativeControlDisabled(disabled);\n    if (disabled) {\n      this.adapter_.addClass(DISABLED);\n    } else {\n      this.adapter_.removeClass(DISABLED);\n    }\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCRadioFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {applyPassive} from '@material/dom/events';\nimport {matches} from '@material/dom/ponyfill';\nimport {MDCRippleAdapter} from './adapter';\nimport {MDCRippleFoundation} from './foundation';\nimport {MDCRippleAttachOpts, MDCRippleCapableSurface} from './types';\nimport * as util from './util';\n\nexport type MDCRippleFactory = (el: Element, foundation?: MDCRippleFoundation) => MDCRipple;\n\nexport class MDCRipple extends MDCComponent<MDCRippleFoundation> implements MDCRippleCapableSurface {\n  static attachTo(root: Element, opts: MDCRippleAttachOpts = {isUnbounded: undefined}): MDCRipple {\n    const ripple = new MDCRipple(root);\n    // Only override unbounded behavior if option is explicitly specified\n    if (opts.isUnbounded !== undefined) {\n      ripple.unbounded = opts.isUnbounded;\n    }\n    return ripple;\n  }\n\n  static createAdapter(instance: MDCRippleCapableSurface): MDCRippleAdapter {\n    return {\n      addClass: (className) => instance.root_.classList.add(className),\n      browserSupportsCssVars: () => util.supportsCssVariables(window),\n      computeBoundingRect: () => instance.root_.getBoundingClientRect(),\n      containsEventTarget: (target) => instance.root_.contains(target as Node),\n      deregisterDocumentInteractionHandler: (evtType, handler) =>\n          document.documentElement.removeEventListener(evtType, handler, applyPassive()),\n      deregisterInteractionHandler: (evtType, handler) =>\n          (instance.root_ as HTMLElement).removeEventListener(evtType, handler, applyPassive()),\n      deregisterResizeHandler: (handler) => window.removeEventListener('resize', handler),\n      getWindowPageOffset: () => ({x: window.pageXOffset, y: window.pageYOffset}),\n      isSurfaceActive: () => matches(instance.root_, ':active'),\n      isSurfaceDisabled: () => Boolean(instance.disabled),\n      isUnbounded: () => Boolean(instance.unbounded),\n      registerDocumentInteractionHandler: (evtType, handler) =>\n          document.documentElement.addEventListener(evtType, handler, applyPassive()),\n      registerInteractionHandler: (evtType, handler) =>\n        (instance.root_ as HTMLElement).addEventListener(evtType, handler, applyPassive()),\n      registerResizeHandler: (handler) => window.addEventListener('resize', handler),\n      removeClass: (className) => instance.root_.classList.remove(className),\n      updateCssVariable: (varName, value) => (instance.root_ as HTMLElement).style.setProperty(varName, value),\n    };\n  }\n\n  // Public visibility for this property is required by MDCRippleCapableSurface.\n  root_!: Element; // assigned in MDCComponent constructor\n\n  disabled = false;\n\n  private unbounded_?: boolean;\n\n  get unbounded(): boolean {\n    return Boolean(this.unbounded_);\n  }\n\n  set unbounded(unbounded: boolean) {\n    this.unbounded_ = Boolean(unbounded);\n    this.setUnbounded_();\n  }\n\n  activate() {\n    this.foundation_.activate();\n  }\n\n  deactivate() {\n    this.foundation_.deactivate();\n  }\n\n  layout() {\n    this.foundation_.layout();\n  }\n\n  getDefaultFoundation() {\n    return new MDCRippleFoundation(MDCRipple.createAdapter(this));\n  }\n\n  initialSyncWithDOM() {\n    const root = this.root_ as HTMLElement;\n    this.unbounded = 'mdcRippleIsUnbounded' in root.dataset;\n  }\n\n  /**\n   * Closure Compiler throws an access control error when directly accessing a\n   * protected or private property inside a getter/setter, like unbounded above.\n   * By accessing the protected property inside a method, we solve that problem.\n   * That's why this function exists.\n   */\n  private setUnbounded_() {\n    this.foundation_.setUnbounded(Boolean(this.unbounded_));\n  }\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport const cssClasses = {\n  // Ripple is a special case where the \"root\" component is really a \"mixin\" of sorts,\n  // given that it's an 'upgrade' to an existing component. That being said it is the root\n  // CSS class that all other CSS classes derive from.\n  BG_FOCUSED: 'mdc-ripple-upgraded--background-focused',\n  FG_ACTIVATION: 'mdc-ripple-upgraded--foreground-activation',\n  FG_DEACTIVATION: 'mdc-ripple-upgraded--foreground-deactivation',\n  ROOT: 'mdc-ripple-upgraded',\n  UNBOUNDED: 'mdc-ripple-upgraded--unbounded',\n};\n\nexport const strings = {\n  VAR_FG_SCALE: '--mdc-ripple-fg-scale',\n  VAR_FG_SIZE: '--mdc-ripple-fg-size',\n  VAR_FG_TRANSLATE_END: '--mdc-ripple-fg-translate-end',\n  VAR_FG_TRANSLATE_START: '--mdc-ripple-fg-translate-start',\n  VAR_LEFT: '--mdc-ripple-left',\n  VAR_TOP: '--mdc-ripple-top',\n};\n\nexport const numbers = {\n  DEACTIVATION_TIMEOUT_MS: 225, // Corresponds to $mdc-ripple-translate-duration (i.e. activation animation duration)\n  FG_DEACTIVATION_MS: 150, // Corresponds to $mdc-ripple-fade-out-duration (i.e. deactivation animation duration)\n  INITIAL_ORIGIN_SCALE: 0.6,\n  PADDING: 10,\n  TAP_DELAY_MS: 300, // Delay between touch and simulated mouse events on touch devices\n};\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCRippleAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\nimport {MDCRipplePoint} from './types';\nimport {getNormalizedEventCoords} from './util';\n\ninterface ActivationStateType {\n  isActivated?: boolean;\n  hasDeactivationUXRun?: boolean;\n  wasActivatedByPointer?: boolean;\n  wasElementMadeActive?: boolean;\n  activationEvent?: Event;\n  isProgrammatic?: boolean;\n}\n\ninterface FgTranslationCoordinates {\n  startPoint: MDCRipplePoint;\n  endPoint: MDCRipplePoint;\n}\n\ninterface Coordinates {\n  left: number;\n  top: number;\n}\n\ntype ActivationEventType = 'touchstart' | 'pointerdown' | 'mousedown' | 'keydown';\ntype DeactivationEventType = 'touchend' | 'pointerup' | 'mouseup' | 'contextmenu';\n\n// Activation events registered on the root element of each instance for activation\nconst ACTIVATION_EVENT_TYPES: ActivationEventType[] = [\n  'touchstart', 'pointerdown', 'mousedown', 'keydown',\n];\n\n// Deactivation events registered on documentElement when a pointer-related down event occurs\nconst POINTER_DEACTIVATION_EVENT_TYPES: DeactivationEventType[] = [\n  'touchend', 'pointerup', 'mouseup', 'contextmenu',\n];\n\n// simultaneous nested activations\nlet activatedTargets: Array<EventTarget | null> = [];\n\nexport class MDCRippleFoundation extends MDCFoundation<MDCRippleAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get numbers() {\n    return numbers;\n  }\n\n  static get defaultAdapter(): MDCRippleAdapter {\n    return {\n      addClass: () => undefined,\n      browserSupportsCssVars: () => true,\n      computeBoundingRect: () => ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0}),\n      containsEventTarget: () => true,\n      deregisterDocumentInteractionHandler: () => undefined,\n      deregisterInteractionHandler: () => undefined,\n      deregisterResizeHandler: () => undefined,\n      getWindowPageOffset: () => ({x: 0, y: 0}),\n      isSurfaceActive: () => true,\n      isSurfaceDisabled: () => true,\n      isUnbounded: () => true,\n      registerDocumentInteractionHandler: () => undefined,\n      registerInteractionHandler: () => undefined,\n      registerResizeHandler: () => undefined,\n      removeClass: () => undefined,\n      updateCssVariable: () => undefined,\n    };\n  }\n\n  private activationAnimationHasEnded_ = false;\n  private activationState_: ActivationStateType;\n  private activationTimer_ = 0;\n  private fgDeactivationRemovalTimer_ = 0;\n  private fgScale_ = '0';\n  private frame_ = {width: 0, height: 0};\n  private initialSize_ = 0;\n  private layoutFrame_ = 0;\n  private maxRadius_ = 0;\n  private unboundedCoords_: Coordinates = {left: 0, top: 0};\n\n  private readonly activationTimerCallback_: () => void;\n  private readonly activateHandler_: EventHandlerNonNull;\n  private readonly deactivateHandler_: EventHandlerNonNull;\n  private readonly focusHandler_: EventHandlerNonNull;\n  private readonly blurHandler_: EventHandlerNonNull;\n  private readonly resizeHandler_: EventHandlerNonNull;\n\n  private previousActivationEvent_?: Event;\n\n  constructor(adapter?: Partial<MDCRippleAdapter>) {\n    super({...MDCRippleFoundation.defaultAdapter, ...adapter});\n\n    this.activationState_ = this.defaultActivationState_();\n\n    this.activationTimerCallback_ = () => {\n      this.activationAnimationHasEnded_ = true;\n      this.runDeactivationUXLogicIfReady_();\n    };\n    this.activateHandler_ = (e) => this.activate_(e);\n    this.deactivateHandler_ = () => this.deactivate_();\n    this.focusHandler_ = () => this.handleFocus();\n    this.blurHandler_ = () => this.handleBlur();\n    this.resizeHandler_ = () => this.layout();\n  }\n\n  init() {\n    const supportsPressRipple = this.supportsPressRipple_();\n\n    this.registerRootHandlers_(supportsPressRipple);\n\n    if (supportsPressRipple) {\n      const {ROOT, UNBOUNDED} = MDCRippleFoundation.cssClasses;\n      requestAnimationFrame(() => {\n        this.adapter_.addClass(ROOT);\n        if (this.adapter_.isUnbounded()) {\n          this.adapter_.addClass(UNBOUNDED);\n          // Unbounded ripples need layout logic applied immediately to set coordinates for both shade and ripple\n          this.layoutInternal_();\n        }\n      });\n    }\n  }\n\n  destroy() {\n    if (this.supportsPressRipple_()) {\n      if (this.activationTimer_) {\n        clearTimeout(this.activationTimer_);\n        this.activationTimer_ = 0;\n        this.adapter_.removeClass(MDCRippleFoundation.cssClasses.FG_ACTIVATION);\n      }\n\n      if (this.fgDeactivationRemovalTimer_) {\n        clearTimeout(this.fgDeactivationRemovalTimer_);\n        this.fgDeactivationRemovalTimer_ = 0;\n        this.adapter_.removeClass(MDCRippleFoundation.cssClasses.FG_DEACTIVATION);\n      }\n\n      const {ROOT, UNBOUNDED} = MDCRippleFoundation.cssClasses;\n      requestAnimationFrame(() => {\n        this.adapter_.removeClass(ROOT);\n        this.adapter_.removeClass(UNBOUNDED);\n        this.removeCssVars_();\n      });\n    }\n\n    this.deregisterRootHandlers_();\n    this.deregisterDeactivationHandlers_();\n  }\n\n  /**\n   * @param evt Optional event containing position information.\n   */\n  activate(evt?: Event): void {\n    this.activate_(evt);\n  }\n\n  deactivate(): void {\n    this.deactivate_();\n  }\n\n  layout(): void {\n    if (this.layoutFrame_) {\n      cancelAnimationFrame(this.layoutFrame_);\n    }\n    this.layoutFrame_ = requestAnimationFrame(() => {\n      this.layoutInternal_();\n      this.layoutFrame_ = 0;\n    });\n  }\n\n  setUnbounded(unbounded: boolean): void {\n    const {UNBOUNDED} = MDCRippleFoundation.cssClasses;\n    if (unbounded) {\n      this.adapter_.addClass(UNBOUNDED);\n    } else {\n      this.adapter_.removeClass(UNBOUNDED);\n    }\n  }\n\n  handleFocus(): void {\n    requestAnimationFrame(() =>\n        this.adapter_.addClass(MDCRippleFoundation.cssClasses.BG_FOCUSED));\n  }\n\n  handleBlur(): void {\n    requestAnimationFrame(() =>\n        this.adapter_.removeClass(MDCRippleFoundation.cssClasses.BG_FOCUSED));\n  }\n\n  /**\n   * We compute this property so that we are not querying information about the client\n   * until the point in time where the foundation requests it. This prevents scenarios where\n   * client-side feature-detection may happen too early, such as when components are rendered on the server\n   * and then initialized at mount time on the client.\n   */\n  private supportsPressRipple_(): boolean {\n    return this.adapter_.browserSupportsCssVars();\n  }\n\n  private defaultActivationState_(): ActivationStateType {\n    return {\n      activationEvent: undefined,\n      hasDeactivationUXRun: false,\n      isActivated: false,\n      isProgrammatic: false,\n      wasActivatedByPointer: false,\n      wasElementMadeActive: false,\n    };\n  }\n\n  /**\n   * supportsPressRipple Passed from init to save a redundant function call\n   */\n  private registerRootHandlers_(supportsPressRipple: boolean) {\n    if (supportsPressRipple) {\n      ACTIVATION_EVENT_TYPES.forEach((evtType) => {\n        this.adapter_.registerInteractionHandler(evtType, this.activateHandler_);\n      });\n      if (this.adapter_.isUnbounded()) {\n        this.adapter_.registerResizeHandler(this.resizeHandler_);\n      }\n    }\n\n    this.adapter_.registerInteractionHandler('focus', this.focusHandler_);\n    this.adapter_.registerInteractionHandler('blur', this.blurHandler_);\n  }\n\n  private registerDeactivationHandlers_(evt: Event) {\n    if (evt.type === 'keydown') {\n      this.adapter_.registerInteractionHandler('keyup', this.deactivateHandler_);\n    } else {\n      POINTER_DEACTIVATION_EVENT_TYPES.forEach((evtType) => {\n        this.adapter_.registerDocumentInteractionHandler(evtType, this.deactivateHandler_);\n      });\n    }\n  }\n\n  private deregisterRootHandlers_() {\n    ACTIVATION_EVENT_TYPES.forEach((evtType) => {\n      this.adapter_.deregisterInteractionHandler(evtType, this.activateHandler_);\n    });\n    this.adapter_.deregisterInteractionHandler('focus', this.focusHandler_);\n    this.adapter_.deregisterInteractionHandler('blur', this.blurHandler_);\n\n    if (this.adapter_.isUnbounded()) {\n      this.adapter_.deregisterResizeHandler(this.resizeHandler_);\n    }\n  }\n\n  private deregisterDeactivationHandlers_() {\n    this.adapter_.deregisterInteractionHandler('keyup', this.deactivateHandler_);\n    POINTER_DEACTIVATION_EVENT_TYPES.forEach((evtType) => {\n      this.adapter_.deregisterDocumentInteractionHandler(evtType, this.deactivateHandler_);\n    });\n  }\n\n  private removeCssVars_() {\n    const rippleStrings = MDCRippleFoundation.strings;\n    const keys = Object.keys(rippleStrings) as Array<keyof typeof rippleStrings>;\n    keys.forEach((key) => {\n      if (key.indexOf('VAR_') === 0) {\n        this.adapter_.updateCssVariable(rippleStrings[key], null);\n      }\n    });\n  }\n\n  private activate_(evt?: Event) {\n    if (this.adapter_.isSurfaceDisabled()) {\n      return;\n    }\n\n    const activationState = this.activationState_;\n    if (activationState.isActivated) {\n      return;\n    }\n\n    // Avoid reacting to follow-on events fired by touch device after an already-processed user interaction\n    const previousActivationEvent = this.previousActivationEvent_;\n    const isSameInteraction = previousActivationEvent && evt !== undefined && previousActivationEvent.type !== evt.type;\n    if (isSameInteraction) {\n      return;\n    }\n\n    activationState.isActivated = true;\n    activationState.isProgrammatic = evt === undefined;\n    activationState.activationEvent = evt;\n    activationState.wasActivatedByPointer = activationState.isProgrammatic ? false : evt !== undefined && (\n        evt.type === 'mousedown' || evt.type === 'touchstart' || evt.type === 'pointerdown'\n    );\n\n    const hasActivatedChild = evt !== undefined && activatedTargets.length > 0 && activatedTargets.some(\n        (target) => this.adapter_.containsEventTarget(target));\n    if (hasActivatedChild) {\n      // Immediately reset activation state, while preserving logic that prevents touch follow-on events\n      this.resetActivationState_();\n      return;\n    }\n\n    if (evt !== undefined) {\n      activatedTargets.push(evt.target);\n      this.registerDeactivationHandlers_(evt);\n    }\n\n    activationState.wasElementMadeActive = this.checkElementMadeActive_(evt);\n    if (activationState.wasElementMadeActive) {\n      this.animateActivation_();\n    }\n\n    requestAnimationFrame(() => {\n      // Reset array on next frame after the current event has had a chance to bubble to prevent ancestor ripples\n      activatedTargets = [];\n\n      if (!activationState.wasElementMadeActive\n          && evt !== undefined\n          && ((evt as KeyboardEvent).key === ' ' || (evt as KeyboardEvent).keyCode === 32)) {\n        // If space was pressed, try again within an rAF call to detect :active, because different UAs report\n        // active states inconsistently when they're called within event handling code:\n        // - https://bugs.chromium.org/p/chromium/issues/detail?id=635971\n        // - https://bugzilla.mozilla.org/show_bug.cgi?id=1293741\n        // We try first outside rAF to support Edge, which does not exhibit this problem, but will crash if a CSS\n        // variable is set within a rAF callback for a submit button interaction (#2241).\n        activationState.wasElementMadeActive = this.checkElementMadeActive_(evt);\n        if (activationState.wasElementMadeActive) {\n          this.animateActivation_();\n        }\n      }\n\n      if (!activationState.wasElementMadeActive) {\n        // Reset activation state immediately if element was not made active.\n        this.activationState_ = this.defaultActivationState_();\n      }\n    });\n  }\n\n  private checkElementMadeActive_(evt?: Event) {\n    return (evt !== undefined && evt.type === 'keydown') ? this.adapter_.isSurfaceActive() : true;\n  }\n\n  private animateActivation_() {\n    const {VAR_FG_TRANSLATE_START, VAR_FG_TRANSLATE_END} = MDCRippleFoundation.strings;\n    const {FG_DEACTIVATION, FG_ACTIVATION} = MDCRippleFoundation.cssClasses;\n    const {DEACTIVATION_TIMEOUT_MS} = MDCRippleFoundation.numbers;\n\n    this.layoutInternal_();\n\n    let translateStart = '';\n    let translateEnd = '';\n\n    if (!this.adapter_.isUnbounded()) {\n      const {startPoint, endPoint} = this.getFgTranslationCoordinates_();\n      translateStart = `${startPoint.x}px, ${startPoint.y}px`;\n      translateEnd = `${endPoint.x}px, ${endPoint.y}px`;\n    }\n\n    this.adapter_.updateCssVariable(VAR_FG_TRANSLATE_START, translateStart);\n    this.adapter_.updateCssVariable(VAR_FG_TRANSLATE_END, translateEnd);\n    // Cancel any ongoing activation/deactivation animations\n    clearTimeout(this.activationTimer_);\n    clearTimeout(this.fgDeactivationRemovalTimer_);\n    this.rmBoundedActivationClasses_();\n    this.adapter_.removeClass(FG_DEACTIVATION);\n\n    // Force layout in order to re-trigger the animation.\n    this.adapter_.computeBoundingRect();\n    this.adapter_.addClass(FG_ACTIVATION);\n    this.activationTimer_ = setTimeout(() => this.activationTimerCallback_(), DEACTIVATION_TIMEOUT_MS);\n  }\n\n  private getFgTranslationCoordinates_(): FgTranslationCoordinates {\n    const {activationEvent, wasActivatedByPointer} = this.activationState_;\n\n    let startPoint;\n    if (wasActivatedByPointer) {\n      startPoint = getNormalizedEventCoords(\n          activationEvent,\n          this.adapter_.getWindowPageOffset(),\n          this.adapter_.computeBoundingRect(),\n      );\n    } else {\n      startPoint = {\n        x: this.frame_.width / 2,\n        y: this.frame_.height / 2,\n      };\n    }\n    // Center the element around the start point.\n    startPoint = {\n      x: startPoint.x - (this.initialSize_ / 2),\n      y: startPoint.y - (this.initialSize_ / 2),\n    };\n\n    const endPoint = {\n      x: (this.frame_.width / 2) - (this.initialSize_ / 2),\n      y: (this.frame_.height / 2) - (this.initialSize_ / 2),\n    };\n\n    return {startPoint, endPoint};\n  }\n\n  private runDeactivationUXLogicIfReady_() {\n    // This method is called both when a pointing device is released, and when the activation animation ends.\n    // The deactivation animation should only run after both of those occur.\n    const {FG_DEACTIVATION} = MDCRippleFoundation.cssClasses;\n    const {hasDeactivationUXRun, isActivated} = this.activationState_;\n    const activationHasEnded = hasDeactivationUXRun || !isActivated;\n\n    if (activationHasEnded && this.activationAnimationHasEnded_) {\n      this.rmBoundedActivationClasses_();\n      this.adapter_.addClass(FG_DEACTIVATION);\n      this.fgDeactivationRemovalTimer_ = setTimeout(() => {\n        this.adapter_.removeClass(FG_DEACTIVATION);\n      }, numbers.FG_DEACTIVATION_MS);\n    }\n  }\n\n  private rmBoundedActivationClasses_() {\n    const {FG_ACTIVATION} = MDCRippleFoundation.cssClasses;\n    this.adapter_.removeClass(FG_ACTIVATION);\n    this.activationAnimationHasEnded_ = false;\n    this.adapter_.computeBoundingRect();\n  }\n\n  private resetActivationState_() {\n    this.previousActivationEvent_ = this.activationState_.activationEvent;\n    this.activationState_ = this.defaultActivationState_();\n    // Touch devices may fire additional events for the same interaction within a short time.\n    // Store the previous event until it's safe to assume that subsequent events are for new interactions.\n    setTimeout(() => this.previousActivationEvent_ = undefined, MDCRippleFoundation.numbers.TAP_DELAY_MS);\n  }\n\n  private deactivate_(): void {\n    const activationState = this.activationState_;\n    // This can happen in scenarios such as when you have a keyup event that blurs the element.\n    if (!activationState.isActivated) {\n      return;\n    }\n\n    const state: ActivationStateType = {...activationState};\n\n    if (activationState.isProgrammatic) {\n      requestAnimationFrame(() => this.animateDeactivation_(state));\n      this.resetActivationState_();\n    } else {\n      this.deregisterDeactivationHandlers_();\n      requestAnimationFrame(() => {\n        this.activationState_.hasDeactivationUXRun = true;\n        this.animateDeactivation_(state);\n        this.resetActivationState_();\n      });\n    }\n  }\n\n  private animateDeactivation_({wasActivatedByPointer, wasElementMadeActive}: ActivationStateType) {\n    if (wasActivatedByPointer || wasElementMadeActive) {\n      this.runDeactivationUXLogicIfReady_();\n    }\n  }\n\n  private layoutInternal_() {\n    this.frame_ = this.adapter_.computeBoundingRect();\n    const maxDim = Math.max(this.frame_.height, this.frame_.width);\n\n    // Surface diameter is treated differently for unbounded vs. bounded ripples.\n    // Unbounded ripple diameter is calculated smaller since the surface is expected to already be padded appropriately\n    // to extend the hitbox, and the ripple is expected to meet the edges of the padded hitbox (which is typically\n    // square). Bounded ripples, on the other hand, are fully expected to expand beyond the surface's longest diameter\n    // (calculated based on the diagonal plus a constant padding), and are clipped at the surface's border via\n    // `overflow: hidden`.\n    const getBoundedRadius = () => {\n      const hypotenuse = Math.sqrt(Math.pow(this.frame_.width, 2) + Math.pow(this.frame_.height, 2));\n      return hypotenuse + MDCRippleFoundation.numbers.PADDING;\n    };\n\n    this.maxRadius_ = this.adapter_.isUnbounded() ? maxDim : getBoundedRadius();\n\n    // Ripple is sized as a fraction of the largest dimension of the surface, then scales up using a CSS scale transform\n    this.initialSize_ = Math.floor(maxDim * MDCRippleFoundation.numbers.INITIAL_ORIGIN_SCALE);\n    this.fgScale_ = `${this.maxRadius_ / this.initialSize_}`;\n\n    this.updateLayoutCssVars_();\n  }\n\n  private updateLayoutCssVars_() {\n    const {\n      VAR_FG_SIZE, VAR_LEFT, VAR_TOP, VAR_FG_SCALE,\n    } = MDCRippleFoundation.strings;\n\n    this.adapter_.updateCssVariable(VAR_FG_SIZE, `${this.initialSize_}px`);\n    this.adapter_.updateCssVariable(VAR_FG_SCALE, this.fgScale_);\n\n    if (this.adapter_.isUnbounded()) {\n      this.unboundedCoords_ = {\n        left: Math.round((this.frame_.width / 2) - (this.initialSize_ / 2)),\n        top: Math.round((this.frame_.height / 2) - (this.initialSize_ / 2)),\n      };\n\n      this.adapter_.updateCssVariable(VAR_LEFT, `${this.unboundedCoords_.left}px`);\n      this.adapter_.updateCssVariable(VAR_TOP, `${this.unboundedCoords_.top}px`);\n    }\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCRippleFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport * as util from './util';\n\nexport {util};\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport {MDCRipplePoint} from './types';\n\n/**\n * Stores result from supportsCssVariables to avoid redundant processing to\n * detect CSS custom variable support.\n */\nlet supportsCssVariables_: boolean | undefined;\n\nfunction detectEdgePseudoVarBug(windowObj: Window): boolean {\n  // Detect versions of Edge with buggy var() support\n  // See: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/11495448/\n  const document = windowObj.document;\n  const node = document.createElement('div');\n  node.className = 'mdc-ripple-surface--test-edge-var-bug';\n  // Append to head instead of body because this script might be invoked in the\n  // head, in which case the body doesn't exist yet. The probe works either way.\n  document.head.appendChild(node);\n\n  // The bug exists if ::before style ends up propagating to the parent element.\n  // Additionally, getComputedStyle returns null in iframes with display: \"none\" in Firefox,\n  // but Firefox is known to support CSS custom properties correctly.\n  // See: https://bugzilla.mozilla.org/show_bug.cgi?id=548397\n  const computedStyle = windowObj.getComputedStyle(node);\n  const hasPseudoVarBug = computedStyle !== null && computedStyle.borderTopStyle === 'solid';\n  if (node.parentNode) {\n    node.parentNode.removeChild(node);\n  }\n  return hasPseudoVarBug;\n}\n\nexport function supportsCssVariables(windowObj: Window, forceRefresh = false): boolean {\n  const {CSS} = windowObj;\n  let supportsCssVars = supportsCssVariables_;\n  if (typeof supportsCssVariables_ === 'boolean' && !forceRefresh) {\n    return supportsCssVariables_;\n  }\n\n  const supportsFunctionPresent = CSS && typeof CSS.supports === 'function';\n  if (!supportsFunctionPresent) {\n    return false;\n  }\n\n  const explicitlySupportsCssVars = CSS.supports('--css-vars', 'yes');\n  // See: https://bugs.webkit.org/show_bug.cgi?id=154669\n  // See: README section on Safari\n  const weAreFeatureDetectingSafari10plus = (\n      CSS.supports('(--css-vars: yes)') &&\n      CSS.supports('color', '#00000000')\n  );\n\n  if (explicitlySupportsCssVars || weAreFeatureDetectingSafari10plus) {\n    supportsCssVars = !detectEdgePseudoVarBug(windowObj);\n  } else {\n    supportsCssVars = false;\n  }\n\n  if (!forceRefresh) {\n    supportsCssVariables_ = supportsCssVars;\n  }\n  return supportsCssVars;\n}\n\nexport function getNormalizedEventCoords(evt: Event | undefined, pageOffset: MDCRipplePoint, clientRect: ClientRect):\n    MDCRipplePoint {\n  if (!evt) {\n    return {x: 0, y: 0};\n  }\n  const {x, y} = pageOffset;\n  const documentX = x + clientRect.left;\n  const documentY = y + clientRect.top;\n\n  let normalizedX;\n  let normalizedY;\n  // Determine touch point relative to the ripple container.\n  if (evt.type === 'touchstart') {\n    const touchEvent = evt as TouchEvent;\n    normalizedX = touchEvent.changedTouches[0].pageX - documentX;\n    normalizedY = touchEvent.changedTouches[0].pageY - documentY;\n  } else {\n    const mouseEvent = evt as MouseEvent;\n    normalizedX = mouseEvent.pageX - documentX;\n    normalizedY = mouseEvent.pageY - documentY;\n  }\n\n  return {x: normalizedX, y: normalizedY};\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {CustomEventListener, SpecificEventListener} from '@material/base/types';\nimport {MDCFloatingLabel, MDCFloatingLabelFactory} from '@material/floating-label/component';\nimport {MDCLineRipple, MDCLineRippleFactory} from '@material/line-ripple/component';\nimport * as menuSurfaceConstants from '@material/menu-surface/constants';\nimport {MDCMenu, MDCMenuFactory} from '@material/menu/component';\nimport * as menuConstants from '@material/menu/constants';\nimport {MDCMenuItemEvent} from '@material/menu/types';\nimport {MDCNotchedOutline, MDCNotchedOutlineFactory} from '@material/notched-outline/component';\nimport {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\nimport {MDCSelectAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCSelectFoundation} from './foundation';\nimport {MDCSelectHelperText, MDCSelectHelperTextFactory} from './helper-text/component';\nimport {MDCSelectIcon, MDCSelectIconFactory} from './icon/component';\nimport {MDCSelectEventDetail, MDCSelectFoundationMap} from './types';\n\nconst VALIDATION_ATTR_WHITELIST = ['required', 'aria-required'];\n\nexport class MDCSelect extends MDCComponent<MDCSelectFoundation> implements MDCRippleCapableSurface {\n  static attachTo(root: Element): MDCSelect {\n    return new MDCSelect(root);\n  }\n\n  // Public visibility for this property is required by MDCRippleCapableSurface.\n  root_!: HTMLElement; // assigned in MDCComponent constructor\n\n  ripple!: MDCRipple | null;\n\n  private menu_!: MDCMenu | null; // assigned in enhancedSelectSetup_()\n  private isMenuOpen_!: boolean; // assigned in initialize()\n\n  // Exactly one of these fields must be non-null.\n  private nativeControl_!: HTMLSelectElement | null; // assigned in initialize()\n  private selectedText_!: HTMLElement | null; // assigned in initialize()\n\n  private targetElement_!: HTMLElement; // assigned in initialize()\n\n  private hiddenInput_!: HTMLInputElement | null; // assigned in enhancedSelectSetup_()\n  private menuElement_!: Element | null; // assigned in enhancedSelectSetup_()\n  private leadingIcon_?: MDCSelectIcon; // assigned in initialize()\n  private helperText_!: MDCSelectHelperText | null; // assigned in initialize()\n  private lineRipple_!: MDCLineRipple | null; // assigned in initialize()\n  private label_!: MDCFloatingLabel | null; // assigned in initialize()\n  private outline_!: MDCNotchedOutline | null; // assigned in initialize()\n  private handleChange_!: SpecificEventListener<'change'>; // assigned in initialize()\n  private handleFocus_!: SpecificEventListener<'focus'>; // assigned in initialize()\n  private handleBlur_!: SpecificEventListener<'blur'>; // assigned in initialize()\n  private handleClick_!: SpecificEventListener<'click'>; // assigned in initialize()\n  private handleKeydown_!: SpecificEventListener<'keydown'>; // assigned in initialize()\n  private handleMenuOpened_!: EventListener; // assigned in initialize()\n  private handleMenuClosed_!: EventListener; // assigned in initialize()\n  private handleMenuSelected_!: CustomEventListener<MDCMenuItemEvent>; // assigned in initialize()\n  private validationObserver_!: MutationObserver; // assigned in initialize()\n\n  initialize(\n      labelFactory: MDCFloatingLabelFactory = (el) => new MDCFloatingLabel(el),\n      lineRippleFactory: MDCLineRippleFactory = (el) => new MDCLineRipple(el),\n      outlineFactory: MDCNotchedOutlineFactory = (el) => new MDCNotchedOutline(el),\n      menuFactory: MDCMenuFactory = (el) => new MDCMenu(el),\n      iconFactory: MDCSelectIconFactory = (el) => new MDCSelectIcon(el),\n      helperTextFactory: MDCSelectHelperTextFactory = (el) => new MDCSelectHelperText(el),\n  ) {\n    this.isMenuOpen_ = false;\n    this.nativeControl_ = this.root_.querySelector(strings.NATIVE_CONTROL_SELECTOR);\n    this.selectedText_ = this.root_.querySelector(strings.SELECTED_TEXT_SELECTOR);\n\n    const targetElement = this.nativeControl_ || this.selectedText_;\n    if (!targetElement) {\n      throw new Error(\n          'MDCSelect: Missing required element: Exactly one of the following selectors must be present: ' +\n          `'${strings.NATIVE_CONTROL_SELECTOR}' or '${strings.SELECTED_TEXT_SELECTOR}'`,\n      );\n    }\n\n    this.targetElement_ = targetElement;\n    if (this.targetElement_.hasAttribute(strings.ARIA_CONTROLS)) {\n      const helperTextElement = document.getElementById(this.targetElement_.getAttribute(strings.ARIA_CONTROLS)!);\n      if (helperTextElement) {\n        this.helperText_ = helperTextFactory(helperTextElement);\n      }\n    }\n\n    if (this.selectedText_) {\n      this.enhancedSelectSetup_(menuFactory);\n    }\n\n    const labelElement = this.root_.querySelector(strings.LABEL_SELECTOR);\n    this.label_ = labelElement ? labelFactory(labelElement) : null;\n\n    const lineRippleElement = this.root_.querySelector(strings.LINE_RIPPLE_SELECTOR);\n    this.lineRipple_ = lineRippleElement ? lineRippleFactory(lineRippleElement) : null;\n\n    const outlineElement = this.root_.querySelector(strings.OUTLINE_SELECTOR);\n    this.outline_ = outlineElement ? outlineFactory(outlineElement) : null;\n\n    const leadingIcon = this.root_.querySelector(strings.LEADING_ICON_SELECTOR);\n    if (leadingIcon) {\n      this.root_.classList.add(cssClasses.WITH_LEADING_ICON);\n      this.leadingIcon_ = iconFactory(leadingIcon);\n\n      if (this.menuElement_) {\n        this.menuElement_.classList.add(cssClasses.WITH_LEADING_ICON);\n      }\n    }\n\n    if (!this.root_.classList.contains(cssClasses.OUTLINED)) {\n      this.ripple = this.createRipple_();\n    }\n\n    // The required state needs to be sync'd before the mutation observer is added.\n    this.initialSyncRequiredState_();\n    this.addMutationObserverForRequired_();\n  }\n\n  /**\n   * Initializes the select's event listeners and internal state based\n   * on the environment's state.\n   */\n  initialSyncWithDOM() {\n    this.handleChange_ = () => this.foundation_.handleChange(/* didChange */ true);\n    this.handleFocus_ = () => this.foundation_.handleFocus();\n    this.handleBlur_ = () => this.foundation_.handleBlur();\n    this.handleClick_ = (evt) => {\n      if (this.selectedText_) {\n        this.selectedText_.focus();\n      }\n      this.foundation_.handleClick(this.getNormalizedXCoordinate_(evt));\n    };\n    this.handleKeydown_ = (evt) => this.foundation_.handleKeydown(evt);\n    this.handleMenuSelected_ = (evtData) => this.selectedIndex = evtData.detail.index;\n    this.handleMenuOpened_ = () => {\n      this.foundation_.handleMenuOpened();\n\n      if (this.menu_!.items.length === 0) {\n        return;\n      }\n\n      // Menu should open to the last selected element, should open to first menu item otherwise.\n      const focusItemIndex = this.selectedIndex >= 0 ? this.selectedIndex : 0;\n      const focusItemEl = this.menu_!.items[focusItemIndex] as HTMLElement;\n      focusItemEl.focus();\n    };\n    this.handleMenuClosed_ = () => {\n      this.foundation_.handleMenuClosed();\n\n      // isMenuOpen_ is used to track the state of the menu opening or closing since the menu.open function\n      // will return false if the menu is still closing and this method listens to the closed event which\n      // occurs after the menu is already closed.\n      this.isMenuOpen_ = false;\n      this.selectedText_!.removeAttribute('aria-expanded');\n      if (document.activeElement !== this.selectedText_) {\n        this.foundation_.handleBlur();\n      }\n    };\n\n    this.targetElement_.addEventListener('change', this.handleChange_);\n    this.targetElement_.addEventListener('focus', this.handleFocus_);\n    this.targetElement_.addEventListener('blur', this.handleBlur_);\n\n    this.targetElement_.addEventListener('click', this.handleClick_ as EventListener);\n\n    if (this.menuElement_) {\n      this.selectedText_!.addEventListener('keydown', this.handleKeydown_);\n      this.menu_!.listen(menuSurfaceConstants.strings.CLOSED_EVENT, this.handleMenuClosed_);\n      this.menu_!.listen(menuSurfaceConstants.strings.OPENED_EVENT, this.handleMenuOpened_);\n      this.menu_!.listen(menuConstants.strings.SELECTED_EVENT, this.handleMenuSelected_);\n\n      if (this.hiddenInput_ && this.hiddenInput_.value) {\n        // If the hidden input already has a value, use it to restore the select's value.\n        // This can happen e.g. if the user goes back or (in some browsers) refreshes the page.\n        const enhancedAdapterMethods = this.getEnhancedSelectAdapterMethods_();\n        enhancedAdapterMethods.setValue(this.hiddenInput_.value);\n      } else if (this.menuElement_.querySelector(strings.SELECTED_ITEM_SELECTOR)) {\n        // If an element is selected, the select should set the initial selected text.\n        const enhancedAdapterMethods = this.getEnhancedSelectAdapterMethods_();\n        enhancedAdapterMethods.setValue(enhancedAdapterMethods.getValue());\n      }\n    }\n\n    // Initially sync floating label\n    this.foundation_.handleChange(/* didChange */ false);\n\n    if (this.root_.classList.contains(cssClasses.DISABLED)\n        || (this.nativeControl_ && this.nativeControl_.disabled)) {\n      this.disabled = true;\n    }\n  }\n\n  destroy() {\n    this.targetElement_.removeEventListener('change', this.handleChange_);\n    this.targetElement_.removeEventListener('focus', this.handleFocus_);\n    this.targetElement_.removeEventListener('blur', this.handleBlur_);\n    this.targetElement_.removeEventListener('keydown', this.handleKeydown_);\n    this.targetElement_.removeEventListener('click', this.handleClick_ as EventListener);\n\n    if (this.menu_) {\n      this.menu_.unlisten(menuSurfaceConstants.strings.CLOSED_EVENT, this.handleMenuClosed_);\n      this.menu_.unlisten(menuSurfaceConstants.strings.OPENED_EVENT, this.handleMenuOpened_);\n      this.menu_.unlisten(menuConstants.strings.SELECTED_EVENT, this.handleMenuSelected_);\n      this.menu_.destroy();\n    }\n\n    if (this.ripple) {\n      this.ripple.destroy();\n    }\n    if (this.outline_) {\n      this.outline_.destroy();\n    }\n    if (this.leadingIcon_) {\n      this.leadingIcon_.destroy();\n    }\n    if (this.helperText_) {\n      this.helperText_.destroy();\n    }\n    if (this.validationObserver_) {\n      this.validationObserver_.disconnect();\n    }\n\n    super.destroy();\n  }\n\n  get value(): string {\n    return this.foundation_.getValue();\n  }\n\n  set value(value: string) {\n    this.foundation_.setValue(value);\n  }\n\n  get selectedIndex(): number {\n    let selectedIndex = -1;\n    if (this.menuElement_ && this.menu_) {\n      const selectedEl = this.menuElement_.querySelector(strings.SELECTED_ITEM_SELECTOR)!;\n      selectedIndex = this.menu_.items.indexOf(selectedEl);\n    } else if (this.nativeControl_) {\n      selectedIndex = this.nativeControl_.selectedIndex;\n    }\n    return selectedIndex;\n  }\n\n  set selectedIndex(selectedIndex: number) {\n    this.foundation_.setSelectedIndex(selectedIndex);\n  }\n\n  get disabled(): boolean {\n    return this.root_.classList.contains(cssClasses.DISABLED) ||\n        (this.nativeControl_ ? this.nativeControl_.disabled : false);\n  }\n\n  set disabled(disabled: boolean) {\n    this.foundation_.setDisabled(disabled);\n  }\n\n  set leadingIconAriaLabel(label: string) {\n    this.foundation_.setLeadingIconAriaLabel(label);\n  }\n\n  /**\n   * Sets the text content of the leading icon.\n   */\n  set leadingIconContent(content: string) {\n    this.foundation_.setLeadingIconContent(content);\n  }\n\n  /**\n   * Sets the text content of the helper text.\n   */\n  set helperTextContent(content: string) {\n    this.foundation_.setHelperTextContent(content);\n  }\n\n  /**\n   * Sets the current invalid state of the select.\n   */\n  set valid(isValid: boolean) {\n    this.foundation_.setValid(isValid);\n  }\n\n  /**\n   * Checks if the select is in a valid state.\n   */\n  get valid(): boolean {\n    return this.foundation_.isValid();\n  }\n\n  /**\n   * Sets the control to the required state.\n   */\n  set required(isRequired: boolean) {\n    if (this.nativeControl_) {\n      this.nativeControl_.required = isRequired;\n    } else {\n      if (isRequired) {\n        this.selectedText_!.setAttribute('aria-required', isRequired.toString());\n      } else {\n        this.selectedText_!.removeAttribute('aria-required');\n      }\n    }\n  }\n\n  /**\n   * Returns whether the select is required.\n   */\n  get required(): boolean {\n    if (this.nativeControl_) {\n      return this.nativeControl_.required;\n    } else {\n      return this.selectedText_!.getAttribute('aria-required') === 'true';\n    }\n  }\n\n  /**\n   * Recomputes the outline SVG path for the outline element.\n   */\n  layout() {\n    this.foundation_.layout();\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCSelectAdapter = {\n      ...(this.nativeControl_ ? this.getNativeSelectAdapterMethods_() : this.getEnhancedSelectAdapterMethods_()),\n      ...this.getCommonAdapterMethods_(),\n      ...this.getOutlineAdapterMethods_(),\n      ...this.getLabelAdapterMethods_(),\n    };\n    return new MDCSelectFoundation(adapter, this.getFoundationMap_());\n  }\n\n  /**\n   * Handles setup for the enhanced menu.\n   */\n  private enhancedSelectSetup_(menuFactory: MDCMenuFactory) {\n    const isDisabled = this.root_.classList.contains(cssClasses.DISABLED);\n    this.selectedText_!.setAttribute('tabindex', isDisabled ? '-1' : '0');\n    this.hiddenInput_ = this.root_.querySelector(strings.HIDDEN_INPUT_SELECTOR);\n    this.menuElement_ = this.root_.querySelector(strings.MENU_SELECTOR)!;\n    this.menu_ = menuFactory(this.menuElement_);\n    this.menu_.hoistMenuToBody();\n    this.menu_.setAnchorElement(this.root_);\n    this.menu_.setAnchorCorner(menuSurfaceConstants.Corner.BOTTOM_START);\n    this.menu_.wrapFocus = false;\n  }\n\n  private createRipple_(): MDCRipple {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCRippleAdapter = {\n      ...MDCRipple.createAdapter(this),\n      registerInteractionHandler: (evtType, handler) => this.targetElement_.addEventListener(evtType, handler),\n      deregisterInteractionHandler: (evtType, handler) => this.targetElement_.removeEventListener(evtType, handler),\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCRipple(this.root_, new MDCRippleFoundation(adapter));\n  }\n\n  private getNativeSelectAdapterMethods_() {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      getValue: () => this.nativeControl_!.value,\n      setValue: (value: string) => {\n        this.nativeControl_!.value = value;\n      },\n      openMenu: () => undefined,\n      closeMenu: () => undefined,\n      isMenuOpen: () => false,\n      setSelectedIndex: (index: number) => {\n        this.nativeControl_!.selectedIndex = index;\n      },\n      setDisabled: (isDisabled: boolean) => {\n        this.nativeControl_!.disabled = isDisabled;\n      },\n      setValid: (isValid: boolean) => {\n        if (isValid) {\n          this.root_.classList.remove(cssClasses.INVALID);\n        } else {\n          this.root_.classList.add(cssClasses.INVALID);\n        }\n      },\n      checkValidity: () => this.nativeControl_!.checkValidity(),\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private getEnhancedSelectAdapterMethods_() {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      getValue: () => {\n        const listItem = this.menuElement_!.querySelector(strings.SELECTED_ITEM_SELECTOR);\n        if (listItem && listItem.hasAttribute(strings.ENHANCED_VALUE_ATTR)) {\n          return listItem.getAttribute(strings.ENHANCED_VALUE_ATTR) || '';\n        }\n        return '';\n      },\n      setValue: (value: string) => {\n        const element = this.menuElement_!.querySelector(`[${strings.ENHANCED_VALUE_ATTR}=\"${value}\"]`);\n        this.setEnhancedSelectedIndex_(element ? this.menu_!.items.indexOf(element) : -1);\n      },\n      openMenu: () => {\n        if (this.menu_ && !this.menu_.open) {\n          this.menu_.open = true;\n          this.isMenuOpen_ = true;\n          this.selectedText_!.setAttribute('aria-expanded', 'true');\n        }\n      },\n      closeMenu: () => {\n        if (this.menu_ && this.menu_.open) {\n          this.menu_.open = false;\n        }\n      },\n      isMenuOpen: () => Boolean(this.menu_) && this.isMenuOpen_,\n      setSelectedIndex: (index: number) => this.setEnhancedSelectedIndex_(index),\n      setDisabled: (isDisabled: boolean) => {\n        this.selectedText_!.setAttribute('tabindex', isDisabled ? '-1' : '0');\n        this.selectedText_!.setAttribute('aria-disabled', isDisabled.toString());\n        if (this.hiddenInput_) {\n          this.hiddenInput_.disabled = isDisabled;\n        }\n      },\n      checkValidity: () => {\n        const classList = this.root_.classList;\n        if (classList.contains(cssClasses.REQUIRED) && !classList.contains(cssClasses.DISABLED)) {\n          // See notes for required attribute under https://www.w3.org/TR/html52/sec-forms.html#the-select-element\n          // TL;DR: Invalid if no index is selected, or if the first index is selected and has an empty value.\n          return this.selectedIndex !== -1 && (this.selectedIndex !== 0 || Boolean(this.value));\n        } else {\n          return true;\n        }\n      },\n      setValid: (isValid: boolean) => {\n        this.selectedText_!.setAttribute('aria-invalid', (!isValid).toString());\n        if (isValid) {\n          this.root_.classList.remove(cssClasses.INVALID);\n        } else {\n          this.root_.classList.add(cssClasses.INVALID);\n        }\n      },\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private getCommonAdapterMethods_() {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClass: (className: string) => this.root_.classList.add(className),\n      removeClass: (className: string) => this.root_.classList.remove(className),\n      hasClass: (className: string) => this.root_.classList.contains(className),\n      setRippleCenter: (normalizedX: number) => this.lineRipple_ && this.lineRipple_.setRippleCenter(normalizedX),\n      activateBottomLine: () => this.lineRipple_ && this.lineRipple_.activate(),\n      deactivateBottomLine: () => this.lineRipple_ && this.lineRipple_.deactivate(),\n      notifyChange: (value: string) => {\n        const index = this.selectedIndex;\n        this.emit<MDCSelectEventDetail>(strings.CHANGE_EVENT, {value, index}, true /* shouldBubble  */);\n      },\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private getOutlineAdapterMethods_() {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      hasOutline: () => Boolean(this.outline_),\n      notchOutline: (labelWidth: number) => this.outline_ && this.outline_.notch(labelWidth),\n      closeOutline: () => this.outline_ && this.outline_.closeNotch(),\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private getLabelAdapterMethods_() {\n    return {\n      floatLabel: (shouldFloat: boolean) => this.label_ && this.label_.float(shouldFloat),\n      getLabelWidth: () => this.label_ ? this.label_.getWidth() : 0,\n    };\n  }\n\n  /**\n   * Calculates where the line ripple should start based on the x coordinate within the component.\n   */\n  private getNormalizedXCoordinate_(evt: MouseEvent | TouchEvent): number {\n    const targetClientRect = (evt.target as Element).getBoundingClientRect();\n    const xCoordinate = this.isTouchEvent_(evt) ? evt.touches[0].clientX : evt.clientX;\n    return xCoordinate - targetClientRect.left;\n  }\n\n  private isTouchEvent_(evt: MouseEvent | TouchEvent): evt is TouchEvent {\n    return Boolean((evt as TouchEvent).touches);\n  }\n\n  /**\n   * Returns a map of all subcomponents to subfoundations.\n   */\n  private getFoundationMap_(): Partial<MDCSelectFoundationMap> {\n    return {\n      helperText: this.helperText_ ? this.helperText_.foundation : undefined,\n      leadingIcon: this.leadingIcon_ ? this.leadingIcon_.foundation : undefined,\n    };\n  }\n\n  private setEnhancedSelectedIndex_(index: number) {\n    const selectedItem = this.menu_!.items[index];\n    this.selectedText_!.textContent = selectedItem ? selectedItem.textContent!.trim() : '';\n    const previouslySelected = this.menuElement_!.querySelector(strings.SELECTED_ITEM_SELECTOR);\n\n    if (previouslySelected) {\n      previouslySelected.classList.remove(cssClasses.SELECTED_ITEM_CLASS);\n      previouslySelected.removeAttribute(strings.ARIA_SELECTED_ATTR);\n    }\n\n    if (selectedItem) {\n      selectedItem.classList.add(cssClasses.SELECTED_ITEM_CLASS);\n      selectedItem.setAttribute(strings.ARIA_SELECTED_ATTR, 'true');\n    }\n\n    // Synchronize hidden input's value with data-value attribute of selected item.\n    // This code path is also followed when setting value directly, so this covers all cases.\n    if (this.hiddenInput_) {\n      this.hiddenInput_.value = selectedItem ? selectedItem.getAttribute(strings.ENHANCED_VALUE_ATTR) || '' : '';\n    }\n\n    this.layout();\n  }\n\n  private initialSyncRequiredState_() {\n    const isRequired =\n        (this.targetElement_ as HTMLSelectElement).required\n        || this.targetElement_.getAttribute('aria-required') === 'true'\n        || this.root_.classList.contains(cssClasses.REQUIRED);\n    if (isRequired) {\n      if (this.nativeControl_) {\n        this.nativeControl_.required = true;\n      } else {\n        this.selectedText_!.setAttribute('aria-required', 'true');\n      }\n      this.root_.classList.add(cssClasses.REQUIRED);\n    }\n  }\n\n  private addMutationObserverForRequired_() {\n    const observerHandler = (attributesList: string[]) => {\n      attributesList.some((attributeName) => {\n        if (VALIDATION_ATTR_WHITELIST.indexOf(attributeName) === -1) {\n          return false;\n        }\n\n        if (this.selectedText_) {\n          if (this.selectedText_.getAttribute('aria-required') === 'true') {\n            this.root_.classList.add(cssClasses.REQUIRED);\n          } else {\n            this.root_.classList.remove(cssClasses.REQUIRED);\n          }\n        } else {\n          if (this.nativeControl_!.required) {\n            this.root_.classList.add(cssClasses.REQUIRED);\n          } else {\n            this.root_.classList.remove(cssClasses.REQUIRED);\n          }\n        }\n\n        return true;\n      });\n    };\n\n    const getAttributesList = (mutationsList: MutationRecord[]): string[] => {\n      return mutationsList\n          .map((mutation) => mutation.attributeName)\n          .filter((attributeName) => attributeName) as string[];\n    };\n    const observer = new MutationObserver((mutationsList) => observerHandler(getAttributesList(mutationsList)));\n    observer.observe(this.targetElement_, {attributes: true});\n    this.validationObserver_ = observer;\n  }\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n  ACTIVATED: 'mdc-select--activated',\n  DISABLED: 'mdc-select--disabled',\n  FOCUSED: 'mdc-select--focused',\n  INVALID: 'mdc-select--invalid',\n  OUTLINED: 'mdc-select--outlined',\n  REQUIRED: 'mdc-select--required',\n  ROOT: 'mdc-select',\n  SELECTED_ITEM_CLASS: 'mdc-list-item--selected',\n  WITH_LEADING_ICON: 'mdc-select--with-leading-icon',\n};\n\nconst strings = {\n  ARIA_CONTROLS: 'aria-controls',\n  ARIA_SELECTED_ATTR: 'aria-selected',\n  CHANGE_EVENT: 'MDCSelect:change',\n  ENHANCED_VALUE_ATTR: 'data-value',\n  HIDDEN_INPUT_SELECTOR: 'input[type=\"hidden\"]',\n  LABEL_SELECTOR: '.mdc-floating-label',\n  LEADING_ICON_SELECTOR: '.mdc-select__icon',\n  LINE_RIPPLE_SELECTOR: '.mdc-line-ripple',\n  MENU_SELECTOR: '.mdc-select__menu',\n  NATIVE_CONTROL_SELECTOR: '.mdc-select__native-control',\n  OUTLINE_SELECTOR: '.mdc-notched-outline',\n  SELECTED_ITEM_SELECTOR: `.${cssClasses.SELECTED_ITEM_CLASS}`,\n  SELECTED_TEXT_SELECTOR: '.mdc-select__selected-text',\n};\n\nconst numbers = {\n  LABEL_SCALE: 0.75,\n};\n\nexport {cssClasses, strings, numbers};\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCSelectAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\nimport {MDCSelectHelperTextFoundation} from './helper-text/foundation';\nimport {MDCSelectIconFoundation} from './icon/foundation';\nimport {MDCSelectFoundationMap} from './types';\n\nexport class MDCSelectFoundation extends MDCFoundation<MDCSelectAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get numbers() {\n    return numbers;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  /**\n   * See {@link MDCSelectAdapter} for typing information on parameters and return types.\n   */\n  static get defaultAdapter(): MDCSelectAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      hasClass: () => false,\n      activateBottomLine: () => undefined,\n      deactivateBottomLine: () => undefined,\n      setValue: () => undefined,\n      getValue: () => '',\n      floatLabel: () => undefined,\n      getLabelWidth: () => 0,\n      hasOutline: () => false,\n      notchOutline: () => undefined,\n      closeOutline: () => undefined,\n      openMenu: () => undefined,\n      closeMenu: () => undefined,\n      isMenuOpen: () => false,\n      setSelectedIndex: () => undefined,\n      setDisabled: () => undefined,\n      setRippleCenter: () => undefined,\n      notifyChange: () => undefined,\n      checkValidity: () => false,\n      setValid: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private readonly leadingIcon_: MDCSelectIconFoundation | undefined;\n  private readonly helperText_: MDCSelectHelperTextFoundation | undefined;\n\n  /* istanbul ignore next: optional argument is not a branch statement */\n  /**\n   * @param adapter\n   * @param foundationMap Map from subcomponent names to their subfoundations.\n   */\n  constructor(adapter?: Partial<MDCSelectAdapter>, foundationMap: Partial<MDCSelectFoundationMap> = {}) {\n    super({...MDCSelectFoundation.defaultAdapter, ...adapter});\n\n    this.leadingIcon_ = foundationMap.leadingIcon;\n    this.helperText_ = foundationMap.helperText;\n  }\n\n  setSelectedIndex(index: number) {\n    this.adapter_.setSelectedIndex(index);\n    this.adapter_.closeMenu();\n    const didChange = true;\n    this.handleChange(didChange);\n  }\n\n  setValue(value: string) {\n    this.adapter_.setValue(value);\n    const didChange = true;\n    this.handleChange(didChange);\n  }\n\n  getValue() {\n    return this.adapter_.getValue();\n  }\n\n  setDisabled(isDisabled: boolean) {\n    if (isDisabled) {\n      this.adapter_.addClass(cssClasses.DISABLED);\n    } else {\n      this.adapter_.removeClass(cssClasses.DISABLED);\n    }\n    this.adapter_.setDisabled(isDisabled);\n    this.adapter_.closeMenu();\n\n    if (this.leadingIcon_) {\n      this.leadingIcon_.setDisabled(isDisabled);\n    }\n  }\n\n  /**\n   * @param content Sets the content of the helper text.\n   */\n  setHelperTextContent(content: string) {\n    if (this.helperText_) {\n      this.helperText_.setContent(content);\n    }\n  }\n\n  layout() {\n    const openNotch = this.getValue().length > 0;\n    this.notchOutline(openNotch);\n  }\n\n  handleMenuOpened() {\n    this.adapter_.addClass(cssClasses.ACTIVATED);\n  }\n\n  handleMenuClosed() {\n    this.adapter_.removeClass(cssClasses.ACTIVATED);\n  }\n\n  /**\n   * Handles value changes, via change event or programmatic updates.\n   */\n  handleChange(didChange = true) {\n    const value = this.getValue();\n    const optionHasValue = value.length > 0;\n    const isRequired = this.adapter_.hasClass(cssClasses.REQUIRED);\n\n    this.notchOutline(optionHasValue);\n\n    if (!this.adapter_.hasClass(cssClasses.FOCUSED)) {\n      this.adapter_.floatLabel(optionHasValue);\n    }\n\n    if (didChange) {\n      this.adapter_.notifyChange(value);\n\n      if (isRequired) {\n        this.setValid(this.isValid());\n        if (this.helperText_) {\n          this.helperText_.setValidity(this.isValid());\n        }\n      }\n    }\n  }\n\n  /**\n   * Handles focus events from select element.\n   */\n  handleFocus() {\n    this.adapter_.addClass(cssClasses.FOCUSED);\n    this.adapter_.floatLabel(true);\n    this.notchOutline(true);\n    this.adapter_.activateBottomLine();\n    if (this.helperText_) {\n      this.helperText_.showToScreenReader();\n    }\n  }\n\n  /**\n   * Handles blur events from select element.\n   */\n  handleBlur() {\n    if (this.adapter_.isMenuOpen()) {\n      return;\n    }\n    this.adapter_.removeClass(cssClasses.FOCUSED);\n    this.handleChange(false);\n    this.adapter_.deactivateBottomLine();\n\n    const isRequired = this.adapter_.hasClass(cssClasses.REQUIRED);\n\n    if (isRequired) {\n      this.setValid(this.isValid());\n      if (this.helperText_) {\n        this.helperText_.setValidity(this.isValid());\n      }\n    }\n  }\n\n  handleClick(normalizedX: number) {\n    if (this.adapter_.isMenuOpen()) {\n      return;\n    }\n    this.adapter_.setRippleCenter(normalizedX);\n\n    this.adapter_.openMenu();\n  }\n\n  handleKeydown(event: KeyboardEvent) {\n    if (this.adapter_.isMenuOpen()) {\n      return;\n    }\n\n    const isEnter = event.key === 'Enter' || event.keyCode === 13;\n    const isSpace = event.key === 'Space' || event.keyCode === 32;\n    const arrowUp = event.key === 'ArrowUp' || event.keyCode === 38;\n    const arrowDown = event.key === 'ArrowDown' || event.keyCode === 40;\n\n    if (this.adapter_.hasClass(cssClasses.FOCUSED) && (isEnter || isSpace || arrowUp || arrowDown)) {\n      this.adapter_.openMenu();\n      event.preventDefault();\n    }\n  }\n\n  /**\n   * Opens/closes the notched outline.\n   */\n  notchOutline(openNotch: boolean) {\n    if (!this.adapter_.hasOutline()) {\n      return;\n    }\n    const isFocused = this.adapter_.hasClass(cssClasses.FOCUSED);\n\n    if (openNotch) {\n      const labelScale = numbers.LABEL_SCALE;\n      const labelWidth = this.adapter_.getLabelWidth() * labelScale;\n      this.adapter_.notchOutline(labelWidth);\n    } else if (!isFocused) {\n      this.adapter_.closeOutline();\n    }\n  }\n\n  /**\n   * Sets the aria label of the leading icon.\n   */\n  setLeadingIconAriaLabel(label: string) {\n    if (this.leadingIcon_) {\n      this.leadingIcon_.setAriaLabel(label);\n    }\n  }\n\n  /**\n   * Sets the text content of the leading icon.\n   */\n  setLeadingIconContent(content: string) {\n    if (this.leadingIcon_) {\n      this.leadingIcon_.setContent(content);\n    }\n  }\n\n  setValid(isValid: boolean) {\n    this.adapter_.setValid(isValid);\n  }\n\n  isValid() {\n    return this.adapter_.checkValidity();\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCSelectFoundation;\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCSelectHelperTextAdapter} from './adapter';\nimport {MDCSelectHelperTextFoundation} from './foundation';\n\nexport type MDCSelectHelperTextFactory =\n    (el: Element, foundation?: MDCSelectHelperTextFoundation) => MDCSelectHelperText;\n\nexport class MDCSelectHelperText extends MDCComponent<MDCSelectHelperTextFoundation> {\n  static attachTo(root: Element): MDCSelectHelperText {\n    return new MDCSelectHelperText(root);\n  }\n\n  get foundation(): MDCSelectHelperTextFoundation {\n    return this.foundation_;\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCSelectHelperTextAdapter = {\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      hasClass: (className) => this.root_.classList.contains(className),\n      setAttr: (attr, value) => this.root_.setAttribute(attr, value),\n      removeAttr: (attr) => this.root_.removeAttribute(attr),\n      setContent: (content) => {\n        this.root_.textContent = content;\n      },\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCSelectHelperTextFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst strings = {\n  ARIA_HIDDEN: 'aria-hidden',\n  ROLE: 'role',\n};\n\nconst cssClasses = {\n  HELPER_TEXT_PERSISTENT: 'mdc-select-helper-text--persistent',\n  HELPER_TEXT_VALIDATION_MSG: 'mdc-select-helper-text--validation-msg',\n};\n\nexport {strings, cssClasses};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCSelectHelperTextAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCSelectHelperTextFoundation extends MDCFoundation<MDCSelectHelperTextAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  /**\n   * See {@link MDCSelectHelperTextAdapter} for typing information on parameters and return types.\n   */\n  static get defaultAdapter(): MDCSelectHelperTextAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      hasClass: () => false,\n      setAttr: () => undefined,\n      removeAttr: () => undefined,\n      setContent: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  constructor(adapter?: Partial<MDCSelectHelperTextAdapter>) {\n    super({...MDCSelectHelperTextFoundation.defaultAdapter, ...adapter});\n  }\n\n  /**\n   * Sets the content of the helper text field.\n   */\n  setContent(content: string) {\n    this.adapter_.setContent(content);\n  }\n\n  /**\n   *  Sets the persistency of the helper text.\n   */\n  setPersistent(isPersistent: boolean) {\n    if (isPersistent) {\n      this.adapter_.addClass(cssClasses.HELPER_TEXT_PERSISTENT);\n    } else {\n      this.adapter_.removeClass(cssClasses.HELPER_TEXT_PERSISTENT);\n    }\n  }\n\n  /**\n   * @param isValidation True to make the helper text act as an error validation message.\n   */\n  setValidation(isValidation: boolean) {\n    if (isValidation) {\n      this.adapter_.addClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n    } else {\n      this.adapter_.removeClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n    }\n  }\n\n  /**\n   * Makes the helper text visible to screen readers.\n   */\n  showToScreenReader() {\n    this.adapter_.removeAttr(strings.ARIA_HIDDEN);\n  }\n\n  /**\n   * Sets the validity of the helper text based on the select validity.\n   */\n  setValidity(selectIsValid: boolean) {\n    const helperTextIsPersistent = this.adapter_.hasClass(cssClasses.HELPER_TEXT_PERSISTENT);\n    const helperTextIsValidationMsg = this.adapter_.hasClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n    const validationMsgNeedsDisplay = helperTextIsValidationMsg && !selectIsValid;\n\n    if (validationMsgNeedsDisplay) {\n      this.adapter_.setAttr(strings.ROLE, 'alert');\n    } else {\n      this.adapter_.removeAttr(strings.ROLE);\n    }\n\n    if (!helperTextIsPersistent && !validationMsgNeedsDisplay) {\n      this.hide_();\n    }\n  }\n\n  /**\n   * Hides the help text from screen readers.\n   */\n  private hide_() {\n    this.adapter_.setAttr(strings.ARIA_HIDDEN, 'true');\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCSelectHelperTextFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport {cssClasses as helperTextCssClasses, strings as helperTextStrings} from './constants';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCSelectIconAdapter} from './adapter';\nimport {MDCSelectIconFoundation} from './foundation';\n\nexport type MDCSelectIconFactory = (el: Element, foundation?: MDCSelectIconFoundation) => MDCSelectIcon;\n\nexport class MDCSelectIcon extends MDCComponent<MDCSelectIconFoundation> {\n  static attachTo(root: Element): MDCSelectIcon {\n    return new MDCSelectIcon(root);\n  }\n\n  get foundation(): MDCSelectIconFoundation {\n    return this.foundation_;\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCSelectIconAdapter = {\n      getAttr: (attr) => this.root_.getAttribute(attr),\n      setAttr: (attr, value) => this.root_.setAttribute(attr, value),\n      removeAttr: (attr) => this.root_.removeAttribute(attr),\n      setContent: (content) => {\n        this.root_.textContent = content;\n      },\n      registerInteractionHandler: (evtType, handler) => this.listen(evtType, handler),\n      deregisterInteractionHandler: (evtType, handler) => this.unlisten(evtType, handler),\n      notifyIconAction: () => this.emit(\n          MDCSelectIconFoundation.strings.ICON_EVENT, {} /* evtData */, true /* shouldBubble */),\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCSelectIconFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst strings = {\n  ICON_EVENT: 'MDCSelect:icon',\n  ICON_ROLE: 'button',\n};\n\nexport {strings};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCSelectIconAdapter} from './adapter';\nimport {strings} from './constants';\n\ntype InteractionEventType = 'click' | 'keydown';\n\nconst INTERACTION_EVENTS: InteractionEventType[] = ['click', 'keydown'];\n\nexport class MDCSelectIconFoundation extends MDCFoundation<MDCSelectIconAdapter> {\n  static get strings() {\n    return strings;\n  }\n\n  /**\n   * See {@link MDCSelectIconAdapter} for typing information on parameters and return types.\n   */\n  static get defaultAdapter(): MDCSelectIconAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      getAttr: () => null,\n      setAttr: () => undefined,\n      removeAttr: () => undefined,\n      setContent: () => undefined,\n      registerInteractionHandler: () => undefined,\n      deregisterInteractionHandler: () => undefined,\n      notifyIconAction: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private savedTabIndex_: string | null = null;\n\n  // assigned in initialSyncWithDOM()\n  private readonly interactionHandler_!: SpecificEventListener<InteractionEventType>;\n\n  constructor(adapter?: Partial<MDCSelectIconAdapter>) {\n    super({...MDCSelectIconFoundation.defaultAdapter, ...adapter});\n\n    this.interactionHandler_ = (evt) => this.handleInteraction(evt);\n  }\n\n  init() {\n    this.savedTabIndex_ = this.adapter_.getAttr('tabindex');\n\n    INTERACTION_EVENTS.forEach((evtType) => {\n      this.adapter_.registerInteractionHandler(evtType, this.interactionHandler_);\n    });\n  }\n\n  destroy() {\n    INTERACTION_EVENTS.forEach((evtType) => {\n      this.adapter_.deregisterInteractionHandler(evtType, this.interactionHandler_);\n    });\n  }\n\n  setDisabled(disabled: boolean) {\n    if (!this.savedTabIndex_) {\n      return;\n    }\n\n    if (disabled) {\n      this.adapter_.setAttr('tabindex', '-1');\n      this.adapter_.removeAttr('role');\n    } else {\n      this.adapter_.setAttr('tabindex', this.savedTabIndex_);\n      this.adapter_.setAttr('role', strings.ICON_ROLE);\n    }\n  }\n\n  setAriaLabel(label: string) {\n    this.adapter_.setAttr('aria-label', label);\n  }\n\n  setContent(content: string) {\n    this.adapter_.setContent(content);\n  }\n\n  handleInteraction(evt: MouseEvent | KeyboardEvent) {\n    const isEnterKey = (evt as KeyboardEvent).key === 'Enter' || (evt as KeyboardEvent).keyCode === 13;\n    if (evt.type === 'click' || isEnterKey) {\n      this.adapter_.notifyIconAction();\n    }\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCSelectIconFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport {strings as iconStrings} from './constants';\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\nexport * from './helper-text/index';\nexport * from './icon/index';\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {applyPassive} from '@material/dom/events';\nimport {MDCSliderAdapter} from './adapter';\nimport {strings} from './constants';\nimport {MDCSliderFoundation} from './foundation';\n\nexport class MDCSlider extends MDCComponent<MDCSliderFoundation> {\n  static attachTo(root: Element) {\n    return new MDCSlider(root);\n  }\n\n  protected root_!: HTMLElement; // assigned in MDCComponent constructor\n\n  private thumbContainer_!: HTMLElement; // assigned in initialize()\n  private track_!: HTMLElement; // assigned in initialize()\n  private pinValueMarker_!: HTMLElement; // assigned in initialize()\n  private trackMarkerContainer_!: HTMLElement; // assigned in initialize()\n\n  get value(): number {\n    return this.foundation_.getValue();\n  }\n\n  set value(value: number) {\n    this.foundation_.setValue(value);\n  }\n\n  get min(): number {\n    return this.foundation_.getMin();\n  }\n\n  set min(min: number) {\n    this.foundation_.setMin(min);\n  }\n\n  get max(): number {\n    return this.foundation_.getMax();\n  }\n\n  set max(max: number) {\n    this.foundation_.setMax(max);\n  }\n\n  get step(): number {\n    return this.foundation_.getStep();\n  }\n\n  set step(step: number) {\n    this.foundation_.setStep(step);\n  }\n\n  get disabled(): boolean {\n    return this.foundation_.isDisabled();\n  }\n\n  set disabled(disabled: boolean) {\n    this.foundation_.setDisabled(disabled);\n  }\n\n  initialize() {\n    this.thumbContainer_ = this.root_.querySelector<HTMLElement>(strings.THUMB_CONTAINER_SELECTOR)!;\n    this.track_ = this.root_.querySelector<HTMLElement>(strings.TRACK_SELECTOR)!;\n    this.pinValueMarker_ = this.root_.querySelector<HTMLElement>(strings.PIN_VALUE_MARKER_SELECTOR)!;\n    this.trackMarkerContainer_ = this.root_.querySelector<HTMLElement>(strings.TRACK_MARKER_CONTAINER_SELECTOR)!;\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCSliderAdapter = {\n      hasClass: (className) => this.root_.classList.contains(className),\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      getAttribute: (name) => this.root_.getAttribute(name),\n      setAttribute: (name, value) => this.root_.setAttribute(name, value),\n      removeAttribute: (name) => this.root_.removeAttribute(name),\n      computeBoundingRect: () => this.root_.getBoundingClientRect(),\n      getTabIndex: () => this.root_.tabIndex,\n      registerInteractionHandler: (evtType, handler) => this.listen(evtType, handler, applyPassive()),\n      deregisterInteractionHandler: (evtType, handler) => this.unlisten(evtType, handler, applyPassive()),\n      registerThumbContainerInteractionHandler: (evtType, handler) => {\n        this.thumbContainer_.addEventListener(evtType, handler, applyPassive());\n      },\n      deregisterThumbContainerInteractionHandler: (evtType, handler) => {\n        this.thumbContainer_.removeEventListener(evtType, handler, applyPassive());\n      },\n      registerBodyInteractionHandler: (evtType, handler) => document.body.addEventListener(evtType, handler),\n      deregisterBodyInteractionHandler: (evtType, handler) => document.body.removeEventListener(evtType, handler),\n      registerResizeHandler: (handler) => window.addEventListener('resize', handler),\n      deregisterResizeHandler: (handler) => window.removeEventListener('resize', handler),\n      notifyInput: () => this.emit<MDCSlider>(strings.INPUT_EVENT, this), // TODO(acdvorak): Create detail interface\n      notifyChange: () => this.emit<MDCSlider>(strings.CHANGE_EVENT, this), // TODO(acdvorak): Create detail interface\n      setThumbContainerStyleProperty: (propertyName, value) => {\n        this.thumbContainer_.style.setProperty(propertyName, value);\n      },\n      setTrackStyleProperty: (propertyName, value) => this.track_.style.setProperty(propertyName, value),\n      setMarkerValue: (value) => this.pinValueMarker_.innerText = value.toLocaleString(),\n      appendTrackMarkers: (numMarkers) => {\n        const frag = document.createDocumentFragment();\n        for (let i = 0; i < numMarkers; i++) {\n          const marker = document.createElement('div');\n          marker.classList.add('mdc-slider__track-marker');\n          frag.appendChild(marker);\n        }\n        this.trackMarkerContainer_.appendChild(frag);\n      },\n      removeTrackMarkers: () => {\n        while (this.trackMarkerContainer_.firstChild) {\n          this.trackMarkerContainer_.removeChild(this.trackMarkerContainer_.firstChild);\n        }\n      },\n      setLastTrackMarkersStyleProperty: (propertyName, value) => {\n        // We remove and append new nodes, thus, the last track marker must be dynamically found.\n        const lastTrackMarker = this.root_.querySelector<HTMLElement>(strings.LAST_TRACK_MARKER_SELECTOR)!;\n        lastTrackMarker.style.setProperty(propertyName, value);\n      },\n      isRTL: () => getComputedStyle(this.root_).direction === 'rtl',\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCSliderFoundation(adapter);\n  }\n\n  initialSyncWithDOM() {\n    const origValueNow = this.parseFloat_(this.root_.getAttribute(strings.ARIA_VALUENOW), this.value);\n    const min = this.parseFloat_(this.root_.getAttribute(strings.ARIA_VALUEMIN), this.min);\n    const max = this.parseFloat_(this.root_.getAttribute(strings.ARIA_VALUEMAX), this.max);\n\n    // min and max need to be set in the right order to avoid throwing an error\n    // when the new min is greater than the default max.\n    if (min >= this.max) {\n      this.max = max;\n      this.min = min;\n    } else {\n      this.min = min;\n      this.max = max;\n    }\n\n    this.step = this.parseFloat_(this.root_.getAttribute(strings.STEP_DATA_ATTR), this.step);\n    this.value = origValueNow;\n    this.disabled = (\n        this.root_.hasAttribute(strings.ARIA_DISABLED) &&\n        this.root_.getAttribute(strings.ARIA_DISABLED) !== 'false'\n    );\n    this.foundation_.setupTrackMarker();\n  }\n\n  layout() {\n    this.foundation_.layout();\n  }\n\n  stepUp(amount = (this.step || 1)) {\n    this.value += amount;\n  }\n\n  stepDown(amount = (this.step || 1)) {\n    this.value -= amount;\n  }\n\n  private parseFloat_(str: string | null, defaultValue: number) {\n    const num = parseFloat(str!); // tslint:disable-line:ban\n    const isNumeric = typeof num === 'number' && isFinite(num);\n    return isNumeric ? num : defaultValue;\n  }\n}\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n  ACTIVE: 'mdc-slider--active',\n  DISABLED: 'mdc-slider--disabled',\n  DISCRETE: 'mdc-slider--discrete',\n  FOCUS: 'mdc-slider--focus',\n  HAS_TRACK_MARKER: 'mdc-slider--display-markers',\n  IN_TRANSIT: 'mdc-slider--in-transit',\n  IS_DISCRETE: 'mdc-slider--discrete',\n};\n\nconst strings = {\n  ARIA_DISABLED: 'aria-disabled',\n  ARIA_VALUEMAX: 'aria-valuemax',\n  ARIA_VALUEMIN: 'aria-valuemin',\n  ARIA_VALUENOW: 'aria-valuenow',\n  CHANGE_EVENT: 'MDCSlider:change',\n  INPUT_EVENT: 'MDCSlider:input',\n  LAST_TRACK_MARKER_SELECTOR: '.mdc-slider__track-marker:last-child',\n  PIN_VALUE_MARKER_SELECTOR: '.mdc-slider__pin-value-marker',\n  STEP_DATA_ATTR: 'data-step',\n  THUMB_CONTAINER_SELECTOR: '.mdc-slider__thumb-container',\n  TRACK_MARKER_CONTAINER_SELECTOR: '.mdc-slider__track-marker-container',\n  TRACK_SELECTOR: '.mdc-slider__track',\n};\n\nconst numbers = {\n  PAGE_FACTOR: 4,\n};\n\nexport {cssClasses, strings, numbers};\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {getCorrectEventName, getCorrectPropertyName} from '@material/animation/util';\nimport {MDCFoundation} from '@material/base/foundation';\nimport {EventType, SpecificEventListener} from '@material/base/types';\nimport {MDCSliderAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\ntype UpEventType = 'mouseup' | 'pointerup' | 'touchend';\ntype DownEventType = 'mousedown' | 'pointerdown' | 'touchstart';\ntype MoveEventType = 'mousemove' | 'pointermove' | 'touchmove';\ntype MouseLikeEvent = MouseEvent | PointerEvent | TouchEvent;\n\ntype MoveEventMap = {\n  readonly [K in DownEventType]: MoveEventType;\n};\n\nconst DOWN_EVENTS: DownEventType[] = ['mousedown', 'pointerdown', 'touchstart'];\nconst UP_EVENTS: UpEventType[] = ['mouseup', 'pointerup', 'touchend'];\n\nconst MOVE_EVENT_MAP: MoveEventMap = {\n  mousedown: 'mousemove',\n  pointerdown: 'pointermove',\n  touchstart: 'touchmove',\n};\n\nconst KEY_IDS = {\n  ARROW_DOWN: 'ArrowDown',\n  ARROW_LEFT: 'ArrowLeft',\n  ARROW_RIGHT: 'ArrowRight',\n  ARROW_UP: 'ArrowUp',\n  END: 'End',\n  HOME: 'Home',\n  PAGE_DOWN: 'PageDown',\n  PAGE_UP: 'PageUp',\n};\n\nexport class MDCSliderFoundation extends MDCFoundation<MDCSliderAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get numbers() {\n    return numbers;\n  }\n\n  static get defaultAdapter(): MDCSliderAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      hasClass: () => false,\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      getAttribute: () => null,\n      setAttribute: () => undefined,\n      removeAttribute: () => undefined,\n      computeBoundingRect: () => ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0}),\n      getTabIndex: () => 0,\n      registerInteractionHandler: () => undefined,\n      deregisterInteractionHandler: () => undefined,\n      registerThumbContainerInteractionHandler: () => undefined,\n      deregisterThumbContainerInteractionHandler: () => undefined,\n      registerBodyInteractionHandler: () => undefined,\n      deregisterBodyInteractionHandler: () => undefined,\n      registerResizeHandler: () => undefined,\n      deregisterResizeHandler: () => undefined,\n      notifyInput: () => undefined,\n      notifyChange: () => undefined,\n      setThumbContainerStyleProperty: () => undefined,\n      setTrackStyleProperty: () => undefined,\n      setMarkerValue: () => undefined,\n      appendTrackMarkers: () => undefined,\n      removeTrackMarkers: () => undefined,\n      setLastTrackMarkersStyleProperty: () => undefined,\n      isRTL: () => false,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private rect_!: ClientRect; // assigned in layout() via init()\n\n  /**\n   * We set this to NaN since we want it to be a number, but we can't use '0' or '-1'\n   * because those could be valid tabindices set by the client code.\n   */\n  private savedTabIndex_ = NaN;\n\n  private active_ = false;\n  private inTransit_ = false;\n  private isDiscrete_ = false;\n  private hasTrackMarker_ = false;\n  private handlingThumbTargetEvt_ = false;\n  private min_ = 0;\n  private max_ = 100;\n  private step_ = 0;\n  private value_ = 0;\n  private disabled_ = false;\n  private preventFocusState_ = false;\n\n  private readonly thumbContainerPointerHandler_: SpecificEventListener<DownEventType>;\n  private readonly interactionStartHandler_: SpecificEventListener<DownEventType>;\n  private readonly keydownHandler_: SpecificEventListener<'keydown'>;\n  private readonly focusHandler_: SpecificEventListener<'focus'>;\n  private readonly blurHandler_: SpecificEventListener<'blur'>;\n  private readonly resizeHandler_: SpecificEventListener<'resize'>;\n\n  constructor(adapter?: Partial<MDCSliderAdapter>) {\n    super({...MDCSliderFoundation.defaultAdapter, ...adapter});\n\n    this.thumbContainerPointerHandler_ = () => this.handlingThumbTargetEvt_ = true;\n    this.interactionStartHandler_ = (evt: MouseLikeEvent) => this.handleDown_(evt);\n    this.keydownHandler_ = (evt) => this.handleKeydown_(evt);\n    this.focusHandler_ = () => this.handleFocus_();\n    this.blurHandler_ = () => this.handleBlur_();\n    this.resizeHandler_ = () => this.layout();\n  }\n\n  init() {\n    this.isDiscrete_ = this.adapter_.hasClass(cssClasses.IS_DISCRETE);\n    this.hasTrackMarker_ = this.adapter_.hasClass(cssClasses.HAS_TRACK_MARKER);\n\n    DOWN_EVENTS.forEach((evtName) => {\n      this.adapter_.registerInteractionHandler(evtName, this.interactionStartHandler_);\n      this.adapter_.registerThumbContainerInteractionHandler(evtName, this.thumbContainerPointerHandler_);\n    });\n\n    this.adapter_.registerInteractionHandler('keydown', this.keydownHandler_);\n    this.adapter_.registerInteractionHandler('focus', this.focusHandler_);\n    this.adapter_.registerInteractionHandler('blur', this.blurHandler_);\n    this.adapter_.registerResizeHandler(this.resizeHandler_);\n\n    this.layout();\n\n    // At last step, provide a reasonable default value to discrete slider\n    if (this.isDiscrete_ && this.getStep() === 0) {\n      this.step_ = 1;\n    }\n  }\n\n  destroy() {\n    DOWN_EVENTS.forEach((evtName) => {\n      this.adapter_.deregisterInteractionHandler(evtName, this.interactionStartHandler_);\n      this.adapter_.deregisterThumbContainerInteractionHandler(evtName, this.thumbContainerPointerHandler_);\n    });\n\n    this.adapter_.deregisterInteractionHandler('keydown', this.keydownHandler_);\n    this.adapter_.deregisterInteractionHandler('focus', this.focusHandler_);\n    this.adapter_.deregisterInteractionHandler('blur', this.blurHandler_);\n    this.adapter_.deregisterResizeHandler(this.resizeHandler_);\n  }\n\n  setupTrackMarker() {\n    if (this.isDiscrete_ && this.hasTrackMarker_ && this.getStep() !== 0) {\n      const min = this.getMin();\n      const max = this.getMax();\n      const step = this.getStep();\n      let numMarkers = (max - min) / step;\n\n      // In case distance between max & min is indivisible to step,\n      // we place the secondary to last marker proportionally at where thumb\n      // could reach and place the last marker at max value\n      const indivisible = Math.ceil(numMarkers) !== numMarkers;\n      if (indivisible) {\n        numMarkers = Math.ceil(numMarkers);\n      }\n\n      this.adapter_.removeTrackMarkers();\n      this.adapter_.appendTrackMarkers(numMarkers);\n\n      if (indivisible) {\n        const lastStepRatio = (max - numMarkers * step) / step + 1;\n        this.adapter_.setLastTrackMarkersStyleProperty('flex-grow', String(lastStepRatio));\n      }\n    }\n  }\n\n  layout() {\n    this.rect_ = this.adapter_.computeBoundingRect();\n    this.updateUIForCurrentValue_();\n  }\n\n  getValue(): number {\n    return this.value_;\n  }\n\n  setValue(value: number) {\n    this.setValue_(value, false);\n  }\n\n  getMax(): number {\n    return this.max_;\n  }\n\n  setMax(max: number) {\n    if (max < this.min_) {\n      throw new Error('Cannot set max to be less than the slider\\'s minimum value');\n    }\n    this.max_ = max;\n    this.setValue_(this.value_, false, true);\n    this.adapter_.setAttribute(strings.ARIA_VALUEMAX, String(this.max_));\n    this.setupTrackMarker();\n  }\n\n  getMin(): number {\n    return this.min_;\n  }\n\n  setMin(min: number) {\n    if (min > this.max_) {\n      throw new Error('Cannot set min to be greater than the slider\\'s maximum value');\n    }\n    this.min_ = min;\n    this.setValue_(this.value_, false, true);\n    this.adapter_.setAttribute(strings.ARIA_VALUEMIN, String(this.min_));\n    this.setupTrackMarker();\n  }\n\n  getStep(): number {\n    return this.step_;\n  }\n\n  setStep(step: number) {\n    if (step < 0) {\n      throw new Error('Step cannot be set to a negative number');\n    }\n    if (this.isDiscrete_ && (typeof (step) !== 'number' || step < 1)) {\n      step = 1;\n    }\n    this.step_ = step;\n    this.setValue_(this.value_, false, true);\n    this.setupTrackMarker();\n  }\n\n  isDisabled(): boolean {\n    return this.disabled_;\n  }\n\n  setDisabled(disabled: boolean) {\n    this.disabled_ = disabled;\n    this.toggleClass_(cssClasses.DISABLED, this.disabled_);\n    if (this.disabled_) {\n      this.savedTabIndex_ = this.adapter_.getTabIndex();\n      this.adapter_.setAttribute(strings.ARIA_DISABLED, 'true');\n      this.adapter_.removeAttribute('tabindex');\n    } else {\n      this.adapter_.removeAttribute(strings.ARIA_DISABLED);\n      if (!isNaN(this.savedTabIndex_)) {\n        this.adapter_.setAttribute('tabindex', String(this.savedTabIndex_));\n      }\n    }\n  }\n\n  /**\n   * Called when the user starts interacting with the slider\n   */\n  private handleDown_(downEvent: MouseLikeEvent) {\n    if (this.disabled_) {\n      return;\n    }\n\n    this.preventFocusState_ = true;\n    this.setInTransit_(!this.handlingThumbTargetEvt_);\n    this.handlingThumbTargetEvt_ = false;\n    this.setActive_(true);\n\n    const moveHandler = (moveEvent: MouseLikeEvent) => {\n      this.handleMove_(moveEvent);\n    };\n\n    const moveEventType = MOVE_EVENT_MAP[downEvent.type as DownEventType];\n\n    // Note: upHandler is [de]registered on ALL potential pointer-related release event types, since some browsers\n    // do not always fire these consistently in pairs.\n    // (See https://github.com/material-components/material-components-web/issues/1192)\n    const upHandler = () => {\n      this.handleUp_();\n      this.adapter_.deregisterBodyInteractionHandler(moveEventType, moveHandler);\n      UP_EVENTS.forEach((evtName) => this.adapter_.deregisterBodyInteractionHandler(evtName, upHandler));\n    };\n\n    this.adapter_.registerBodyInteractionHandler(moveEventType, moveHandler);\n    UP_EVENTS.forEach((evtName) => this.adapter_.registerBodyInteractionHandler(evtName, upHandler));\n    this.setValueFromEvt_(downEvent);\n  }\n\n  /**\n   * Called when the user moves the slider\n   */\n  private handleMove_(evt: MouseLikeEvent) {\n    evt.preventDefault();\n    this.setValueFromEvt_(evt);\n  }\n\n  /**\n   * Called when the user's interaction with the slider ends\n   */\n  private handleUp_() {\n    this.setActive_(false);\n    this.adapter_.notifyChange();\n  }\n\n  /**\n   * Returns the pageX of the event\n   */\n  private getPageX_(evt: MouseLikeEvent): number {\n    if ((evt as TouchEvent).targetTouches && (evt as TouchEvent).targetTouches.length > 0) {\n      return (evt as TouchEvent).targetTouches[0].pageX;\n    }\n    return (evt as MouseEvent).pageX;\n  }\n\n  /**\n   * Sets the slider value from an event\n   */\n  private setValueFromEvt_(evt: MouseLikeEvent) {\n    const pageX = this.getPageX_(evt);\n    const value = this.computeValueFromPageX_(pageX);\n    this.setValue_(value, true);\n  }\n\n  /**\n   * Computes the new value from the pageX position\n   */\n  private computeValueFromPageX_(pageX: number): number {\n    const {max_: max, min_: min} = this;\n    const xPos = pageX - this.rect_.left;\n    let pctComplete = xPos / this.rect_.width;\n    if (this.adapter_.isRTL()) {\n      pctComplete = 1 - pctComplete;\n    }\n    // Fit the percentage complete between the range [min,max]\n    // by remapping from [0, 1] to [min, min+(max-min)].\n    return min + pctComplete * (max - min);\n  }\n\n  /**\n   * Handles keydown events\n   */\n  private handleKeydown_(evt: KeyboardEvent) {\n    const keyId = this.getKeyId_(evt);\n    const value = this.getValueForKeyId_(keyId);\n    if (isNaN(value)) {\n      return;\n    }\n\n    // Prevent page from scrolling due to key presses that would normally scroll the page\n    evt.preventDefault();\n    this.adapter_.addClass(cssClasses.FOCUS);\n    this.setValue_(value, true);\n    this.adapter_.notifyChange();\n  }\n\n  /**\n   * Returns the computed name of the event\n   */\n  private getKeyId_(kbdEvt: KeyboardEvent): string {\n    if (kbdEvt.key === KEY_IDS.ARROW_LEFT || kbdEvt.keyCode === 37) {\n      return KEY_IDS.ARROW_LEFT;\n    }\n    if (kbdEvt.key === KEY_IDS.ARROW_RIGHT || kbdEvt.keyCode === 39) {\n      return KEY_IDS.ARROW_RIGHT;\n    }\n    if (kbdEvt.key === KEY_IDS.ARROW_UP || kbdEvt.keyCode === 38) {\n      return KEY_IDS.ARROW_UP;\n    }\n    if (kbdEvt.key === KEY_IDS.ARROW_DOWN || kbdEvt.keyCode === 40) {\n      return KEY_IDS.ARROW_DOWN;\n    }\n    if (kbdEvt.key === KEY_IDS.HOME || kbdEvt.keyCode === 36) {\n      return KEY_IDS.HOME;\n    }\n    if (kbdEvt.key === KEY_IDS.END || kbdEvt.keyCode === 35) {\n      return KEY_IDS.END;\n    }\n    if (kbdEvt.key === KEY_IDS.PAGE_UP || kbdEvt.keyCode === 33) {\n      return KEY_IDS.PAGE_UP;\n    }\n    if (kbdEvt.key === KEY_IDS.PAGE_DOWN || kbdEvt.keyCode === 34) {\n      return KEY_IDS.PAGE_DOWN;\n    }\n    return '';\n  }\n\n  /**\n   * Computes the value given a keyboard key ID\n   */\n  private getValueForKeyId_(keyId: string): number {\n    const {max_: max, min_: min, step_: step} = this;\n    let delta = step || (max - min) / 100;\n    const valueNeedsToBeFlipped = this.adapter_.isRTL() && (\n        keyId === KEY_IDS.ARROW_LEFT || keyId === KEY_IDS.ARROW_RIGHT\n    );\n    if (valueNeedsToBeFlipped) {\n      delta = -delta;\n    }\n\n    switch (keyId) {\n      case KEY_IDS.ARROW_LEFT:\n      case KEY_IDS.ARROW_DOWN:\n        return this.value_ - delta;\n      case KEY_IDS.ARROW_RIGHT:\n      case KEY_IDS.ARROW_UP:\n        return this.value_ + delta;\n      case KEY_IDS.HOME:\n        return this.min_;\n      case KEY_IDS.END:\n        return this.max_;\n      case KEY_IDS.PAGE_UP:\n        return this.value_ + delta * numbers.PAGE_FACTOR;\n      case KEY_IDS.PAGE_DOWN:\n        return this.value_ - delta * numbers.PAGE_FACTOR;\n      default:\n        return NaN;\n    }\n  }\n\n  private handleFocus_() {\n    if (this.preventFocusState_) {\n      return;\n    }\n    this.adapter_.addClass(cssClasses.FOCUS);\n  }\n\n  private handleBlur_() {\n    this.preventFocusState_ = false;\n    this.adapter_.removeClass(cssClasses.FOCUS);\n  }\n\n  /**\n   * Sets the value of the slider\n   */\n  private setValue_(value: number, shouldFireInput: boolean, force = false) {\n    if (value === this.value_ && !force) {\n      return;\n    }\n\n    const {min_: min, max_: max} = this;\n    const valueSetToBoundary = value === min || value === max;\n    if (this.step_ && !valueSetToBoundary) {\n      value = this.quantize_(value);\n    }\n    if (value < min) {\n      value = min;\n    } else if (value > max) {\n      value = max;\n    }\n    this.value_ = value;\n    this.adapter_.setAttribute(strings.ARIA_VALUENOW, String(this.value_));\n    this.updateUIForCurrentValue_();\n\n    if (shouldFireInput) {\n      this.adapter_.notifyInput();\n      if (this.isDiscrete_) {\n        this.adapter_.setMarkerValue(value);\n      }\n    }\n  }\n\n  /**\n   * Calculates the quantized value\n   */\n  private quantize_(value: number): number {\n    const numSteps = Math.round(value / this.step_);\n    return numSteps * this.step_;\n  }\n\n  private updateUIForCurrentValue_() {\n    const {max_: max, min_: min, value_: value} = this;\n    const pctComplete = (value - min) / (max - min);\n    let translatePx = pctComplete * this.rect_.width;\n    if (this.adapter_.isRTL()) {\n      translatePx = this.rect_.width - translatePx;\n    }\n\n    const transformProp = getCorrectPropertyName(window, 'transform');\n    const transitionendEvtName = getCorrectEventName(window, 'transitionend') as EventType;\n\n    if (this.inTransit_) {\n      const onTransitionEnd = () => {\n        this.setInTransit_(false);\n        this.adapter_.deregisterThumbContainerInteractionHandler(transitionendEvtName, onTransitionEnd);\n      };\n      this.adapter_.registerThumbContainerInteractionHandler(transitionendEvtName, onTransitionEnd);\n    }\n\n    requestAnimationFrame(() => {\n      // NOTE(traviskaufman): It would be nice to use calc() here,\n      // but IE cannot handle calcs in transforms correctly.\n      // See: https://goo.gl/NC2itk\n      // Also note that the -50% offset is used to center the slider thumb.\n      this.adapter_.setThumbContainerStyleProperty(transformProp, `translateX(${translatePx}px) translateX(-50%)`);\n      this.adapter_.setTrackStyleProperty(transformProp, `scaleX(${pctComplete})`);\n    });\n  }\n\n  /**\n   * Toggles the active state of the slider\n   */\n  private setActive_(active: boolean) {\n    this.active_ = active;\n    this.toggleClass_(cssClasses.ACTIVE, this.active_);\n  }\n\n  /**\n   * Toggles the inTransit state of the slider\n   */\n  private setInTransit_(inTransit: boolean) {\n    this.inTransit_ = inTransit;\n    this.toggleClass_(cssClasses.IN_TRANSIT, this.inTransit_);\n  }\n\n  /**\n   * Conditionally adds or removes a class based on shouldBePresent\n   */\n  private toggleClass_(className: string, shouldBePresent: boolean) {\n    if (shouldBePresent) {\n      this.adapter_.addClass(className);\n    } else {\n      this.adapter_.removeClass(className);\n    }\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCSliderFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {closest} from '@material/dom/ponyfill';\nimport {MDCSnackbarAdapter} from './adapter';\nimport {strings} from './constants';\nimport {MDCSnackbarFoundation} from './foundation';\nimport {MDCSnackbarAnnouncer, MDCSnackbarAnnouncerFactory, MDCSnackbarCloseEventDetail} from './types';\nimport * as util from './util';\n\nconst {\n  SURFACE_SELECTOR, LABEL_SELECTOR, ACTION_SELECTOR, DISMISS_SELECTOR,\n  OPENING_EVENT, OPENED_EVENT, CLOSING_EVENT, CLOSED_EVENT,\n} = strings;\n\nexport class MDCSnackbar extends MDCComponent<MDCSnackbarFoundation> {\n  static attachTo(root: Element) {\n    return new MDCSnackbar(root);\n  }\n\n  private announce_!: MDCSnackbarAnnouncer; // assigned in initialize()\n\n  private actionEl_!: Element; // assigned in initialSyncWithDOM()\n  private labelEl_!: Element; // assigned in initialSyncWithDOM()\n  private surfaceEl_!: Element; // assigned in initialSyncWithDOM()\n\n  private handleKeyDown_!: SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n  private handleSurfaceClick_!: SpecificEventListener<'click'>; // assigned in initialSyncWithDOM()\n\n  initialize(announcerFactory: MDCSnackbarAnnouncerFactory = () => util.announce) {\n    this.announce_ = announcerFactory();\n  }\n\n  initialSyncWithDOM() {\n    this.surfaceEl_ = this.root_.querySelector(SURFACE_SELECTOR)!;\n    this.labelEl_ = this.root_.querySelector(LABEL_SELECTOR)!;\n    this.actionEl_ = this.root_.querySelector(ACTION_SELECTOR)!;\n\n    this.handleKeyDown_ = (evt) => this.foundation_.handleKeyDown(evt);\n    this.handleSurfaceClick_ = (evt) => {\n      const target = evt.target as Element;\n      if (this.isActionButton_(target)) {\n        this.foundation_.handleActionButtonClick(evt);\n      } else if (this.isActionIcon_(target)) {\n        this.foundation_.handleActionIconClick(evt);\n      }\n    };\n\n    this.registerKeyDownHandler_(this.handleKeyDown_);\n    this.registerSurfaceClickHandler_(this.handleSurfaceClick_);\n  }\n\n  destroy() {\n    super.destroy();\n    this.deregisterKeyDownHandler_(this.handleKeyDown_);\n    this.deregisterSurfaceClickHandler_(this.handleSurfaceClick_);\n  }\n\n  open() {\n    this.foundation_.open();\n  }\n\n  /**\n   * @param reason Why the snackbar was closed. Value will be passed to CLOSING_EVENT and CLOSED_EVENT via the\n   *     `event.detail.reason` property. Standard values are REASON_ACTION and REASON_DISMISS, but custom\n   *     client-specific values may also be used if desired.\n   */\n  close(reason = '') {\n    this.foundation_.close(reason);\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCSnackbarAdapter = {\n      addClass: (className) => this.root_.classList.add(className),\n      announce: () => this.announce_(this.labelEl_),\n      notifyClosed: (reason) => this.emit<MDCSnackbarCloseEventDetail>(CLOSED_EVENT, reason ? {reason} : {}),\n      notifyClosing: (reason) => this.emit<MDCSnackbarCloseEventDetail>(CLOSING_EVENT, reason ? {reason} : {}),\n      notifyOpened: () => this.emit(OPENED_EVENT, {}),\n      notifyOpening: () => this.emit(OPENING_EVENT, {}),\n      removeClass: (className) => this.root_.classList.remove(className),\n    };\n    return new MDCSnackbarFoundation(adapter);\n  }\n\n  get timeoutMs(): number {\n    return this.foundation_.getTimeoutMs();\n  }\n\n  set timeoutMs(timeoutMs: number) {\n    this.foundation_.setTimeoutMs(timeoutMs);\n  }\n\n  get closeOnEscape(): boolean {\n    return this.foundation_.getCloseOnEscape();\n  }\n\n  set closeOnEscape(closeOnEscape: boolean) {\n    this.foundation_.setCloseOnEscape(closeOnEscape);\n  }\n\n  get isOpen(): boolean {\n    return this.foundation_.isOpen();\n  }\n\n  get labelText(): string {\n    // This property only returns null if the node is a document, DOCTYPE, or notation.\n    // On Element nodes, it always returns a string.\n    return this.labelEl_.textContent!;\n  }\n\n  set labelText(labelText: string) {\n    this.labelEl_.textContent = labelText;\n  }\n\n  get actionButtonText(): string {\n    return this.actionEl_.textContent!;\n  }\n\n  set actionButtonText(actionButtonText: string) {\n    this.actionEl_.textContent = actionButtonText;\n  }\n\n  private registerKeyDownHandler_(handler: SpecificEventListener<'keydown'>) {\n    this.listen('keydown', handler);\n  }\n\n  private deregisterKeyDownHandler_(handler: SpecificEventListener<'keydown'>) {\n    this.unlisten('keydown', handler);\n  }\n\n  private registerSurfaceClickHandler_(handler: SpecificEventListener<'click'>) {\n    this.surfaceEl_.addEventListener('click', handler as EventListener);\n  }\n\n  private deregisterSurfaceClickHandler_(handler: SpecificEventListener<'click'>) {\n    this.surfaceEl_.removeEventListener('click', handler as EventListener);\n  }\n\n  private isActionButton_(target: Element): boolean {\n    return Boolean(closest(target, ACTION_SELECTOR));\n  }\n\n  private isActionIcon_(target: Element): boolean {\n    return Boolean(closest(target, DISMISS_SELECTOR));\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n  CLOSING: 'mdc-snackbar--closing',\n  OPEN: 'mdc-snackbar--open',\n  OPENING: 'mdc-snackbar--opening',\n};\n\nconst strings = {\n  ACTION_SELECTOR: '.mdc-snackbar__action',\n  ARIA_LIVE_LABEL_TEXT_ATTR: 'data-mdc-snackbar-label-text',\n  CLOSED_EVENT: 'MDCSnackbar:closed',\n  CLOSING_EVENT: 'MDCSnackbar:closing',\n  DISMISS_SELECTOR: '.mdc-snackbar__dismiss',\n  LABEL_SELECTOR: '.mdc-snackbar__label',\n  OPENED_EVENT: 'MDCSnackbar:opened',\n  OPENING_EVENT: 'MDCSnackbar:opening',\n  REASON_ACTION: 'action',\n  REASON_DISMISS: 'dismiss',\n  SURFACE_SELECTOR: '.mdc-snackbar__surface',\n};\n\nconst numbers = {\n  DEFAULT_AUTO_DISMISS_TIMEOUT_MS: 5000,\n  MAX_AUTO_DISMISS_TIMEOUT_MS: 10000,\n  MIN_AUTO_DISMISS_TIMEOUT_MS: 4000,\n\n  // These variables need to be kept in sync with the values in _variables.scss.\n  SNACKBAR_ANIMATION_CLOSE_TIME_MS: 75,\n  SNACKBAR_ANIMATION_OPEN_TIME_MS: 150,\n\n  /**\n   * Number of milliseconds to wait between temporarily clearing the label text\n   * in the DOM and subsequently restoring it. This is necessary to force IE 11\n   * to pick up the `aria-live` content change and announce it to the user.\n   */\n  ARIA_LIVE_DELAY_MS: 1000,\n};\n\nexport {cssClasses, strings, numbers};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCSnackbarAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\nconst {OPENING, OPEN, CLOSING} = cssClasses;\nconst {REASON_ACTION, REASON_DISMISS} = strings;\n\nexport class MDCSnackbarFoundation extends MDCFoundation<MDCSnackbarAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get numbers() {\n    return numbers;\n  }\n\n  static get defaultAdapter(): MDCSnackbarAdapter {\n    return {\n      addClass: () => undefined,\n      announce: () => undefined,\n      notifyClosed: () => undefined,\n      notifyClosing: () => undefined,\n      notifyOpened: () => undefined,\n      notifyOpening: () => undefined,\n      removeClass: () => undefined,\n    };\n  }\n\n  private isOpen_ = false;\n  private animationFrame_ = 0;\n  private animationTimer_ = 0;\n  private autoDismissTimer_ = 0;\n  private autoDismissTimeoutMs_ = numbers.DEFAULT_AUTO_DISMISS_TIMEOUT_MS;\n  private closeOnEscape_ = true;\n\n  constructor(adapter?: Partial<MDCSnackbarAdapter>) {\n    super({...MDCSnackbarFoundation.defaultAdapter, ...adapter});\n  }\n\n  destroy() {\n    this.clearAutoDismissTimer_();\n    cancelAnimationFrame(this.animationFrame_);\n    this.animationFrame_ = 0;\n    clearTimeout(this.animationTimer_);\n    this.animationTimer_ = 0;\n    this.adapter_.removeClass(OPENING);\n    this.adapter_.removeClass(OPEN);\n    this.adapter_.removeClass(CLOSING);\n  }\n\n  open() {\n    this.clearAutoDismissTimer_();\n    this.isOpen_ = true;\n    this.adapter_.notifyOpening();\n    this.adapter_.removeClass(CLOSING);\n    this.adapter_.addClass(OPENING);\n    this.adapter_.announce();\n\n    // Wait a frame once display is no longer \"none\", to establish basis for animation\n    this.runNextAnimationFrame_(() => {\n      this.adapter_.addClass(OPEN);\n\n      this.animationTimer_ = setTimeout(() => {\n        this.handleAnimationTimerEnd_();\n        this.adapter_.notifyOpened();\n        this.autoDismissTimer_ = setTimeout(() => {\n          this.close(REASON_DISMISS);\n        }, this.getTimeoutMs());\n      }, numbers.SNACKBAR_ANIMATION_OPEN_TIME_MS);\n    });\n  }\n\n  /**\n   * @param reason Why the snackbar was closed. Value will be passed to CLOSING_EVENT and CLOSED_EVENT via the\n   *     `event.detail.reason` property. Standard values are REASON_ACTION and REASON_DISMISS, but custom\n   *     client-specific values may also be used if desired.\n   */\n  close(reason = '') {\n    if (!this.isOpen_) {\n      // Avoid redundant close calls (and events), e.g. repeated interactions as the snackbar is animating closed\n      return;\n    }\n\n    cancelAnimationFrame(this.animationFrame_);\n    this.animationFrame_ = 0;\n    this.clearAutoDismissTimer_();\n\n    this.isOpen_ = false;\n    this.adapter_.notifyClosing(reason);\n    this.adapter_.addClass(cssClasses.CLOSING);\n    this.adapter_.removeClass(cssClasses.OPEN);\n    this.adapter_.removeClass(cssClasses.OPENING);\n\n    clearTimeout(this.animationTimer_);\n    this.animationTimer_ = setTimeout(() => {\n      this.handleAnimationTimerEnd_();\n      this.adapter_.notifyClosed(reason);\n    }, numbers.SNACKBAR_ANIMATION_CLOSE_TIME_MS);\n  }\n\n  isOpen(): boolean {\n    return this.isOpen_;\n  }\n\n  getTimeoutMs(): number {\n    return this.autoDismissTimeoutMs_;\n  }\n\n  setTimeoutMs(timeoutMs: number) {\n    // Use shorter variable names to make the code more readable\n    const minValue = numbers.MIN_AUTO_DISMISS_TIMEOUT_MS;\n    const maxValue = numbers.MAX_AUTO_DISMISS_TIMEOUT_MS;\n\n    if (timeoutMs <= maxValue && timeoutMs >= minValue) {\n      this.autoDismissTimeoutMs_ = timeoutMs;\n    } else {\n      throw new Error(`timeoutMs must be an integer in the range ${minValue}–${maxValue}, but got '${timeoutMs}'`);\n    }\n  }\n\n  getCloseOnEscape(): boolean {\n    return this.closeOnEscape_;\n  }\n\n  setCloseOnEscape(closeOnEscape: boolean) {\n    this.closeOnEscape_ = closeOnEscape;\n  }\n\n  handleKeyDown(evt: KeyboardEvent) {\n    const isEscapeKey = evt.key === 'Escape' || evt.keyCode === 27;\n    if (isEscapeKey && this.getCloseOnEscape()) {\n      this.close(REASON_DISMISS);\n    }\n  }\n\n  handleActionButtonClick(_evt: MouseEvent) {\n    this.close(REASON_ACTION);\n  }\n\n  handleActionIconClick(_evt: MouseEvent) {\n    this.close(REASON_DISMISS);\n  }\n\n  private clearAutoDismissTimer_() {\n    clearTimeout(this.autoDismissTimer_);\n    this.autoDismissTimer_ = 0;\n  }\n\n  private handleAnimationTimerEnd_() {\n    this.animationTimer_ = 0;\n    this.adapter_.removeClass(cssClasses.OPENING);\n    this.adapter_.removeClass(cssClasses.CLOSING);\n  }\n\n  /**\n   * Runs the given logic on the next animation frame, using setTimeout to factor in Firefox reflow behavior.\n   */\n  private runNextAnimationFrame_(callback: () => void) {\n    cancelAnimationFrame(this.animationFrame_);\n    this.animationFrame_ = requestAnimationFrame(() => {\n      this.animationFrame_ = 0;\n      clearTimeout(this.animationTimer_);\n      this.animationTimer_ = setTimeout(callback, 0);\n    });\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCSnackbarFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport * as util from './util';\n\nexport {util};\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {numbers, strings} from './constants';\n\nconst {ARIA_LIVE_DELAY_MS} = numbers;\nconst {ARIA_LIVE_LABEL_TEXT_ATTR} = strings;\n\nfunction announce(ariaEl: Element, labelEl: Element = ariaEl) {\n  const priority = ariaEl.getAttribute('aria-live');\n\n  // Trim text to ignore `&nbsp;` (see below).\n  // textContent is only null if the node is a document, DOCTYPE, or notation.\n  const labelText = labelEl.textContent!.trim();\n  if (!labelText || !priority) {\n    return;\n  }\n\n  // Temporarily disable `aria-live` to prevent JAWS+Firefox from announcing the message twice.\n  ariaEl.setAttribute('aria-live', 'off');\n\n  // Temporarily clear `textContent` to force a DOM mutation event that will be detected by screen readers.\n  // `aria-live` elements are only announced when the element's `textContent` *changes*, so snackbars\n  // sent to the browser in the initial HTML response won't be read unless we clear the element's `textContent` first.\n  // Similarly, displaying the same snackbar message twice in a row doesn't trigger a DOM mutation event,\n  // so screen readers won't announce the second message unless we first clear `textContent`.\n  //\n  // We have to clear the label text two different ways to make it work in all browsers and screen readers:\n  //\n  //   1. `textContent = ''` is required for IE11 + JAWS\n  //   2. `innerHTML = '&nbsp;'` is required for Chrome + JAWS and NVDA\n  //\n  // All other browser/screen reader combinations support both methods.\n  //\n  // The wrapper `<span>` visually hides the space character so that it doesn't cause jank when added/removed.\n  // N.B.: Setting `position: absolute`, `opacity: 0`, or `height: 0` prevents Chrome from detecting the DOM change.\n  //\n  // This technique has been tested in:\n  //\n  //   * JAWS 2019:\n  //       - Chrome 70\n  //       - Firefox 60 (ESR)\n  //       - IE 11\n  //   * NVDA 2018:\n  //       - Chrome 70\n  //       - Firefox 60 (ESR)\n  //       - IE 11\n  //   * ChromeVox 53\n  labelEl.textContent = '';\n  labelEl.innerHTML = '<span style=\"display: inline-block; width: 0; height: 1px;\">&nbsp;</span>';\n\n  // Prevent visual jank by temporarily displaying the label text in the ::before pseudo-element.\n  // CSS generated content is normally announced by screen readers\n  // (except in IE 11; see https://tink.uk/accessibility-support-for-css-generated-content/);\n  // however, `aria-live` is turned off, so this DOM update will be ignored by screen readers.\n  labelEl.setAttribute(ARIA_LIVE_LABEL_TEXT_ATTR, labelText);\n\n  setTimeout(() => {\n    // Allow screen readers to announce changes to the DOM again.\n    ariaEl.setAttribute('aria-live', priority);\n\n    // Remove the message from the ::before pseudo-element.\n    labelEl.removeAttribute(ARIA_LIVE_LABEL_TEXT_ATTR);\n\n    // Restore the original label text, which will be announced by screen readers.\n    labelEl.textContent = labelText;\n  }, ARIA_LIVE_DELAY_MS);\n}\n\nexport {announce};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {EventType} from '@material/base/types';\nimport {applyPassive} from '@material/dom/events';\nimport {matches} from '@material/dom/ponyfill';\nimport {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\nimport {MDCSwitchAdapter} from './adapter';\nimport {MDCSwitchFoundation} from './foundation';\n\nexport class MDCSwitch extends MDCComponent<MDCSwitchFoundation> implements MDCRippleCapableSurface {\n  static attachTo(root: HTMLElement) {\n    return new MDCSwitch(root);\n  }\n\n  // Public visibility for this property is required by MDCRippleCapableSurface.\n  root_!: Element; // assigned in MDCComponent constructor\n\n  private readonly ripple_ = this.createRipple_();\n\n  // Initialized in `initialSyncWithDOM`.\n  private changeHandler_!: EventListener;\n\n  destroy() {\n    super.destroy();\n    this.ripple_.destroy();\n    this.nativeControl_.removeEventListener('change', this.changeHandler_);\n  }\n\n  initialSyncWithDOM() {\n    this.changeHandler_ = (...args) => this.foundation_.handleChange(...args);\n    this.nativeControl_.addEventListener('change', this.changeHandler_);\n\n    // Sometimes the checked state of the input element is saved in the history.\n    // The switch styling should match the checked state of the input element.\n    // Do an initial sync between the native control and the foundation.\n    this.checked = this.checked;\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCSwitchAdapter = {\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      setNativeControlChecked: (checked) => this.nativeControl_.checked = checked,\n      setNativeControlDisabled: (disabled) => this.nativeControl_.disabled = disabled,\n    };\n    return new MDCSwitchFoundation(adapter);\n  }\n\n  get ripple() {\n    return this.ripple_;\n  }\n\n  get checked() {\n    return this.nativeControl_.checked;\n  }\n\n  set checked(checked) {\n    this.foundation_.setChecked(checked);\n  }\n\n  get disabled() {\n    return this.nativeControl_.disabled;\n  }\n\n  set disabled(disabled) {\n    this.foundation_.setDisabled(disabled);\n  }\n\n  private createRipple_(): MDCRipple {\n    const {RIPPLE_SURFACE_SELECTOR} = MDCSwitchFoundation.strings;\n    const rippleSurface = this.root_.querySelector(RIPPLE_SURFACE_SELECTOR) as HTMLElement;\n\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCRippleAdapter = {\n      ...MDCRipple.createAdapter(this),\n      addClass: (className: string) => rippleSurface.classList.add(className),\n      computeBoundingRect: () => rippleSurface.getBoundingClientRect(),\n      deregisterInteractionHandler: (evtType: EventType, handler: EventListener) => {\n        this.nativeControl_.removeEventListener(evtType, handler, applyPassive());\n      },\n      isSurfaceActive: () => matches(this.nativeControl_, ':active'),\n      isUnbounded: () => true,\n      registerInteractionHandler: (evtType: EventType, handler: EventListener) => {\n        this.nativeControl_.addEventListener(evtType, handler, applyPassive());\n      },\n      removeClass: (className: string) => rippleSurface.classList.remove(className),\n      updateCssVariable: (varName: string, value: string) => {\n        rippleSurface.style.setProperty(varName, value);\n      },\n    };\n    return new MDCRipple(this.root_, new MDCRippleFoundation(adapter));\n  }\n\n  private get nativeControl_() {\n    const {NATIVE_CONTROL_SELECTOR} = MDCSwitchFoundation.strings;\n    return this.root_.querySelector(NATIVE_CONTROL_SELECTOR) as HTMLInputElement;\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n/** CSS classes used by the switch. */\nconst cssClasses = {\n  /** Class used for a switch that is in the \"checked\" (on) position. */\n  CHECKED: 'mdc-switch--checked',\n  /** Class used for a switch that is disabled. */\n  DISABLED: 'mdc-switch--disabled',\n};\n\n/** String constants used by the switch. */\nconst strings = {\n  /** A CSS selector used to locate the native HTML control for the switch.  */\n  NATIVE_CONTROL_SELECTOR: '.mdc-switch__native-control',\n  /** A CSS selector used to locate the ripple surface element for the switch. */\n  RIPPLE_SURFACE_SELECTOR: '.mdc-switch__thumb-underlay',\n};\n\nexport {cssClasses, strings};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCSwitchAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCSwitchFoundation extends MDCFoundation<MDCSwitchAdapter> {\n  /** The string constants used by the switch. */\n  static get strings() {\n    return strings;\n  }\n\n  /** The CSS classes used by the switch. */\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  /** The default Adapter for the switch. */\n  static get defaultAdapter(): MDCSwitchAdapter {\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      setNativeControlChecked: () => undefined,\n      setNativeControlDisabled: () => undefined,\n    };\n  }\n\n  constructor(adapter?: Partial<MDCSwitchAdapter>) {\n    super({...MDCSwitchFoundation.defaultAdapter, ...adapter});\n  }\n\n  /** Sets the checked state of the switch. */\n  setChecked(checked: boolean) {\n    this.adapter_.setNativeControlChecked(checked);\n    this.updateCheckedStyling_(checked);\n  }\n\n  /** Sets the disabled state of the switch. */\n  setDisabled(disabled: boolean) {\n    this.adapter_.setNativeControlDisabled(disabled);\n    if (disabled) {\n      this.adapter_.addClass(cssClasses.DISABLED);\n    } else {\n      this.adapter_.removeClass(cssClasses.DISABLED);\n    }\n  }\n\n  /** Handles the change event for the switch native control. */\n  handleChange(evt: Event) {\n    const nativeControl = evt.target as HTMLInputElement;\n    this.updateCheckedStyling_(nativeControl.checked);\n  }\n\n  /** Updates the styling of the switch based on its checked state. */\n  private updateCheckedStyling_(checked: boolean) {\n    if (checked) {\n      this.adapter_.addClass(cssClasses.CHECKED);\n    } else {\n      this.adapter_.removeClass(cssClasses.CHECKED);\n    }\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCSwitchFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {CustomEventListener, SpecificEventListener} from '@material/base/types';\nimport {MDCTabScroller, MDCTabScrollerFactory} from '@material/tab-scroller/component';\nimport {MDCTab, MDCTabFactory} from '@material/tab/component';\nimport {MDCTabFoundation} from '@material/tab/foundation';\nimport {MDCTabInteractionEvent} from '@material/tab/types';\nimport {MDCTabBarAdapter} from './adapter';\nimport {MDCTabBarFoundation} from './foundation';\nimport {MDCTabBarActivatedEventDetail} from './types';\n\nconst {strings} = MDCTabBarFoundation;\n\nlet tabIdCounter = 0;\n\nexport class MDCTabBar extends MDCComponent<MDCTabBarFoundation> {\n  static attachTo(root: Element): MDCTabBar {\n    return new MDCTabBar(root);\n  }\n\n  private tabList_!: MDCTab[]; // assigned in initialize()\n  private tabScroller_!: MDCTabScroller | null; // assigned in initialize()\n  private handleTabInteraction_!: CustomEventListener<MDCTabInteractionEvent>; // assigned in initialSyncWithDOM()\n  private handleKeyDown_!: SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n\n  set focusOnActivate(focusOnActivate: boolean) {\n    this.tabList_.forEach((tab) => tab.focusOnActivate = focusOnActivate);\n  }\n\n  set useAutomaticActivation(useAutomaticActivation: boolean) {\n    this.foundation_.setUseAutomaticActivation(useAutomaticActivation);\n  }\n\n  initialize(\n      tabFactory: MDCTabFactory = (el) => new MDCTab(el),\n      tabScrollerFactory: MDCTabScrollerFactory = (el) => new MDCTabScroller(el),\n  ) {\n    this.tabList_ = this.instantiateTabs_(tabFactory);\n    this.tabScroller_ = this.instantiateTabScroller_(tabScrollerFactory);\n  }\n\n  initialSyncWithDOM() {\n    this.handleTabInteraction_ = (evt) => this.foundation_.handleTabInteraction(evt);\n    this.handleKeyDown_ = (evt) => this.foundation_.handleKeyDown(evt);\n\n    this.listen(MDCTabFoundation.strings.INTERACTED_EVENT, this.handleTabInteraction_);\n    this.listen('keydown', this.handleKeyDown_);\n\n    for (let i = 0; i < this.tabList_.length; i++) {\n      if (this.tabList_[i].active) {\n        this.scrollIntoView(i);\n        break;\n      }\n    }\n  }\n\n  destroy() {\n    super.destroy();\n    this.unlisten(MDCTabFoundation.strings.INTERACTED_EVENT, this.handleTabInteraction_);\n    this.unlisten('keydown', this.handleKeyDown_);\n    this.tabList_.forEach((tab) => tab.destroy());\n\n    if (this.tabScroller_) {\n      this.tabScroller_.destroy();\n    }\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCTabBarAdapter = {\n      scrollTo: (scrollX) => this.tabScroller_!.scrollTo(scrollX),\n      incrementScroll: (scrollXIncrement) => this.tabScroller_!.incrementScroll(scrollXIncrement),\n      getScrollPosition: () => this.tabScroller_!.getScrollPosition(),\n      getScrollContentWidth: () => this.tabScroller_!.getScrollContentWidth(),\n      getOffsetWidth: () => (this.root_ as HTMLElement).offsetWidth,\n      isRTL: () => window.getComputedStyle(this.root_).getPropertyValue('direction') === 'rtl',\n      setActiveTab: (index) => this.foundation_.activateTab(index),\n      activateTabAtIndex: (index, clientRect) => this.tabList_[index].activate(clientRect),\n      deactivateTabAtIndex: (index) => this.tabList_[index].deactivate(),\n      focusTabAtIndex: (index) => this.tabList_[index].focus(),\n      getTabIndicatorClientRectAtIndex: (index) => this.tabList_[index].computeIndicatorClientRect(),\n      getTabDimensionsAtIndex: (index) => this.tabList_[index].computeDimensions(),\n      getPreviousActiveTabIndex: () => {\n        for (let i = 0; i < this.tabList_.length; i++) {\n          if (this.tabList_[i].active) {\n            return i;\n          }\n        }\n        return -1;\n      },\n      getFocusedTabIndex: () => {\n        const tabElements = this.getTabElements_();\n        const activeElement = document.activeElement!;\n        return tabElements.indexOf(activeElement);\n      },\n      getIndexOfTabById: (id) => {\n        for (let i = 0; i < this.tabList_.length; i++) {\n          if (this.tabList_[i].id === id) {\n            return i;\n          }\n        }\n        return -1;\n      },\n      getTabListLength: () => this.tabList_.length,\n      notifyTabActivated: (index) =>\n          this.emit<MDCTabBarActivatedEventDetail>(strings.TAB_ACTIVATED_EVENT, {index}, true),\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCTabBarFoundation(adapter);\n  }\n\n  /**\n   * Activates the tab at the given index\n   * @param index The index of the tab\n   */\n  activateTab(index: number) {\n    this.foundation_.activateTab(index);\n  }\n\n  /**\n   * Scrolls the tab at the given index into view\n   * @param index THe index of the tab\n   */\n  scrollIntoView(index: number) {\n    this.foundation_.scrollIntoView(index);\n  }\n\n  /**\n   * Returns all the tab elements in a nice clean array\n   */\n  private getTabElements_(): Element[] {\n    return [].slice.call(this.root_.querySelectorAll(strings.TAB_SELECTOR));\n  }\n\n  /**\n   * Instantiates tab components on all child tab elements\n   */\n  private instantiateTabs_(tabFactory: MDCTabFactory) {\n    return this.getTabElements_().map((el) => {\n      el.id = el.id || `mdc-tab-${++tabIdCounter}`;\n      return tabFactory(el);\n    });\n  }\n\n  /**\n   * Instantiates tab scroller component on the child tab scroller element\n   */\n  private instantiateTabScroller_(tabScrollerFactory: MDCTabScrollerFactory): MDCTabScroller | null {\n    const tabScrollerElement = this.root_.querySelector(strings.TAB_SCROLLER_SELECTOR);\n    if (tabScrollerElement) {\n      return tabScrollerFactory(tabScrollerElement);\n    }\n    return null;\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst strings = {\n  ARROW_LEFT_KEY: 'ArrowLeft',\n  ARROW_RIGHT_KEY: 'ArrowRight',\n  END_KEY: 'End',\n  ENTER_KEY: 'Enter',\n  HOME_KEY: 'Home',\n  SPACE_KEY: 'Space',\n  TAB_ACTIVATED_EVENT: 'MDCTabBar:activated',\n  TAB_SCROLLER_SELECTOR: '.mdc-tab-scroller',\n  TAB_SELECTOR: '.mdc-tab',\n};\n\nconst numbers = {\n  ARROW_LEFT_KEYCODE: 37,\n  ARROW_RIGHT_KEYCODE: 39,\n  END_KEYCODE: 35,\n  ENTER_KEYCODE: 13,\n  EXTRA_SCROLL_AMOUNT: 20,\n  HOME_KEYCODE: 36,\n  SPACE_KEYCODE: 32,\n};\n\nexport {numbers, strings};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCTabDimensions, MDCTabInteractionEvent} from '@material/tab/types';\nimport {MDCTabBarAdapter} from './adapter';\nimport {numbers, strings} from './constants';\n\nconst ACCEPTABLE_KEYS = new Set<string>();\n// IE11 has no support for new Set with iterable so we need to initialize this by hand\nACCEPTABLE_KEYS.add(strings.ARROW_LEFT_KEY);\nACCEPTABLE_KEYS.add(strings.ARROW_RIGHT_KEY);\nACCEPTABLE_KEYS.add(strings.END_KEY);\nACCEPTABLE_KEYS.add(strings.HOME_KEY);\nACCEPTABLE_KEYS.add(strings.ENTER_KEY);\nACCEPTABLE_KEYS.add(strings.SPACE_KEY);\n\nconst KEYCODE_MAP = new Map<number, string>();\n// IE11 has no support for new Map with iterable so we need to initialize this by hand\nKEYCODE_MAP.set(numbers.ARROW_LEFT_KEYCODE, strings.ARROW_LEFT_KEY);\nKEYCODE_MAP.set(numbers.ARROW_RIGHT_KEYCODE, strings.ARROW_RIGHT_KEY);\nKEYCODE_MAP.set(numbers.END_KEYCODE, strings.END_KEY);\nKEYCODE_MAP.set(numbers.HOME_KEYCODE, strings.HOME_KEY);\nKEYCODE_MAP.set(numbers.ENTER_KEYCODE, strings.ENTER_KEY);\nKEYCODE_MAP.set(numbers.SPACE_KEYCODE, strings.SPACE_KEY);\n\nexport class MDCTabBarFoundation extends MDCFoundation<MDCTabBarAdapter> {\n  static get strings() {\n    return strings;\n  }\n\n  static get numbers() {\n    return numbers;\n  }\n\n  static get defaultAdapter(): MDCTabBarAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      scrollTo: () => undefined,\n      incrementScroll: () => undefined,\n      getScrollPosition: () => 0,\n      getScrollContentWidth: () => 0,\n      getOffsetWidth: () => 0,\n      isRTL: () => false,\n      setActiveTab: () => undefined,\n      activateTabAtIndex: () => undefined,\n      deactivateTabAtIndex: () => undefined,\n      focusTabAtIndex: () => undefined,\n      getTabIndicatorClientRectAtIndex: () => ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0}),\n      getTabDimensionsAtIndex: () => ({rootLeft: 0, rootRight: 0, contentLeft: 0, contentRight: 0}),\n      getPreviousActiveTabIndex: () => -1,\n      getFocusedTabIndex: () => -1,\n      getIndexOfTabById: () => -1,\n      getTabListLength: () => 0,\n      notifyTabActivated: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private useAutomaticActivation_ = false;\n\n  constructor(adapter?: Partial<MDCTabBarAdapter>) {\n    super({...MDCTabBarFoundation.defaultAdapter, ...adapter});\n  }\n\n  /**\n   * Switches between automatic and manual activation modes.\n   * See https://www.w3.org/TR/wai-aria-practices/#tabpanel for examples.\n   */\n  setUseAutomaticActivation(useAutomaticActivation: boolean) {\n    this.useAutomaticActivation_ = useAutomaticActivation;\n  }\n\n  activateTab(index: number) {\n    const previousActiveIndex = this.adapter_.getPreviousActiveTabIndex();\n    if (!this.indexIsInRange_(index) || index === previousActiveIndex) {\n      return;\n    }\n\n    let previousClientRect;\n    if (previousActiveIndex !== -1) {\n      this.adapter_.deactivateTabAtIndex(previousActiveIndex);\n      previousClientRect = this.adapter_.getTabIndicatorClientRectAtIndex(previousActiveIndex);\n    }\n\n    this.adapter_.activateTabAtIndex(index, previousClientRect);\n    this.scrollIntoView(index);\n\n    this.adapter_.notifyTabActivated(index);\n  }\n\n  handleKeyDown(evt: KeyboardEvent) {\n    // Get the key from the event\n    const key = this.getKeyFromEvent_(evt);\n\n    // Early exit if the event key isn't one of the keyboard navigation keys\n    if (key === undefined) {\n      return;\n    }\n\n    // Prevent default behavior for movement keys, but not for activation keys, since :active is used to apply ripple\n    if (!this.isActivationKey_(key)) {\n      evt.preventDefault();\n    }\n\n    if (this.useAutomaticActivation_) {\n      if (this.isActivationKey_(key)) {\n        return;\n      }\n\n      const index = this.determineTargetFromKey_(this.adapter_.getPreviousActiveTabIndex(), key);\n      this.adapter_.setActiveTab(index);\n      this.scrollIntoView(index);\n    } else {\n      const focusedTabIndex = this.adapter_.getFocusedTabIndex();\n      if (this.isActivationKey_(key)) {\n        this.adapter_.setActiveTab(focusedTabIndex);\n      } else {\n        const index = this.determineTargetFromKey_(focusedTabIndex, key);\n        this.adapter_.focusTabAtIndex(index);\n        this.scrollIntoView(index);\n      }\n    }\n  }\n\n  /**\n   * Handles the MDCTab:interacted event\n   */\n  handleTabInteraction(evt: MDCTabInteractionEvent) {\n    this.adapter_.setActiveTab(this.adapter_.getIndexOfTabById(evt.detail.tabId));\n  }\n\n  /**\n   * Scrolls the tab at the given index into view\n   * @param index The tab index to make visible\n   */\n  scrollIntoView(index: number) {\n    // Early exit if the index is out of range\n    if (!this.indexIsInRange_(index)) {\n      return;\n    }\n\n    // Always scroll to 0 if scrolling to the 0th index\n    if (index === 0) {\n      return this.adapter_.scrollTo(0);\n    }\n\n    // Always scroll to the max value if scrolling to the Nth index\n    // MDCTabScroller.scrollTo() will never scroll past the max possible value\n    if (index === this.adapter_.getTabListLength() - 1) {\n      return this.adapter_.scrollTo(this.adapter_.getScrollContentWidth());\n    }\n\n    if (this.isRTL_()) {\n      return this.scrollIntoViewRTL_(index);\n    }\n\n    this.scrollIntoView_(index);\n  }\n\n  /**\n   * Private method for determining the index of the destination tab based on what key was pressed\n   * @param origin The original index from which to determine the destination\n   * @param key The name of the key\n   */\n  private determineTargetFromKey_(origin: number, key: string): number {\n    const isRTL = this.isRTL_();\n    const maxIndex = this.adapter_.getTabListLength() - 1;\n    const shouldGoToEnd = key === strings.END_KEY;\n    const shouldDecrement = key === strings.ARROW_LEFT_KEY && !isRTL || key === strings.ARROW_RIGHT_KEY && isRTL;\n    const shouldIncrement = key === strings.ARROW_RIGHT_KEY && !isRTL || key === strings.ARROW_LEFT_KEY && isRTL;\n    let index = origin;\n\n    if (shouldGoToEnd) {\n      index = maxIndex;\n    } else if (shouldDecrement) {\n      index -= 1;\n    } else if (shouldIncrement) {\n      index += 1;\n    } else {\n      index = 0;\n    }\n\n    if (index < 0) {\n      index = maxIndex;\n    } else if (index > maxIndex) {\n      index = 0;\n    }\n\n    return index;\n  }\n\n  /**\n   * Calculates the scroll increment that will make the tab at the given index visible\n   * @param index The index of the tab\n   * @param nextIndex The index of the next tab\n   * @param scrollPosition The current scroll position\n   * @param barWidth The width of the Tab Bar\n   */\n  private calculateScrollIncrement_(\n      index: number,\n      nextIndex: number,\n      scrollPosition: number,\n      barWidth: number,\n  ): number {\n    const nextTabDimensions = this.adapter_.getTabDimensionsAtIndex(nextIndex);\n    const relativeContentLeft = nextTabDimensions.contentLeft - scrollPosition - barWidth;\n    const relativeContentRight = nextTabDimensions.contentRight - scrollPosition;\n    const leftIncrement = relativeContentRight - numbers.EXTRA_SCROLL_AMOUNT;\n    const rightIncrement = relativeContentLeft + numbers.EXTRA_SCROLL_AMOUNT;\n\n    if (nextIndex < index) {\n      return Math.min(leftIncrement, 0);\n    }\n\n    return Math.max(rightIncrement, 0);\n  }\n\n  /**\n   * Calculates the scroll increment that will make the tab at the given index visible in RTL\n   * @param index The index of the tab\n   * @param nextIndex The index of the next tab\n   * @param scrollPosition The current scroll position\n   * @param barWidth The width of the Tab Bar\n   * @param scrollContentWidth The width of the scroll content\n   */\n  private calculateScrollIncrementRTL_(\n      index: number,\n      nextIndex: number,\n      scrollPosition: number,\n      barWidth: number,\n      scrollContentWidth: number,\n  ): number {\n    const nextTabDimensions = this.adapter_.getTabDimensionsAtIndex(nextIndex);\n    const relativeContentLeft = scrollContentWidth - nextTabDimensions.contentLeft - scrollPosition;\n    const relativeContentRight = scrollContentWidth - nextTabDimensions.contentRight - scrollPosition - barWidth;\n    const leftIncrement = relativeContentRight + numbers.EXTRA_SCROLL_AMOUNT;\n    const rightIncrement = relativeContentLeft - numbers.EXTRA_SCROLL_AMOUNT;\n\n    if (nextIndex > index) {\n      return Math.max(leftIncrement, 0);\n    }\n\n    return Math.min(rightIncrement, 0);\n  }\n\n  /**\n   * Determines the index of the adjacent tab closest to either edge of the Tab Bar\n   * @param index The index of the tab\n   * @param tabDimensions The dimensions of the tab\n   * @param scrollPosition The current scroll position\n   * @param barWidth The width of the tab bar\n   */\n  private findAdjacentTabIndexClosestToEdge_(\n      index: number,\n      tabDimensions: MDCTabDimensions,\n      scrollPosition: number,\n      barWidth: number,\n  ): number {\n    /**\n     * Tabs are laid out in the Tab Scroller like this:\n     *\n     *    Scroll Position\n     *    +---+\n     *    |   |   Bar Width\n     *    |   +-----------------------------------+\n     *    |   |                                   |\n     *    |   V                                   V\n     *    |   +-----------------------------------+\n     *    V   |             Tab Scroller          |\n     *    +------------+--------------+-------------------+\n     *    |    Tab     |      Tab     |        Tab        |\n     *    +------------+--------------+-------------------+\n     *        |                                   |\n     *        +-----------------------------------+\n     *\n     * To determine the next adjacent index, we look at the Tab root left and\n     * Tab root right, both relative to the scroll position. If the Tab root\n     * left is less than 0, then we know it's out of view to the left. If the\n     * Tab root right minus the bar width is greater than 0, we know the Tab is\n     * out of view to the right. From there, we either increment or decrement\n     * the index.\n     */\n    const relativeRootLeft = tabDimensions.rootLeft - scrollPosition;\n    const relativeRootRight = tabDimensions.rootRight - scrollPosition - barWidth;\n    const relativeRootDelta = relativeRootLeft + relativeRootRight;\n    const leftEdgeIsCloser = relativeRootLeft < 0 || relativeRootDelta < 0;\n    const rightEdgeIsCloser = relativeRootRight > 0 || relativeRootDelta > 0;\n\n    if (leftEdgeIsCloser) {\n      return index - 1;\n    }\n\n    if (rightEdgeIsCloser) {\n      return index + 1;\n    }\n\n    return -1;\n  }\n\n  /**\n   * Determines the index of the adjacent tab closest to either edge of the Tab Bar in RTL\n   * @param index The index of the tab\n   * @param tabDimensions The dimensions of the tab\n   * @param scrollPosition The current scroll position\n   * @param barWidth The width of the tab bar\n   * @param scrollContentWidth The width of the scroller content\n   */\n  private findAdjacentTabIndexClosestToEdgeRTL_(\n      index: number,\n      tabDimensions: MDCTabDimensions,\n      scrollPosition: number,\n      barWidth: number,\n      scrollContentWidth: number,\n  ): number {\n    const rootLeft = scrollContentWidth - tabDimensions.rootLeft - barWidth - scrollPosition;\n    const rootRight = scrollContentWidth - tabDimensions.rootRight - scrollPosition;\n    const rootDelta = rootLeft + rootRight;\n    const leftEdgeIsCloser = rootLeft > 0 || rootDelta > 0;\n    const rightEdgeIsCloser = rootRight < 0 || rootDelta < 0;\n\n    if (leftEdgeIsCloser) {\n      return index + 1;\n    }\n\n    if (rightEdgeIsCloser) {\n      return index - 1;\n    }\n\n    return -1;\n  }\n\n  /**\n   * Returns the key associated with a keydown event\n   * @param evt The keydown event\n   */\n  private getKeyFromEvent_(evt: KeyboardEvent): string {\n    if (ACCEPTABLE_KEYS.has(evt.key)) {\n      return evt.key;\n    }\n    return KEYCODE_MAP.get(evt.keyCode)!;\n  }\n\n  private isActivationKey_(key: string) {\n    return key === strings.SPACE_KEY || key === strings.ENTER_KEY;\n  }\n\n  /**\n   * Returns whether a given index is inclusively between the ends\n   * @param index The index to test\n   */\n  private indexIsInRange_(index: number) {\n    return index >= 0 && index < this.adapter_.getTabListLength();\n  }\n\n  /**\n   * Returns the view's RTL property\n   */\n  private isRTL_(): boolean {\n    return this.adapter_.isRTL();\n  }\n\n  /**\n   * Scrolls the tab at the given index into view for left-to-right user agents.\n   * @param index The index of the tab to scroll into view\n   */\n  private scrollIntoView_(index: number) {\n    const scrollPosition = this.adapter_.getScrollPosition();\n    const barWidth = this.adapter_.getOffsetWidth();\n    const tabDimensions = this.adapter_.getTabDimensionsAtIndex(index);\n    const nextIndex = this.findAdjacentTabIndexClosestToEdge_(index, tabDimensions, scrollPosition, barWidth);\n\n    if (!this.indexIsInRange_(nextIndex)) {\n      return;\n    }\n\n    const scrollIncrement = this.calculateScrollIncrement_(index, nextIndex, scrollPosition, barWidth);\n    this.adapter_.incrementScroll(scrollIncrement);\n  }\n\n  /**\n   * Scrolls the tab at the given index into view in RTL\n   * @param index The tab index to make visible\n   */\n  private scrollIntoViewRTL_(index: number) {\n    const scrollPosition = this.adapter_.getScrollPosition();\n    const barWidth = this.adapter_.getOffsetWidth();\n    const tabDimensions = this.adapter_.getTabDimensionsAtIndex(index);\n    const scrollWidth = this.adapter_.getScrollContentWidth();\n    const nextIndex = this.findAdjacentTabIndexClosestToEdgeRTL_(\n        index, tabDimensions, scrollPosition, barWidth, scrollWidth);\n\n    if (!this.indexIsInRange_(nextIndex)) {\n      return;\n    }\n\n    const scrollIncrement = this.calculateScrollIncrementRTL_(index, nextIndex, scrollPosition, barWidth, scrollWidth);\n    this.adapter_.incrementScroll(scrollIncrement);\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabBarFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\n\nimport {MDCTabIndicatorAdapter} from './adapter';\nimport {MDCFadingTabIndicatorFoundation} from './fading-foundation';\nimport {MDCTabIndicatorFoundation} from './foundation';\nimport {MDCSlidingTabIndicatorFoundation} from './sliding-foundation';\n\nexport type MDCTabIndicatorFactory = (el: Element, foundation?: MDCTabIndicatorFoundation) => MDCTabIndicator;\n\nexport class MDCTabIndicator extends MDCComponent<MDCTabIndicatorFoundation> {\n  static attachTo(root: Element): MDCTabIndicator {\n    return new MDCTabIndicator(root);\n  }\n\n  private content_!: HTMLElement; // assigned in initialize()\n\n  initialize() {\n    this.content_ = this.root_.querySelector<HTMLElement>(MDCTabIndicatorFoundation.strings.CONTENT_SELECTOR)!;\n  }\n\n  computeContentClientRect(): ClientRect {\n    return this.foundation_.computeContentClientRect();\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCTabIndicatorAdapter = {\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      computeContentClientRect: () => this.content_.getBoundingClientRect(),\n      setContentStyleProperty: (prop, value) => this.content_.style.setProperty(prop, value),\n    };\n    // tslint:enable:object-literal-sort-keys\n\n    if (this.root_.classList.contains(MDCTabIndicatorFoundation.cssClasses.FADE)) {\n      return new MDCFadingTabIndicatorFoundation(adapter);\n    }\n\n    // Default to the sliding indicator\n    return new MDCSlidingTabIndicatorFoundation(adapter);\n  }\n\n  activate(previousIndicatorClientRect?: ClientRect) {\n    this.foundation_.activate(previousIndicatorClientRect);\n  }\n\n  deactivate() {\n    this.foundation_.deactivate();\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n  ACTIVE: 'mdc-tab-indicator--active',\n  FADE: 'mdc-tab-indicator--fade',\n  NO_TRANSITION: 'mdc-tab-indicator--no-transition',\n};\n\nconst strings = {\n  CONTENT_SELECTOR: '.mdc-tab-indicator__content',\n};\n\nexport {\n  cssClasses,\n  strings,\n};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCTabIndicatorFoundation} from './foundation';\n\n/* istanbul ignore next: subclass is not a branch statement */\nexport class MDCFadingTabIndicatorFoundation extends MDCTabIndicatorFoundation {\n  activate() {\n    this.adapter_.addClass(MDCTabIndicatorFoundation.cssClasses.ACTIVE);\n  }\n\n  deactivate() {\n    this.adapter_.removeClass(MDCTabIndicatorFoundation.cssClasses.ACTIVE);\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCFadingTabIndicatorFoundation;\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCTabIndicatorAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport abstract class MDCTabIndicatorFoundation extends MDCFoundation<MDCTabIndicatorAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get defaultAdapter(): MDCTabIndicatorAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      computeContentClientRect: () => ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0}),\n      setContentStyleProperty: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  constructor(adapter?: Partial<MDCTabIndicatorAdapter>) {\n    super({...MDCTabIndicatorFoundation.defaultAdapter, ...adapter});\n  }\n\n  computeContentClientRect(): ClientRect {\n    return this.adapter_.computeContentClientRect();\n  }\n\n  abstract activate(previousIndicatorClientRect?: ClientRect): void;\n  abstract deactivate(): void;\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabIndicatorFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './fading-foundation';\nexport * from './sliding-foundation';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCTabIndicatorFoundation} from './foundation';\n\n/* istanbul ignore next: subclass is not a branch statement */\nexport class MDCSlidingTabIndicatorFoundation extends MDCTabIndicatorFoundation {\n  activate(previousIndicatorClientRect?: ClientRect) {\n    // Early exit if no indicator is present to handle cases where an indicator\n    // may be activated without a prior indicator state\n    if (!previousIndicatorClientRect) {\n      this.adapter_.addClass(MDCTabIndicatorFoundation.cssClasses.ACTIVE);\n      return;\n    }\n\n    // This animation uses the FLIP approach. You can read more about it at the link below:\n    // https://aerotwist.com/blog/flip-your-animations/\n\n    // Calculate the dimensions based on the dimensions of the previous indicator\n    const currentClientRect = this.computeContentClientRect();\n    const widthDelta = previousIndicatorClientRect.width / currentClientRect.width;\n    const xPosition = previousIndicatorClientRect.left - currentClientRect.left;\n    this.adapter_.addClass(MDCTabIndicatorFoundation.cssClasses.NO_TRANSITION);\n    this.adapter_.setContentStyleProperty('transform', `translateX(${xPosition}px) scaleX(${widthDelta})`);\n\n    // Force repaint before updating classes and transform to ensure the transform properly takes effect\n    this.computeContentClientRect();\n\n    this.adapter_.removeClass(MDCTabIndicatorFoundation.cssClasses.NO_TRANSITION);\n    this.adapter_.addClass(MDCTabIndicatorFoundation.cssClasses.ACTIVE);\n    this.adapter_.setContentStyleProperty('transform', '');\n  }\n\n  deactivate() {\n    this.adapter_.removeClass(MDCTabIndicatorFoundation.cssClasses.ACTIVE);\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCSlidingTabIndicatorFoundation;\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {applyPassive} from '@material/dom/events';\nimport {matches} from '@material/dom/ponyfill';\nimport {MDCTabScrollerAdapter} from './adapter';\nimport {MDCTabScrollerFoundation} from './foundation';\nimport * as util from './util';\n\ntype InteractionEventType = 'wheel' | 'touchstart' | 'pointerdown' | 'mousedown' | 'keydown';\n\nexport type MDCTabScrollerFactory = (el: Element, foundation?: MDCTabScrollerFoundation) => MDCTabScroller;\n\nexport class MDCTabScroller extends MDCComponent<MDCTabScrollerFoundation> {\n  static attachTo(root: Element): MDCTabScroller {\n    return new MDCTabScroller(root);\n  }\n\n  private content_!: HTMLElement; // assigned in initialize()\n  private area_!: HTMLElement; // assigned in initialize()\n  private handleInteraction_!: SpecificEventListener<InteractionEventType>; // assigned in initialSyncWithDOM()\n  private handleTransitionEnd_!: SpecificEventListener<'transitionend'>; // assigned in initialSyncWithDOM()\n\n  initialize() {\n    this.area_ = this.root_.querySelector<HTMLElement>(MDCTabScrollerFoundation.strings.AREA_SELECTOR)!;\n    this.content_ = this.root_.querySelector<HTMLElement>(MDCTabScrollerFoundation.strings.CONTENT_SELECTOR)!;\n  }\n\n  initialSyncWithDOM() {\n    this.handleInteraction_ = () => this.foundation_.handleInteraction();\n    this.handleTransitionEnd_ = (evt) => this.foundation_.handleTransitionEnd(evt);\n\n    this.area_.addEventListener('wheel', this.handleInteraction_, applyPassive());\n    this.area_.addEventListener('touchstart', this.handleInteraction_, applyPassive());\n    this.area_.addEventListener('pointerdown', this.handleInteraction_, applyPassive());\n    this.area_.addEventListener('mousedown', this.handleInteraction_, applyPassive());\n    this.area_.addEventListener('keydown', this.handleInteraction_, applyPassive());\n    this.content_.addEventListener('transitionend', this.handleTransitionEnd_);\n  }\n\n  destroy() {\n    super.destroy();\n\n    this.area_.removeEventListener('wheel', this.handleInteraction_, applyPassive());\n    this.area_.removeEventListener('touchstart', this.handleInteraction_, applyPassive());\n    this.area_.removeEventListener('pointerdown', this.handleInteraction_, applyPassive());\n    this.area_.removeEventListener('mousedown', this.handleInteraction_, applyPassive());\n    this.area_.removeEventListener('keydown', this.handleInteraction_, applyPassive());\n    this.content_.removeEventListener('transitionend', this.handleTransitionEnd_);\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCTabScrollerAdapter = {\n      eventTargetMatchesSelector: (evtTarget, selector) => matches(evtTarget as Element, selector),\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      addScrollAreaClass: (className) => this.area_.classList.add(className),\n      setScrollAreaStyleProperty: (prop, value) => this.area_.style.setProperty(prop, value),\n      setScrollContentStyleProperty: (prop, value) => this.content_.style.setProperty(prop, value),\n      getScrollContentStyleValue: (propName) => window.getComputedStyle(this.content_).getPropertyValue(propName),\n      setScrollAreaScrollLeft: (scrollX) => this.area_.scrollLeft = scrollX,\n      getScrollAreaScrollLeft: () => this.area_.scrollLeft,\n      getScrollContentOffsetWidth: () => this.content_.offsetWidth,\n      getScrollAreaOffsetWidth: () => this.area_.offsetWidth,\n      computeScrollAreaClientRect: () => this.area_.getBoundingClientRect(),\n      computeScrollContentClientRect: () => this.content_.getBoundingClientRect(),\n      computeHorizontalScrollbarHeight: () => util.computeHorizontalScrollbarHeight(document),\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCTabScrollerFoundation(adapter);\n  }\n\n  /**\n   * Returns the current visual scroll position\n   */\n  getScrollPosition(): number {\n    return this.foundation_.getScrollPosition();\n  }\n\n  /**\n   * Returns the width of the scroll content\n   */\n  getScrollContentWidth(): number {\n    return this.content_.offsetWidth;\n  }\n\n  /**\n   * Increments the scroll value by the given amount\n   * @param scrollXIncrement The pixel value by which to increment the scroll value\n   */\n  incrementScroll(scrollXIncrement: number) {\n    this.foundation_.incrementScroll(scrollXIncrement);\n  }\n\n  /**\n   * Scrolls to the given pixel position\n   * @param scrollX The pixel value to scroll to\n   */\n  scrollTo(scrollX: number) {\n    this.foundation_.scrollTo(scrollX);\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n  ANIMATING: 'mdc-tab-scroller--animating',\n  SCROLL_AREA_SCROLL: 'mdc-tab-scroller__scroll-area--scroll',\n  SCROLL_TEST: 'mdc-tab-scroller__test',\n};\n\nconst strings = {\n  AREA_SELECTOR: '.mdc-tab-scroller__scroll-area',\n  CONTENT_SELECTOR: '.mdc-tab-scroller__scroll-content',\n};\n\nexport {\n  cssClasses,\n  strings,\n};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCTabScrollerAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCTabScrollerRTLDefault} from './rtl-default-scroller';\nimport {MDCTabScrollerRTLNegative} from './rtl-negative-scroller';\nimport {MDCTabScrollerRTLReverse} from './rtl-reverse-scroller';\nimport {MDCTabScrollerRTL} from './rtl-scroller';\nimport {MDCTabScrollerAnimation, MDCTabScrollerHorizontalEdges} from './types';\n\nexport class MDCTabScrollerFoundation extends MDCFoundation<MDCTabScrollerAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get defaultAdapter(): MDCTabScrollerAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      eventTargetMatchesSelector: () => false,\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      addScrollAreaClass: () => undefined,\n      setScrollAreaStyleProperty: () => undefined,\n      setScrollContentStyleProperty: () => undefined,\n      getScrollContentStyleValue: () => '',\n      setScrollAreaScrollLeft: () => undefined,\n      getScrollAreaScrollLeft: () => 0,\n      getScrollContentOffsetWidth: () => 0,\n      getScrollAreaOffsetWidth: () => 0,\n      computeScrollAreaClientRect: () => ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0}),\n      computeScrollContentClientRect: () => ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0}),\n      computeHorizontalScrollbarHeight: () => 0,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  /**\n   * Controls whether we should handle the transitionend and interaction events during the animation.\n   */\n  private isAnimating_ = false;\n\n  /**\n   * The MDCTabScrollerRTL instance varies per browser and allows us to encapsulate the peculiar browser behavior\n   * of RTL scrolling in it's own class.\n   */\n  private rtlScrollerInstance_?: MDCTabScrollerRTL;\n\n  constructor(adapter?: Partial<MDCTabScrollerAdapter>) {\n    super({...MDCTabScrollerFoundation.defaultAdapter, ...adapter});\n  }\n\n  init() {\n    // Compute horizontal scrollbar height on scroller with overflow initially hidden, then update overflow to scroll\n    // and immediately adjust bottom margin to avoid the scrollbar initially appearing before JS runs.\n    const horizontalScrollbarHeight = this.adapter_.computeHorizontalScrollbarHeight();\n    this.adapter_.setScrollAreaStyleProperty('margin-bottom', -horizontalScrollbarHeight + 'px');\n    this.adapter_.addScrollAreaClass(MDCTabScrollerFoundation.cssClasses.SCROLL_AREA_SCROLL);\n  }\n\n  /**\n   * Computes the current visual scroll position\n   */\n  getScrollPosition(): number {\n    if (this.isRTL_()) {\n      return this.computeCurrentScrollPositionRTL_();\n    }\n\n    const currentTranslateX = this.calculateCurrentTranslateX_();\n    const scrollLeft = this.adapter_.getScrollAreaScrollLeft();\n    return scrollLeft - currentTranslateX;\n  }\n\n  /**\n   * Handles interaction events that occur during transition\n   */\n  handleInteraction() {\n    // Early exit if we aren't animating\n    if (!this.isAnimating_) {\n      return;\n    }\n\n    // Prevent other event listeners from handling this event\n    this.stopScrollAnimation_();\n  }\n\n  /**\n   * Handles the transitionend event\n   */\n  handleTransitionEnd(evt: Event) {\n    // Early exit if we aren't animating or the event was triggered by a different element.\n    const evtTarget = evt.target as Element;\n    if (!this.isAnimating_ ||\n        !this.adapter_.eventTargetMatchesSelector(evtTarget, MDCTabScrollerFoundation.strings.CONTENT_SELECTOR)) {\n      return;\n    }\n\n    this.isAnimating_ = false;\n    this.adapter_.removeClass(MDCTabScrollerFoundation.cssClasses.ANIMATING);\n  }\n\n  /**\n   * Increment the scroll value by the scrollXIncrement\n   * @param scrollXIncrement The value by which to increment the scroll position\n   */\n  incrementScroll(scrollXIncrement: number) {\n    // Early exit for non-operational increment values\n    if (scrollXIncrement === 0) {\n      return;\n    }\n\n    if (this.isRTL_()) {\n      return this.incrementScrollRTL_(scrollXIncrement);\n    }\n\n    this.incrementScroll_(scrollXIncrement);\n  }\n\n  /**\n   * Scrolls to the given scrollX value\n   */\n  scrollTo(scrollX: number) {\n    if (this.isRTL_()) {\n      return this.scrollToRTL_(scrollX);\n    }\n\n    this.scrollTo_(scrollX);\n  }\n\n  /**\n   * @return Browser-specific {@link MDCTabScrollerRTL} instance.\n   */\n  getRTLScroller(): MDCTabScrollerRTL {\n    if (!this.rtlScrollerInstance_) {\n      this.rtlScrollerInstance_ = this.rtlScrollerFactory_();\n    }\n\n    return this.rtlScrollerInstance_;\n  }\n\n  /**\n   * @return translateX value from a CSS matrix transform function string.\n   */\n  private calculateCurrentTranslateX_(): number {\n    const transformValue = this.adapter_.getScrollContentStyleValue('transform');\n    // Early exit if no transform is present\n    if (transformValue === 'none') {\n      return 0;\n    }\n\n    // The transform value comes back as a matrix transformation in the form\n    // of `matrix(a, b, c, d, tx, ty)`. We only care about tx (translateX) so\n    // we're going to grab all the parenthesized values, strip out tx, and\n    // parse it.\n    const match = /\\((.+?)\\)/.exec(transformValue);\n    if (!match) {\n      return 0;\n    }\n\n    const matrixParams = match[1];\n\n    // tslint:disable-next-line:ban-ts-ignore \"Unused vars\" should be a linter warning, not a compiler error.\n    // @ts-ignore These unused variables should retain their semantic names for clarity.\n    const [a, b, c, d, tx, ty] = matrixParams.split(',');\n\n    return parseFloat(tx); // tslint:disable-line:ban\n  }\n\n  /**\n   * Calculates a safe scroll value that is > 0 and < the max scroll value\n   * @param scrollX The distance to scroll\n   */\n  private clampScrollValue_(scrollX: number): number {\n    const edges = this.calculateScrollEdges_();\n    return Math.min(Math.max(edges.left, scrollX), edges.right);\n  }\n\n  private computeCurrentScrollPositionRTL_(): number {\n    const translateX = this.calculateCurrentTranslateX_();\n    return this.getRTLScroller().getScrollPositionRTL(translateX);\n  }\n\n  private calculateScrollEdges_(): MDCTabScrollerHorizontalEdges {\n    const contentWidth = this.adapter_.getScrollContentOffsetWidth();\n    const rootWidth = this.adapter_.getScrollAreaOffsetWidth();\n    return {\n      left: 0,\n      right: contentWidth - rootWidth,\n    };\n  }\n\n  /**\n   * Internal scroll method\n   * @param scrollX The new scroll position\n   */\n  private scrollTo_(scrollX: number) {\n    const currentScrollX = this.getScrollPosition();\n    const safeScrollX = this.clampScrollValue_(scrollX);\n    const scrollDelta = safeScrollX - currentScrollX;\n    this.animate_({\n      finalScrollPosition: safeScrollX,\n      scrollDelta,\n    });\n  }\n\n  /**\n   * Internal RTL scroll method\n   * @param scrollX The new scroll position\n   */\n  private scrollToRTL_(scrollX: number) {\n    const animation = this.getRTLScroller().scrollToRTL(scrollX);\n    this.animate_(animation);\n  }\n\n  /**\n   * Internal increment scroll method\n   * @param scrollX The new scroll position increment\n   */\n  private incrementScroll_(scrollX: number) {\n    const currentScrollX = this.getScrollPosition();\n    const targetScrollX = scrollX + currentScrollX;\n    const safeScrollX = this.clampScrollValue_(targetScrollX);\n    const scrollDelta = safeScrollX - currentScrollX;\n    this.animate_({\n      finalScrollPosition: safeScrollX,\n      scrollDelta,\n    });\n  }\n\n  /**\n   * Internal increment scroll RTL method\n   * @param scrollX The new scroll position RTL increment\n   */\n  private incrementScrollRTL_(scrollX: number) {\n    const animation = this.getRTLScroller().incrementScrollRTL(scrollX);\n    this.animate_(animation);\n  }\n\n  /**\n   * Animates the tab scrolling\n   * @param animation The animation to apply\n   */\n  private animate_(animation: MDCTabScrollerAnimation) {\n    // Early exit if translateX is 0, which means there's no animation to perform\n    if (animation.scrollDelta === 0) {\n      return;\n    }\n\n    this.stopScrollAnimation_();\n    // This animation uses the FLIP approach.\n    // Read more here: https://aerotwist.com/blog/flip-your-animations/\n    this.adapter_.setScrollAreaScrollLeft(animation.finalScrollPosition);\n    this.adapter_.setScrollContentStyleProperty('transform', `translateX(${animation.scrollDelta}px)`);\n    // Force repaint\n    this.adapter_.computeScrollAreaClientRect();\n\n    requestAnimationFrame(() => {\n      this.adapter_.addClass(MDCTabScrollerFoundation.cssClasses.ANIMATING);\n      this.adapter_.setScrollContentStyleProperty('transform', 'none');\n    });\n\n    this.isAnimating_ = true;\n  }\n\n  /**\n   * Stops scroll animation\n   */\n  private stopScrollAnimation_() {\n    this.isAnimating_ = false;\n    const currentScrollPosition = this.getAnimatingScrollPosition_();\n    this.adapter_.removeClass(MDCTabScrollerFoundation.cssClasses.ANIMATING);\n    this.adapter_.setScrollContentStyleProperty('transform', 'translateX(0px)');\n    this.adapter_.setScrollAreaScrollLeft(currentScrollPosition);\n  }\n\n  /**\n   * Gets the current scroll position during animation\n   */\n  private getAnimatingScrollPosition_(): number {\n    const currentTranslateX = this.calculateCurrentTranslateX_();\n    const scrollLeft = this.adapter_.getScrollAreaScrollLeft();\n    if (this.isRTL_()) {\n      return this.getRTLScroller().getAnimatingScrollPosition(scrollLeft, currentTranslateX);\n    }\n\n    return scrollLeft - currentTranslateX;\n  }\n\n  /**\n   * Determines the RTL Scroller to use\n   */\n  private rtlScrollerFactory_(): MDCTabScrollerRTL {\n    // Browsers have three different implementations of scrollLeft in RTL mode,\n    // dependent on the browser. The behavior is based off the max LTR\n    // scrollLeft value and 0.\n    //\n    // * Default scrolling in RTL *\n    //    - Left-most value: 0\n    //    - Right-most value: Max LTR scrollLeft value\n    //\n    // * Negative scrolling in RTL *\n    //    - Left-most value: Negated max LTR scrollLeft value\n    //    - Right-most value: 0\n    //\n    // * Reverse scrolling in RTL *\n    //    - Left-most value: Max LTR scrollLeft value\n    //    - Right-most value: 0\n    //\n    // We use those principles below to determine which RTL scrollLeft\n    // behavior is implemented in the current browser.\n    const initialScrollLeft = this.adapter_.getScrollAreaScrollLeft();\n    this.adapter_.setScrollAreaScrollLeft(initialScrollLeft - 1);\n    const newScrollLeft = this.adapter_.getScrollAreaScrollLeft();\n\n    // If the newScrollLeft value is negative,then we know that the browser has\n    // implemented negative RTL scrolling, since all other implementations have\n    // only positive values.\n    if (newScrollLeft < 0) {\n      // Undo the scrollLeft test check\n      this.adapter_.setScrollAreaScrollLeft(initialScrollLeft);\n      return new MDCTabScrollerRTLNegative(this.adapter_);\n    }\n\n    const rootClientRect = this.adapter_.computeScrollAreaClientRect();\n    const contentClientRect = this.adapter_.computeScrollContentClientRect();\n    const rightEdgeDelta = Math.round(contentClientRect.right - rootClientRect.right);\n    // Undo the scrollLeft test check\n    this.adapter_.setScrollAreaScrollLeft(initialScrollLeft);\n\n    // By calculating the clientRect of the root element and the clientRect of\n    // the content element, we can determine how much the scroll value changed\n    // when we performed the scrollLeft subtraction above.\n    if (rightEdgeDelta === newScrollLeft) {\n      return new MDCTabScrollerRTLReverse(this.adapter_);\n    }\n\n    return new MDCTabScrollerRTLDefault(this.adapter_);\n  }\n\n  private isRTL_(): boolean {\n    return this.adapter_.getScrollContentStyleValue('direction') === 'rtl';\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabScrollerFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport * as util from './util';\n\nexport {util};\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCTabScrollerRTL} from './rtl-scroller';\nimport {MDCTabScrollerAnimation, MDCTabScrollerHorizontalEdges} from './types';\n\nexport class MDCTabScrollerRTLDefault extends MDCTabScrollerRTL {\n  getScrollPositionRTL(): number {\n    const currentScrollLeft = this.adapter_.getScrollAreaScrollLeft();\n    const {right} = this.calculateScrollEdges_();\n    // Scroll values on most browsers are ints instead of floats so we round\n    return Math.round(right - currentScrollLeft);\n  }\n\n  scrollToRTL(scrollX: number): MDCTabScrollerAnimation {\n    const edges = this.calculateScrollEdges_();\n    const currentScrollLeft = this.adapter_.getScrollAreaScrollLeft();\n    const clampedScrollLeft = this.clampScrollValue_(edges.right - scrollX);\n    return {\n      finalScrollPosition: clampedScrollLeft,\n      scrollDelta: clampedScrollLeft - currentScrollLeft,\n    };\n  }\n\n  incrementScrollRTL(scrollX: number): MDCTabScrollerAnimation {\n    const currentScrollLeft = this.adapter_.getScrollAreaScrollLeft();\n    const clampedScrollLeft = this.clampScrollValue_(currentScrollLeft - scrollX);\n    return {\n      finalScrollPosition: clampedScrollLeft,\n      scrollDelta: clampedScrollLeft - currentScrollLeft,\n    };\n  }\n\n  getAnimatingScrollPosition(scrollX: number): number {\n    return scrollX;\n  }\n\n  private calculateScrollEdges_(): MDCTabScrollerHorizontalEdges {\n    const contentWidth = this.adapter_.getScrollContentOffsetWidth();\n    const rootWidth = this.adapter_.getScrollAreaOffsetWidth();\n    return {\n      left: 0,\n      right: contentWidth - rootWidth,\n    };\n  }\n\n  private clampScrollValue_(scrollX: number): number {\n    const edges = this.calculateScrollEdges_();\n    return Math.min(Math.max(edges.left, scrollX), edges.right);\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabScrollerRTLDefault;\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCTabScrollerRTL} from './rtl-scroller';\nimport {MDCTabScrollerAnimation, MDCTabScrollerHorizontalEdges} from './types';\n\nexport class MDCTabScrollerRTLNegative extends MDCTabScrollerRTL {\n  getScrollPositionRTL(translateX: number): number {\n    const currentScrollLeft = this.adapter_.getScrollAreaScrollLeft();\n    return Math.round(translateX - currentScrollLeft);\n  }\n\n  scrollToRTL(scrollX: number): MDCTabScrollerAnimation {\n    const currentScrollLeft = this.adapter_.getScrollAreaScrollLeft();\n    const clampedScrollLeft = this.clampScrollValue_(-scrollX);\n    return {\n      finalScrollPosition: clampedScrollLeft,\n      scrollDelta: clampedScrollLeft - currentScrollLeft,\n    };\n  }\n\n  incrementScrollRTL(scrollX: number): MDCTabScrollerAnimation {\n    const currentScrollLeft = this.adapter_.getScrollAreaScrollLeft();\n    const clampedScrollLeft = this.clampScrollValue_(currentScrollLeft - scrollX);\n    return {\n      finalScrollPosition: clampedScrollLeft,\n      scrollDelta: clampedScrollLeft - currentScrollLeft,\n    };\n  }\n\n  getAnimatingScrollPosition(scrollX: number, translateX: number): number {\n    return scrollX - translateX;\n  }\n\n  private calculateScrollEdges_(): MDCTabScrollerHorizontalEdges {\n    const contentWidth = this.adapter_.getScrollContentOffsetWidth();\n    const rootWidth = this.adapter_.getScrollAreaOffsetWidth();\n    return {\n      left: rootWidth - contentWidth,\n      right: 0,\n    };\n  }\n\n  private clampScrollValue_(scrollX: number): number {\n    const edges = this.calculateScrollEdges_();\n    return Math.max(Math.min(edges.right, scrollX), edges.left);\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabScrollerRTLNegative;\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCTabScrollerRTL} from './rtl-scroller';\nimport {MDCTabScrollerAnimation, MDCTabScrollerHorizontalEdges} from './types';\n\nexport class MDCTabScrollerRTLReverse extends MDCTabScrollerRTL {\n  getScrollPositionRTL(translateX: number): number {\n    const currentScrollLeft = this.adapter_.getScrollAreaScrollLeft();\n    // Scroll values on most browsers are ints instead of floats so we round\n    return Math.round(currentScrollLeft - translateX);\n  }\n\n  scrollToRTL(scrollX: number): MDCTabScrollerAnimation {\n    const currentScrollLeft = this.adapter_.getScrollAreaScrollLeft();\n    const clampedScrollLeft = this.clampScrollValue_(scrollX);\n    return {\n      finalScrollPosition: clampedScrollLeft,\n      scrollDelta: currentScrollLeft - clampedScrollLeft,\n    };\n  }\n\n  incrementScrollRTL(scrollX: number): MDCTabScrollerAnimation {\n    const currentScrollLeft = this.adapter_.getScrollAreaScrollLeft();\n    const clampedScrollLeft = this.clampScrollValue_(currentScrollLeft + scrollX);\n    return {\n      finalScrollPosition: clampedScrollLeft,\n      scrollDelta: currentScrollLeft - clampedScrollLeft,\n    };\n  }\n\n  getAnimatingScrollPosition(scrollX: number, translateX: number): number {\n    return scrollX + translateX;\n  }\n\n  private calculateScrollEdges_(): MDCTabScrollerHorizontalEdges {\n    const contentWidth = this.adapter_.getScrollContentOffsetWidth();\n    const rootWidth = this.adapter_.getScrollAreaOffsetWidth();\n    return {\n      left: contentWidth - rootWidth,\n      right: 0,\n    };\n  }\n\n  private clampScrollValue_(scrollX: number): number {\n    const edges = this.calculateScrollEdges_();\n    return Math.min(Math.max(edges.right, scrollX), edges.left);\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabScrollerRTLReverse;\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCTabScrollerAdapter} from './adapter';\nimport {MDCTabScrollerAnimation} from './types';\n\nexport abstract class MDCTabScrollerRTL {\n  protected readonly adapter_: MDCTabScrollerAdapter;\n\n  constructor(adapter: MDCTabScrollerAdapter) {\n    this.adapter_ = adapter;\n  }\n\n  abstract getScrollPositionRTL(translateX: number): number;\n\n  abstract scrollToRTL(scrollX: number): MDCTabScrollerAnimation;\n\n  abstract incrementScrollRTL(scrollX: number): MDCTabScrollerAnimation;\n\n  /**\n   * @param scrollX The current scrollX position\n   * @param translateX The current translateX position\n   */\n  abstract getAnimatingScrollPosition(scrollX: number, translateX: number): number;\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabScrollerRTL;\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {cssClasses} from './constants';\n\n/**\n * Stores result from computeHorizontalScrollbarHeight to avoid redundant processing.\n */\nlet horizontalScrollbarHeight_: number | undefined;\n\n/**\n * Computes the height of browser-rendered horizontal scrollbars using a self-created test element.\n * May return 0 (e.g. on OS X browsers under default configuration).\n */\nexport function computeHorizontalScrollbarHeight(documentObj: Document, shouldCacheResult = true): number {\n  if (shouldCacheResult && typeof horizontalScrollbarHeight_ !== 'undefined') {\n    return horizontalScrollbarHeight_;\n  }\n\n  const el = documentObj.createElement('div');\n  el.classList.add(cssClasses.SCROLL_TEST);\n  documentObj.body.appendChild(el);\n\n  const horizontalScrollbarHeight = el.offsetHeight - el.clientHeight;\n  documentObj.body.removeChild(el);\n\n  if (shouldCacheResult) {\n    horizontalScrollbarHeight_ = horizontalScrollbarHeight;\n  }\n  return horizontalScrollbarHeight;\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCRipple, MDCRippleFactory} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\nimport {MDCTabIndicator, MDCTabIndicatorFactory} from '@material/tab-indicator/component';\nimport {MDCTabAdapter} from './adapter';\nimport {MDCTabFoundation} from './foundation';\nimport {MDCTabDimensions, MDCTabInteractionEventDetail} from './types';\n\nexport type MDCTabFactory = (el: Element, foundation?: MDCTabFoundation) => MDCTab;\n\nexport class MDCTab extends MDCComponent<MDCTabFoundation> implements MDCRippleCapableSurface {\n  static attachTo(root: Element): MDCTab {\n    return new MDCTab(root);\n  }\n\n  id!: string; // assigned in initialize();\n\n  // Public visibility for this property is required by MDCRippleCapableSurface.\n  root_!: HTMLElement; // assigned in MDCComponent constructor\n\n  private ripple_!: MDCRipple; // assigned in initialize();\n  private tabIndicator_!: MDCTabIndicator; // assigned in initialize();\n  private content_!: HTMLElement; // assigned in initialize();\n  private handleClick_!: SpecificEventListener<'click'>; // assigned in initialize();\n\n  initialize(\n      rippleFactory: MDCRippleFactory = (el, foundation) => new MDCRipple(el, foundation),\n      tabIndicatorFactory: MDCTabIndicatorFactory = (el) => new MDCTabIndicator(el),\n  ) {\n    this.id = this.root_.id;\n    const rippleSurface = this.root_.querySelector<HTMLElement>(MDCTabFoundation.strings.RIPPLE_SELECTOR)!;\n    const rippleAdapter = {\n      ...MDCRipple.createAdapter(this),\n      addClass: (className: string) => rippleSurface.classList.add(className),\n      removeClass: (className: string) => rippleSurface.classList.remove(className),\n      updateCssVariable: (varName: string, value: string) => rippleSurface.style.setProperty(varName, value),\n    };\n    const rippleFoundation = new MDCRippleFoundation(rippleAdapter);\n    this.ripple_ = rippleFactory(this.root_, rippleFoundation);\n\n    const tabIndicatorElement = this.root_.querySelector(MDCTabFoundation.strings.TAB_INDICATOR_SELECTOR)!;\n    this.tabIndicator_ = tabIndicatorFactory(tabIndicatorElement);\n    this.content_ = this.root_.querySelector<HTMLElement>(MDCTabFoundation.strings.CONTENT_SELECTOR)!;\n  }\n\n  initialSyncWithDOM() {\n    this.handleClick_ = () => this.foundation_.handleClick();\n    this.listen('click', this.handleClick_);\n  }\n\n  destroy() {\n    this.unlisten('click', this.handleClick_);\n    this.ripple_.destroy();\n    super.destroy();\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCTabAdapter = {\n      setAttr: (attr, value) => this.root_.setAttribute(attr, value),\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      hasClass: (className) => this.root_.classList.contains(className),\n      activateIndicator: (previousIndicatorClientRect) => this.tabIndicator_.activate(previousIndicatorClientRect),\n      deactivateIndicator: () => this.tabIndicator_.deactivate(),\n      notifyInteracted: () => this.emit<MDCTabInteractionEventDetail>(\n          MDCTabFoundation.strings.INTERACTED_EVENT, {tabId: this.id}, true /* bubble */),\n      getOffsetLeft: () => this.root_.offsetLeft,\n      getOffsetWidth: () => this.root_.offsetWidth,\n      getContentOffsetLeft: () => this.content_.offsetLeft,\n      getContentOffsetWidth: () => this.content_.offsetWidth,\n      focus: () => this.root_.focus(),\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCTabFoundation(adapter);\n  }\n\n  /**\n   * Getter for the active state of the tab\n   */\n  get active(): boolean {\n    return this.foundation_.isActive();\n  }\n\n  set focusOnActivate(focusOnActivate: boolean) {\n    this.foundation_.setFocusOnActivate(focusOnActivate);\n  }\n\n  /**\n   * Activates the tab\n   */\n  activate(computeIndicatorClientRect?: ClientRect) {\n    this.foundation_.activate(computeIndicatorClientRect);\n  }\n\n  /**\n   * Deactivates the tab\n   */\n  deactivate() {\n    this.foundation_.deactivate();\n  }\n\n  /**\n   * Returns the indicator's client rect\n   */\n  computeIndicatorClientRect(): ClientRect {\n    return this.tabIndicator_.computeContentClientRect();\n  }\n\n  computeDimensions(): MDCTabDimensions {\n    return this.foundation_.computeDimensions();\n  }\n\n  /**\n   * Focuses the tab\n   */\n  focus() {\n    this.root_.focus();\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n  ACTIVE: 'mdc-tab--active',\n};\n\nconst strings = {\n  ARIA_SELECTED: 'aria-selected',\n  CONTENT_SELECTOR: '.mdc-tab__content',\n  INTERACTED_EVENT: 'MDCTab:interacted',\n  RIPPLE_SELECTOR: '.mdc-tab__ripple',\n  TABINDEX: 'tabIndex',\n  TAB_INDICATOR_SELECTOR: '.mdc-tab-indicator',\n};\n\nexport {\n  cssClasses,\n  strings,\n};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCTabAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCTabDimensions} from './types';\n\nexport class MDCTabFoundation extends MDCFoundation<MDCTabAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get defaultAdapter(): MDCTabAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      hasClass: () => false,\n      setAttr: () => undefined,\n      activateIndicator: () => undefined,\n      deactivateIndicator: () => undefined,\n      notifyInteracted: () => undefined,\n      getOffsetLeft: () => 0,\n      getOffsetWidth: () => 0,\n      getContentOffsetLeft: () => 0,\n      getContentOffsetWidth: () => 0,\n      focus: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private focusOnActivate_ = true;\n\n  constructor(adapter?: Partial<MDCTabAdapter>) {\n    super({...MDCTabFoundation.defaultAdapter, ...adapter});\n  }\n\n  handleClick() {\n    // It's up to the parent component to keep track of the active Tab and\n    // ensure we don't activate a Tab that's already active.\n    this.adapter_.notifyInteracted();\n  }\n\n  isActive(): boolean {\n    return this.adapter_.hasClass(cssClasses.ACTIVE);\n  }\n\n  /**\n   * Sets whether the tab should focus itself when activated\n   */\n  setFocusOnActivate(focusOnActivate: boolean) {\n    this.focusOnActivate_ = focusOnActivate;\n  }\n\n  /**\n   * Activates the Tab\n   */\n  activate(previousIndicatorClientRect?: ClientRect) {\n    this.adapter_.addClass(cssClasses.ACTIVE);\n    this.adapter_.setAttr(strings.ARIA_SELECTED, 'true');\n    this.adapter_.setAttr(strings.TABINDEX, '0');\n    this.adapter_.activateIndicator(previousIndicatorClientRect);\n    if (this.focusOnActivate_) {\n      this.adapter_.focus();\n    }\n  }\n\n  /**\n   * Deactivates the Tab\n   */\n  deactivate() {\n    // Early exit\n    if (!this.isActive()) {\n      return;\n    }\n\n    this.adapter_.removeClass(cssClasses.ACTIVE);\n    this.adapter_.setAttr(strings.ARIA_SELECTED, 'false');\n    this.adapter_.setAttr(strings.TABINDEX, '-1');\n    this.adapter_.deactivateIndicator();\n  }\n\n  /**\n   * Returns the dimensions of the Tab\n   */\n  computeDimensions(): MDCTabDimensions {\n    const rootWidth = this.adapter_.getOffsetWidth();\n    const rootLeft = this.adapter_.getOffsetLeft();\n    const contentWidth = this.adapter_.getContentOffsetWidth();\n    const contentLeft = this.adapter_.getContentOffsetLeft();\n\n    return {\n      contentLeft: rootLeft + contentLeft,\n      contentRight: rootLeft + contentLeft + contentWidth,\n      rootLeft,\n      rootRight: rootLeft + rootWidth,\n    };\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCTextFieldCharacterCounterAdapter} from './adapter';\nimport {MDCTextFieldCharacterCounterFoundation} from './foundation';\n\nexport type MDCTextFieldCharacterCounterFactory =\n    (el: Element, foundation?: MDCTextFieldCharacterCounterFoundation) => MDCTextFieldCharacterCounter;\n\nexport class MDCTextFieldCharacterCounter extends MDCComponent<MDCTextFieldCharacterCounterFoundation> {\n  static attachTo(root: Element): MDCTextFieldCharacterCounter {\n    return new MDCTextFieldCharacterCounter(root);\n  }\n\n  get foundation(): MDCTextFieldCharacterCounterFoundation {\n    return this.foundation_;\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCTextFieldCharacterCounterAdapter = {\n      setContent: (content) => {\n        this.root_.textContent = content;\n      },\n    };\n    return new MDCTextFieldCharacterCounterFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n  ROOT: 'mdc-text-field-character-counter',\n};\n\nconst strings = {\n  ROOT_SELECTOR: `.${cssClasses.ROOT}`,\n};\n\nexport {strings, cssClasses};\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCTextFieldCharacterCounterAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCTextFieldCharacterCounterFoundation extends MDCFoundation<MDCTextFieldCharacterCounterAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  /**\n   * See {@link MDCTextFieldCharacterCounterAdapter} for typing information on parameters and return types.\n   */\n  static get defaultAdapter(): MDCTextFieldCharacterCounterAdapter {\n    return {\n      setContent: () => undefined,\n    };\n  }\n\n  constructor(adapter?: Partial<MDCTextFieldCharacterCounterAdapter>) {\n    super({...MDCTextFieldCharacterCounterFoundation.defaultAdapter, ...adapter});\n  }\n\n  setCounterValue(currentLength: number, maxLength: number) {\n    currentLength = Math.min(currentLength, maxLength);\n    this.adapter_.setContent(`${currentLength} / ${maxLength}`);\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTextFieldCharacterCounterFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport {cssClasses as characterCountCssClasses, strings as characterCountStrings} from './constants';\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {applyPassive} from '@material/dom/events';\nimport * as ponyfill from '@material/dom/ponyfill';\nimport {MDCFloatingLabel, MDCFloatingLabelFactory} from '@material/floating-label/component';\nimport {MDCLineRipple, MDCLineRippleFactory} from '@material/line-ripple/component';\nimport {MDCNotchedOutline, MDCNotchedOutlineFactory} from '@material/notched-outline/component';\nimport {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple, MDCRippleFactory} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\nimport {\n  MDCTextFieldAdapter,\n  MDCTextFieldInputAdapter,\n  MDCTextFieldLabelAdapter,\n  MDCTextFieldLineRippleAdapter,\n  MDCTextFieldOutlineAdapter,\n  MDCTextFieldRootAdapter,\n} from './adapter';\nimport {\n  MDCTextFieldCharacterCounter,\n  MDCTextFieldCharacterCounterFactory,\n} from './character-counter/component';\nimport {MDCTextFieldCharacterCounterFoundation} from './character-counter/foundation';\nimport {cssClasses, strings} from './constants';\nimport {MDCTextFieldFoundation} from './foundation';\nimport {\n  MDCTextFieldHelperText,\n  MDCTextFieldHelperTextFactory,\n} from './helper-text/component';\nimport {MDCTextFieldHelperTextFoundation} from './helper-text/foundation';\nimport {MDCTextFieldIcon, MDCTextFieldIconFactory} from './icon/component';\nimport {MDCTextFieldFoundationMap} from './types';\n\nexport class MDCTextField extends MDCComponent<MDCTextFieldFoundation> implements MDCRippleCapableSurface {\n  static attachTo(root: Element): MDCTextField {\n    return new MDCTextField(root);\n  }\n\n  // Public visibility for this property is required by MDCRippleCapableSurface.\n  root_!: HTMLElement; // assigned in MDCComponent constructor\n\n  ripple!: MDCRipple | null; // assigned in initialize()\n\n  // The only required sub-element.\n  private input_!: HTMLInputElement; // assigned in initialize()\n\n  // Optional sub-elements.\n  private characterCounter_!: MDCTextFieldCharacterCounter | null; // assigned in initialize()\n  private helperText_!: MDCTextFieldHelperText | null; // assigned in initialize()\n  private label_!: MDCFloatingLabel | null; // assigned in initialize()\n  private leadingIcon_!: MDCTextFieldIcon | null; // assigned in initialize()\n  private lineRipple_!: MDCLineRipple | null; // assigned in initialize()\n  private outline_!: MDCNotchedOutline | null; // assigned in initialize()\n  private trailingIcon_!: MDCTextFieldIcon | null; // assigned in initialize()\n\n  initialize(\n      rippleFactory: MDCRippleFactory = (el, foundation) => new MDCRipple(el, foundation),\n      lineRippleFactory: MDCLineRippleFactory = (el) => new MDCLineRipple(el),\n      helperTextFactory: MDCTextFieldHelperTextFactory = (el) => new MDCTextFieldHelperText(el),\n      characterCounterFactory: MDCTextFieldCharacterCounterFactory = (el) => new MDCTextFieldCharacterCounter(el),\n      iconFactory: MDCTextFieldIconFactory = (el) => new MDCTextFieldIcon(el),\n      labelFactory: MDCFloatingLabelFactory = (el) => new MDCFloatingLabel(el),\n      outlineFactory: MDCNotchedOutlineFactory = (el) => new MDCNotchedOutline(el),\n  ) {\n    this.input_ = this.root_.querySelector<HTMLInputElement>(strings.INPUT_SELECTOR)!;\n\n    const labelElement = this.root_.querySelector(strings.LABEL_SELECTOR);\n    this.label_ = labelElement ? labelFactory(labelElement) : null;\n\n    const lineRippleElement = this.root_.querySelector(strings.LINE_RIPPLE_SELECTOR);\n    this.lineRipple_ = lineRippleElement ? lineRippleFactory(lineRippleElement) : null;\n\n    const outlineElement = this.root_.querySelector(strings.OUTLINE_SELECTOR);\n    this.outline_ = outlineElement ? outlineFactory(outlineElement) : null;\n\n    // Helper text\n    const helperTextStrings = MDCTextFieldHelperTextFoundation.strings;\n    const nextElementSibling = this.root_.nextElementSibling;\n    const hasHelperLine = (nextElementSibling && nextElementSibling.classList.contains(cssClasses.HELPER_LINE));\n    const helperTextEl =\n        hasHelperLine && nextElementSibling && nextElementSibling.querySelector(helperTextStrings.ROOT_SELECTOR);\n    this.helperText_ = helperTextEl ? helperTextFactory(helperTextEl) : null;\n\n    // Character counter\n    const characterCounterStrings = MDCTextFieldCharacterCounterFoundation.strings;\n    let characterCounterEl = this.root_.querySelector(characterCounterStrings.ROOT_SELECTOR);\n    // If character counter is not found in root element search in sibling element.\n    if (!characterCounterEl && hasHelperLine && nextElementSibling) {\n      characterCounterEl = nextElementSibling.querySelector(characterCounterStrings.ROOT_SELECTOR);\n    }\n    this.characterCounter_ = characterCounterEl ? characterCounterFactory(characterCounterEl) : null;\n\n    this.leadingIcon_ = null;\n    this.trailingIcon_ = null;\n    const iconElements = this.root_.querySelectorAll(strings.ICON_SELECTOR);\n    if (iconElements.length > 0) {\n      if (iconElements.length > 1) { // Has both icons.\n        this.leadingIcon_ = iconFactory(iconElements[0]);\n        this.trailingIcon_ = iconFactory(iconElements[1]);\n      } else {\n        if (this.root_.classList.contains(cssClasses.WITH_LEADING_ICON)) {\n          this.leadingIcon_ = iconFactory(iconElements[0]);\n        } else {\n          this.trailingIcon_ = iconFactory(iconElements[0]);\n        }\n      }\n    }\n\n    this.ripple = this.createRipple_(rippleFactory);\n  }\n\n  destroy() {\n    if (this.ripple) {\n      this.ripple.destroy();\n    }\n    if (this.lineRipple_) {\n      this.lineRipple_.destroy();\n    }\n    if (this.helperText_) {\n      this.helperText_.destroy();\n    }\n    if (this.characterCounter_) {\n      this.characterCounter_.destroy();\n    }\n    if (this.leadingIcon_) {\n      this.leadingIcon_.destroy();\n    }\n    if (this.trailingIcon_) {\n      this.trailingIcon_.destroy();\n    }\n    if (this.label_) {\n      this.label_.destroy();\n    }\n    if (this.outline_) {\n      this.outline_.destroy();\n    }\n    super.destroy();\n  }\n\n  /**\n   * Initializes the Text Field's internal state based on the environment's\n   * state.\n   */\n  initialSyncWithDOM() {\n    this.disabled = this.input_.disabled;\n  }\n\n  get value(): string {\n    return this.foundation_.getValue();\n  }\n\n  /**\n   * @param value The value to set on the input.\n   */\n  set value(value: string) {\n    this.foundation_.setValue(value);\n  }\n\n  get disabled(): boolean {\n    return this.foundation_.isDisabled();\n  }\n\n  /**\n   * @param disabled Sets the Text Field disabled or enabled.\n   */\n  set disabled(disabled: boolean) {\n    this.foundation_.setDisabled(disabled);\n  }\n\n  get valid(): boolean {\n    return this.foundation_.isValid();\n  }\n\n  /**\n   * @param valid Sets the Text Field valid or invalid.\n   */\n  set valid(valid: boolean) {\n    this.foundation_.setValid(valid);\n  }\n\n  get required(): boolean {\n    return this.input_.required;\n  }\n\n  /**\n   * @param required Sets the Text Field to required.\n   */\n  set required(required: boolean) {\n    this.input_.required = required;\n  }\n\n  get pattern(): string {\n    return this.input_.pattern;\n  }\n\n  /**\n   * @param pattern Sets the input element's validation pattern.\n   */\n  set pattern(pattern: string) {\n    this.input_.pattern = pattern;\n  }\n\n  get minLength(): number {\n    return this.input_.minLength;\n  }\n\n  /**\n   * @param minLength Sets the input element's minLength.\n   */\n  set minLength(minLength: number) {\n    this.input_.minLength = minLength;\n  }\n\n  get maxLength(): number {\n    return this.input_.maxLength;\n  }\n\n  /**\n   * @param maxLength Sets the input element's maxLength.\n   */\n  set maxLength(maxLength: number) {\n    // Chrome throws exception if maxLength is set to a value less than zero\n    if (maxLength < 0) {\n      this.input_.removeAttribute('maxLength');\n    } else {\n      this.input_.maxLength = maxLength;\n    }\n  }\n\n  get min(): string {\n    return this.input_.min;\n  }\n\n  /**\n   * @param min Sets the input element's min.\n   */\n  set min(min: string) {\n    this.input_.min = min;\n  }\n\n  get max(): string {\n    return this.input_.max;\n  }\n\n  /**\n   * @param max Sets the input element's max.\n   */\n  set max(max: string) {\n    this.input_.max = max;\n  }\n\n  get step(): string {\n    return this.input_.step;\n  }\n\n  /**\n   * @param step Sets the input element's step.\n   */\n  set step(step: string) {\n    this.input_.step = step;\n  }\n\n  /**\n   * Sets the helper text element content.\n   */\n  set helperTextContent(content: string) {\n    this.foundation_.setHelperTextContent(content);\n  }\n\n  /**\n   * Sets the aria label of the leading icon.\n   */\n  set leadingIconAriaLabel(label: string) {\n    this.foundation_.setLeadingIconAriaLabel(label);\n  }\n\n  /**\n   * Sets the text content of the leading icon.\n   */\n  set leadingIconContent(content: string) {\n    this.foundation_.setLeadingIconContent(content);\n  }\n\n  /**\n   * Sets the aria label of the trailing icon.\n   */\n  set trailingIconAriaLabel(label: string) {\n    this.foundation_.setTrailingIconAriaLabel(label);\n  }\n\n  /**\n   * Sets the text content of the trailing icon.\n   */\n  set trailingIconContent(content: string) {\n    this.foundation_.setTrailingIconContent(content);\n  }\n\n  /**\n   * Enables or disables the use of native validation. Use this for custom validation.\n   * @param useNativeValidation Set this to false to ignore native input validation.\n   */\n  set useNativeValidation(useNativeValidation: boolean) {\n    this.foundation_.setUseNativeValidation(useNativeValidation);\n  }\n\n  /**\n   * Focuses the input element.\n   */\n  focus() {\n    this.input_.focus();\n  }\n\n  /**\n   * Recomputes the outline SVG path for the outline element.\n   */\n  layout() {\n    const openNotch = this.foundation_.shouldFloat;\n    this.foundation_.notchOutline(openNotch);\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCTextFieldAdapter = {\n      ...this.getRootAdapterMethods_(),\n      ...this.getInputAdapterMethods_(),\n      ...this.getLabelAdapterMethods_(),\n      ...this.getLineRippleAdapterMethods_(),\n      ...this.getOutlineAdapterMethods_(),\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCTextFieldFoundation(adapter, this.getFoundationMap_());\n  }\n\n  private getRootAdapterMethods_(): MDCTextFieldRootAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      hasClass: (className) => this.root_.classList.contains(className),\n      registerTextFieldInteractionHandler: (evtType, handler) => this.listen(evtType, handler),\n      deregisterTextFieldInteractionHandler: (evtType, handler) => this.unlisten(evtType, handler),\n      registerValidationAttributeChangeHandler: (handler) => {\n        const getAttributesList = (mutationsList: MutationRecord[]): string[] => {\n          return mutationsList\n              .map((mutation) => mutation.attributeName)\n              .filter((attributeName) => attributeName) as string[];\n        };\n        const observer = new MutationObserver((mutationsList) => handler(getAttributesList(mutationsList)));\n        const config = {attributes: true};\n        observer.observe(this.input_, config);\n        return observer;\n      },\n      deregisterValidationAttributeChangeHandler: (observer) => observer.disconnect(),\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private getInputAdapterMethods_(): MDCTextFieldInputAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      getNativeInput: () => this.input_,\n      isFocused: () => document.activeElement === this.input_,\n      registerInputInteractionHandler: (evtType, handler) =>\n        this.input_.addEventListener(evtType, handler, applyPassive()),\n      deregisterInputInteractionHandler: (evtType, handler) =>\n        this.input_.removeEventListener(evtType, handler, applyPassive()),\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private getLabelAdapterMethods_(): MDCTextFieldLabelAdapter {\n    return {\n      floatLabel: (shouldFloat) => this.label_ && this.label_.float(shouldFloat),\n      getLabelWidth: () => this.label_ ? this.label_.getWidth() : 0,\n      hasLabel: () => Boolean(this.label_),\n      shakeLabel: (shouldShake) => this.label_ && this.label_.shake(shouldShake),\n    };\n  }\n\n  private getLineRippleAdapterMethods_(): MDCTextFieldLineRippleAdapter {\n    return {\n      activateLineRipple: () => {\n        if (this.lineRipple_) {\n          this.lineRipple_.activate();\n        }\n      },\n      deactivateLineRipple: () => {\n        if (this.lineRipple_) {\n          this.lineRipple_.deactivate();\n        }\n      },\n      setLineRippleTransformOrigin: (normalizedX) => {\n        if (this.lineRipple_) {\n          this.lineRipple_.setRippleCenter(normalizedX);\n        }\n      },\n    };\n  }\n\n  private getOutlineAdapterMethods_(): MDCTextFieldOutlineAdapter {\n    return {\n      closeOutline: () => this.outline_ && this.outline_.closeNotch(),\n      hasOutline: () => Boolean(this.outline_),\n      notchOutline: (labelWidth) => this.outline_ && this.outline_.notch(labelWidth),\n    };\n  }\n\n  /**\n   * @return A map of all subcomponents to subfoundations.\n   */\n  private getFoundationMap_(): Partial<MDCTextFieldFoundationMap> {\n    return {\n      characterCounter: this.characterCounter_ ? this.characterCounter_.foundation : undefined,\n      helperText: this.helperText_ ? this.helperText_.foundation : undefined,\n      leadingIcon: this.leadingIcon_ ? this.leadingIcon_.foundation : undefined,\n      trailingIcon: this.trailingIcon_ ? this.trailingIcon_.foundation : undefined,\n    };\n  }\n\n  private createRipple_(rippleFactory: MDCRippleFactory): MDCRipple | null {\n    const isTextArea = this.root_.classList.contains(cssClasses.TEXTAREA);\n    const isOutlined = this.root_.classList.contains(cssClasses.OUTLINED);\n\n    if (isTextArea || isOutlined) {\n      return null;\n    }\n\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCRippleAdapter = {\n      ...MDCRipple.createAdapter(this),\n      isSurfaceActive: () => ponyfill.matches(this.input_, ':active'),\n      registerInteractionHandler: (evtType, handler) => this.input_.addEventListener(evtType, handler, applyPassive()),\n      deregisterInteractionHandler: (evtType, handler) =>\n        this.input_.removeEventListener(evtType, handler, applyPassive()),\n    };\n    // tslint:enable:object-literal-sort-keys\n    return rippleFactory(this.root_, new MDCRippleFoundation(adapter));\n  }\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst strings = {\n  ARIA_CONTROLS: 'aria-controls',\n  ICON_SELECTOR: '.mdc-text-field__icon',\n  INPUT_SELECTOR: '.mdc-text-field__input',\n  LABEL_SELECTOR: '.mdc-floating-label',\n  LINE_RIPPLE_SELECTOR: '.mdc-line-ripple',\n  OUTLINE_SELECTOR: '.mdc-notched-outline',\n};\n\nconst cssClasses = {\n  DENSE: 'mdc-text-field--dense',\n  DISABLED: 'mdc-text-field--disabled',\n  FOCUSED: 'mdc-text-field--focused',\n  FULLWIDTH: 'mdc-text-field--fullwidth',\n  HELPER_LINE: 'mdc-text-field-helper-line',\n  INVALID: 'mdc-text-field--invalid',\n  NO_LABEL: 'mdc-text-field--no-label',\n  OUTLINED: 'mdc-text-field--outlined',\n  ROOT: 'mdc-text-field',\n  TEXTAREA: 'mdc-text-field--textarea',\n  WITH_LEADING_ICON: 'mdc-text-field--with-leading-icon',\n  WITH_TRAILING_ICON: 'mdc-text-field--with-trailing-icon',\n};\n\nconst numbers = {\n  DENSE_LABEL_SCALE: 0.923,\n  LABEL_SCALE: 0.75,\n};\n\n/**\n * Whitelist based off of https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/HTML5/Constraint_validation\n * under the \"Validation-related attributes\" section.\n */\nconst VALIDATION_ATTR_WHITELIST = [\n  'pattern', 'min', 'max', 'required', 'step', 'minlength', 'maxlength',\n];\n\n/**\n * Label should always float for these types as they show some UI even if value is empty.\n */\nconst ALWAYS_FLOAT_TYPES = [\n  'color', 'date', 'datetime-local', 'month', 'range', 'time', 'week',\n];\n\nexport {cssClasses, strings, numbers, VALIDATION_ATTR_WHITELIST, ALWAYS_FLOAT_TYPES};\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCTextFieldAdapter} from './adapter';\nimport {MDCTextFieldCharacterCounterFoundation} from './character-counter/foundation';\nimport {ALWAYS_FLOAT_TYPES, cssClasses, numbers, strings, VALIDATION_ATTR_WHITELIST} from './constants';\nimport {MDCTextFieldHelperTextFoundation} from './helper-text/foundation';\nimport {MDCTextFieldIconFoundation} from './icon/foundation';\nimport {MDCTextFieldFoundationMap, MDCTextFieldNativeInputElement} from './types';\n\ntype PointerDownEventType = 'mousedown' | 'touchstart';\ntype InteractionEventType = 'click' | 'keydown';\n\nconst POINTERDOWN_EVENTS: PointerDownEventType[] = ['mousedown', 'touchstart'];\nconst INTERACTION_EVENTS: InteractionEventType[] = ['click', 'keydown'];\n\nexport class MDCTextFieldFoundation extends MDCFoundation<MDCTextFieldAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  static get numbers() {\n    return numbers;\n  }\n\n  private get shouldAlwaysFloat_(): boolean {\n    const type = this.getNativeInput_().type;\n    return ALWAYS_FLOAT_TYPES.indexOf(type) >= 0;\n  }\n\n  get shouldFloat(): boolean {\n    return this.shouldAlwaysFloat_ || this.isFocused_ || Boolean(this.getValue()) || this.isBadInput_();\n  }\n\n  get shouldShake(): boolean {\n    return !this.isFocused_ && !this.isValid() && Boolean(this.getValue());\n  }\n\n  /**\n   * See {@link MDCTextFieldAdapter} for typing information on parameters and return types.\n   */\n  static get defaultAdapter(): MDCTextFieldAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      hasClass: () => true,\n      registerTextFieldInteractionHandler: () => undefined,\n      deregisterTextFieldInteractionHandler: () => undefined,\n      registerInputInteractionHandler: () => undefined,\n      deregisterInputInteractionHandler: () => undefined,\n      registerValidationAttributeChangeHandler: () => new MutationObserver(() => undefined),\n      deregisterValidationAttributeChangeHandler: () => undefined,\n      getNativeInput: () => null,\n      isFocused: () => false,\n      activateLineRipple: () => undefined,\n      deactivateLineRipple: () => undefined,\n      setLineRippleTransformOrigin: () => undefined,\n      shakeLabel: () => undefined,\n      floatLabel: () => undefined,\n      hasLabel: () => false,\n      getLabelWidth: () => 0,\n      hasOutline: () => false,\n      notchOutline: () => undefined,\n      closeOutline: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private isFocused_ = false;\n  private receivedUserInput_ = false;\n  private isValid_ = true;\n  private useNativeValidation_ = true;\n\n  private readonly inputFocusHandler_: () => void;\n  private readonly inputBlurHandler_: SpecificEventListener<'blur'>;\n  private readonly inputInputHandler_: SpecificEventListener<'input'>;\n  private readonly setPointerXOffset_: SpecificEventListener<PointerDownEventType>;\n  private readonly textFieldInteractionHandler_: SpecificEventListener<InteractionEventType>;\n  private readonly validationAttributeChangeHandler_: (attributesList: string[]) => void;\n  private validationObserver_!: MutationObserver; // assigned in init()\n\n  private readonly helperText_?: MDCTextFieldHelperTextFoundation;\n  private readonly characterCounter_?: MDCTextFieldCharacterCounterFoundation;\n  private readonly leadingIcon_?: MDCTextFieldIconFoundation;\n  private readonly trailingIcon_?: MDCTextFieldIconFoundation;\n\n  /**\n   * @param adapter\n   * @param foundationMap Map from subcomponent names to their subfoundations.\n   */\n  constructor(adapter?: Partial<MDCTextFieldAdapter>, foundationMap: Partial<MDCTextFieldFoundationMap> = {}) {\n    super({...MDCTextFieldFoundation.defaultAdapter, ...adapter});\n\n    this.helperText_ = foundationMap.helperText;\n    this.characterCounter_ = foundationMap.characterCounter;\n    this.leadingIcon_ = foundationMap.leadingIcon;\n    this.trailingIcon_ = foundationMap.trailingIcon;\n\n    this.inputFocusHandler_ = () => this.activateFocus();\n    this.inputBlurHandler_ = () => this.deactivateFocus();\n    this.inputInputHandler_ = () => this.handleInput();\n    this.setPointerXOffset_ = (evt) => this.setTransformOrigin(evt);\n    this.textFieldInteractionHandler_ = () => this.handleTextFieldInteraction();\n    this.validationAttributeChangeHandler_ = (attributesList) => this.handleValidationAttributeChange(attributesList);\n  }\n\n  init() {\n    if (this.adapter_.isFocused()) {\n      this.inputFocusHandler_();\n    } else if (this.adapter_.hasLabel() && this.shouldFloat) {\n      this.notchOutline(true);\n      this.adapter_.floatLabel(true);\n    }\n\n    this.adapter_.registerInputInteractionHandler('focus', this.inputFocusHandler_);\n    this.adapter_.registerInputInteractionHandler('blur', this.inputBlurHandler_);\n    this.adapter_.registerInputInteractionHandler('input', this.inputInputHandler_);\n    POINTERDOWN_EVENTS.forEach((evtType) => {\n      this.adapter_.registerInputInteractionHandler(evtType, this.setPointerXOffset_);\n    });\n    INTERACTION_EVENTS.forEach((evtType) => {\n      this.adapter_.registerTextFieldInteractionHandler(evtType, this.textFieldInteractionHandler_);\n    });\n    this.validationObserver_ =\n        this.adapter_.registerValidationAttributeChangeHandler(this.validationAttributeChangeHandler_);\n    this.setCharacterCounter_(this.getValue().length);\n  }\n\n  destroy() {\n    this.adapter_.deregisterInputInteractionHandler('focus', this.inputFocusHandler_);\n    this.adapter_.deregisterInputInteractionHandler('blur', this.inputBlurHandler_);\n    this.adapter_.deregisterInputInteractionHandler('input', this.inputInputHandler_);\n    POINTERDOWN_EVENTS.forEach((evtType) => {\n      this.adapter_.deregisterInputInteractionHandler(evtType, this.setPointerXOffset_);\n    });\n    INTERACTION_EVENTS.forEach((evtType) => {\n      this.adapter_.deregisterTextFieldInteractionHandler(evtType, this.textFieldInteractionHandler_);\n    });\n    this.adapter_.deregisterValidationAttributeChangeHandler(this.validationObserver_);\n  }\n\n  /**\n   * Handles user interactions with the Text Field.\n   */\n  handleTextFieldInteraction() {\n    const nativeInput = this.adapter_.getNativeInput();\n    if (nativeInput && nativeInput.disabled) {\n      return;\n    }\n    this.receivedUserInput_ = true;\n  }\n\n  /**\n   * Handles validation attribute changes\n   */\n  handleValidationAttributeChange(attributesList: string[]): void {\n    attributesList.some((attributeName) => {\n      if (VALIDATION_ATTR_WHITELIST.indexOf(attributeName) > -1) {\n        this.styleValidity_(true);\n        return true;\n      }\n      return false;\n    });\n\n    if (attributesList.indexOf('maxlength') > -1) {\n      this.setCharacterCounter_(this.getValue().length);\n    }\n  }\n\n  /**\n   * Opens/closes the notched outline.\n   */\n  notchOutline(openNotch: boolean) {\n    if (!this.adapter_.hasOutline()) {\n      return;\n    }\n\n    if (openNotch) {\n      const isDense = this.adapter_.hasClass(cssClasses.DENSE);\n      const labelScale = isDense ? numbers.DENSE_LABEL_SCALE : numbers.LABEL_SCALE;\n      const labelWidth = this.adapter_.getLabelWidth() * labelScale;\n      this.adapter_.notchOutline(labelWidth);\n    } else {\n      this.adapter_.closeOutline();\n    }\n  }\n\n  /**\n   * Activates the text field focus state.\n   */\n  activateFocus() {\n    this.isFocused_ = true;\n    this.styleFocused_(this.isFocused_);\n    this.adapter_.activateLineRipple();\n    if (this.adapter_.hasLabel()) {\n      this.notchOutline(this.shouldFloat);\n      this.adapter_.floatLabel(this.shouldFloat);\n      this.adapter_.shakeLabel(this.shouldShake);\n    }\n    if (this.helperText_) {\n      this.helperText_.showToScreenReader();\n    }\n  }\n\n  /**\n   * Sets the line ripple's transform origin, so that the line ripple activate\n   * animation will animate out from the user's click location.\n   */\n  setTransformOrigin(evt: TouchEvent | MouseEvent): void {\n    const touches = (evt as TouchEvent).touches;\n    const targetEvent = touches ? touches[0] : evt;\n    const targetClientRect = (targetEvent.target as Element).getBoundingClientRect();\n    const normalizedX = (targetEvent as MouseEvent).clientX - targetClientRect.left;\n    this.adapter_.setLineRippleTransformOrigin(normalizedX);\n  }\n\n  /**\n   * Handles input change of text input and text area.\n   */\n  handleInput() {\n    this.autoCompleteFocus();\n    this.setCharacterCounter_(this.getValue().length);\n  }\n\n  /**\n   * Activates the Text Field's focus state in cases when the input value\n   * changes without user input (e.g. programmatically).\n   */\n  autoCompleteFocus() {\n    if (!this.receivedUserInput_) {\n      this.activateFocus();\n    }\n  }\n\n  /**\n   * Deactivates the Text Field's focus state.\n   */\n  deactivateFocus() {\n    this.isFocused_ = false;\n    this.adapter_.deactivateLineRipple();\n    const isValid = this.isValid();\n    this.styleValidity_(isValid);\n    this.styleFocused_(this.isFocused_);\n    if (this.adapter_.hasLabel()) {\n      this.notchOutline(this.shouldFloat);\n      this.adapter_.floatLabel(this.shouldFloat);\n      this.adapter_.shakeLabel(this.shouldShake);\n    }\n    if (!this.shouldFloat) {\n      this.receivedUserInput_ = false;\n    }\n  }\n\n  getValue(): string {\n    return this.getNativeInput_().value;\n  }\n\n  /**\n   * @param value The value to set on the input Element.\n   */\n  setValue(value: string): void {\n    // Prevent Safari from moving the caret to the end of the input when the value has not changed.\n    if (this.getValue() !== value) {\n      this.getNativeInput_().value = value;\n    }\n    this.setCharacterCounter_(value.length);\n    const isValid = this.isValid();\n    this.styleValidity_(isValid);\n    if (this.adapter_.hasLabel()) {\n      this.notchOutline(this.shouldFloat);\n      this.adapter_.floatLabel(this.shouldFloat);\n      this.adapter_.shakeLabel(this.shouldShake);\n    }\n  }\n\n  /**\n   * @return The custom validity state, if set; otherwise, the result of a native validity check.\n   */\n  isValid(): boolean {\n    return this.useNativeValidation_\n        ? this.isNativeInputValid_() : this.isValid_;\n  }\n\n  /**\n   * @param isValid Sets the custom validity state of the Text Field.\n   */\n  setValid(isValid: boolean): void {\n    this.isValid_ = isValid;\n    this.styleValidity_(isValid);\n\n    const shouldShake = !isValid && !this.isFocused_;\n    if (this.adapter_.hasLabel()) {\n      this.adapter_.shakeLabel(shouldShake);\n    }\n  }\n\n  /**\n   * Enables or disables the use of native validation. Use this for custom validation.\n   * @param useNativeValidation Set this to false to ignore native input validation.\n   */\n  setUseNativeValidation(useNativeValidation: boolean): void {\n    this.useNativeValidation_ = useNativeValidation;\n  }\n\n  isDisabled(): boolean {\n    return this.getNativeInput_().disabled;\n  }\n\n  /**\n   * @param disabled Sets the text-field disabled or enabled.\n   */\n  setDisabled(disabled: boolean): void {\n    this.getNativeInput_().disabled = disabled;\n    this.styleDisabled_(disabled);\n  }\n\n  /**\n   * @param content Sets the content of the helper text.\n   */\n  setHelperTextContent(content: string): void {\n    if (this.helperText_) {\n      this.helperText_.setContent(content);\n    }\n  }\n\n  /**\n   * Sets the aria label of the leading icon.\n   */\n  setLeadingIconAriaLabel(label: string): void {\n    if (this.leadingIcon_) {\n      this.leadingIcon_.setAriaLabel(label);\n    }\n  }\n\n  /**\n   * Sets the text content of the leading icon.\n   */\n  setLeadingIconContent(content: string): void {\n    if (this.leadingIcon_) {\n      this.leadingIcon_.setContent(content);\n    }\n  }\n\n  /**\n   * Sets the aria label of the trailing icon.\n   */\n  setTrailingIconAriaLabel(label: string): void {\n    if (this.trailingIcon_) {\n      this.trailingIcon_.setAriaLabel(label);\n    }\n  }\n\n  /**\n   * Sets the text content of the trailing icon.\n   */\n  setTrailingIconContent(content: string): void {\n    if (this.trailingIcon_) {\n      this.trailingIcon_.setContent(content);\n    }\n  }\n\n  /**\n   * Sets character counter values that shows characters used and the total character limit.\n   */\n  private setCharacterCounter_(currentLength: number): void {\n    if (!this.characterCounter_) {\n      return;\n    }\n\n    const maxLength = this.getNativeInput_().maxLength;\n    if (maxLength === -1) {\n      throw new Error('MDCTextFieldFoundation: Expected maxlength html property on text input or textarea.');\n    }\n\n    this.characterCounter_.setCounterValue(currentLength, maxLength);\n  }\n\n  /**\n   * @return True if the Text Field input fails in converting the user-supplied value.\n   */\n  private isBadInput_(): boolean {\n    // The badInput property is not supported in IE 11 💩.\n    return this.getNativeInput_().validity.badInput || false;\n  }\n\n  /**\n   * @return The result of native validity checking (ValidityState.valid).\n   */\n  private isNativeInputValid_(): boolean {\n    return this.getNativeInput_().validity.valid;\n  }\n\n  /**\n   * Styles the component based on the validity state.\n   */\n  private styleValidity_(isValid: boolean): void {\n    const {INVALID} = MDCTextFieldFoundation.cssClasses;\n    if (isValid) {\n      this.adapter_.removeClass(INVALID);\n    } else {\n      this.adapter_.addClass(INVALID);\n    }\n    if (this.helperText_) {\n      this.helperText_.setValidity(isValid);\n    }\n  }\n\n  /**\n   * Styles the component based on the focused state.\n   */\n  private styleFocused_(isFocused: boolean): void {\n    const {FOCUSED} = MDCTextFieldFoundation.cssClasses;\n    if (isFocused) {\n      this.adapter_.addClass(FOCUSED);\n    } else {\n      this.adapter_.removeClass(FOCUSED);\n    }\n  }\n\n  /**\n   * Styles the component based on the disabled state.\n   */\n  private styleDisabled_(isDisabled: boolean): void {\n    const {DISABLED, INVALID} = MDCTextFieldFoundation.cssClasses;\n    if (isDisabled) {\n      this.adapter_.addClass(DISABLED);\n      this.adapter_.removeClass(INVALID);\n    } else {\n      this.adapter_.removeClass(DISABLED);\n    }\n\n    if (this.leadingIcon_) {\n      this.leadingIcon_.setDisabled(isDisabled);\n    }\n\n    if (this.trailingIcon_) {\n      this.trailingIcon_.setDisabled(isDisabled);\n    }\n  }\n\n  /**\n   * @return The native text input element from the host environment, or an object with the same shape for unit tests.\n   */\n  private getNativeInput_(): MDCTextFieldNativeInputElement {\n    // this.adapter_ may be undefined in foundation unit tests. This happens when testdouble is creating a mock object\n    // and invokes the shouldShake/shouldFloat getters (which in turn call getValue(), which calls this method) before\n    // init() has been called from the MDCTextField constructor. To work around that issue, we return a dummy object.\n    const nativeInput = this.adapter_ ? this.adapter_.getNativeInput() : null;\n    return nativeInput || {\n      disabled: false,\n      maxLength: -1,\n      type: 'input',\n      validity: {\n        badInput: false,\n        valid: true,\n      },\n      value: '',\n    };\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTextFieldFoundation;\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCTextFieldHelperTextAdapter} from './adapter';\nimport {MDCTextFieldHelperTextFoundation} from './foundation';\n\nexport type MDCTextFieldHelperTextFactory =\n    (el: Element, foundation?: MDCTextFieldHelperTextFoundation) => MDCTextFieldHelperText;\n\nexport class MDCTextFieldHelperText extends MDCComponent<MDCTextFieldHelperTextFoundation> {\n  static attachTo(root: Element): MDCTextFieldHelperText {\n    return new MDCTextFieldHelperText(root);\n  }\n\n  get foundation(): MDCTextFieldHelperTextFoundation {\n    return this.foundation_;\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCTextFieldHelperTextAdapter = {\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      hasClass: (className) => this.root_.classList.contains(className),\n      setAttr: (attr, value) => this.root_.setAttribute(attr, value),\n      removeAttr: (attr) => this.root_.removeAttribute(attr),\n      setContent: (content) => {\n        this.root_.textContent = content;\n      },\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCTextFieldHelperTextFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n  HELPER_TEXT_PERSISTENT: 'mdc-text-field-helper-text--persistent',\n  HELPER_TEXT_VALIDATION_MSG: 'mdc-text-field-helper-text--validation-msg',\n  ROOT: 'mdc-text-field-helper-text',\n};\n\nconst strings = {\n  ARIA_HIDDEN: 'aria-hidden',\n  ROLE: 'role',\n  ROOT_SELECTOR: `.${cssClasses.ROOT}`,\n};\n\nexport {strings, cssClasses};\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCTextFieldHelperTextAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCTextFieldHelperTextFoundation extends MDCFoundation<MDCTextFieldHelperTextAdapter> {\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get strings() {\n    return strings;\n  }\n\n  /**\n   * See {@link MDCTextFieldHelperTextAdapter} for typing information on parameters and return types.\n   */\n  static get defaultAdapter(): MDCTextFieldHelperTextAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      hasClass: () => false,\n      setAttr: () => undefined,\n      removeAttr: () => undefined,\n      setContent: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  constructor(adapter?: Partial<MDCTextFieldHelperTextAdapter>) {\n    super({...MDCTextFieldHelperTextFoundation.defaultAdapter, ...adapter});\n  }\n\n  /**\n   * Sets the content of the helper text field.\n   */\n  setContent(content: string) {\n    this.adapter_.setContent(content);\n  }\n\n  /**\n   * @param isPersistent Sets the persistency of the helper text.\n   */\n  setPersistent(isPersistent: boolean) {\n    if (isPersistent) {\n      this.adapter_.addClass(cssClasses.HELPER_TEXT_PERSISTENT);\n    } else {\n      this.adapter_.removeClass(cssClasses.HELPER_TEXT_PERSISTENT);\n    }\n  }\n\n  /**\n   * @param isValidation True to make the helper text act as an error validation message.\n   */\n  setValidation(isValidation: boolean) {\n    if (isValidation) {\n      this.adapter_.addClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n    } else {\n      this.adapter_.removeClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n    }\n  }\n\n  /**\n   * Makes the helper text visible to the screen reader.\n   */\n  showToScreenReader() {\n    this.adapter_.removeAttr(strings.ARIA_HIDDEN);\n  }\n\n  /**\n   * Sets the validity of the helper text based on the input validity.\n   */\n  setValidity(inputIsValid: boolean) {\n    const helperTextIsPersistent = this.adapter_.hasClass(cssClasses.HELPER_TEXT_PERSISTENT);\n    const helperTextIsValidationMsg = this.adapter_.hasClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n    const validationMsgNeedsDisplay = helperTextIsValidationMsg && !inputIsValid;\n\n    if (validationMsgNeedsDisplay) {\n      this.adapter_.setAttr(strings.ROLE, 'alert');\n    } else {\n      this.adapter_.removeAttr(strings.ROLE);\n    }\n\n    if (!helperTextIsPersistent && !validationMsgNeedsDisplay) {\n      this.hide_();\n    }\n  }\n\n  /**\n   * Hides the help text from screen readers.\n   */\n  private hide_() {\n    this.adapter_.setAttr(strings.ARIA_HIDDEN, 'true');\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTextFieldHelperTextFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport {cssClasses as helperTextCssClasses, strings as helperTextStrings} from './constants';\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCTextFieldIconAdapter} from './adapter';\nimport {MDCTextFieldIconFoundation} from './foundation';\n\nexport type MDCTextFieldIconFactory = (el: Element, foundation?: MDCTextFieldIconFoundation) => MDCTextFieldIcon;\n\nexport class MDCTextFieldIcon extends MDCComponent<MDCTextFieldIconFoundation> {\n  static attachTo(root: Element): MDCTextFieldIcon {\n    return new MDCTextFieldIcon(root);\n  }\n\n  get foundation(): MDCTextFieldIconFoundation {\n    return this.foundation_;\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCTextFieldIconAdapter = {\n      getAttr: (attr) => this.root_.getAttribute(attr),\n      setAttr: (attr, value) => this.root_.setAttribute(attr, value),\n      removeAttr: (attr) => this.root_.removeAttribute(attr),\n      setContent: (content) => {\n        this.root_.textContent = content;\n      },\n      registerInteractionHandler: (evtType, handler) => this.listen(evtType, handler),\n      deregisterInteractionHandler: (evtType, handler) => this.unlisten(evtType, handler),\n      notifyIconAction: () => this.emit(\n          MDCTextFieldIconFoundation.strings.ICON_EVENT, {} /* evtData */, true /* shouldBubble */),\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCTextFieldIconFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst strings = {\n  ICON_EVENT: 'MDCTextField:icon',\n  ICON_ROLE: 'button',\n};\n\nconst cssClasses = {\n  ROOT: 'mdc-text-field__icon',\n};\n\nexport {strings, cssClasses};\n","/**\n * @license\n * Copyright 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCTextFieldIconAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\ntype InteractionEventType = 'click' | 'keydown';\n\nconst INTERACTION_EVENTS: InteractionEventType[] = ['click', 'keydown'];\n\nexport class MDCTextFieldIconFoundation extends MDCFoundation<MDCTextFieldIconAdapter> {\n  static get strings() {\n    return strings;\n  }\n\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  /**\n   * See {@link MDCTextFieldIconAdapter} for typing information on parameters and return types.\n   */\n  static get defaultAdapter(): MDCTextFieldIconAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      getAttr: () => null,\n      setAttr: () => undefined,\n      removeAttr: () => undefined,\n      setContent: () => undefined,\n      registerInteractionHandler: () => undefined,\n      deregisterInteractionHandler: () => undefined,\n      notifyIconAction: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private savedTabIndex_: string | null = null;\n  private readonly interactionHandler_: SpecificEventListener<InteractionEventType>;\n\n  constructor(adapter?: Partial<MDCTextFieldIconAdapter>) {\n    super({...MDCTextFieldIconFoundation.defaultAdapter, ...adapter});\n\n    this.interactionHandler_ = (evt) => this.handleInteraction(evt);\n  }\n\n  init() {\n    this.savedTabIndex_ = this.adapter_.getAttr('tabindex');\n\n    INTERACTION_EVENTS.forEach((evtType) => {\n      this.adapter_.registerInteractionHandler(evtType, this.interactionHandler_);\n    });\n  }\n\n  destroy() {\n    INTERACTION_EVENTS.forEach((evtType) => {\n      this.adapter_.deregisterInteractionHandler(evtType, this.interactionHandler_);\n    });\n  }\n\n  setDisabled(disabled: boolean) {\n    if (!this.savedTabIndex_) {\n      return;\n    }\n\n    if (disabled) {\n      this.adapter_.setAttr('tabindex', '-1');\n      this.adapter_.removeAttr('role');\n    } else {\n      this.adapter_.setAttr('tabindex', this.savedTabIndex_);\n      this.adapter_.setAttr('role', strings.ICON_ROLE);\n    }\n  }\n\n  setAriaLabel(label: string) {\n    this.adapter_.setAttr('aria-label', label);\n  }\n\n  setContent(content: string) {\n    this.adapter_.setContent(content);\n  }\n\n  handleInteraction(evt: MouseEvent | KeyboardEvent) {\n    const isEnterKey = (evt as KeyboardEvent).key === 'Enter' || (evt as KeyboardEvent).keyCode === 13;\n    if (evt.type === 'click' || isEnterKey) {\n      this.adapter_.notifyIconAction();\n    }\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTextFieldIconFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport {cssClasses as iconCssClasses, strings as iconStrings} from './constants';\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\nexport * from './character-counter/index';\nexport * from './helper-text/index';\nexport * from './icon/index';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCRipple, MDCRippleFactory} from '@material/ripple/component';\nimport {MDCTopAppBarAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCFixedTopAppBarFoundation} from './fixed/foundation';\nimport {MDCTopAppBarBaseFoundation} from './foundation';\nimport {MDCShortTopAppBarFoundation} from './short/foundation';\nimport {MDCTopAppBarFoundation} from './standard/foundation';\n\nexport class MDCTopAppBar extends MDCComponent<MDCTopAppBarBaseFoundation> {\n  static attachTo(root: Element): MDCTopAppBar {\n    return new MDCTopAppBar(root);\n  }\n\n  private handleNavigationClick_!: SpecificEventListener<'click'>; // assigned in initialSyncWithDOM()\n  private handleWindowResize_!: SpecificEventListener<'resize'>; // assigned in initialSyncWithDOM()\n  private handleTargetScroll_!: SpecificEventListener<'scroll'>; // assigned in initialSyncWithDOM()\n  private navIcon_!: Element | null;\n  private iconRipples_!: MDCRipple[];\n  private scrollTarget_!: EventTarget;\n\n  initialize(rippleFactory: MDCRippleFactory = (el) => MDCRipple.attachTo(el)) {\n    this.navIcon_ = this.root_.querySelector(strings.NAVIGATION_ICON_SELECTOR);\n\n    // Get all icons in the toolbar and instantiate the ripples\n    const icons: Element[] = [].slice.call(this.root_.querySelectorAll(strings.ACTION_ITEM_SELECTOR));\n    if (this.navIcon_) {\n      icons.push(this.navIcon_);\n    }\n\n    this.iconRipples_ = icons.map((icon) => {\n      const ripple = rippleFactory(icon);\n      ripple.unbounded = true;\n      return ripple;\n    });\n\n    this.scrollTarget_ = window;\n  }\n\n  initialSyncWithDOM() {\n    this.handleNavigationClick_ = this.foundation_.handleNavigationClick.bind(this.foundation_);\n    this.handleWindowResize_ = this.foundation_.handleWindowResize.bind(this.foundation_);\n    this.handleTargetScroll_ = this.foundation_.handleTargetScroll.bind(this.foundation_);\n\n    this.scrollTarget_.addEventListener('scroll', this.handleTargetScroll_ as EventListener);\n\n    if (this.navIcon_) {\n      this.navIcon_.addEventListener('click', this.handleNavigationClick_ as EventListener);\n    }\n\n    const isFixed = this.root_.classList.contains(cssClasses.FIXED_CLASS);\n    const isShort = this.root_.classList.contains(cssClasses.SHORT_CLASS);\n    if (!isShort && !isFixed) {\n      window.addEventListener('resize', this.handleWindowResize_ as EventListener);\n    }\n  }\n\n  destroy() {\n    this.iconRipples_.forEach((iconRipple) => iconRipple.destroy());\n    this.scrollTarget_.removeEventListener('scroll', this.handleTargetScroll_ as EventListener);\n    if (this.navIcon_) {\n      this.navIcon_.removeEventListener('click', this.handleNavigationClick_ as EventListener);\n    }\n    const isFixed = this.root_.classList.contains(cssClasses.FIXED_CLASS);\n    const isShort = this.root_.classList.contains(cssClasses.SHORT_CLASS);\n    if (!isShort && !isFixed) {\n      window.removeEventListener('resize', this.handleWindowResize_ as EventListener);\n    }\n    super.destroy();\n  }\n\n  setScrollTarget(target: EventTarget) {\n    // Remove scroll handler from the previous scroll target\n    this.scrollTarget_.removeEventListener('scroll', this.handleTargetScroll_ as EventListener);\n\n    this.scrollTarget_ = target;\n\n    // Initialize scroll handler on the new scroll target\n    this.handleTargetScroll_ =\n      this.foundation_.handleTargetScroll.bind(this.foundation_);\n    this.scrollTarget_.addEventListener('scroll', this.handleTargetScroll_ as EventListener);\n  }\n\n  getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n    // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    const adapter: MDCTopAppBarAdapter = {\n      hasClass: (className) => this.root_.classList.contains(className),\n      addClass: (className) => this.root_.classList.add(className),\n      removeClass: (className) => this.root_.classList.remove(className),\n      setStyle: (property, value) => (this.root_ as HTMLElement).style.setProperty(property, value),\n      getTopAppBarHeight: () => this.root_.clientHeight,\n      notifyNavigationIconClicked: () => this.emit(strings.NAVIGATION_EVENT, {}),\n      getViewportScrollY: () => {\n        const win = this.scrollTarget_ as Window;\n        const el = this.scrollTarget_ as Element;\n        return win.pageYOffset !== undefined ? win.pageYOffset : el.scrollTop;\n      },\n      getTotalActionItems: () => this.root_.querySelectorAll(strings.ACTION_ITEM_SELECTOR).length,\n    };\n    // tslint:enable:object-literal-sort-keys\n\n    let foundation: MDCTopAppBarBaseFoundation;\n    if (this.root_.classList.contains(cssClasses.SHORT_CLASS)) {\n      foundation = new MDCShortTopAppBarFoundation(adapter);\n    } else if (this.root_.classList.contains(cssClasses.FIXED_CLASS)) {\n      foundation = new MDCFixedTopAppBarFoundation(adapter);\n    } else {\n      foundation = new MDCTopAppBarFoundation(adapter);\n    }\n\n    return foundation;\n  }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n  FIXED_CLASS: 'mdc-top-app-bar--fixed',\n  FIXED_SCROLLED_CLASS: 'mdc-top-app-bar--fixed-scrolled',\n  SHORT_CLASS: 'mdc-top-app-bar--short',\n  SHORT_COLLAPSED_CLASS: 'mdc-top-app-bar--short-collapsed',\n  SHORT_HAS_ACTION_ITEM_CLASS: 'mdc-top-app-bar--short-has-action-item',\n};\n\nconst numbers = {\n  DEBOUNCE_THROTTLE_RESIZE_TIME_MS: 100,\n  MAX_TOP_APP_BAR_HEIGHT: 128,\n};\n\nconst strings = {\n  ACTION_ITEM_SELECTOR: '.mdc-top-app-bar__action-item',\n  NAVIGATION_EVENT: 'MDCTopAppBar:nav',\n  NAVIGATION_ICON_SELECTOR: '.mdc-top-app-bar__navigation-icon',\n  ROOT_SELECTOR: '.mdc-top-app-bar',\n  TITLE_SELECTOR: '.mdc-top-app-bar__title',\n};\n\nexport {cssClasses, numbers, strings};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {cssClasses} from '../constants';\nimport {MDCTopAppBarFoundation} from '../standard/foundation';\n\nexport class MDCFixedTopAppBarFoundation extends MDCTopAppBarFoundation {\n  /**\n   * State variable for the previous scroll iteration top app bar state\n   */\n  private wasScrolled_ = false;\n\n  /**\n   * Scroll handler for applying/removing the modifier class on the fixed top app bar.\n   * @override\n   */\n  handleTargetScroll() {\n    const currentScroll = this.adapter_.getViewportScrollY();\n\n    if (currentScroll <= 0) {\n      if (this.wasScrolled_) {\n        this.adapter_.removeClass(cssClasses.FIXED_SCROLLED_CLASS);\n        this.wasScrolled_ = false;\n      }\n    } else {\n      if (!this.wasScrolled_) {\n        this.adapter_.addClass(cssClasses.FIXED_SCROLLED_CLASS);\n        this.wasScrolled_ = true;\n      }\n    }\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCFixedTopAppBarFoundation;\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCTopAppBarAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\nexport class MDCTopAppBarBaseFoundation extends MDCFoundation<MDCTopAppBarAdapter> {\n  static get strings() {\n    return strings;\n  }\n\n  static get cssClasses() {\n    return cssClasses;\n  }\n\n  static get numbers() {\n    return numbers;\n  }\n\n  /**\n   * See {@link MDCTopAppBarAdapter} for typing information on parameters and return types.\n   */\n  static get defaultAdapter(): MDCTopAppBarAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      hasClass: () => false,\n      setStyle: () => undefined,\n      getTopAppBarHeight: () => 0,\n      notifyNavigationIconClicked: () => undefined,\n      getViewportScrollY: () => 0,\n      getTotalActionItems: () => 0,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  /* istanbul ignore next: optional argument is not a branch statement */\n  constructor(adapter?: Partial<MDCTopAppBarAdapter>) {\n    super({...MDCTopAppBarBaseFoundation.defaultAdapter, ...adapter});\n  }\n\n  /** Other variants of TopAppBar foundation overrides this method */\n  handleTargetScroll() {} // tslint:disable-line:no-empty\n  /** Other variants of TopAppBar foundation overrides this method */\n  handleWindowResize() {} // tslint:disable-line:no-empty\n\n  handleNavigationClick() {\n    this.adapter_.notifyNavigationIconClicked();\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTopAppBarBaseFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './fixed/foundation';\nexport * from './short/foundation';\nexport * from './standard/foundation';\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCTopAppBarAdapter} from '../adapter';\nimport {cssClasses} from '../constants';\nimport {MDCTopAppBarBaseFoundation} from '../foundation';\n\nexport class MDCShortTopAppBarFoundation extends MDCTopAppBarBaseFoundation {\n  // Public visibility for backward compatibility.\n  get isCollapsed(): boolean {\n    return this.isCollapsed_;\n  }\n\n  private isCollapsed_ = false;\n\n  private isAlwaysCollapsed_ = false;\n\n  /* istanbul ignore next: optional argument is not a branch statement */\n  constructor(adapter?: Partial<MDCTopAppBarAdapter>) {\n    super(adapter);\n  }\n\n  init() {\n    super.init();\n\n    if (this.adapter_.getTotalActionItems() > 0) {\n      this.adapter_.addClass(cssClasses.SHORT_HAS_ACTION_ITEM_CLASS);\n    }\n\n    // If initialized with SHORT_COLLAPSED_CLASS, the bar should always be collapsed\n    this.setAlwaysCollapsed(\n      this.adapter_.hasClass(cssClasses.SHORT_COLLAPSED_CLASS));\n  }\n\n  /**\n   * Set if the short top app bar should always be collapsed.\n   *\n   * @param value When `true`, bar will always be collapsed. When `false`, bar may collapse or expand based on scroll.\n   */\n  setAlwaysCollapsed(value: boolean) {\n    this.isAlwaysCollapsed_ = !!value;\n    if (this.isAlwaysCollapsed_) {\n      this.collapse_();\n    } else {\n      // let maybeCollapseBar_ determine if the bar should be collapsed\n      this.maybeCollapseBar_();\n    }\n  }\n\n  getAlwaysCollapsed() {\n    return this.isAlwaysCollapsed_;\n  }\n\n  /**\n   * Scroll handler for applying/removing the collapsed modifier class on the short top app bar.\n   * @override\n   */\n  handleTargetScroll() {\n    this.maybeCollapseBar_();\n  }\n\n  private maybeCollapseBar_() {\n    if (this.isAlwaysCollapsed_) {\n      return;\n    }\n    const currentScroll = this.adapter_.getViewportScrollY();\n\n    if (currentScroll <= 0) {\n      if (this.isCollapsed_) {\n        this.uncollapse_();\n      }\n    } else {\n      if (!this.isCollapsed_) {\n        this.collapse_();\n      }\n    }\n  }\n\n  private uncollapse_() {\n    this.adapter_.removeClass(cssClasses.SHORT_COLLAPSED_CLASS);\n    this.isCollapsed_ = false;\n  }\n\n  private collapse_() {\n    this.adapter_.addClass(cssClasses.SHORT_COLLAPSED_CLASS);\n    this.isCollapsed_ = true;\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCShortTopAppBarFoundation;\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCTopAppBarAdapter} from '../adapter';\nimport {numbers} from '../constants';\nimport {MDCTopAppBarBaseFoundation} from '../foundation';\n\nconst INITIAL_VALUE = 0;\n\nexport class MDCTopAppBarFoundation extends MDCTopAppBarBaseFoundation {\n  /**\n   * Indicates if the top app bar was docked in the previous scroll handler iteration.\n   */\n  private wasDocked_ = true;\n\n  /**\n   * Indicates if the top app bar is docked in the fully shown position.\n   */\n  private isDockedShowing_ = true;\n\n  /**\n   * Variable for current scroll position of the top app bar\n   */\n  private currentAppBarOffsetTop_ = 0;\n\n  /**\n   * Used to prevent the top app bar from being scrolled out of view during resize events\n   */\n  private isCurrentlyBeingResized_ = false;\n\n  /**\n   * The timeout that's used to throttle the resize events\n   */\n  private resizeThrottleId_ = INITIAL_VALUE;\n\n  /**\n   * Used for diffs of current scroll position vs previous scroll position\n   */\n  private lastScrollPosition_: number;\n\n  /**\n   * Used to verify when the top app bar is completely showing or completely hidden\n   */\n  private topAppBarHeight_: number;\n\n  /**\n   * The timeout that's used to debounce toggling the isCurrentlyBeingResized_ variable after a resize\n   */\n  private resizeDebounceId_ = INITIAL_VALUE;\n\n  /* istanbul ignore next: optional argument is not a branch statement */\n  constructor(adapter?: Partial<MDCTopAppBarAdapter>) {\n    super(adapter);\n\n    this.lastScrollPosition_ = this.adapter_.getViewportScrollY();\n    this.topAppBarHeight_ = this.adapter_.getTopAppBarHeight();\n  }\n\n  destroy() {\n    super.destroy();\n    this.adapter_.setStyle('top', '');\n  }\n\n  /**\n   * Scroll handler for the default scroll behavior of the top app bar.\n   * @override\n   */\n  handleTargetScroll() {\n    const currentScrollPosition = Math.max(this.adapter_.getViewportScrollY(), 0);\n    const diff = currentScrollPosition - this.lastScrollPosition_;\n    this.lastScrollPosition_ = currentScrollPosition;\n\n    // If the window is being resized the lastScrollPosition_ needs to be updated but the\n    // current scroll of the top app bar should stay in the same position.\n    if (!this.isCurrentlyBeingResized_) {\n      this.currentAppBarOffsetTop_ -= diff;\n\n      if (this.currentAppBarOffsetTop_ > 0) {\n        this.currentAppBarOffsetTop_ = 0;\n      } else if (Math.abs(this.currentAppBarOffsetTop_) > this.topAppBarHeight_) {\n        this.currentAppBarOffsetTop_ = -this.topAppBarHeight_;\n      }\n\n      this.moveTopAppBar_();\n    }\n  }\n\n  /**\n   * Top app bar resize handler that throttle/debounce functions that execute updates.\n   * @override\n   */\n  handleWindowResize() {\n    // Throttle resize events 10 p/s\n    if (!this.resizeThrottleId_) {\n      this.resizeThrottleId_ = setTimeout(() => {\n        this.resizeThrottleId_ = INITIAL_VALUE;\n        this.throttledResizeHandler_();\n      }, numbers.DEBOUNCE_THROTTLE_RESIZE_TIME_MS);\n    }\n\n    this.isCurrentlyBeingResized_ = true;\n\n    if (this.resizeDebounceId_) {\n      clearTimeout(this.resizeDebounceId_);\n    }\n\n    this.resizeDebounceId_ = setTimeout(() => {\n      this.handleTargetScroll();\n      this.isCurrentlyBeingResized_ = false;\n      this.resizeDebounceId_ = INITIAL_VALUE;\n    }, numbers.DEBOUNCE_THROTTLE_RESIZE_TIME_MS);\n  }\n\n  /**\n   * Function to determine if the DOM needs to update.\n   */\n  private checkForUpdate_(): boolean {\n    const offscreenBoundaryTop = -this.topAppBarHeight_;\n    const hasAnyPixelsOffscreen = this.currentAppBarOffsetTop_ < 0;\n    const hasAnyPixelsOnscreen = this.currentAppBarOffsetTop_ > offscreenBoundaryTop;\n    const partiallyShowing = hasAnyPixelsOffscreen && hasAnyPixelsOnscreen;\n\n    // If it's partially showing, it can't be docked.\n    if (partiallyShowing) {\n      this.wasDocked_ = false;\n    } else {\n      // Not previously docked and not partially showing, it's now docked.\n      if (!this.wasDocked_) {\n        this.wasDocked_ = true;\n        return true;\n      } else if (this.isDockedShowing_ !== hasAnyPixelsOnscreen) {\n        this.isDockedShowing_ = hasAnyPixelsOnscreen;\n        return true;\n      }\n    }\n\n    return partiallyShowing;\n  }\n\n  /**\n   * Function to move the top app bar if needed.\n   */\n  private moveTopAppBar_() {\n    if (this.checkForUpdate_()) {\n      // Once the top app bar is fully hidden we use the max potential top app bar height as our offset\n      // so the top app bar doesn't show if the window resizes and the new height > the old height.\n      let offset = this.currentAppBarOffsetTop_;\n      if (Math.abs(offset) >= this.topAppBarHeight_) {\n        offset = -numbers.MAX_TOP_APP_BAR_HEIGHT;\n      }\n\n      this.adapter_.setStyle('top', offset + 'px');\n    }\n  }\n\n  /**\n   * Throttled function that updates the top app bar scrolled values if the\n   * top app bar height changes.\n   */\n  private throttledResizeHandler_() {\n    const currentHeight = this.adapter_.getTopAppBarHeight();\n    if (this.topAppBarHeight_ !== currentHeight) {\n      this.wasDocked_ = false;\n\n      // Since the top app bar has a different height depending on the screen width, this\n      // will ensure that the top app bar remains in the correct location if\n      // completely hidden and a resize makes the top app bar a different height.\n      this.currentAppBarOffsetTop_ -= this.topAppBarHeight_ - currentHeight;\n      this.topAppBarHeight_ = currentHeight;\n    }\n    this.handleTargetScroll();\n  }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTopAppBarFoundation;\n"],"sourceRoot":""}