{"version":3,"sources":["webpack://mdc/webpack/universalModuleDefinition","webpack://mdc/webpack/bootstrap","webpack://mdc/./node_modules/process/browser.js","webpack://mdc/./node_modules/safevalues/builders/attribute_builders.js","webpack://mdc/./node_modules/safevalues/builders/html_builders.js","webpack://mdc/./node_modules/safevalues/builders/html_sanitizer/html_sanitizer.js","webpack://mdc/./node_modules/safevalues/builders/html_sanitizer/html_sanitizer_builder.js","webpack://mdc/./node_modules/safevalues/builders/html_sanitizer/inert_fragment.js","webpack://mdc/./node_modules/safevalues/builders/html_sanitizer/no_clobber.js","webpack://mdc/./node_modules/safevalues/builders/html_sanitizer/sanitizer_table/default_sanitizer_table.js","webpack://mdc/./node_modules/safevalues/builders/html_sanitizer/sanitizer_table/sanitizer_table.js","webpack://mdc/./node_modules/safevalues/builders/resource_url_builders.js","webpack://mdc/./node_modules/safevalues/builders/script_builders.js","webpack://mdc/./node_modules/safevalues/builders/sensitive_attributes.js","webpack://mdc/./node_modules/safevalues/builders/style_builders.js","webpack://mdc/./node_modules/safevalues/builders/style_sheet_builders.js","webpack://mdc/./node_modules/safevalues/builders/url_sanitizer.js","webpack://mdc/./node_modules/safevalues/dom/elements/anchor.js","webpack://mdc/./node_modules/safevalues/dom/elements/area.js","webpack://mdc/./node_modules/safevalues/dom/elements/button.js","webpack://mdc/./node_modules/safevalues/dom/elements/element.js","webpack://mdc/./node_modules/safevalues/dom/elements/embed.js","webpack://mdc/./node_modules/safevalues/dom/elements/form.js","webpack://mdc/./node_modules/safevalues/dom/elements/iframe.js","webpack://mdc/./node_modules/safevalues/dom/elements/input.js","webpack://mdc/./node_modules/safevalues/dom/elements/link.js","webpack://mdc/./node_modules/safevalues/dom/elements/object.js","webpack://mdc/./node_modules/safevalues/dom/elements/script.js","webpack://mdc/./node_modules/safevalues/dom/elements/style.js","webpack://mdc/./node_modules/safevalues/dom/globals/document.js","webpack://mdc/./node_modules/safevalues/dom/globals/dom_parser.js","webpack://mdc/./node_modules/safevalues/dom/globals/global.js","webpack://mdc/./node_modules/safevalues/dom/globals/location.js","webpack://mdc/./node_modules/safevalues/dom/globals/range.js","webpack://mdc/./node_modules/safevalues/dom/globals/service_worker_container.js","webpack://mdc/./node_modules/safevalues/dom/globals/window.js","webpack://mdc/./node_modules/safevalues/dom/globals/worker.js","webpack://mdc/./node_modules/safevalues/dom/index.js","webpack://mdc/./node_modules/safevalues/environment/dev.js","webpack://mdc/./node_modules/safevalues/index.js","webpack://mdc/./node_modules/safevalues/internals/attribute_impl.js","webpack://mdc/./node_modules/safevalues/internals/html_impl.js","webpack://mdc/./node_modules/safevalues/internals/resource_url_impl.js","webpack://mdc/./node_modules/safevalues/internals/script_impl.js","webpack://mdc/./node_modules/safevalues/internals/secrets.js","webpack://mdc/./node_modules/safevalues/internals/string_literal.js","webpack://mdc/./node_modules/safevalues/internals/style_impl.js","webpack://mdc/./node_modules/safevalues/internals/style_sheet_impl.js","webpack://mdc/./node_modules/safevalues/internals/trusted_types.js","webpack://mdc/./packages/material-components-web/index.ts","webpack://mdc/./packages/mdc-animation/animationframe.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-banner/adapter.ts","webpack://mdc/./packages/mdc-banner/component.ts","webpack://mdc/./packages/mdc-banner/constants.ts","webpack://mdc/./packages/mdc-banner/foundation.ts","webpack://mdc/./packages/mdc-banner/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-base/observer-foundation.ts","webpack://mdc/./packages/mdc-base/observer.ts","webpack://mdc/./packages/mdc-base/types.ts","webpack://mdc/./packages/mdc-checkbox/adapter.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/deprecated/chip-set/adapter.ts","webpack://mdc/./packages/mdc-chips/deprecated/chip-set/component.ts","webpack://mdc/./packages/mdc-chips/deprecated/chip-set/constants.ts","webpack://mdc/./packages/mdc-chips/deprecated/chip-set/foundation.ts","webpack://mdc/./packages/mdc-chips/deprecated/chip-set/index.ts","webpack://mdc/./packages/mdc-chips/deprecated/chip/adapter.ts","webpack://mdc/./packages/mdc-chips/deprecated/chip/component.ts","webpack://mdc/./packages/mdc-chips/deprecated/chip/constants.ts","webpack://mdc/./packages/mdc-chips/deprecated/chip/foundation.ts","webpack://mdc/./packages/mdc-chips/deprecated/chip/index.ts","webpack://mdc/./packages/mdc-chips/deprecated/chip/types.ts","webpack://mdc/./packages/mdc-chips/deprecated/index.ts","webpack://mdc/./packages/mdc-chips/deprecated/trailingaction/adapter.ts","webpack://mdc/./packages/mdc-chips/deprecated/trailingaction/component.ts","webpack://mdc/./packages/mdc-chips/deprecated/trailingaction/constants.ts","webpack://mdc/./packages/mdc-chips/deprecated/trailingaction/foundation.ts","webpack://mdc/./packages/mdc-chips/deprecated/trailingaction/index.ts","webpack://mdc/./packages/mdc-chips/deprecated/trailingaction/types.ts","webpack://mdc/./packages/mdc-circular-progress/adapter.ts","webpack://mdc/./packages/mdc-circular-progress/component.ts","webpack://mdc/./packages/mdc-circular-progress/constants.ts","webpack://mdc/./packages/mdc-circular-progress/foundation.ts","webpack://mdc/./packages/mdc-circular-progress/index.ts","webpack://mdc/./packages/mdc-data-table/adapter.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-data-table/types.ts","webpack://mdc/./packages/mdc-dialog/adapter.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/types.ts","webpack://mdc/./packages/mdc-dialog/util.ts","webpack://mdc/./packages/mdc-dom/announce.ts","webpack://mdc/./packages/mdc-dom/events.ts","webpack://mdc/./packages/mdc-dom/focus-trap.ts","webpack://mdc/./packages/mdc-dom/index.ts","webpack://mdc/./packages/mdc-dom/keyboard.ts","webpack://mdc/./packages/mdc-dom/ponyfill.ts","webpack://mdc/./packages/mdc-drawer/adapter.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/util.ts","webpack://mdc/./packages/mdc-floating-label/adapter.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/adapter.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-icon-button/adapter.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-icon-button/types.ts","webpack://mdc/./packages/mdc-line-ripple/adapter.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/adapter.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-linear-progress/types.ts","webpack://mdc/./packages/mdc-list/adapter.ts","webpack://mdc/./packages/mdc-list/component.ts","webpack://mdc/./packages/mdc-list/constants.ts","webpack://mdc/./packages/mdc-list/events.ts","webpack://mdc/./packages/mdc-list/foundation.ts","webpack://mdc/./packages/mdc-list/index.ts","webpack://mdc/./packages/mdc-list/typeahead.ts","webpack://mdc/./packages/mdc-list/types.ts","webpack://mdc/./packages/mdc-menu-surface/adapter.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/types.ts","webpack://mdc/./packages/mdc-menu/adapter.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-menu/types.ts","webpack://mdc/./packages/mdc-notched-outline/adapter.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/adapter.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/adapter.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/types.ts","webpack://mdc/./packages/mdc-ripple/util.ts","webpack://mdc/./packages/mdc-segmented-button/index.ts","webpack://mdc/./packages/mdc-segmented-button/segment/adapter.ts","webpack://mdc/./packages/mdc-segmented-button/segment/component.ts","webpack://mdc/./packages/mdc-segmented-button/segment/constants.ts","webpack://mdc/./packages/mdc-segmented-button/segment/foundation.ts","webpack://mdc/./packages/mdc-segmented-button/segment/index.ts","webpack://mdc/./packages/mdc-segmented-button/segmented-button/adapter.ts","webpack://mdc/./packages/mdc-segmented-button/segmented-button/component.ts","webpack://mdc/./packages/mdc-segmented-button/segmented-button/constants.ts","webpack://mdc/./packages/mdc-segmented-button/segmented-button/foundation.ts","webpack://mdc/./packages/mdc-segmented-button/segmented-button/index.ts","webpack://mdc/./packages/mdc-segmented-button/types.ts","webpack://mdc/./packages/mdc-select/adapter.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/adapter.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/adapter.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-select/types.ts","webpack://mdc/./packages/mdc-slider/adapter.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-slider/types.ts","webpack://mdc/./packages/mdc-snackbar/adapter.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/types.ts","webpack://mdc/./packages/mdc-snackbar/util.ts","webpack://mdc/./packages/mdc-switch/adapter.ts","webpack://mdc/./packages/mdc-switch/component.ts","webpack://mdc/./packages/mdc-switch/constants.ts","webpack://mdc/./packages/mdc-switch/deprecated/adapter.ts","webpack://mdc/./packages/mdc-switch/deprecated/component.ts","webpack://mdc/./packages/mdc-switch/deprecated/constants.ts","webpack://mdc/./packages/mdc-switch/deprecated/foundation.ts","webpack://mdc/./packages/mdc-switch/deprecated/index.ts","webpack://mdc/./packages/mdc-switch/foundation.ts","webpack://mdc/./packages/mdc-switch/index.ts","webpack://mdc/./packages/mdc-tab-bar/adapter.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-bar/types.ts","webpack://mdc/./packages/mdc-tab-indicator/adapter.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/adapter.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/types.ts","webpack://mdc/./packages/mdc-tab-scroller/util.ts","webpack://mdc/./packages/mdc-tab/adapter.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-tab/types.ts","webpack://mdc/./packages/mdc-textfield/adapter.ts","webpack://mdc/./packages/mdc-textfield/character-counter/adapter.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/adapter.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/adapter.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-textfield/types.ts","webpack://mdc/./packages/mdc-tooltip/adapter.ts","webpack://mdc/./packages/mdc-tooltip/component.ts","webpack://mdc/./packages/mdc-tooltip/constants.ts","webpack://mdc/./packages/mdc-tooltip/foundation.ts","webpack://mdc/./packages/mdc-tooltip/index.ts","webpack://mdc/./packages/mdc-top-app-bar/adapter.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":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,O;ACVA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,kDAA0C,gCAAgC;AAC1E;AACA;;AAEA;AACA;AACA;AACA,gEAAwD,kBAAkB;AAC1E;AACA,yDAAiD,cAAc;AAC/D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAyC,iCAAiC;AAC1E,wHAAgH,mBAAmB,EAAE;AACrI;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;;AAGA;AACA;;;;;;;;;;;;AClFA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,uBAAuB,sBAAsB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,qCAAqC;;AAErC;AACA;AACA;;AAEA,2BAA2B;AAC3B;AACA;AACA;AACA,4BAA4B,UAAU;;;;;;;;;;;;;ACvLzB;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,uBAAuB,mBAAO,CAAC,0FAA6B;AAC5D,uBAAuB,mBAAO,CAAC,0FAA6B;AAC5D,6BAA6B,mBAAO,CAAC,0FAAwB;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA,wCAAwC;AACxC;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;;;;;;;;;;;;AC3Ca;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,kBAAkB,mBAAO,CAAC,gFAAwB;AAClD,0BAA0B,mBAAO,CAAC,gGAAgC;AAClE,oBAAoB,mBAAO,CAAC,oFAA0B;AACtD;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA,6BAA6B,cAAc;AAC3C;AACA;AACA;AACA;AACA,kEAAkE;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,cAAc;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C;AAC3C,4BAA4B;AAC5B,4BAA4B;AAC5B,8BAA8B;AAC9B,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACxFa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,MAAM,gBAAgB;AACzC;AACA;AACA;AACA;AACA,iBAAiB,sBAAsB;AACvC;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,2EAAuB;AAC/B,kBAAkB,mBAAO,CAAC,mFAA2B;AACrD;AACA,gBAAgB,mBAAO,CAAC,+EAAyB;AACjD,sBAAsB,mBAAO,CAAC,6EAAkB;AAChD,uBAAuB,mBAAO,CAAC,6FAAkB;AACjD,mBAAmB,mBAAO,CAAC,qFAAc;AACzC,gCAAgC,mBAAO,CAAC,+IAA2C;AACnF,wBAAwB,mBAAO,CAAC,+HAAmC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,IAAqC;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,4BAA4B,EAAE;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mHAAmH,2BAA2B;AAC9I;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,QAAQ,gBAAgB;AAC/C;AACA;AACA;AACA;AACA,qBAAqB,0BAA0B;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA,aAAa,EAEJ;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+FAA+F,sBAAsB;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,QAAQ,gBAAgB;AAC/C;AACA;AACA;AACA;AACA,qBAAqB,0BAA0B;AAC/C;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA,8BAA8B,sGAAsG,EAAE;AACtI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,8CAA8C;AACvE;AACA;;;;;;;;;;;;;ACvQa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,MAAM,gBAAgB;AACzC;AACA;AACA;AACA;AACA,iBAAiB,sBAAsB;AACvC;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,gBAAgB,mBAAO,CAAC,+EAAyB;AACjD,uBAAuB,mBAAO,CAAC,6FAAkB;AACjD,gCAAgC,mBAAO,CAAC,+IAA2C;AACnF,wBAAwB,mBAAO,CAAC,+HAAmC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+FAA+F,sBAAsB;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,QAAQ,gBAAgB;AAC/C;AACA;AACA;AACA;AACA,qBAAqB,0BAA0B;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uGAAuG,wBAAwB;AAC/H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,QAAQ,gBAAgB;AAC/C;AACA;AACA;AACA;AACA,qBAAqB,0BAA0B;AAC/C;AACA;AACA;AACA,4DAA4D,UAAU;AACtE;AACA;AACA;AACA;AACA,qDAAqD,UAAU;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,QAAQ,gBAAgB;AACvD;AACA;AACA;AACA;AACA,6BAA6B,0BAA0B;AACvD;AACA;AACA;AACA;AACA,uBAAuB,QAAQ,gBAAgB;AAC/C;AACA;AACA;AACA;AACA,qBAAqB,0BAA0B;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+FAA+F,sBAAsB;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,QAAQ,gBAAgB;AAC/C;AACA;AACA;AACA;AACA,qBAAqB,0BAA0B;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,gFAAgF;AAC9H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,6DAA6D;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,6DAA6D;AACxG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;;;;;;;;;;;;;ACpNa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,gBAAgB,mBAAO,CAAC,qFAA4B;AACpD,kBAAkB,mBAAO,CAAC,mFAA2B;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACtBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AC/Ba;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,wBAAwB,mBAAO,CAAC,+GAAmB;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,8EAA8E;AACpG;AACA;AACA;AACA;AACA,sBAAsB,8EAA8E;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,8EAA8E;AACnG;AACA;AACA;AACA;AACA,qBAAqB,8EAA8E;AACnG;AACA;AACA;AACA;AACA,qBAAqB,8EAA8E;AACnG;AACA;AACA;AACA;AACA,qBAAqB,8EAA8E;AACnG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,8EAA8E;AAC5F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,8EAA8E;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACjPa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA,gCAAgC;AAChC;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,8FAA8F;;;;;;;;;;;;;ACnDlF;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,0BAA0B,mBAAO,CAAC,gGAAgC;AAClE,oBAAoB,mBAAO,CAAC,oFAA0B;AACtD,uBAAuB,mBAAO,CAAC,0FAA6B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD,IAAI;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,uBAAuB;AAC3C;AACA;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,iBAAiB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,mBAAmB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,0BAA0B;AACpE;AACA;AACA;;;;;;;;;;;;;ACzNa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,oBAAoB,mBAAO,CAAC,oFAA0B;AACtD,uBAAuB,mBAAO,CAAC,0FAA6B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,UAAU,YAAY;AAC1B;AACA;AACA;AACA;AACA;AACA,IAAI,SAAS,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,uBAAuB;AAC3C;AACA;AACA,QAAQ,IAAqC;AAC7C,yCAAyC,iBAAiB,EAAE;AAC5D;AACA;AACA;AACA;AACA;AACA,kDAAkD;AAClD;AACA;AACA;AACA,wBAAwB,uBAAuB;AAC/C;AACA;AACA,iDAAiD,qCAAqC,EAAE;AACxF;AACA;AACA;AACA;;;;;;;;;;;;;AC1Fa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACvBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,uBAAuB,mBAAO,CAAC,0FAA6B;AAC5D,mBAAmB,mBAAO,CAAC,kFAAyB;AACpD;AACA;AACA;AACA;AACA;AACA,iBAAiB,cAAc;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,MAAM;AACrD;AACA;AACA;AACA;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA,yCAAyC;AACzC;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA;AACA,eAAe;AACf,8DAA8D;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACxDa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,uBAAuB,mBAAO,CAAC,0FAA6B;AAC5D,yBAAyB,mBAAO,CAAC,8FAA+B;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA,2DAA2D;AAC3D;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AC7Ca;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA,mBAAO,CAAC,wEAAoB;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACvEa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACjBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACjBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACjBa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,MAAM,gBAAgB;AACzC;AACA;AACA;AACA;AACA,iBAAiB,sBAAsB;AACvC;AACA;AACA;AACA;AACA,4EAA4E,OAAO;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,mBAAO,CAAC,6FAAgC;AAC/D,kBAAkB,mBAAO,CAAC,mFAA2B;AACrD,mBAAmB,mBAAO,CAAC,qFAA4B;AACvD;AACA,eAAe,wBAAwB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,wBAAwB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,iCAAiC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,uBAAuB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,uDAAuD,EAAE;AAC3G;AACA,qCAAqC,mCAAmC,EAAE;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACpIa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,0BAA0B,mBAAO,CAAC,mGAAmC;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACda;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACjBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA,kBAAkB,mBAAO,CAAC,mFAA2B;AACrD,0BAA0B,mBAAO,CAAC,mGAAmC;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACrBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACjBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D,0BAA0B,mBAAO,CAAC,mGAAmC;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AC5Ca;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,0BAA0B,mBAAO,CAAC,mGAAmC;AACrE;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACZa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,0BAA0B,mBAAO,CAAC,mGAAmC;AACrE,oBAAoB,mBAAO,CAAC,uFAA6B;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AC3Ca;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,yBAAyB,mBAAO,CAAC,iGAAkC;AACnE;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACZa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,kBAAkB,mBAAO,CAAC,mFAA2B;AACrD;AACA,uBAAuB,qBAAqB,eAAe,eAAe;AAC1E,cAAc,eAAe;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,2BAA2B;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,2BAA2B;AAC5C;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACpCa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,kBAAkB,mBAAO,CAAC,mFAA2B;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACjBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,oBAAoB,mBAAO,CAAC,uFAA6B;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACvBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D;AACA,wBAAwB,oBAAoB,eAAe,eAAe;AAC1E,UAAU,UAAU;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,uBAAuB,eAAe;AAC/D,eAAe,UAAU;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,sBAAsB,eAAe;AAC7D,eAAe,UAAU;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACxCa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,kBAAkB,mBAAO,CAAC,mFAA2B;AACrD;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACZa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,0BAA0B,mBAAO,CAAC,mGAAmC;AACrE;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACZa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D;AACA,eAAe,kBAAkB,eAAe,aAAa;AAC7D,WAAW,UAAU;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACnBa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,MAAM,gBAAgB;AACzC;AACA;AACA;AACA;AACA,iBAAiB,sBAAsB;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CA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACxEa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B;AACA,gBAAgB,mBAAO,CAAC,iEAAW;AACnC,sBAAsB,mBAAO,CAAC,6EAAiB;AAC/C;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,QAAQ,gIAAgI,EAAE;AACxK;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AClFa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,gBAAgB,mBAAO,CAAC,iEAAW;AACnC,sBAAsB,mBAAO,CAAC,6EAAiB;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AC3Ea;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B;AACA,gBAAgB,mBAAO,CAAC,iEAAW;AACnC,sBAAsB,mBAAO,CAAC,6EAAiB;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,QAAQ,oIAAoI,EAAE;AAC5K;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACnFa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACvBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACtBa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,gBAAgB,sCAAsC,iBAAiB,EAAE;AACvF,6BAA6B,8EAA8E;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,sBAAsB;AAC7C;AACA;AACA,CAAC;AACD,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,gBAAgB,mBAAO,CAAC,iEAAW;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AClFa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,gBAAgB,sCAAsC,iBAAiB,EAAE;AACvF,6BAA6B,8EAA8E;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,sBAAsB;AAC7C;AACA;AACA,CAAC;AACD,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,gBAAgB,mBAAO,CAAC,iEAAW;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AClFa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,UAAU,EAAE;AAC1D,gDAAg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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(\"material-components-web\", [], 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","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.safeAttrPrefix = void 0;\nrequire(\"../environment/dev\");\nvar attribute_impl_1 = require(\"../internals/attribute_impl\");\nvar string_literal_1 = require(\"../internals/string_literal\");\nvar sensitive_attributes_1 = require(\"./sensitive_attributes\");\n/**\n * Creates a SafeAttributePrefix object from a template literal with no\n * interpolations for attributes that share a common prefix guaranteed to be not\n * security sensitive.\n *\n * The template literal is a prefix that makes it obvious this attribute is not\n * security sensitive. If it doesn't, this function will throw.\n */\nfunction safeAttrPrefix(templ) {\n    if (process.env.NODE_ENV !== 'production') {\n        (0, string_literal_1.assertIsTemplateObject)(templ, true, 'safeAttr is a template literal tag function ' +\n            'and should be called using the tagged template syntax. ' +\n            'For example, safeAttr`foo`;');\n    }\n    var attrPrefix = templ[0].toLowerCase();\n    if (process.env.NODE_ENV !== 'production') {\n        if (attrPrefix.indexOf('on') === 0 || 'on'.indexOf(attrPrefix) === 0) {\n            throw new Error(\"Prefix '\".concat(templ[0], \"' does not guarantee the attribute \") +\n                \"to be safe as it is also a prefix for event handler attributes\" +\n                \"Please use 'addEventListener' to set event handlers.\");\n        }\n        sensitive_attributes_1.SECURITY_SENSITIVE_ATTRIBUTES.forEach(function (sensitiveAttr) {\n            if (sensitiveAttr.indexOf(attrPrefix) === 0) {\n                throw new Error(\"Prefix '\".concat(templ[0], \"' does not guarantee the attribute \") +\n                    \"to be safe as it is also a prefix for \" +\n                    \"the security sensitive attribute '\".concat(sensitiveAttr, \"'. \") +\n                    \"Please use native or safe DOM APIs to set the attribute.\");\n            }\n        });\n    }\n    return (0, attribute_impl_1.createAttributePrefix)(attrPrefix);\n}\nexports.safeAttrPrefix = safeAttrPrefix;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.concatHtmls = exports.createScriptSrc = exports.createScript = exports.htmlEscape = void 0;\nvar html_impl_1 = require(\"../internals/html_impl\");\nvar resource_url_impl_1 = require(\"../internals/resource_url_impl\");\nvar script_impl_1 = require(\"../internals/script_impl\");\n/**\n * Returns HTML-escaped text as a `SafeHtml` object.\n *\n * Available options:\n * - `preserveSpaces` turns every second consecutive space character into its\n * HTML entity representation (`&#160;`).\n * - `preserveNewlines` turns newline characters into breaks (`<br>`).\n * - `preserveTabs` wraps tab characters in a span with style=white-space:pre.\n */\nfunction htmlEscape(text, options) {\n    if (options === void 0) { options = {}; }\n    var htmlEscapedString = htmlEscapeToString(text);\n    if (options.preserveSpaces) {\n        // Do this first to ensure we preserve spaces after newlines and tabs.\n        htmlEscapedString =\n            htmlEscapedString.replace(/(^|[\\r\\n\\t ]) /g, '$1&#160;');\n    }\n    if (options.preserveNewlines) {\n        htmlEscapedString = htmlEscapedString.replace(/(\\r\\n|\\n|\\r)/g, '<br>');\n    }\n    if (options.preserveTabs) {\n        htmlEscapedString = htmlEscapedString.replace(/(\\t+)/g, '<span style=\"white-space:pre\">$1</span>');\n    }\n    return (0, html_impl_1.createHtml)(htmlEscapedString);\n}\nexports.htmlEscape = htmlEscape;\n/**\n * Creates a `SafeHtml` representing a script tag with inline script content.\n */\nfunction createScript(script, options) {\n    if (options === void 0) { options = {}; }\n    var unwrappedScript = (0, script_impl_1.unwrapScript)(script).toString();\n    var stringTag = \"<script\";\n    if (options.id) {\n        stringTag += \" id=\\\"\".concat(htmlEscapeToString(options.id), \"\\\"\");\n    }\n    if (options.nonce) {\n        stringTag += \" nonce=\\\"\".concat(htmlEscapeToString(options.nonce), \"\\\"\");\n    }\n    if (options.type) {\n        stringTag += \" type=\\\"\".concat(htmlEscapeToString(options.type), \"\\\"\");\n    }\n    stringTag += \">\".concat(unwrappedScript, \"</script>\");\n    return (0, html_impl_1.createHtml)(stringTag);\n}\nexports.createScript = createScript;\n/**\n * Creates a `SafeHtml` representing a script tag with the src attribute.\n * This also supports CSP nonces and async loading.\n */\nfunction createScriptSrc(src, async, nonce) {\n    var unwrappedSrc = (0, resource_url_impl_1.unwrapResourceUrl)(src).toString();\n    var stringTag = \"<script src=\\\"\".concat(htmlEscapeToString(unwrappedSrc), \"\\\"\");\n    if (async) {\n        stringTag += ' async';\n    }\n    if (nonce) {\n        stringTag += \" nonce=\\\"\".concat(htmlEscapeToString(nonce), \"\\\"\");\n    }\n    stringTag += '>\\x3c/script>';\n    return (0, html_impl_1.createHtml)(stringTag);\n}\nexports.createScriptSrc = createScriptSrc;\n/**\n * HTML-escapes the given text (`&`, `<`, `>`, `\"` and `'`).\n */\nfunction htmlEscapeToString(text) {\n    var escaped = text.replace(/&/g, '&amp;')\n        .replace(/</g, '&lt;')\n        .replace(/>/g, '&gt;')\n        .replace(/\"/g, '&quot;')\n        .replace(/'/g, '&apos;');\n    return escaped;\n}\n/** Creates a `SafeHtml` value by concatenating multiple `SafeHtml`s. */\nfunction concatHtmls(htmls) {\n    return (0, html_impl_1.createHtml)(htmls.map(html_impl_1.unwrapHtml).join(''));\n}\nexports.concatHtmls = concatHtmls;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.sanitizeHtmlToFragment = exports.sanitizeHtmlAssertUnchanged = exports.sanitizeHtml = exports.HtmlSanitizerImpl = void 0;\nrequire(\"../../environment/dev\");\nvar html_impl_1 = require(\"../../internals/html_impl\");\n/* g3_import_pure from '../../internals/pure' */\nvar secrets_1 = require(\"../../internals/secrets\");\nvar url_sanitizer_1 = require(\"../url_sanitizer\");\nvar inert_fragment_1 = require(\"./inert_fragment\");\nvar no_clobber_1 = require(\"./no_clobber\");\nvar default_sanitizer_table_1 = require(\"./sanitizer_table/default_sanitizer_table\");\nvar sanitizer_table_1 = require(\"./sanitizer_table/sanitizer_table\");\n/** Implementation for `HtmlSanitizer` */\nvar HtmlSanitizerImpl = /** @class */ (function () {\n    function HtmlSanitizerImpl(sanitizerTable, token) {\n        this.sanitizerTable = sanitizerTable;\n        this.changes = [];\n        (0, secrets_1.ensureTokenIsValid)(token);\n    }\n    HtmlSanitizerImpl.prototype.sanitizeAssertUnchanged = function (html) {\n        this.changes = [];\n        var sanitizedHtml = this.sanitize(html);\n        if (this.changes.length !== 0) {\n            var message = '';\n            if (process.env.NODE_ENV !== 'production') {\n                message =\n                    \"Unexpected change to HTML value as a result of sanitization. \" +\n                        \"Input: \\\"\".concat(html, \"\\\", sanitized output: \\\"\").concat(sanitizedHtml, \"\\\"\\n\") +\n                        \"List of changes:\".concat(this.changes.join('\\n'));\n            }\n            throw new Error(message);\n        }\n        return sanitizedHtml;\n    };\n    HtmlSanitizerImpl.prototype.sanitize = function (html) {\n        var fakeRoot = document.createElement('span');\n        fakeRoot.appendChild(this.sanitizeToFragment(html));\n        // XML serialization is preferred over HTML serialization as it is\n        // stricter and makes sure all attributes are properly escaped, avoiding\n        // cases where the tree might mutate when parsed again later due to the\n        // complexities of the HTML parsing algorithm\n        var serializedNewTree = new XMLSerializer().serializeToString(fakeRoot);\n        // We remove the outer most element as this is the span node created as\n        // the root for the sanitized tree and contains a spurious xmlns attribute\n        // from the XML serialization step.\n        serializedNewTree = serializedNewTree.slice(serializedNewTree.indexOf('>') + 1, serializedNewTree.lastIndexOf('</'));\n        return (0, html_impl_1.createHtml)(serializedNewTree);\n    };\n    HtmlSanitizerImpl.prototype.sanitizeToFragment = function (html) {\n        var _this = this;\n        var dirtyFragment = (0, inert_fragment_1.createInertFragment)(html);\n        var treeWalker = document.createTreeWalker(dirtyFragment, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT, \n        // IE10 and IE11 won't accept a proper `NodeFilter` interface, and\n        // expect the filtering function to be passed directly. It seems that\n        // other browsers also do not mind getting the function directly. see\n        // https://stackoverflow.com/q/38245898\n        (function (n) { return _this.nodeFilter(n); }), \n        // @ts-ignore: error TS2554: Expected 1-3 arguments, but got 4.\n        false);\n        // `nextNode` is called so we skip the root `DocumentFragment`.\n        var currentNode = treeWalker.nextNode();\n        // We create a root element to attach all the children of the body to. We\n        // use div as it as a semantic-free, generic container and does not\n        // represent anything. This is removed when we serialize the tree back\n        // into a string.\n        var sanitizedFragment = document.createDocumentFragment();\n        var sanitizedParent = sanitizedFragment;\n        while (currentNode !== null) {\n            var sanitizedNode = void 0;\n            if ((0, no_clobber_1.isText)(currentNode)) {\n                sanitizedNode = this.sanitizeTextNode(currentNode);\n            }\n            else if ((0, no_clobber_1.isElement)(currentNode)) {\n                sanitizedNode = this.sanitizeElementNode(currentNode);\n            }\n            else {\n                throw new Error('Node is not of type text or element');\n            }\n            sanitizedParent.appendChild(sanitizedNode);\n            // Advance iterator while keeping track of the sanitized parent for the\n            // current node\n            currentNode = treeWalker.firstChild();\n            if (currentNode) {\n                sanitizedParent = sanitizedNode;\n            }\n            else {\n                while (!(currentNode = treeWalker.nextSibling())) {\n                    if (!(currentNode = treeWalker.parentNode())) {\n                        break;\n                    }\n                    sanitizedParent = sanitizedParent.parentNode;\n                }\n            }\n        }\n        return sanitizedFragment;\n    };\n    HtmlSanitizerImpl.prototype.sanitizeTextNode = function (textNode) {\n        return document.createTextNode(textNode.data);\n    };\n    HtmlSanitizerImpl.prototype.sanitizeElementNode = function (elementNode) {\n        var e_1, _a;\n        var elementName = (0, no_clobber_1.getNodeName)(elementNode);\n        var newNode = document.createElement(elementName);\n        var dirtyAttributes = elementNode.attributes;\n        try {\n            for (var dirtyAttributes_1 = __values(dirtyAttributes), dirtyAttributes_1_1 = dirtyAttributes_1.next(); !dirtyAttributes_1_1.done; dirtyAttributes_1_1 = dirtyAttributes_1.next()) {\n                var _b = dirtyAttributes_1_1.value, name_1 = _b.name, value = _b.value;\n                var policy = this.sanitizerTable.getAttributePolicy(name_1, elementName);\n                if (!this.satisfiesAllConditions(policy.conditions, dirtyAttributes)) {\n                    this.recordChange(\"Not all conditions satisfied for attribute: \".concat(name_1, \".\"));\n                    continue;\n                }\n                switch (policy.policyAction) {\n                    case sanitizer_table_1.AttributePolicyAction.KEEP:\n                        newNode.setAttribute(name_1, value);\n                        break;\n                    case sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL:\n                        var sanitizedAttrUrl = (0, url_sanitizer_1.restrictivelySanitizeUrl)(value);\n                        if (sanitizedAttrUrl !== value) {\n                            this.recordChange(\"Url in attribute \".concat(name_1, \" was modified during sanitization. Original url:\\\"\").concat(value, \"\\\" was sanitized to: \\\"\").concat(sanitizedAttrUrl, \"\\\"\"));\n                        }\n                        newNode.setAttribute(name_1, sanitizedAttrUrl);\n                        break;\n                    case sanitizer_table_1.AttributePolicyAction.KEEP_AND_NORMALIZE:\n                        // We don't consider changing the case of an attribute value to be a\n                        // semantic change\n                        newNode.setAttribute(name_1, value.toLowerCase());\n                        break;\n                    case sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_STYLE:\n                        newNode.setAttribute(name_1, value);\n                        break;\n                    case sanitizer_table_1.AttributePolicyAction.DROP:\n                        this.recordChange(\"Attribute: \".concat(name_1, \" was dropped\"));\n                        break;\n                    default:\n                        checkExhaustive(policy.policyAction, 'Unhandled AttributePolicyAction case');\n                }\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (dirtyAttributes_1_1 && !dirtyAttributes_1_1.done && (_a = dirtyAttributes_1.return)) _a.call(dirtyAttributes_1);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        return newNode;\n    };\n    HtmlSanitizerImpl.prototype.nodeFilter = function (node) {\n        if ((0, no_clobber_1.isText)(node)) {\n            return NodeFilter.FILTER_ACCEPT;\n        }\n        else if (!(0, no_clobber_1.isElement)(node)) {\n            // Getting a node that is neither an `Element` or a `Text` node. This is\n            // likely due to something that is not supposed to be an element in user\n            // code but recognized as such by the TreeWalker (e.g. a polyfill for\n            // other kind of nodes). Since we can't recognize it as an element, we\n            // drop the node, but we don't record it as a meaningful change.\n            return NodeFilter.FILTER_REJECT;\n        }\n        var nodeName = (0, no_clobber_1.getNodeName)(node);\n        if (nodeName === null) {\n            this.recordChange(\"Node name was null for node: \".concat(node));\n            return NodeFilter.FILTER_REJECT;\n        }\n        if (this.sanitizerTable.isAllowedElement(nodeName)) {\n            return NodeFilter.FILTER_ACCEPT;\n        }\n        this.recordChange(\"Element: \".concat(nodeName, \" was dropped\"));\n        return NodeFilter.FILTER_REJECT;\n    };\n    HtmlSanitizerImpl.prototype.recordChange = function (errorMessage) {\n        if (process.env.NODE_ENV !== 'production') {\n            this.changes.push(errorMessage);\n        }\n        else if (this.changes.length === 0) {\n            this.changes.push('');\n        }\n    };\n    HtmlSanitizerImpl.prototype.satisfiesAllConditions = function (conditions, attrs) {\n        var e_2, _a;\n        var _b;\n        if (!conditions) {\n            return true;\n        }\n        try {\n            for (var conditions_1 = __values(conditions), conditions_1_1 = conditions_1.next(); !conditions_1_1.done; conditions_1_1 = conditions_1.next()) {\n                var _c = __read(conditions_1_1.value, 2), attrName = _c[0], expectedValues = _c[1];\n                var value = (_b = attrs.getNamedItem(attrName)) === null || _b === void 0 ? void 0 : _b.value;\n                if (value && !expectedValues.has(value)) {\n                    return false;\n                }\n            }\n        }\n        catch (e_2_1) { e_2 = { error: e_2_1 }; }\n        finally {\n            try {\n                if (conditions_1_1 && !conditions_1_1.done && (_a = conditions_1.return)) _a.call(conditions_1);\n            }\n            finally { if (e_2) throw e_2.error; }\n        }\n        return true;\n    };\n    return HtmlSanitizerImpl;\n}());\nexports.HtmlSanitizerImpl = HtmlSanitizerImpl;\nvar defaultHtmlSanitizer = \n/* #__PURE__ */ (function () { return new HtmlSanitizerImpl(default_sanitizer_table_1.defaultSanitizerTable, secrets_1.secretToken); })();\n/** Sanitizes untrusted html using the default sanitizer configuration. */\nfunction sanitizeHtml(html) {\n    return defaultHtmlSanitizer.sanitize(html);\n}\nexports.sanitizeHtml = sanitizeHtml;\n/**\n * Sanitizes untrusted html using the default sanitizer configuration. Throws\n * an error if the html was changed.\n */\nfunction sanitizeHtmlAssertUnchanged(html) {\n    return defaultHtmlSanitizer.sanitizeAssertUnchanged(html);\n}\nexports.sanitizeHtmlAssertUnchanged = sanitizeHtmlAssertUnchanged;\n/**\n * Sanitizes untrusted html using the default sanitizer configuration. Throws\n * an error if the html was changed.\n */\nfunction sanitizeHtmlToFragment(html) {\n    return defaultHtmlSanitizer.sanitizeToFragment(html);\n}\nexports.sanitizeHtmlToFragment = sanitizeHtmlToFragment;\nfunction checkExhaustive(value, msg) {\n    if (msg === void 0) { msg = \"unexpected value \".concat(value, \"!\"); }\n    throw new Error(msg);\n}\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.HtmlSanitizerBuilder = void 0;\nvar secrets_1 = require(\"../../internals/secrets\");\nvar html_sanitizer_1 = require(\"./html_sanitizer\");\nvar default_sanitizer_table_1 = require(\"./sanitizer_table/default_sanitizer_table\");\nvar sanitizer_table_1 = require(\"./sanitizer_table/sanitizer_table\");\n/** This class allows modifications to the default sanitizer configuration. */\nvar HtmlSanitizerBuilder = /** @class */ (function () {\n    function HtmlSanitizerBuilder() {\n        // To denote if the builder has called build() and therefore should make no\n        // further changes to the sanitizer table.\n        this.calledBuild = false;\n        this.sanitizerTable = default_sanitizer_table_1.defaultSanitizerTable;\n    }\n    /** Builder option to restrict allowed elements to a smaller subset. */\n    HtmlSanitizerBuilder.prototype.onlyAllowElements = function (elementSet) {\n        var e_1, _a;\n        var allowedElements = new Set();\n        var allowedElementPolicies = new Map();\n        try {\n            for (var elementSet_1 = __values(elementSet), elementSet_1_1 = elementSet_1.next(); !elementSet_1_1.done; elementSet_1_1 = elementSet_1.next()) {\n                var element = elementSet_1_1.value;\n                element = element.toUpperCase();\n                if (!this.sanitizerTable.isAllowedElement(element)) {\n                    throw new Error(\"Element: \".concat(element, \", is not allowed by html5_contract.textpb\"));\n                }\n                var elementPolicy = this.sanitizerTable.elementPolicies.get(element);\n                if (elementPolicy !== undefined) {\n                    allowedElementPolicies.set(element, elementPolicy);\n                }\n                else {\n                    allowedElements.add(element);\n                }\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (elementSet_1_1 && !elementSet_1_1.done && (_a = elementSet_1.return)) _a.call(elementSet_1);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        this.sanitizerTable = new sanitizer_table_1.SanitizerTable(allowedElements, allowedElementPolicies, this.sanitizerTable.allowedGlobalAttributes, this.sanitizerTable.globalAttributePolicies);\n        return this;\n    };\n    /**\n     * Builder option to restrict allowed attributes to a smaller subset.\n     *\n     * If the attribute isn't currently allowed then it won't be added.\n     */\n    HtmlSanitizerBuilder.prototype.onlyAllowAttributes = function (attributeSet) {\n        var e_2, _a, e_3, _b, e_4, _c;\n        var allowedGlobalAttributes = new Set();\n        var globalAttributePolicies = new Map();\n        var elementPolicies = new Map();\n        try {\n            for (var attributeSet_1 = __values(attributeSet), attributeSet_1_1 = attributeSet_1.next(); !attributeSet_1_1.done; attributeSet_1_1 = attributeSet_1.next()) {\n                var attribute = attributeSet_1_1.value;\n                if (this.sanitizerTable.allowedGlobalAttributes.has(attribute)) {\n                    allowedGlobalAttributes.add(attribute);\n                }\n                if (this.sanitizerTable.globalAttributePolicies.has(attribute)) {\n                    globalAttributePolicies.set(attribute, this.sanitizerTable.globalAttributePolicies.get(attribute));\n                }\n            }\n        }\n        catch (e_2_1) { e_2 = { error: e_2_1 }; }\n        finally {\n            try {\n                if (attributeSet_1_1 && !attributeSet_1_1.done && (_a = attributeSet_1.return)) _a.call(attributeSet_1);\n            }\n            finally { if (e_2) throw e_2.error; }\n        }\n        try {\n            for (var _d = __values(this.sanitizerTable\n                .elementPolicies.entries()), _e = _d.next(); !_e.done; _e = _d.next()) {\n                var _f = __read(_e.value, 2), elementName = _f[0], originalElementPolicy = _f[1];\n                var newElementPolicy = new Map();\n                try {\n                    for (var _g = (e_4 = void 0, __values(originalElementPolicy\n                        .entries())), _h = _g.next(); !_h.done; _h = _g.next()) {\n                        var _j = __read(_h.value, 2), attribute = _j[0], attributePolicy = _j[1];\n                        if (attributeSet.has(attribute)) {\n                            newElementPolicy.set(attribute, attributePolicy);\n                        }\n                    }\n                }\n                catch (e_4_1) { e_4 = { error: e_4_1 }; }\n                finally {\n                    try {\n                        if (_h && !_h.done && (_c = _g.return)) _c.call(_g);\n                    }\n                    finally { if (e_4) throw e_4.error; }\n                }\n                elementPolicies.set(elementName, newElementPolicy);\n            }\n        }\n        catch (e_3_1) { e_3 = { error: e_3_1 }; }\n        finally {\n            try {\n                if (_e && !_e.done && (_b = _d.return)) _b.call(_d);\n            }\n            finally { if (e_3) throw e_3.error; }\n        }\n        this.sanitizerTable = new sanitizer_table_1.SanitizerTable(this.sanitizerTable.allowedElements, elementPolicies, allowedGlobalAttributes, globalAttributePolicies);\n        return this;\n    };\n    /**\n     * Allows the set of data attributes passed.\n     *\n     * These values must be prefixed with \"data-\"\n     *\n     * If called with onlyAllowElements or onlyAllowAttributes, those methods must\n     * be called first.\n     */\n    HtmlSanitizerBuilder.prototype.allowDataAttributes = function (attributes) {\n        var e_5, _a;\n        var allowedGlobalAttributes = new Set(this.sanitizerTable.allowedGlobalAttributes);\n        try {\n            for (var attributes_1 = __values(attributes), attributes_1_1 = attributes_1.next(); !attributes_1_1.done; attributes_1_1 = attributes_1.next()) {\n                var attribute = attributes_1_1.value;\n                if (attribute.indexOf('data-') !== 0) {\n                    throw new Error(\"data attribute: \".concat(attribute, \" does not begin with the prefix \\\"data-\\\"\"));\n                }\n                allowedGlobalAttributes.add(attribute);\n            }\n        }\n        catch (e_5_1) { e_5 = { error: e_5_1 }; }\n        finally {\n            try {\n                if (attributes_1_1 && !attributes_1_1.done && (_a = attributes_1.return)) _a.call(attributes_1);\n            }\n            finally { if (e_5) throw e_5.error; }\n        }\n        this.sanitizerTable = new sanitizer_table_1.SanitizerTable(this.sanitizerTable.allowedElements, this.sanitizerTable.elementPolicies, allowedGlobalAttributes, this.sanitizerTable.globalAttributePolicies);\n        return this;\n    };\n    /**\n     * Preserves style attributes. Note that the sanitizer won't parse and\n     * sanitize the values but keep them as they are. In particular this means\n     * that the code will be able to call functions that could do undesirable\n     * things (e.g. `url` to trigger a network request), as well as any custom\n     * properties or functions defined by the application.\n     */\n    HtmlSanitizerBuilder.prototype.allowStyleAttributes = function () {\n        var globalAttributePolicies = new Map(this.sanitizerTable.globalAttributePolicies);\n        globalAttributePolicies.set('style', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_STYLE });\n        this.sanitizerTable = new sanitizer_table_1.SanitizerTable(this.sanitizerTable.allowedElements, this.sanitizerTable.elementPolicies, this.sanitizerTable.allowedGlobalAttributes, globalAttributePolicies);\n        return this;\n    };\n    /**\n     * Preserves the class attribute on all elements. This means contents can\n     * adopt CSS styles from other page elements and possibly mask themselves as\n     * legitimate UI elements, which can lead to phishing.\n     */\n    HtmlSanitizerBuilder.prototype.allowClassAttributes = function () {\n        var globalAttributePolicies = new Map(this.sanitizerTable.globalAttributePolicies);\n        globalAttributePolicies.set('class', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP });\n        this.sanitizerTable = new sanitizer_table_1.SanitizerTable(this.sanitizerTable.allowedElements, this.sanitizerTable.elementPolicies, this.sanitizerTable.allowedGlobalAttributes, globalAttributePolicies);\n        return this;\n    };\n    /**\n     * Preserves id attributes. This carries moderate risk as it allows an\n     * element to override other elements with the same ID.\n     */\n    HtmlSanitizerBuilder.prototype.allowIdAttributes = function () {\n        var globalAttributePolicies = new Map(this.sanitizerTable.globalAttributePolicies);\n        globalAttributePolicies.set('id', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP });\n        this.sanitizerTable = new sanitizer_table_1.SanitizerTable(this.sanitizerTable.allowedElements, this.sanitizerTable.elementPolicies, this.sanitizerTable.allowedGlobalAttributes, globalAttributePolicies);\n        return this;\n    };\n    HtmlSanitizerBuilder.prototype.build = function () {\n        if (this.calledBuild) {\n            throw new Error('this sanitizer has already called build');\n        }\n        this.calledBuild = true;\n        return new html_sanitizer_1.HtmlSanitizerImpl(this.sanitizerTable, secrets_1.secretToken);\n    };\n    return HtmlSanitizerBuilder;\n}());\nexports.HtmlSanitizerBuilder = HtmlSanitizerBuilder;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createInertFragment = void 0;\nvar element_1 = require(\"../../dom/elements/element\");\nvar html_impl_1 = require(\"../../internals/html_impl\");\n/**\n * Returns a fragment that contains the parsed HTML for `dirtyHtml` without\n * executing any of the potential payload.\n */\nfunction createInertFragment(dirtyHtml) {\n    var template = document.createElement('template');\n    // This call is only used to create an inert tree for the sanitizer to\n    // further process and is never returned directly to the caller. We can't use\n    // a reviewed conversion in order to avoid an import loop.\n    var temporarySafeHtml = (0, html_impl_1.createHtml)(dirtyHtml);\n    (0, element_1.setInnerHtml)(template, temporarySafeHtml);\n    return template.content;\n}\nexports.createInertFragment = createInertFragment;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isElement = exports.isText = exports.getNodeName = void 0;\n/**\n * Library that provides safe getters for different node properties and\n * checks for clobbering.\n */\n/** Gets a reasonable nodeName, even for clobbered nodes. */\nfunction getNodeName(node) {\n    var nodeName = node.nodeName;\n    // If the property is clobbered, assume it is an `HTMLFormElement`.\n    return (typeof nodeName === 'string') ? nodeName : 'FORM';\n}\nexports.getNodeName = getNodeName;\n/** Returns true if the object passed is a Text node. */\nfunction isText(node) {\n    // The property cannot get clobbered on Text nodes.\n    return node.nodeType === Node.TEXT_NODE;\n}\nexports.isText = isText;\n/** Returns true if the object passed is an Element node. */\nfunction isElement(node) {\n    var nodeType = node.nodeType;\n    // If the property is clobbered, we can assume it is an `HTMLFormElement`, and\n    // thus an `Element`.\n    return (nodeType === Node.ELEMENT_NODE) || (typeof nodeType !== 'number');\n}\nexports.isElement = isElement;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.defaultSanitizerTable = void 0;\nvar sanitizer_table_1 = require(\"./sanitizer_table\");\n/**\n * GENERATED CODE, DO NOT MODIFY\n * This SanitizerTable was generated from the checked in html contract:\n *  webutil/html/types/codegen/html5_contract.textpb\n *\n * You can regenerate this file with:\n * webutil/html/types/codegen/update_generated_source_files.sh\n */\nexports.defaultSanitizerTable = new sanitizer_table_1.SanitizerTable(new Set([\n    'ARTICLE', 'SECTION', 'NAV', 'ASIDE', 'H1', 'H2',\n    'H3', 'H4', 'H5', 'H6', 'HEADER', 'FOOTER',\n    'ADDRESS', 'P', 'HR', 'PRE', 'BLOCKQUOTE', 'OL',\n    'UL', 'LH', 'LI', 'DL', 'DT', 'DD',\n    'FIGURE', 'FIGCAPTION', 'MAIN', 'DIV', 'EM', 'STRONG',\n    'SMALL', 'S', 'CITE', 'Q', 'DFN', 'ABBR',\n    'RUBY', 'RB', 'RT', 'RTC', 'RP', 'DATA',\n    'TIME', 'CODE', 'VAR', 'SAMP', 'KBD', 'SUB',\n    'SUP', 'I', 'B', 'U', 'MARK', 'BDI',\n    'BDO', 'SPAN', 'BR', 'WBR', 'INS', 'DEL',\n    'PICTURE', 'PARAM', 'TRACK', 'MAP', 'TABLE', 'CAPTION',\n    'COLGROUP', 'COL', 'TBODY', 'THEAD', 'TFOOT', 'TR',\n    'TD', 'TH', 'SELECT', 'DATALIST', 'OPTGROUP', 'OPTION',\n    'OUTPUT', 'PROGRESS', 'METER', 'FIELDSET', 'LEGEND', 'DETAILS',\n    'SUMMARY', 'MENU', 'DIALOG', 'SLOT', 'CANVAS', 'FONT',\n    'CENTER',\n]), new Map([\n    [\n        'A', new Map([\n            ['href', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n        ])\n    ],\n    [\n        'AREA', new Map([\n            ['href', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n        ])\n    ],\n    [\n        'LINK', new Map([\n            [\n                'href', {\n                    policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL,\n                    conditions: new Map([[\n                            'rel', new Set([\n                                'alternate',\n                                'author',\n                                'bookmark',\n                                'canonical',\n                                'cite',\n                                'help',\n                                'icon',\n                                'license',\n                                'next',\n                                'prefetch',\n                                'dns-prefetch',\n                                'prerender',\n                                'preconnect',\n                                'preload',\n                                'prev',\n                                'search',\n                                'subresource',\n                            ])\n                        ]])\n                }\n            ],\n        ])\n    ],\n    [\n        'SOURCE', new Map([\n            ['src', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n        ])\n    ],\n    [\n        'IMG', new Map([\n            ['src', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n        ])\n    ],\n    [\n        'VIDEO', new Map([\n            ['src', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n        ])\n    ],\n    [\n        'AUDIO', new Map([\n            ['src', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n        ])\n    ],\n]), new Set([\n    'title',\n    'aria-atomic',\n    'aria-autocomplete',\n    'aria-busy',\n    'aria-checked',\n    'aria-current',\n    'aria-disabled',\n    'aria-dropeffect',\n    'aria-expanded',\n    'aria-haspopup',\n    'aria-hidden',\n    'aria-invalid',\n    'aria-label',\n    'aria-level',\n    'aria-live',\n    'aria-multiline',\n    'aria-multiselectable',\n    'aria-orientation',\n    'aria-posinset',\n    'aria-pressed',\n    'aria-readonly',\n    'aria-relevant',\n    'aria-required',\n    'aria-selected',\n    'aria-setsize',\n    'aria-sort',\n    'aria-valuemax',\n    'aria-valuemin',\n    'aria-valuenow',\n    'aria-valuetext',\n    'alt',\n    'align',\n    'autocapitalize',\n    'autocomplete',\n    'autocorrect',\n    'autofocus',\n    'autoplay',\n    'bgcolor',\n    'border',\n    'cellpadding',\n    'cellspacing',\n    'checked',\n    'color',\n    'cols',\n    'colspan',\n    'controls',\n    'datetime',\n    'disabled',\n    'download',\n    'draggable',\n    'enctype',\n    'face',\n    'formenctype',\n    'frameborder',\n    'height',\n    'hreflang',\n    'hidden',\n    'ismap',\n    'label',\n    'lang',\n    'loop',\n    'max',\n    'maxlength',\n    'media',\n    'minlength',\n    'min',\n    'multiple',\n    'muted',\n    'nonce',\n    'open',\n    'placeholder',\n    'preload',\n    'rel',\n    'required',\n    'reversed',\n    'role',\n    'rows',\n    'rowspan',\n    'selected',\n    'shape',\n    'size',\n    'sizes',\n    'slot',\n    'span',\n    'spellcheck',\n    'start',\n    'step',\n    'summary',\n    'translate',\n    'type',\n    'valign',\n    'value',\n    'width',\n    'wrap',\n    'itemscope',\n    'itemtype',\n    'itemid',\n    'itemprop',\n    'itemref',\n]), new Map([\n    [\n        'dir', {\n            policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_NORMALIZE,\n            conditions: new Map([[\n                    'dir', new Set([\n                        'auto',\n                        'ltr',\n                        'rtl',\n                    ])\n                ]])\n        }\n    ],\n    [\n        'async', {\n            policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_NORMALIZE,\n            conditions: new Map([[\n                    'async', new Set([\n                        'async',\n                    ])\n                ]])\n        }\n    ],\n    ['cite', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n    [\n        'loading', {\n            policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_NORMALIZE,\n            conditions: new Map([[\n                    'loading', new Set([\n                        'eager',\n                        'lazy',\n                    ])\n                ]])\n        }\n    ],\n    ['poster', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n    [\n        'target', {\n            policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_NORMALIZE,\n            conditions: new Map([[\n                    'target', new Set([\n                        '_self',\n                        '_blank',\n                    ])\n                ]])\n        }\n    ],\n]));\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AttributePolicyAction = exports.SanitizerTable = void 0;\n/** Class for holding element and attribute policies used for sanitization. */\nvar SanitizerTable = /** @class */ (function () {\n    function SanitizerTable(allowedElements, elementPolicies, allowedGlobalAttributes, globalAttributePolicies) {\n        this.allowedElements = allowedElements;\n        this.elementPolicies = elementPolicies;\n        this.allowedGlobalAttributes = allowedGlobalAttributes;\n        this.globalAttributePolicies = globalAttributePolicies;\n    }\n    SanitizerTable.prototype.isAllowedElement = function (elementName) {\n        // Note: `HTMLFormElement`s are always dropped, supporting them is very\n        // costly because of the DOM clobberring they can cause. The additional code\n        // size required to properly work around DOM clobberring issues is large and\n        // shouldn't be put on every user of the sanitizer. Thoroughly review\n        // b/210975025 and the CLs linked there before you start allowing form\n        // elements.\n        return elementName.toLowerCase() !== 'form' &&\n            (this.allowedElements.has(elementName) ||\n                this.elementPolicies.has(elementName));\n    };\n    SanitizerTable.prototype.getAttributePolicy = function (attributeName, elementName) {\n        var elementPolicy = this.elementPolicies.get(elementName);\n        if (elementPolicy === null || elementPolicy === void 0 ? void 0 : elementPolicy.has(attributeName)) {\n            return elementPolicy.get(attributeName);\n        }\n        if (this.allowedGlobalAttributes.has(attributeName)) {\n            return { policyAction: AttributePolicyAction.KEEP };\n        }\n        var globalPolicy = this.globalAttributePolicies.get(attributeName);\n        return globalPolicy || { policyAction: AttributePolicyAction.DROP };\n    };\n    return SanitizerTable;\n}());\nexports.SanitizerTable = SanitizerTable;\n/**\n * Values derived from\n * https://godoc.corp.google.com/pkg/google3/third_party/safehtml/sanitizer/policy#AttributePolicy\n */\nvar AttributePolicyAction;\n(function (AttributePolicyAction) {\n    AttributePolicyAction[AttributePolicyAction[\"DROP\"] = 0] = \"DROP\";\n    AttributePolicyAction[AttributePolicyAction[\"KEEP\"] = 1] = \"KEEP\";\n    AttributePolicyAction[AttributePolicyAction[\"KEEP_AND_SANITIZE_URL\"] = 2] = \"KEEP_AND_SANITIZE_URL\";\n    AttributePolicyAction[AttributePolicyAction[\"KEEP_AND_NORMALIZE\"] = 3] = \"KEEP_AND_NORMALIZE\";\n    AttributePolicyAction[AttributePolicyAction[\"KEEP_AND_SANITIZE_STYLE\"] = 4] = \"KEEP_AND_SANITIZE_STYLE\";\n})(AttributePolicyAction = exports.AttributePolicyAction || (exports.AttributePolicyAction = {}));\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.blobUrlFromScript = exports.replaceFragment = exports.appendParams = exports.trustedResourceUrl = void 0;\nrequire(\"../environment/dev\");\nvar resource_url_impl_1 = require(\"../internals/resource_url_impl\");\nvar script_impl_1 = require(\"../internals/script_impl\");\nvar string_literal_1 = require(\"../internals/string_literal\");\n/**\n * Check whether the base url contains a valid origin,\n *\n * A string for an origin must contain only alphanumeric or any of the\n * following: `-.:`, and must not be an IP address. Remember that, as per the\n * documentation for TrustedResourceUrl, the origin must be trustworthy.\n *\n * @param base The base url that contains an origin.\n */\nfunction hasValidOrigin(base) {\n    if (!(/^https:\\/\\//.test(base) || /^\\/\\//.test(base))) {\n        return false;\n    }\n    var originStart = base.indexOf('//') + 2;\n    var originEnd = base.indexOf('/', originStart);\n    // If the base url only contains the prefix (e.g. //), or the slash\n    // for the origin is right after the prefix (e.g. ///), the origin is\n    // missing.\n    if (originEnd <= originStart) {\n        throw new Error(\"Can't interpolate data in a url's origin, \" +\n            \"Please make sure to fully specify the origin, terminated with '/'.\");\n    }\n    var origin = base.substring(originStart, originEnd);\n    if (!/^[0-9a-z.:-]+$/i.test(origin)) {\n        throw new Error('The origin contains unsupported characters.');\n    }\n    if (!/^[^:]*(:[0-9]+)?$/i.test(origin)) {\n        throw new Error('Invalid port number.');\n    }\n    if (!/(^|\\.)[a-z][^.]*$/i.test(origin)) {\n        throw new Error('The top-level domain must start with a letter.');\n    }\n    return true;\n}\n/**\n * Check whether the base url contains a valid about url at its beginning.\n *\n * An about url is either exactly 'about:blank' or 'about:blank#<str>' where\n * <str> can be an arbitrary string.\n *\n * @param base The base url.\n */\nfunction isValidAboutUrl(base) {\n    if (!/^about:blank/.test(base)) {\n        return false;\n    }\n    if (base !== 'about:blank' && !/^about:blank#/.test(base)) {\n        throw new Error('The about url is invalid.');\n    }\n    return true;\n}\n/**\n * Check whether the base url contains a valid path start at its beginning.\n *\n * A valid path start is either a '/' or a '/' followed by at least one\n * character that is not '/' or '\\'.\n *\n * @param base The base url.\n */\nfunction isValidPathStart(base) {\n    if (!/^\\//.test(base)) {\n        return false;\n    }\n    if ((base === '/') ||\n        (base.length > 1 && base[1] !== '/' && base[1] !== '\\\\')) {\n        return true;\n    }\n    throw new Error('The path start in the url is invalid.');\n}\n/**\n * Builds TrustedResourceUrl from a template literal.\n *\n * This factory is a template literal tag function. It should be called with\n * a template literal, with or without embedded expressions. For example,\n *               trustedResourceUrl`//example.com/${bar}`;\n * or\n *               trustedResourceUrl`//example.com`;\n *\n * When this function is called with a template literal without any embedded\n * expressions, the template string may contain anything as the whole URL is\n * a compile-time string constant.\n *\n * When this function is called with a template literal that contains embedded\n * expressions, the template must start with one of the following:\n * - `https://<origin>/`\n * - `//<origin>/`\n * - `/<pathStart>`\n * - `about:blank`\n * - `data:`\n *\n * `<origin>` must contain only alphanumeric or any of the following: `-.:`.\n * Remember that, as per the documentation for TrustedResourceUrl, the origin\n * must be trustworthy. An origin of \"example.com\" could be set with this\n * method, but would tie the security of your site to the security of\n * example.com. Similarly, formats that potentially cover redirects hosted\n * on a trusted origin are problematic, since that could lead to untrusted\n * origins.\n *\n * `<pathStart>` is either an empty string, or a non empty string that does not\n * start with '/' or '\\'.\n * In other words, `/<pathStart>` is either a '/' or a\n * '/' followed by at least one character that is not '/' or '\\'.\n *\n * `data:` (data URL) does not allow embedded expressions in the template\n * literal input.\n *\n * All embedded expressions are URL encoded when they are interpolated. Do not\n * embed expressions that are already URL encoded as they will be double encoded\n * by the builder.\n *\n * @param templateObj This contains the literal part of the template literal.\n * @param rest This represents the template's embedded expressions.\n */\nfunction trustedResourceUrl(templateObj) {\n    var rest = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        rest[_i - 1] = arguments[_i];\n    }\n    // Check if templateObj is actually from a template literal.\n    if (process.env.NODE_ENV !== 'production') {\n        (0, string_literal_1.assertIsTemplateObject)(templateObj, true, 'trustedResourceUrl is a template literal tag function and ' +\n            'can only be called as such (e.g. trustedResourceUrl`/somepath.js`)');\n    }\n    if (rest.length === 0) {\n        return (0, resource_url_impl_1.createResourceUrl)(templateObj[0]);\n    }\n    var base = templateObj[0].toLowerCase();\n    if (process.env.NODE_ENV !== 'production') {\n        if (/^data:/.test(base)) {\n            throw new Error('Data URLs cannot have expressions in the template literal input.');\n        }\n        if (!hasValidOrigin(base) && !isValidPathStart(base) &&\n            !isValidAboutUrl(base)) {\n            throw new Error('Trying to interpolate expressions in an unsupported url format.');\n        }\n    }\n    var urlParts = [templateObj[0]];\n    for (var i = 0; i < rest.length; i++) {\n        urlParts.push(encodeURIComponent(rest[i]));\n        urlParts.push(templateObj[i + 1]);\n    }\n    return (0, resource_url_impl_1.createResourceUrl)(urlParts.join(''));\n}\nexports.trustedResourceUrl = trustedResourceUrl;\n/**\n * Creates a new TrustedResourceUrl with params added to the URL's search\n * parameters.\n *\n * @param params What to add to the URL. Parameters with value `null` or\n * `undefined` are skipped. Both keys and values will be encoded. Do not pass\n * pre-encoded values as this will result them being double encoded. If the\n * value is an array then the same parameter is added for every element in the\n * array.\n */\nfunction appendParams(trustedUrl, params) {\n    var url = (0, resource_url_impl_1.unwrapResourceUrl)(trustedUrl).toString();\n    if (/#/.test(url)) {\n        var message = '';\n        if (process.env.NODE_ENV !== 'production') {\n            message = \"Found a hash in url (\".concat(url, \"), appending not supported\");\n        }\n        throw new Error(message);\n    }\n    var separator = /\\?/.test(url) ? '&' : '?';\n    // for-of has a big polyfill.\n    // tslint:disable-next-line:ban-iterable-foreach\n    params.forEach(function (value, key) {\n        var values = (value instanceof Array) ? value : [value];\n        for (var i = 0; i < values.length; i++) {\n            var v = values[i];\n            if (v === null || v === undefined) {\n                continue;\n            }\n            url += separator + encodeURIComponent(key) + '=' +\n                encodeURIComponent(String(v));\n            separator = '&';\n        }\n    });\n    return (0, resource_url_impl_1.createResourceUrl)(url);\n}\nexports.appendParams = appendParams;\nvar BEFORE_FRAGMENT_REGEXP = /[^#]*/;\n/**\n * Creates a new TrustedResourceUrl based on an existing one but with the\n * addition of a fragment (the part after `#`). If the URL already has a\n * fragment, it is replaced with the new one.\n * @param fragment The fragment to add to the URL, verbatim, without the leading\n * `#`. No additional escaping is applied.\n */\nfunction replaceFragment(trustedUrl, fragment) {\n    var urlString = (0, resource_url_impl_1.unwrapResourceUrl)(trustedUrl).toString();\n    return (0, resource_url_impl_1.createResourceUrl)(BEFORE_FRAGMENT_REGEXP.exec(urlString)[0] + '#' + fragment);\n}\nexports.replaceFragment = replaceFragment;\n/**\n * Creates a `TrustedResourceUrl` by generating a `Blob` from a\n * `SafeScript` and then calling `URL.createObjectURL` with that `Blob`.\n *\n * Caller must call `URL.revokeObjectUrl()` on the stringified url to\n * release the underlying `Blob`.\n */\nfunction blobUrlFromScript(safeScript) {\n    var scriptContent = (0, script_impl_1.unwrapScript)(safeScript).toString();\n    var blob = new Blob([scriptContent], { type: 'text/javascript' });\n    return (0, resource_url_impl_1.createResourceUrl)(URL.createObjectURL(blob));\n}\nexports.blobUrlFromScript = blobUrlFromScript;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.safeScriptWithArgs = exports.scriptFromJson = exports.concatScripts = exports.safeScript = void 0;\nrequire(\"../environment/dev\");\nvar script_impl_1 = require(\"../internals/script_impl\");\nvar string_literal_1 = require(\"../internals/string_literal\");\n/**\n * Creates a SafeScript object from a template literal (without any embedded\n * expressions).\n *\n * This function is a template literal tag function. It should be called with\n * a template literal that does not contain any expressions. For example,\n *                           safeScript`foo`;\n *\n * @param templateObj This contains the literal part of the template literal.\n */\nfunction safeScript(templateObj) {\n    if (process.env.NODE_ENV !== 'production') {\n        (0, string_literal_1.assertIsTemplateObject)(templateObj, false, 'safeScript is a template literal tag function ' +\n            'that only accepts template literals without expressions. ' +\n            'For example, safeScript`foo`;');\n    }\n    return (0, script_impl_1.createScript)(templateObj[0]);\n}\nexports.safeScript = safeScript;\n/** Creates a `SafeScript` value by concatenating multiple `SafeScript`s. */\nfunction concatScripts(scripts) {\n    return (0, script_impl_1.createScript)(scripts.map(script_impl_1.unwrapScript).join(''));\n}\nexports.concatScripts = concatScripts;\n/**\n * Converts a serializable value into JSON that is safe to interpolate into a\n * script context. In particular it escapes < characters so that a value of\n * \"</script>\" doesn't break out of the context.\n * @param value The value to serialize.\n */\nfunction scriptFromJson(value) {\n    return (0, script_impl_1.createScript)(JSON.stringify(value).replace(/</g, '\\\\x3c'));\n}\nexports.scriptFromJson = scriptFromJson;\n/**\n * Creates a `SafeScript` object from a template literal (without any embedded\n * expressions) along with additional arguments that the script should have\n * access to. These arguments will be JSON-encoded and passed to the script as\n * a function call.\n * @example\n * ```ts\n * safeScriptWithArgs`function (name, props) {\n *  console.log(name + ' is ' + props.age);\n * }`('Bob', { 'age': 42 })\n * ```\n * would return a `SafeScript` that represents the following code:\n * ```js\n * (function (name, props) {\n *  console.log(name + ' is ' + props.age);\n * })(\"Bob\",{\"age\":42})\n * ```\n * @note Be careful when passing objects as arguments, as unquoted property\n * names may be changed during compilation.\n * @param templateObj This contains the literal part of the template literal.\n * @param emptyArgs Expressions that evaluate to the empty string to enable\n *     inline comments.\n */\nfunction safeScriptWithArgs(templateObj) {\n    var emptyArgs = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        emptyArgs[_i - 1] = arguments[_i];\n    }\n    if (process.env.NODE_ENV !== 'production') {\n        if (emptyArgs.some(function (a) { return a !== ''; })) {\n            throw new Error('safeScriptWithArgs only allows empty string expressions ' +\n                'to enable inline comments.');\n        }\n        (0, string_literal_1.assertIsTemplateObject)(templateObj, true, 'safeScriptWithArgs is a template literal tag function ' +\n            'that only accepts template literals. ' +\n            'For example, safeScriptWithArgs`foo`;');\n    }\n    return function () {\n        var argValues = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            argValues[_i] = arguments[_i];\n        }\n        var values = argValues.map(function (v) { return scriptFromJson(v).toString(); });\n        return (0, script_impl_1.createScript)(\"(\".concat(templateObj.join(''), \")(\").concat(values.join(','), \")\"));\n    };\n}\nexports.safeScriptWithArgs = safeScriptWithArgs;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SECURITY_SENSITIVE_ATTRIBUTES = void 0;\n// AUTOGENERATED. DO NOT EDIT.\n/**\n * Security sensitive attribute names that should not be set through\n * `setAttribute` or similar functions.\n */\nexports.SECURITY_SENSITIVE_ATTRIBUTES = [\n    'href',\n    'rel',\n    'src',\n    'srcdoc',\n    'action',\n    'formaction',\n    'sandbox',\n    'cite',\n    'poster',\n    'icon',\n];\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.concatStyles = exports.safeStyle = void 0;\nrequire(\"../environment/dev\");\nvar string_literal_1 = require(\"../internals/string_literal\");\nvar style_impl_1 = require(\"../internals/style_impl\");\n/**\n * Creates a SafeStyle object from a template literal (without any embedded\n * expressions).\n *\n * ` style` should be in the format\n * ` name: value; [name: value; ...]` and must not have any < or >\n * characters in it. This is so that SafeStyle's contract is preserved,\n * allowing the SafeStyle to correctly be interpreted as a sequence of CSS\n * declarations and without affecting the syntactic structure of any\n * surrounding CSS and HTML.\n *\n * This function is a template literal tag function. It should be called with\n * a template literal that does not contain any expressions. For example,\n *                          safeStyle`foo`;\n * This function first checks if it is called with a literal template, and\n * then performs basic sanity checks on the format of ` style`\n * but does not constrain the format of ` name} and {@code value`, except\n * for disallowing tag characters.\n *\n * @param templateObj This contains the literal part of the template literal.\n */\nfunction safeStyle(templateObj) {\n    if (process.env.NODE_ENV !== 'production') {\n        (0, string_literal_1.assertIsTemplateObject)(templateObj, false, 'safeStyle is a template literal tag function ' +\n            'that only accepts template literals without expressions. ' +\n            'For example, safeStyle`foo`;');\n    }\n    var style = templateObj[0];\n    if (process.env.NODE_ENV !== 'production') {\n        if (/[<>]/.test(style)) {\n            throw new Error('Forbidden characters in style string: ' + style);\n        }\n        if (!/;$/.test(style)) {\n            throw new Error('Style string does not end with \";\": ' + style);\n        }\n        if (!/:/.test(style)) {\n            throw new Error('Style string should contain one or more \":\": ' + style);\n        }\n    }\n    return (0, style_impl_1.createStyle)(style);\n}\nexports.safeStyle = safeStyle;\n/** Creates a `SafeStyle` value by concatenating multiple `SafeStyle`s. */\nfunction concatStyles(styles) {\n    return (0, style_impl_1.createStyle)(styles.map(style_impl_1.unwrapStyle).join(''));\n}\nexports.concatStyles = concatStyles;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.concatStyleSheets = exports.safeStyleSheet = void 0;\nrequire(\"../environment/dev\");\nvar string_literal_1 = require(\"../internals/string_literal\");\nvar style_sheet_impl_1 = require(\"../internals/style_sheet_impl\");\n/**\n * Creates a SafeStyleSheet object from a template literal (without any\n * embedded expressions).\n *\n * This function is a template literal tag function. It should be called with\n * a template literal that does not contain any expressions. For example,\n *                         safeStyleSheet`foo`;\n * The argument must not have any < or > characters in it. This is so that\n * SafeStyleSheet's contract is preserved, allowing the SafeStyleSheet to\n * correctly be interpreted as a sequence of CSS declarations and without\n * affecting the syntactic structure of any surrounding CSS and HTML.\n *\n * @param templateObj This contains the literal part of the template literal.\n */\nfunction safeStyleSheet(templateObj) {\n    if (process.env.NODE_ENV !== 'production') {\n        (0, string_literal_1.assertIsTemplateObject)(templateObj, false, 'safeStyleSheet is a template literal tag ' +\n            'function that only accepts template literals without ' +\n            'expressions. For example, safeStyleSheet`foo`;');\n    }\n    var styleSheet = templateObj[0];\n    if (process.env.NODE_ENV !== 'production') {\n        if (/[<>]/.test(styleSheet)) {\n            throw new Error('Forbidden characters in styleSheet string: ' + styleSheet);\n        }\n    }\n    return (0, style_sheet_impl_1.createStyleSheet)(styleSheet);\n}\nexports.safeStyleSheet = safeStyleSheet;\n/**\n * Creates a `SafeStyleSheet` value by concatenating multiple `SafeStyleSheet`s.\n */\nfunction concatStyleSheets(sheets) {\n    return (0, style_sheet_impl_1.createStyleSheet)(sheets.map(style_sheet_impl_1.unwrapStyleSheet).join(''));\n}\nexports.concatStyleSheets = concatStyleSheets;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.restrictivelySanitizeUrl = exports.unwrapUrlOrSanitize = exports.sanitizeJavascriptUrl = void 0;\n/**\n * @fileoverview Provides functions to enforce the SafeUrl contract at the sink\n * level.\n */\nrequire(\"../environment/dev\");\nfunction extractScheme(url) {\n    var parsedUrl;\n    try {\n        parsedUrl = new URL(url);\n    }\n    catch (e) {\n        // According to https://url.spec.whatwg.org/#constructors, the URL\n        // constructor with one parameter throws if `url` is not absolute. In this\n        // case, we are sure that no explicit scheme (javascript: ) is set.\n        // This can also be a URL parsing error, but in this case the URL won't be\n        // run anyway.\n        return 'https:';\n    }\n    return parsedUrl.protocol;\n}\n// We can't use an ES6 Set here because gws somehow depends on this code and\n// doesn't want to pay the cost of a polyfill.\nvar ALLOWED_SCHEMES = ['data:', 'http:', 'https:', 'mailto:', 'ftp:'];\n/**\n * Checks that the URL scheme is not javascript.\n * The URL parsing relies on the URL API in browsers that support it.\n * @param url The URL to sanitize for a SafeUrl sink.\n * @return undefined if url has a javascript: scheme, the original URL\n *     otherwise.\n */\nfunction sanitizeJavascriptUrl(url) {\n    var parsedScheme = extractScheme(url);\n    if (parsedScheme === 'javascript:') {\n        if (process.env.NODE_ENV !== 'production') {\n            console.error(\"A URL with content '\".concat(url, \"' was sanitized away.\"));\n        }\n        return undefined;\n    }\n    return url;\n}\nexports.sanitizeJavascriptUrl = sanitizeJavascriptUrl;\n/**\n * Adapter to sanitize string URLs in DOM sink wrappers.\n * @return undefined if the URL was sanitized.\n */\nfunction unwrapUrlOrSanitize(url) {\n    return sanitizeJavascriptUrl(url);\n}\nexports.unwrapUrlOrSanitize = unwrapUrlOrSanitize;\n/**\n * Sanitizes a URL restrictively.\n * This sanitizer protects against XSS and potentially other uncommon and\n * undesirable schemes that an attacker could use for e.g. phishing (tel:,\n * callto: ssh: etc schemes). This sanitizer is primarily meant to be used by\n * the HTML sanitizer.\n */\nfunction restrictivelySanitizeUrl(url) {\n    var parsedScheme = extractScheme(url);\n    if (parsedScheme !== undefined &&\n        ALLOWED_SCHEMES.indexOf(parsedScheme.toLowerCase()) !== -1) {\n        return url;\n    }\n    return 'about:invalid#zClosurez';\n}\nexports.restrictivelySanitizeUrl = restrictivelySanitizeUrl;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setHref = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\n/**\n * Sets the Href attribute from the given Url.\n */\nfunction setHref(anchor, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        anchor.href = sanitizedUrl;\n    }\n}\nexports.setHref = setHref;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setHref = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\n/**\n * Sets the Href attribute from the given Url.\n */\nfunction setHref(area, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        area.href = sanitizedUrl;\n    }\n}\nexports.setHref = setHref;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setFormaction = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\n/**\n * Sets the Formaction attribute from the given Url.\n */\nfunction setFormaction(button, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        button.formAction = sanitizedUrl;\n    }\n}\nexports.setFormaction = setFormaction;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setPrefixedAttribute = exports.buildPrefixedAttributeSetter = exports.insertAdjacentHtml = exports.setCssText = exports.setOuterHtml = exports.setInnerHtml = void 0;\n/**\n * @fileoverview This contains safe wrappers for properties that aren't specific\n * to one kind of HTMLElement (like innerHTML), plus other setters and functions\n * that are not tied to elements (like location.href or Worker constructor).\n */\nvar attribute_impl_1 = require(\"../../internals/attribute_impl\");\nvar html_impl_1 = require(\"../../internals/html_impl\");\nvar style_impl_1 = require(\"../../internals/style_impl\");\n/**\n * Safely set {@link Element.innerHTML} on a given ShadowRoot or Element which\n * may not be a `<script>` element or a `<style>` element.\n */\nfunction setInnerHtml(elOrRoot, v) {\n    if (isElement(elOrRoot)) {\n        throwIfScriptOrStyle(elOrRoot);\n    }\n    elOrRoot.innerHTML = (0, html_impl_1.unwrapHtml)(v);\n}\nexports.setInnerHtml = setInnerHtml;\n/**\n * Safely set {@link Element.outerHTML} for the given Element.\n */\nfunction setOuterHtml(e, v) {\n    var parent = e.parentElement;\n    if (parent !== null) {\n        throwIfScriptOrStyle(parent);\n    }\n    e.outerHTML = (0, html_impl_1.unwrapHtml)(v);\n}\nexports.setOuterHtml = setOuterHtml;\n/**\n * Set `ElementCSSInlineStyle.cssText` for the given `ElementCSSInlineStyle`.\n */\nfunction setCssText(e, v) {\n    e.style.cssText = (0, style_impl_1.unwrapStyle)(v);\n}\nexports.setCssText = setCssText;\n/**\n * Safely call {@link Element.insertAdjacentHTML} for the given Element.\n */\nfunction insertAdjacentHtml(element, position, v) {\n    var tagContext = (position === 'beforebegin' || position === 'afterend') ?\n        element.parentElement :\n        element;\n    if (tagContext !== null) {\n        throwIfScriptOrStyle(tagContext);\n    }\n    element.insertAdjacentHTML(position, (0, html_impl_1.unwrapHtml)(v));\n}\nexports.insertAdjacentHtml = insertAdjacentHtml;\n/**\n * Given a set of known-to-be-safe prefixes (e.g., \"data-\", \"aria-\", \"js\"),\n * return a setter function that allows you to set attributes on an element,\n * as long as the names of the attributes to be set has one of the prefixes.\n *\n * The returned setter ensures that setting any dangerous attribute, e.g.,\n * \"src\", \"href\" will cause an exception. This is intended to be used as the\n * safe alterantive of `Element#setAttribute`, when applications need to set\n * attributes that do not have security implications and do not have a\n * corresponding DOM property.\n */\nfunction buildPrefixedAttributeSetter(prefix) {\n    var otherPrefixes = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        otherPrefixes[_i - 1] = arguments[_i];\n    }\n    var prefixes = __spreadArray([prefix], __read(otherPrefixes), false);\n    return function (e, attr, value) {\n        setPrefixedAttribute(prefixes, e, attr, value);\n    };\n}\nexports.buildPrefixedAttributeSetter = buildPrefixedAttributeSetter;\n/**\n * The safe alternative to Element#setAttribute. The function takes a list of\n * `SafeAttributePrefix`, making developer intention explicit. The attribute\n * to be set must has one of the safe prefixes, otherwise the function throws\n * an Error.\n */\nfunction setPrefixedAttribute(attrPrefixes, e, attr, value) {\n    if (attrPrefixes.length === 0) {\n        throw new Error('No prefixes are provided');\n    }\n    var prefixes = attrPrefixes.map(function (s) { return (0, attribute_impl_1.unwrapAttributePrefix)(s); });\n    var attrLower = attr.toLowerCase();\n    if (prefixes.every(function (p) { return attrLower.indexOf(p) !== 0; })) {\n        throw new Error(\"Attribute \\\"\".concat(attr, \"\\\" does not match any of the allowed prefixes.\"));\n    }\n    e.setAttribute(attr, value);\n}\nexports.setPrefixedAttribute = setPrefixedAttribute;\nfunction throwIfScriptOrStyle(element) {\n    if (element.tagName.toLowerCase() === 'script') {\n        throw new Error('Use setTextContent with a SafeScript.');\n    }\n    else if (element.tagName.toLowerCase() === 'style') {\n        throw new Error('Use setTextContent with a SafeStyleSheet.');\n    }\n}\nfunction isElement(elOrRoot) {\n    return elOrRoot.tagName !== undefined;\n}\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setSrc = void 0;\nvar resource_url_impl_1 = require(\"../../internals/resource_url_impl\");\n/**\n * Sets the Src attribute from the given SafeUrl.\n */\nfunction setSrc(embedEl, url) {\n    embedEl.src = (0, resource_url_impl_1.unwrapResourceUrl)(url);\n}\nexports.setSrc = setSrc;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setAction = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\n/**\n * Sets the Action attribute from the given Url.\n */\nfunction setAction(form, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        form.action = sanitizedUrl;\n    }\n}\nexports.setAction = setAction;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setSrcdoc = exports.setSrc = void 0;\n/**\n * @fileoverview Safe iframe helpers and go/intents-for-iframes-for-closure\n */\nvar html_impl_1 = require(\"../../internals/html_impl\");\nvar resource_url_impl_1 = require(\"../../internals/resource_url_impl\");\n/** Sets the Src attribute using a TrustedResourceUrl */\nfunction setSrc(iframe, v) {\n    iframe.src = (0, resource_url_impl_1.unwrapResourceUrl)(v).toString();\n}\nexports.setSrc = setSrc;\n/** Sets the Srcdoc attribute using a SafeHtml */\nfunction setSrcdoc(iframe, v) {\n    iframe.srcdoc = (0, html_impl_1.unwrapHtml)(v);\n}\nexports.setSrcdoc = setSrcdoc;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setFormaction = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\n/**\n * Sets the Formaction attribute from the given Url.\n */\nfunction setFormaction(input, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        input.formAction = sanitizedUrl;\n    }\n}\nexports.setFormaction = setFormaction;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setHrefAndRel = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\nvar resource_url_impl_1 = require(\"../../internals/resource_url_impl\");\nvar SAFE_URL_REL_VALUES = [\n    'alternate',\n    'author',\n    'bookmark',\n    'canonical',\n    'cite',\n    'help',\n    'icon',\n    'license',\n    'next',\n    'prefetch',\n    'dns-prefetch',\n    'prerender',\n    'preconnect',\n    'preload',\n    'prev',\n    'search',\n    'subresource',\n];\nfunction setHrefAndRel(link, url, rel) {\n    if (url instanceof resource_url_impl_1.TrustedResourceUrl) {\n        link.href = (0, resource_url_impl_1.unwrapResourceUrl)(url).toString();\n    }\n    else {\n        if (SAFE_URL_REL_VALUES.indexOf(rel) === -1) {\n            throw new Error(\"TrustedResourceUrl href attribute required with rel=\\\"\".concat(rel, \"\\\"\"));\n        }\n        var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n        if (sanitizedUrl === undefined) {\n            return;\n        }\n        link.href = sanitizedUrl;\n    }\n    link.rel = rel;\n}\nexports.setHrefAndRel = setHrefAndRel;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setData = void 0;\nvar resource_url_impl_1 = require(\"../../internals/resource_url_impl\");\n/** Sets the data attribute using a TrustedResourceUrl */\nfunction setData(obj, v) {\n    obj.data = (0, resource_url_impl_1.unwrapResourceUrl)(v);\n}\nexports.setData = setData;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setSrc = exports.setTextContent = void 0;\nvar resource_url_impl_1 = require(\"../../internals/resource_url_impl\");\nvar script_impl_1 = require(\"../../internals/script_impl\");\n/** Returns CSP nonce, if set for any script tag. */\nfunction getScriptNonceFromWindow(win) {\n    var _a;\n    var doc = win.document;\n    // document.querySelector can be undefined in non-browser environments.\n    var script = (_a = doc.querySelector) === null || _a === void 0 ? void 0 : _a.call(doc, 'script[nonce]');\n    if (script) {\n        // Try to get the nonce from the IDL property first, because browsers that\n        // implement additional nonce protection features (currently only Chrome) to\n        // prevent nonce stealing via CSS do not expose the nonce via attributes.\n        // See https://github.com/whatwg/html/issues/2369\n        return script['nonce'] || script.getAttribute('nonce') || '';\n    }\n    return '';\n}\n/** Propagates CSP nonce to dynamically created scripts. */\nfunction setNonceForScriptElement(script) {\n    var win = script.ownerDocument && script.ownerDocument.defaultView;\n    var nonce = getScriptNonceFromWindow(win || window);\n    if (nonce) {\n        script.setAttribute('nonce', nonce);\n    }\n}\n/** Sets textContent from the given SafeScript. */\nfunction setTextContent(script, v) {\n    script.textContent = (0, script_impl_1.unwrapScript)(v);\n    setNonceForScriptElement(script);\n}\nexports.setTextContent = setTextContent;\n/** Sets the Src attribute using a TrustedResourceUrl */\nfunction setSrc(script, v) {\n    script.src = (0, resource_url_impl_1.unwrapResourceUrl)(v);\n    setNonceForScriptElement(script);\n}\nexports.setSrc = setSrc;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setTextContent = void 0;\nvar style_sheet_impl_1 = require(\"../../internals/style_sheet_impl\");\n/** Safe setters for `HTMLStyleElement`s. */\nfunction setTextContent(elem, safeStyleSheet) {\n    elem.textContent = (0, style_sheet_impl_1.unwrapStyleSheet)(safeStyleSheet);\n}\nexports.setTextContent = setTextContent;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.execCommandInsertHtml = exports.execCommand = exports.write = void 0;\nvar html_impl_1 = require(\"../../internals/html_impl\");\n/**\n * write safely calls {@link Document.write} on the given {@link Document} with\n * the given {@link SafeHtml}.\n */\nfunction write(doc, text) {\n    doc.write((0, html_impl_1.unwrapHtml)(text));\n}\nexports.write = write;\n/**\n * Safely calls {@link Document.execCommand}. When command is insertHtml, a\n * SafeHtml must be passed in as value.\n */\nfunction execCommand(doc, command, value) {\n    var commandString = String(command);\n    var valueArgument = value;\n    if (commandString.toLowerCase() === 'inserthtml') {\n        valueArgument = (0, html_impl_1.unwrapHtml)(value);\n    }\n    return doc.execCommand(commandString, /* showUi= */ false, valueArgument);\n}\nexports.execCommand = execCommand;\n/**\n * Safely calls {@link Document.execCommand}('insertHtml').\n * @deprecated Use safeDocument.execCommand.\n */\nfunction execCommandInsertHtml(doc, html) {\n    return doc.execCommand('insertHTML', /* showUi= */ false, (0, html_impl_1.unwrapHtml)(html));\n}\nexports.execCommandInsertHtml = execCommandInsertHtml;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseFromString = exports.parseHtml = void 0;\nvar html_impl_1 = require(\"../../internals/html_impl\");\n/** Safely parses a string using the HTML parser. */\nfunction parseHtml(parser, html) {\n    return parseFromString(parser, html, 'text/html');\n}\nexports.parseHtml = parseHtml;\n/** Safely parses a string using the HTML or XML parser. */\nfunction parseFromString(parser, content, contentType) {\n    return parser.parseFromString((0, html_impl_1.unwrapHtml)(content), contentType);\n}\nexports.parseFromString = parseFromString;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.globalEval = void 0;\nvar script_impl_1 = require(\"../../internals/script_impl\");\n/**\n * Evaluates a SafeScript value in the given scope using eval.\n *\n * Strongly consider avoiding this, as eval blocks CSP adoption and does not\n * benefit from compiler optimizations.\n */\nfunction globalEval(win, script) {\n    var trustedScript = (0, script_impl_1.unwrapScript)(script);\n    var result = win.eval(trustedScript);\n    if (result === trustedScript) {\n        // https://crbug.com/1024786 manifesting in workers.\n        result = win.eval(trustedScript.toString());\n    }\n    return result;\n}\nexports.globalEval = globalEval;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.assign = exports.replace = exports.setHref = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\n/**\n * setHref safely sets {@link Location.href} on the given {@link Location} with\n * given {@link Url}.\n */\nfunction setHref(loc, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        loc.href = sanitizedUrl;\n    }\n}\nexports.setHref = setHref;\n/**\n * replace safely calls {@link Location.replace} on the given {@link Location}\n * with given {@link Url}.\n */\nfunction replace(loc, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        loc.replace(sanitizedUrl);\n    }\n}\nexports.replace = replace;\n/**\n * assign safely calls {@link Location.assign} on the given {@link Location}\n * with given {@link Url}.\n */\nfunction assign(loc, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        loc.assign(sanitizedUrl);\n    }\n}\nexports.assign = assign;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createContextualFragment = void 0;\nvar html_impl_1 = require(\"../../internals/html_impl\");\n/** Safely creates a contextualFragment. */\nfunction createContextualFragment(range, html) {\n    return range.createContextualFragment((0, html_impl_1.unwrapHtml)(html));\n}\nexports.createContextualFragment = createContextualFragment;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.register = void 0;\nvar resource_url_impl_1 = require(\"../../internals/resource_url_impl\");\n/** Safely registers a service worker by URL */\nfunction register(container, scriptURL, options) {\n    return container.register((0, resource_url_impl_1.unwrapResourceUrl)(scriptURL), options);\n}\nexports.register = register;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.open = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\n/**\n * open calls {@link Window.open} on the given {@link Window}, given a\n * target {@link Url}.\n */\nfunction open(win, url, target, features) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        return win.open(sanitizedUrl, target, features);\n    }\n    return null;\n}\nexports.open = open;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.importScripts = exports.createShared = exports.create = void 0;\nvar resource_url_impl_1 = require(\"../../internals/resource_url_impl\");\n/**\n * Safely creates a Web Worker.\n *\n * Example usage:\n *   const trustedResourceUrl = trustedResourceUrl`/safe_script.js`;\n *   safedom.safeWorker.create(trustedResourceUrl);\n * which is a safe alternative to\n *   new Worker(url);\n * The latter can result in loading untrusted code.\n */\nfunction create(url, options) {\n    return new Worker((0, resource_url_impl_1.unwrapResourceUrl)(url), options);\n}\nexports.create = create;\n/** Safely creates a shared Web Worker. */\nfunction createShared(url, options) {\n    return new SharedWorker((0, resource_url_impl_1.unwrapResourceUrl)(url), options);\n}\nexports.createShared = createShared;\n/** Safely calls importScripts */\nfunction importScripts(scope) {\n    var urls = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        urls[_i - 1] = arguments[_i];\n    }\n    scope.importScripts.apply(scope, __spreadArray([], __read(urls.map(function (url) { return (0, resource_url_impl_1.unwrapResourceUrl)(url); })), false));\n}\nexports.importScripts = importScripts;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.safeWorker = exports.safeWindow = exports.safeServiceWorkerContainer = exports.safeRange = exports.safeLocation = exports.safeGlobal = exports.safeDomParser = exports.safeDocument = exports.safeStyleEl = exports.safeScriptEl = exports.safeObjectEl = exports.safeLinkEl = exports.safeInputEl = exports.safeIframeEl = exports.safeFormEl = exports.safeEmbedEl = exports.safeElement = exports.safeButtonEl = exports.safeAreaEl = exports.safeAnchorEl = void 0;\n/**\n * @fileoverview This file re-exports all of the wrappers to ensure that we have\n * a clearly defined interface.\n */\nexports.safeAnchorEl = __importStar(require(\"./elements/anchor\"));\nexports.safeAreaEl = __importStar(require(\"./elements/area\"));\nexports.safeButtonEl = __importStar(require(\"./elements/button\"));\nexports.safeElement = __importStar(require(\"./elements/element\"));\nexports.safeEmbedEl = __importStar(require(\"./elements/embed\"));\nexports.safeFormEl = __importStar(require(\"./elements/form\"));\nexports.safeIframeEl = __importStar(require(\"./elements/iframe\"));\nexports.safeInputEl = __importStar(require(\"./elements/input\"));\nexports.safeLinkEl = __importStar(require(\"./elements/link\"));\nexports.safeObjectEl = __importStar(require(\"./elements/object\"));\nexports.safeScriptEl = __importStar(require(\"./elements/script\"));\nexports.safeStyleEl = __importStar(require(\"./elements/style\"));\nexports.safeDocument = __importStar(require(\"./globals/document\"));\nexports.safeDomParser = __importStar(require(\"./globals/dom_parser\"));\nexports.safeGlobal = __importStar(require(\"./globals/global\"));\nexports.safeLocation = __importStar(require(\"./globals/location\"));\nexports.safeRange = __importStar(require(\"./globals/range\"));\nexports.safeServiceWorkerContainer = __importStar(require(\"./globals/service_worker_container\"));\nexports.safeWindow = __importStar(require(\"./globals/window\"));\nexports.safeWorker = __importStar(require(\"./globals/worker\"));\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\n/**\n * Ensure process.env.NODE_ENV is set even when not running under Webpack or\n * Node. Terser will strip this out of production binaries.\n */\n/*#__PURE__*/ (function () {\n    if (typeof process === 'undefined') {\n        window.process = { env: { NODE_ENV: 'development' } };\n    }\n})();\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unwrapStyleSheet = exports.SafeStyleSheet = exports.isStyleSheet = exports.unwrapStyle = exports.SafeStyle = exports.isStyle = exports.unwrapScript = exports.SafeScript = exports.isScript = exports.EMPTY_SCRIPT = exports.unwrapResourceUrl = exports.TrustedResourceUrl = exports.isResourceUrl = exports.unwrapHtml = exports.SafeHtml = exports.isHtml = exports.EMPTY_HTML = exports.unwrapAttributePrefix = exports.SafeAttributePrefix = exports.safeStyleSheet = exports.concatStyleSheets = exports.safeStyle = exports.concatStyles = exports.scriptFromJson = exports.safeScriptWithArgs = exports.safeScript = exports.concatScripts = exports.trustedResourceUrl = exports.replaceFragment = exports.blobUrlFromScript = exports.appendParams = exports.HtmlSanitizerBuilder = exports.sanitizeHtmlToFragment = exports.sanitizeHtmlAssertUnchanged = exports.sanitizeHtml = exports.htmlEscape = exports.createScriptSrc = exports.createScript = exports.concatHtmls = exports.safeAttrPrefix = void 0;\n/** Safe builders */\nvar attribute_builders_1 = require(\"./builders/attribute_builders\");\nObject.defineProperty(exports, \"safeAttrPrefix\", { enumerable: true, get: function () { return attribute_builders_1.safeAttrPrefix; } });\nvar html_builders_1 = require(\"./builders/html_builders\");\nObject.defineProperty(exports, \"concatHtmls\", { enumerable: true, get: function () { return html_builders_1.concatHtmls; } });\nObject.defineProperty(exports, \"createScript\", { enumerable: true, get: function () { return html_builders_1.createScript; } });\nObject.defineProperty(exports, \"createScriptSrc\", { enumerable: true, get: function () { return html_builders_1.createScriptSrc; } });\nObject.defineProperty(exports, \"htmlEscape\", { enumerable: true, get: function () { return html_builders_1.htmlEscape; } });\nvar html_sanitizer_1 = require(\"./builders/html_sanitizer/html_sanitizer\");\nObject.defineProperty(exports, \"sanitizeHtml\", { enumerable: true, get: function () { return html_sanitizer_1.sanitizeHtml; } });\nObject.defineProperty(exports, \"sanitizeHtmlAssertUnchanged\", { enumerable: true, get: function () { return html_sanitizer_1.sanitizeHtmlAssertUnchanged; } });\nObject.defineProperty(exports, \"sanitizeHtmlToFragment\", { enumerable: true, get: function () { return html_sanitizer_1.sanitizeHtmlToFragment; } });\nvar html_sanitizer_builder_1 = require(\"./builders/html_sanitizer/html_sanitizer_builder\");\nObject.defineProperty(exports, \"HtmlSanitizerBuilder\", { enumerable: true, get: function () { return html_sanitizer_builder_1.HtmlSanitizerBuilder; } });\nvar resource_url_builders_1 = require(\"./builders/resource_url_builders\");\nObject.defineProperty(exports, \"appendParams\", { enumerable: true, get: function () { return resource_url_builders_1.appendParams; } });\nObject.defineProperty(exports, \"blobUrlFromScript\", { enumerable: true, get: function () { return resource_url_builders_1.blobUrlFromScript; } });\nObject.defineProperty(exports, \"replaceFragment\", { enumerable: true, get: function () { return resource_url_builders_1.replaceFragment; } });\nObject.defineProperty(exports, \"trustedResourceUrl\", { enumerable: true, get: function () { return resource_url_builders_1.trustedResourceUrl; } });\nvar script_builders_1 = require(\"./builders/script_builders\");\nObject.defineProperty(exports, \"concatScripts\", { enumerable: true, get: function () { return script_builders_1.concatScripts; } });\nObject.defineProperty(exports, \"safeScript\", { enumerable: true, get: function () { return script_builders_1.safeScript; } });\nObject.defineProperty(exports, \"safeScriptWithArgs\", { enumerable: true, get: function () { return script_builders_1.safeScriptWithArgs; } });\nObject.defineProperty(exports, \"scriptFromJson\", { enumerable: true, get: function () { return script_builders_1.scriptFromJson; } });\nvar style_builders_1 = require(\"./builders/style_builders\");\nObject.defineProperty(exports, \"concatStyles\", { enumerable: true, get: function () { return style_builders_1.concatStyles; } });\nObject.defineProperty(exports, \"safeStyle\", { enumerable: true, get: function () { return style_builders_1.safeStyle; } });\nvar style_sheet_builders_1 = require(\"./builders/style_sheet_builders\");\nObject.defineProperty(exports, \"concatStyleSheets\", { enumerable: true, get: function () { return style_sheet_builders_1.concatStyleSheets; } });\nObject.defineProperty(exports, \"safeStyleSheet\", { enumerable: true, get: function () { return style_sheet_builders_1.safeStyleSheet; } });\n/** Types, constants and unwrappers */\nvar attribute_impl_1 = require(\"./internals/attribute_impl\");\nObject.defineProperty(exports, \"SafeAttributePrefix\", { enumerable: true, get: function () { return attribute_impl_1.SafeAttributePrefix; } });\nObject.defineProperty(exports, \"unwrapAttributePrefix\", { enumerable: true, get: function () { return attribute_impl_1.unwrapAttributePrefix; } });\nvar html_impl_1 = require(\"./internals/html_impl\");\nObject.defineProperty(exports, \"EMPTY_HTML\", { enumerable: true, get: function () { return html_impl_1.EMPTY_HTML; } });\nObject.defineProperty(exports, \"isHtml\", { enumerable: true, get: function () { return html_impl_1.isHtml; } });\nObject.defineProperty(exports, \"SafeHtml\", { enumerable: true, get: function () { return html_impl_1.SafeHtml; } });\nObject.defineProperty(exports, \"unwrapHtml\", { enumerable: true, get: function () { return html_impl_1.unwrapHtml; } });\nvar resource_url_impl_1 = require(\"./internals/resource_url_impl\");\nObject.defineProperty(exports, \"isResourceUrl\", { enumerable: true, get: function () { return resource_url_impl_1.isResourceUrl; } });\nObject.defineProperty(exports, \"TrustedResourceUrl\", { enumerable: true, get: function () { return resource_url_impl_1.TrustedResourceUrl; } });\nObject.defineProperty(exports, \"unwrapResourceUrl\", { enumerable: true, get: function () { return resource_url_impl_1.unwrapResourceUrl; } });\nvar script_impl_1 = require(\"./internals/script_impl\");\nObject.defineProperty(exports, \"EMPTY_SCRIPT\", { enumerable: true, get: function () { return script_impl_1.EMPTY_SCRIPT; } });\nObject.defineProperty(exports, \"isScript\", { enumerable: true, get: function () { return script_impl_1.isScript; } });\nObject.defineProperty(exports, \"SafeScript\", { enumerable: true, get: function () { return script_impl_1.SafeScript; } });\nObject.defineProperty(exports, \"unwrapScript\", { enumerable: true, get: function () { return script_impl_1.unwrapScript; } });\nvar style_impl_1 = require(\"./internals/style_impl\");\nObject.defineProperty(exports, \"isStyle\", { enumerable: true, get: function () { return style_impl_1.isStyle; } });\nObject.defineProperty(exports, \"SafeStyle\", { enumerable: true, get: function () { return style_impl_1.SafeStyle; } });\nObject.defineProperty(exports, \"unwrapStyle\", { enumerable: true, get: function () { return style_impl_1.unwrapStyle; } });\nvar style_sheet_impl_1 = require(\"./internals/style_sheet_impl\");\nObject.defineProperty(exports, \"isStyleSheet\", { enumerable: true, get: function () { return style_sheet_impl_1.isStyleSheet; } });\nObject.defineProperty(exports, \"SafeStyleSheet\", { enumerable: true, get: function () { return style_sheet_impl_1.SafeStyleSheet; } });\nObject.defineProperty(exports, \"unwrapStyleSheet\", { enumerable: true, get: function () { return style_sheet_impl_1.unwrapStyleSheet; } });\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unwrapAttributePrefix = exports.createAttributePrefix = exports.SafeAttributePrefix = void 0;\nrequire(\"../environment/dev\");\nvar secrets_1 = require(\"./secrets\");\n/** A prefix with which an attribute is safe to set using plain strings. */\nvar SafeAttributePrefix = /** @class */ (function () {\n    function SafeAttributePrefix() {\n    }\n    return SafeAttributePrefix;\n}());\nexports.SafeAttributePrefix = SafeAttributePrefix;\n/** Implementation for `SafeAttributePrefix` */\nvar AttributePrefixImpl = /** @class */ (function (_super) {\n    __extends(AttributePrefixImpl, _super);\n    function AttributePrefixImpl(attrPrefix, token) {\n        var _this = _super.call(this) || this;\n        if (process.env.NODE_ENV !== 'production') {\n            (0, secrets_1.ensureTokenIsValid)(token);\n        }\n        _this.privateDoNotAccessOrElseWrappedAttrPrefix = attrPrefix;\n        return _this;\n    }\n    AttributePrefixImpl.prototype.toString = function () {\n        return this.privateDoNotAccessOrElseWrappedAttrPrefix;\n    };\n    return AttributePrefixImpl;\n}(SafeAttributePrefix));\n/**\n * Builds a new `SafeAttribute` from the given string, without enforcing\n * safety guarantees. This shouldn't be exposed to application developers, and\n * must only be used as a step towards safe builders or safe constants.\n */\nfunction createAttributePrefix(attrPrefix) {\n    return new AttributePrefixImpl(attrPrefix, secrets_1.secretToken);\n}\nexports.createAttributePrefix = createAttributePrefix;\n/**\n * Returns the string value of the passed `SafeAttributePrefix` object while\n * ensuring it has the correct type.\n */\nfunction unwrapAttributePrefix(value) {\n    if (value instanceof AttributePrefixImpl) {\n        return value.privateDoNotAccessOrElseWrappedAttrPrefix;\n    }\n    else {\n        var message = '';\n        if (process.env.NODE_ENV !== 'production') {\n            message = 'Unexpected type when unwrapping SafeAttributePrefix';\n        }\n        throw new Error(message);\n    }\n}\nexports.unwrapAttributePrefix = unwrapAttributePrefix;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unwrapHtml = exports.isHtml = exports.EMPTY_HTML = exports.createHtml = exports.SafeHtml = void 0;\nrequire(\"../environment/dev\");\n/* g3_import_pure from './pure' */\nvar secrets_1 = require(\"./secrets\");\nvar trusted_types_1 = require(\"./trusted_types\");\n/**\n * Runtime implementation of `TrustedHTML` in browsers that don't support it.\n */\nvar HtmlImpl = /** @class */ (function () {\n    function HtmlImpl(html, token) {\n        if (process.env.NODE_ENV !== 'production') {\n            (0, secrets_1.ensureTokenIsValid)(token);\n        }\n        this.privateDoNotAccessOrElseWrappedHtml = html;\n    }\n    HtmlImpl.prototype.toString = function () {\n        return this.privateDoNotAccessOrElseWrappedHtml.toString();\n    };\n    return HtmlImpl;\n}());\nfunction createHtmlInternal(html, trusted) {\n    return (trusted !== null && trusted !== void 0 ? trusted : new HtmlImpl(html, secrets_1.secretToken));\n}\nvar GlobalTrustedHTML = (typeof window !== undefined) ? window.TrustedHTML : undefined;\n/**\n * Also exports the constructor so that instanceof checks work.\n */\nexports.SafeHtml = (GlobalTrustedHTML !== null && GlobalTrustedHTML !== void 0 ? GlobalTrustedHTML : HtmlImpl);\n/**\n * Builds a new `SafeHtml` from the given string, without enforcing safety\n * guarantees. It may cause side effects by creating a Trusted Types policy.\n * This shouldn't be exposed to application developers, and must only be used as\n * a step towards safe builders or safe constants.\n */\nfunction createHtml(html) {\n    var _a;\n    /** @noinline */\n    var noinlineHtml = html;\n    return createHtmlInternal(noinlineHtml, (_a = (0, trusted_types_1.getTrustedTypesPolicy)()) === null || _a === void 0 ? void 0 : _a.createHTML(noinlineHtml));\n}\nexports.createHtml = createHtml;\n/**\n * An empty `SafeHtml` constant.\n * Unlike the function above, using this will not create a policy.\n */\nexports.EMPTY_HTML = \n/* #__PURE__ */ (function () { var _a; return createHtmlInternal('', (_a = (0, trusted_types_1.getTrustedTypes)()) === null || _a === void 0 ? void 0 : _a.emptyHTML); })();\n/**\n * Checks if the given value is a `SafeHtml` instance.\n */\nfunction isHtml(value) {\n    return value instanceof exports.SafeHtml;\n}\nexports.isHtml = isHtml;\n/**\n * Returns the value of the passed `SafeHtml` object while ensuring it\n * has the correct type.\n *\n * Returns a native `TrustedHTML` or a string if Trusted Types are disabled.\n */\nfunction unwrapHtml(value) {\n    var _a;\n    if ((_a = (0, trusted_types_1.getTrustedTypes)()) === null || _a === void 0 ? void 0 : _a.isHTML(value)) {\n        return value;\n    }\n    else if (value instanceof HtmlImpl) {\n        return value.privateDoNotAccessOrElseWrappedHtml;\n    }\n    else {\n        var message = '';\n        if (process.env.NODE_ENV !== 'production') {\n            message = 'Unexpected type when unwrapping SafeHtml';\n        }\n        throw new Error(message);\n    }\n}\nexports.unwrapHtml = unwrapHtml;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unwrapResourceUrl = exports.isResourceUrl = exports.createResourceUrl = exports.TrustedResourceUrl = void 0;\nrequire(\"../environment/dev\");\nvar secrets_1 = require(\"./secrets\");\nvar trusted_types_1 = require(\"./trusted_types\");\n/**\n * Runtime implementation of `TrustedScriptURL` in browsers that don't support\n * it.\n */\nvar ResourceUrlImpl = /** @class */ (function () {\n    function ResourceUrlImpl(url, token) {\n        if (process.env.NODE_ENV !== 'production') {\n            (0, secrets_1.ensureTokenIsValid)(token);\n        }\n        this.privateDoNotAccessOrElseWrappedResourceUrl = url;\n    }\n    ResourceUrlImpl.prototype.toString = function () {\n        return this.privateDoNotAccessOrElseWrappedResourceUrl.toString();\n    };\n    return ResourceUrlImpl;\n}());\nvar GlobalTrustedScriptURL = (typeof window !== undefined) ? window.TrustedScriptURL : undefined;\n/**\n * Also exports the constructor so that instanceof checks work.\n */\nexports.TrustedResourceUrl = (GlobalTrustedScriptURL !== null && GlobalTrustedScriptURL !== void 0 ? GlobalTrustedScriptURL : ResourceUrlImpl);\n/**\n * Builds a new `TrustedResourceUrl` from the given string, without\n * enforcing safety guarantees. It may cause side effects by creating a Trusted\n * Types policy. This shouldn't be exposed to application developers, and must\n * only be used as a step towards safe builders or safe constants.\n */\nfunction createResourceUrl(url) {\n    var _a;\n    /** @noinline */\n    var noinlineUrl = url;\n    var trustedScriptURL = (_a = (0, trusted_types_1.getTrustedTypesPolicy)()) === null || _a === void 0 ? void 0 : _a.createScriptURL(noinlineUrl);\n    return (trustedScriptURL !== null && trustedScriptURL !== void 0 ? trustedScriptURL : new ResourceUrlImpl(noinlineUrl, secrets_1.secretToken));\n}\nexports.createResourceUrl = createResourceUrl;\n/**\n * Checks if the given value is a `TrustedResourceUrl` instance.\n */\nfunction isResourceUrl(value) {\n    return value instanceof exports.TrustedResourceUrl;\n}\nexports.isResourceUrl = isResourceUrl;\n/**\n * Returns the value of the passed `TrustedResourceUrl` object while ensuring it\n * has the correct type.\n *\n * Returns a native `TrustedScriptURL` or a string if Trusted Types are\n * disabled.\n */\nfunction unwrapResourceUrl(value) {\n    var _a;\n    if ((_a = (0, trusted_types_1.getTrustedTypes)()) === null || _a === void 0 ? void 0 : _a.isScriptURL(value)) {\n        return value;\n    }\n    else if (value instanceof ResourceUrlImpl) {\n        return value.privateDoNotAccessOrElseWrappedResourceUrl;\n    }\n    else {\n        var message = '';\n        if (process.env.NODE_ENV !== 'production') {\n            message = 'Unexpected type when unwrapping TrustedResourceUrl';\n        }\n        throw new Error(message);\n    }\n}\nexports.unwrapResourceUrl = unwrapResourceUrl;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unwrapScript = exports.isScript = exports.EMPTY_SCRIPT = exports.createScript = exports.SafeScript = void 0;\nrequire(\"../environment/dev\");\n/* g3_import_pure from './pure' */\nvar secrets_1 = require(\"./secrets\");\nvar trusted_types_1 = require(\"./trusted_types\");\n/**\n * Runtime implementation of `TrustedScript` in browswers that don't support it.\n * script element.\n */\nvar ScriptImpl = /** @class */ (function () {\n    function ScriptImpl(script, token) {\n        if (process.env.NODE_ENV !== 'production') {\n            (0, secrets_1.ensureTokenIsValid)(token);\n        }\n        this.privateDoNotAccessOrElseWrappedScript = script;\n    }\n    ScriptImpl.prototype.toString = function () {\n        return this.privateDoNotAccessOrElseWrappedScript.toString();\n    };\n    return ScriptImpl;\n}());\nfunction createScriptInternal(script, trusted) {\n    return (trusted !== null && trusted !== void 0 ? trusted : new ScriptImpl(script, secrets_1.secretToken));\n}\nvar GlobalTrustedScript = (typeof window !== undefined) ? window.TrustedScript : undefined;\n/**\n * Also exports the constructor so that instanceof checks work.\n */\nexports.SafeScript = (GlobalTrustedScript !== null && GlobalTrustedScript !== void 0 ? GlobalTrustedScript : ScriptImpl);\n/**\n * Builds a new `SafeScript` from the given string, without enforcing\n * safety guarantees. It may cause side effects by creating a Trusted Types\n * policy. This shouldn't be exposed to application developers, and must only be\n * used as a step towards safe builders or safe constants.\n */\nfunction createScript(script) {\n    var _a;\n    /** @noinline */\n    var noinlineScript = script;\n    return createScriptInternal(noinlineScript, (_a = (0, trusted_types_1.getTrustedTypesPolicy)()) === null || _a === void 0 ? void 0 : _a.createScript(noinlineScript));\n}\nexports.createScript = createScript;\n/**\n * An empty `SafeScript` constant.\n * Unlike the functions above, using this will not create a policy.\n */\nexports.EMPTY_SCRIPT = \n/* #__PURE__ */ (function () { var _a; return createScriptInternal('', (_a = (0, trusted_types_1.getTrustedTypes)()) === null || _a === void 0 ? void 0 : _a.emptyScript); })();\n/**\n * Checks if the given value is a `SafeScript` instance.\n */\nfunction isScript(value) {\n    return value instanceof exports.SafeScript;\n}\nexports.isScript = isScript;\n/**\n * Returns the value of the passed `SafeScript` object while ensuring it\n * has the correct type.\n *\n * Returns a native `TrustedScript` or a string if Trusted Types are disabled.\n */\nfunction unwrapScript(value) {\n    var _a;\n    if ((_a = (0, trusted_types_1.getTrustedTypes)()) === null || _a === void 0 ? void 0 : _a.isScript(value)) {\n        return value;\n    }\n    else if (value instanceof ScriptImpl) {\n        return value.privateDoNotAccessOrElseWrappedScript;\n    }\n    else {\n        var message = '';\n        if (process.env.NODE_ENV !== 'production') {\n            message = 'Unexpected type when unwrapping SafeScript';\n        }\n        throw new Error(message);\n    }\n}\nexports.unwrapScript = unwrapScript;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ensureTokenIsValid = exports.secretToken = void 0;\n/**\n * A secret token that must be passed to safe type constructors. It is only\n * accessible from within safevalues, ensuring that unrestricted safe type\n * creation is only possible within safevalues. In particular, this prevents\n * forgery such as `safeHtmlValue.constructor('javascript:evil')`.\n */\nexports.secretToken = {};\n/**\n * Asserts that the given token matches the secret safevalues token. An\n * exception is thrown if that is not the case.\n */\nfunction ensureTokenIsValid(token) {\n    if (token !== exports.secretToken) {\n        throw new Error('Bad secret');\n    }\n}\nexports.ensureTokenIsValid = ensureTokenIsValid;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.assertIsTemplateObject = void 0;\n/**\n * An object of type TemplateStringsArray represents the literal part(s) of a\n * template literal. This function checks if a TemplateStringsArray object is\n * actually from a template literal.\n *\n * @param templateObj This contains the literal part of the template literal.\n * @param hasExprs If true, the input template may contain embedded expressions.\n * @param errorMsg The custom error message in case any checks fail.\n */\nfunction assertIsTemplateObject(templateObj, hasExprs, errorMsg) {\n    if (!Array.isArray(templateObj) || !Array.isArray(templateObj.raw) ||\n        (!hasExprs && templateObj.length !== 1)) {\n        throw new TypeError(errorMsg);\n    }\n}\nexports.assertIsTemplateObject = assertIsTemplateObject;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unwrapStyle = exports.isStyle = exports.createStyle = exports.SafeStyle = void 0;\nrequire(\"../environment/dev\");\nvar secrets_1 = require(\"./secrets\");\n/**\n * Sequence of CSS declarations safe to use in style contexts in an HTML\n * document or in DOM APIs.\n */\nvar SafeStyle = /** @class */ (function () {\n    function SafeStyle() {\n    }\n    return SafeStyle;\n}());\nexports.SafeStyle = SafeStyle;\n/** Implementation for `SafeStyle` */\nvar StyleImpl = /** @class */ (function (_super) {\n    __extends(StyleImpl, _super);\n    function StyleImpl(style, token) {\n        var _this = _super.call(this) || this;\n        if (process.env.NODE_ENV !== 'production') {\n            (0, secrets_1.ensureTokenIsValid)(token);\n        }\n        _this.privateDoNotAccessOrElseWrappedStyle = style;\n        return _this;\n    }\n    StyleImpl.prototype.toString = function () {\n        return this.privateDoNotAccessOrElseWrappedStyle;\n    };\n    return StyleImpl;\n}(SafeStyle));\n/**\n * Builds a new `SafeStyle` from the given string, without enforcing\n * safety guarantees. This shouldn't be exposed to application developers, and\n * must only be used as a step towards safe builders or safe constants.\n */\nfunction createStyle(style) {\n    return new StyleImpl(style, secrets_1.secretToken);\n}\nexports.createStyle = createStyle;\n/**\n * Checks if the given value is a `SafeStyle` instance.\n */\nfunction isStyle(value) {\n    return value instanceof StyleImpl;\n}\nexports.isStyle = isStyle;\n/**\n * Returns the string value of the passed `SafeStyle` object while ensuring it\n * has the correct type.\n */\nfunction unwrapStyle(value) {\n    if (value instanceof StyleImpl) {\n        return value.privateDoNotAccessOrElseWrappedStyle;\n    }\n    else {\n        var message = '';\n        if (process.env.NODE_ENV !== 'production') {\n            message = 'Unexpected type when unwrapping SafeStyle';\n        }\n        throw new Error(message);\n    }\n}\nexports.unwrapStyle = unwrapStyle;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unwrapStyleSheet = exports.isStyleSheet = exports.createStyleSheet = exports.SafeStyleSheet = void 0;\nrequire(\"../environment/dev\");\nvar secrets_1 = require(\"./secrets\");\n/**\n * A complete CSS style sheet, safe to use in style contexts in an HTML document\n * or DOM APIs.\n */\nvar SafeStyleSheet = /** @class */ (function () {\n    function SafeStyleSheet() {\n    }\n    return SafeStyleSheet;\n}());\nexports.SafeStyleSheet = SafeStyleSheet;\n/** Implementation for `SafeStyleSheet` */\nvar StyleSheetImpl = /** @class */ (function (_super) {\n    __extends(StyleSheetImpl, _super);\n    function StyleSheetImpl(styleSheet, token) {\n        var _this = _super.call(this) || this;\n        if (process.env.NODE_ENV !== 'production') {\n            (0, secrets_1.ensureTokenIsValid)(token);\n        }\n        _this.privateDoNotAccessOrElseWrappedStyleSheet = styleSheet;\n        return _this;\n    }\n    StyleSheetImpl.prototype.toString = function () {\n        return this.privateDoNotAccessOrElseWrappedStyleSheet;\n    };\n    return StyleSheetImpl;\n}(SafeStyleSheet));\n/**\n * Builds a new `SafeStyleSheet` from the given string, without enforcing\n * safety guarantees. This shouldn't be exposed to application developers, and\n * must only be used as a step towards safe builders or safe constants.\n */\nfunction createStyleSheet(styleSheet) {\n    return new StyleSheetImpl(styleSheet, secrets_1.secretToken);\n}\nexports.createStyleSheet = createStyleSheet;\n/**\n * Checks if the given value is a `SafeStyleSheet` instance.\n */\nfunction isStyleSheet(value) {\n    return value instanceof StyleSheetImpl;\n}\nexports.isStyleSheet = isStyleSheet;\n/**\n * Returns the string value of the passed `SafeStyleSheet` object while\n * ensuring it has the correct type.\n */\nfunction unwrapStyleSheet(value) {\n    if (value instanceof StyleSheetImpl) {\n        return value.privateDoNotAccessOrElseWrappedStyleSheet;\n    }\n    else {\n        var message = '';\n        if (process.env.NODE_ENV !== 'production') {\n            message = 'Unexpected type when unwrapping SafeStyleSheet';\n        }\n        throw new Error(message);\n    }\n}\nexports.unwrapStyleSheet = unwrapStyleSheet;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.TEST_ONLY = exports.getTrustedTypesPolicy = exports.getTrustedTypes = void 0;\n/**\n * The name of the Trusted Types policy used by TS safevalues, or empty\n * to disable Trusted Types. This duplicates the 'google#safe', but\n * can be overridden in tests.\n */\nvar trustedTypesPolicyName = 'google#safe';\n/** Helper to retrieve the value of `window.trustedTypes`. */\nfunction trustedTypes() {\n    if (typeof window !== 'undefined') {\n        return window.trustedTypes;\n    }\n    return undefined;\n}\n/**\n * Returns window.trustedTypes if Trusted Types are enabled and supported, or\n * null otherwise.\n */\nfunction getTrustedTypes() {\n    var _a;\n    return (trustedTypesPolicyName !== '') ? ((_a = trustedTypes()) !== null && _a !== void 0 ? _a : null) : null;\n}\nexports.getTrustedTypes = getTrustedTypes;\n/**\n * The Trusted Types policy used by TS safevalues, or null if Trusted Types\n * are not enabled/supported, or undefined if the policy has not been created\n * yet.\n */\nvar trustedTypesPolicy;\n/**\n * Returns the Trusted Types policy used by TS safevalues, or null if Trusted\n * Types are not enabled/supported. The first call to this function will\n * create the policy.\n */\nfunction getTrustedTypesPolicy() {\n    var _a, _b;\n    if (trustedTypesPolicy === undefined) {\n        try {\n            trustedTypesPolicy =\n                (_b = (_a = getTrustedTypes()) === null || _a === void 0 ? void 0 : _a.createPolicy(trustedTypesPolicyName, {\n                    createHTML: function (s) { return s; },\n                    createScript: function (s) { return s; },\n                    createScriptURL: function (s) { return s; }\n                })) !== null && _b !== void 0 ? _b : null;\n        }\n        catch (_c) {\n            // In Chromium versions before 81, trustedTypes.createPolicy throws if\n            // called with a name that is already registered, even if no CSP is set.\n            // Until users have largely migrated to 81 or above, catch the error not\n            // to break the applications functionally. In such case, the code will\n            // fall back to using regular Safe Types.\n            trustedTypesPolicy = null;\n        }\n    }\n    return trustedTypesPolicy;\n}\nexports.getTrustedTypesPolicy = getTrustedTypesPolicy;\n/** Helpers for tests. */\nexports.TEST_ONLY = {\n    resetDefaults: function () {\n        trustedTypesPolicy = undefined;\n        trustedTypesPolicyName = 'google#safe';\n    },\n    setTrustedTypesPolicyName: function (name) {\n        trustedTypesPolicyName = name;\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 autoInit from '@material/auto-init/index';\nimport * as banner from '@material/banner/index';\nimport * as base from '@material/base/index';\nimport * as checkbox from '@material/checkbox/index';\nimport * as chips from '@material/chips/deprecated/index';\nimport * as circularProgress from '@material/circular-progress/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 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 segmentedButton from '@material/segmented-button/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 tooltip from '@material/tooltip/index';\nimport * as topAppBar from '@material/top-app-bar/index';\n\n// Register all components\nautoInit.register('MDCBanner', banner.MDCBanner);\nautoInit.register('MDCCheckbox', checkbox.MDCCheckbox);\nautoInit.register('MDCChip', chips.MDCChip);\nautoInit.register('MDCChipSet', chips.MDCChipSet);\nautoInit.register('MDCCircularProgress', circularProgress.MDCCircularProgress);\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('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('MDCSegmentedButton', segmentedButton.MDCSegmentedButton);\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('MDCTooltip', tooltip.MDCTooltip);\nautoInit.register('MDCTopAppBar', topAppBar.MDCTopAppBar);\n\n// Export all components.\nexport {\n  autoInit,\n  banner,\n  base,\n  checkbox,\n  chips,\n  circularProgress,\n  dataTable,\n  dialog,\n  dom,\n  drawer,\n  floatingLabel,\n  formField,\n  iconButton,\n  lineRipple,\n  linearProgress,\n  list,\n  menu,\n  menuSurface,\n  notchedOutline,\n  radio,\n  ripple,\n  segmentedButton,\n  select,\n  slider,\n  snackbar,\n  switchControl,\n  tab,\n  tabBar,\n  tabIndicator,\n  tabScroller,\n  textField,\n  tooltip,\n  topAppBar,\n};\n","/**\n * @license\n * Copyright 2020 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 * AnimationFrame provides a user-friendly abstraction around requesting\n * and canceling animation frames.\n */\nexport class AnimationFrame {\n  private readonly rafIDs = new Map<string, number>();\n\n  /**\n   * Requests an animation frame. Cancels any existing frame with the same key.\n   * @param {string} key The key for this callback.\n   * @param {FrameRequestCallback} callback The callback to be executed.\n   */\n  request(key: string, callback: FrameRequestCallback) {\n    this.cancel(key);\n    const frameID = requestAnimationFrame((frame) => {\n      this.rafIDs.delete(key);\n      // Callback must come *after* the key is deleted so that nested calls to\n      // request with the same key are not deleted.\n      callback(frame);\n    });\n    this.rafIDs.set(key, frameID);\n  }\n\n  /**\n   * Cancels a queued callback with the given key.\n   * @param {string} key The key for this callback.\n   */\n  cancel(key: string) {\n    const rafID = this.rafIDs.get(key);\n    if (rafID) {\n      cancelAnimationFrame(rafID);\n      this.rafIDs.delete(key);\n    }\n  }\n\n  /**\n   * Cancels all queued callback.\n   */\n  cancelAll() {\n    // Need to use forEach because it's the only iteration method supported\n    // by IE11. Suppress the underscore because we don't need it.\n    // tslint:disable-next-line:enforce-name-casing\n    this.rafIDs.forEach((_, key) => {\n      this.cancel(key);\n    });\n  }\n\n  /**\n   * Returns the queue of unexecuted callback keys.\n   */\n  getQueue(): string[] {\n    const queue: string[] = [];\n    // Need to use forEach because it's the only iteration method supported\n    // by IE11. Suppress the underscore because we don't need it.\n    // tslint:disable-next-line:enforce-name-casing\n    this.rafIDs.forEach((_, key) => {\n      queue.push(key);\n    });\n    return queue;\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 {CssVendorPropertyMap, JsVendorPropertyMap, PrefixedCssPropertyName, PrefixedJsEventType, StandardCssPropertyName, StandardJsEventType} 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) &&\n      typeof windowObj.document.createElement === 'function';\n}\n\nexport function getCorrectPropertyName(\n    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(\n    windowObj: Window, eventType: StandardJsEventType): StandardJsEventType|\n    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  DATASET_AUTO_INIT_STATE: 'mdcAutoInitState',\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, DATASET_AUTO_INIT_STATE, INITIALIZED_STATE} = strings;\n\n/** MDC Attachable */\nexport interface MDCAttachable extends Function {\n  attachTo(root: HTMLElement): MDCComponent<MDCFoundation>;\n}\n\ninterface InternalComponentRegistry {\n  [key: string]: MDCAttachable;\n}\n\nconst registry: InternalComponentRegistry = {};\n\n// tslint:disable-next-line:no-console\nconst CONSOLE_WARN = console.warn.bind(console);\n\nfunction emit<T extends object>(\n    eventType: string, eventData: T, shouldBubble = false) {\n  let event;\n  if (typeof CustomEvent === 'function') {\n    event = new CustomEvent<T>(eventType, {\n      bubbles: shouldBubble,\n      detail: eventData,\n    });\n  } else {\n    event = document.createEvent('CustomEvent');\n    event.initCustomEvent(eventType, shouldBubble, false, eventData);\n  }\n\n  document.dispatchEvent(event);\n}\n\n/* istanbul ignore next: optional argument is not a branch statement */\n/**\n * Auto-initializes all MDC components on a page.\n */\nfunction mdcAutoInit(root: ParentNode = document) {\n  const components = [];\n  let nodes =\n      Array.from(root.querySelectorAll<HTMLElement>(`[${AUTO_INIT_ATTR}]`));\n  nodes = nodes.filter(\n      (node) => node.dataset[DATASET_AUTO_INIT_STATE] !== 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    // tslint:disable-next-line:enforce-name-casing\n    const Constructor = registry[ctorName];\n    if (typeof Constructor !== 'function') {\n      throw new Error(\n          `(mdc-auto-init) Could not find constructor in registry for ${\n              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\n    // 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.dataset[DATASET_AUTO_INIT_STATE] = 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,\n// rather than an instance of a class.\nmdcAutoInit.register = function(\n    componentName: string,\n    // tslint:disable-next-line:enforce-name-casing\n    Constructor: MDCAttachable, warn = CONSOLE_WARN) {\n  if (typeof Constructor !== 'function') {\n    throw new Error(`(mdc-auto-init) Invalid Constructor value: ${\n        Constructor}. Expected function.`);\n  }\n  const registryValue = registry[componentName];\n  if (registryValue) {\n    warn(`(mdc-auto-init) Overriding registration for ${componentName} with ${\n        Constructor}. Was: ${registryValue}`);\n  }\n  registry[componentName] = Constructor;\n};\n\nmdcAutoInit.deregister = function(componentName: string) {\n  delete registry[componentName];\n};\n\n/** @nocollapse */\nmdcAutoInit.deregisterAll = function() {\n  for (const componentName of Object.keys(registry)) {\n    mdcAutoInit.deregister(componentName);\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 mdcAutoInit;\nexport {mdcAutoInit};\n","/**\n * @license\n * Copyright 2020 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 {Action, CloseReason} from './constants';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCBannerAdapter {\n  /**\n   * Adds the given class to the banner root element.\n   */\n  addClass(className: string): void;\n\n  /**\n   * @return Returns the height of the banner content element.\n   */\n  getContentHeight(): number;\n\n  /**\n   * Broadcasts an event denoting that the banner has finished closing.\n   */\n  notifyClosed(reason: CloseReason): void;\n\n  /**\n   * Broadcasts an event denoting that the banner has just started closing.\n   */\n  notifyClosing(reason: CloseReason): void;\n\n  /**\n   * Broadcasts an event denoting that the banner has finished opening.\n   */\n  notifyOpened(): void;\n\n  /**\n   * Broadcasts an event denoting that the banner has just started opening.\n   */\n  notifyOpening(): void;\n\n  /**\n   * Broadcasts an event denoting that a banner button was clicked without\n   * changing the banner state.\n   */\n  notifyActionClicked(action: Action): void;\n\n  /**\n   * Releases focus from banner and restores focus to the previously focused\n   * element.\n   */\n  releaseFocus(): void;\n\n  /**\n   * Removes the given class from the banner root element.\n   */\n  removeClass(className: string): void;\n\n  /**\n   * Sets a style property of the banner root element to the passed value.\n   */\n  setStyleProperty(propertyName: string, value: string): void;\n\n  /**\n   * Traps focus in banner and focuses on the primary action button.\n   */\n  trapFocus(): void;\n}\n","/**\n * @license\n * Copyright 2020 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 {FocusTrap} from '@material/dom/focus-trap';\nimport {closest} from '@material/dom/ponyfill';\n\nimport {MDCBannerAdapter} from './adapter';\nimport {CloseReason, events, MDCBannerActionEventDetail, MDCBannerCloseEventDetail, MDCBannerFocusTrapFactory, selectors} from './constants';\nimport {MDCBannerFoundation} from './foundation';\n\n/** Vanilla implementation of banner component. */\nexport class MDCBanner extends MDCComponent<MDCBannerFoundation> {\n  static override attachTo(root: HTMLElement) {\n    return new MDCBanner(root);\n  }\n\n  private handleContentClick!:\n      SpecificEventListener<'click'>;            // Assigned in #initialize.\n  private primaryActionEl!: HTMLElement;         // Assigned in #initialize.\n  private secondaryActionEl!: HTMLElement|null;  // Assigned in #initialize.\n  private textEl!: HTMLElement;                  // Assigned in #initialize.\n  private contentEl!: HTMLElement;               // Assigned in #initialize.\n  private focusTrap!: FocusTrap;  // assigned in initialSyncWithDOM()\n  private focusTrapFactory!:\n      MDCBannerFocusTrapFactory;  // assigned in initialize()\n\n  override initialize(\n      focusTrapFactory: MDCBannerFocusTrapFactory = (el, focusOptions) =>\n          new FocusTrap(el, focusOptions),\n  ) {\n    this.contentEl = this.root.querySelector<HTMLElement>(selectors.CONTENT)!;\n    this.textEl = this.root.querySelector<HTMLElement>(selectors.TEXT)!;\n    this.primaryActionEl =\n        this.root.querySelector<HTMLElement>(selectors.PRIMARY_ACTION)!;\n    this.secondaryActionEl =\n        this.root.querySelector<HTMLElement>(selectors.SECONDARY_ACTION)!;\n    this.focusTrapFactory = focusTrapFactory;\n\n    this.handleContentClick = (event) => {\n      const target = event.target as Element;\n      if (closest(target, selectors.PRIMARY_ACTION)) {\n        this.foundation.handlePrimaryActionClick();\n      } else if (closest(target, selectors.SECONDARY_ACTION)) {\n        this.foundation.handleSecondaryActionClick();\n      }\n    };\n  }\n\n  override initialSyncWithDOM() {\n    this.registerContentClickHandler(this.handleContentClick);\n    this.focusTrap = this.focusTrapFactory(\n        this.root, {initialFocusEl: this.primaryActionEl});\n  }\n\n  override destroy() {\n    super.destroy();\n    this.deregisterContentClickHandler(this.handleContentClick);\n  }\n\n  layout() {\n    this.foundation.layout();\n  }\n\n  /**\n   * Opens the banner and fires events.OPENING to indicate the beginning of its\n   * opening animation and then events.OPENED once the animation finishes.\n   */\n  open() {\n    this.foundation.open();\n  }\n\n  /**\n   * Closes the banner and fires events.CLOSING to indicate the beginning of its\n   * closing animation and then events.CLOSED once the animation finishes.\n   * @param reason Why the banner was closed. Value will be passed to\n   *     events.CLOSING and events.CLOSED via the `event.detail.reason`\n   *     property. Standard values are CloseReason.PRIMARY and\n   *     CloseReason.SECONDARY, but CloseReason.UNSPECIFIED is provided for\n   *     custom handling of programmatic closing of the banner.\n   */\n  close(reason: CloseReason) {\n    this.foundation.close(reason);\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCBannerAdapter = {\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      getContentHeight: () => {\n        return this.contentEl.offsetHeight;\n      },\n      notifyClosed: (reason) => {\n        this.emit<MDCBannerCloseEventDetail>(events.CLOSED, {reason});\n      },\n      notifyClosing: (reason) => {\n        this.emit<MDCBannerCloseEventDetail>(events.CLOSING, {reason});\n      },\n      notifyOpened: () => {\n        this.emit(events.OPENED, {});\n      },\n      notifyOpening: () => {\n        this.emit(events.OPENING, {});\n      },\n      notifyActionClicked: (action) => {\n        this.emit<MDCBannerActionEventDetail>(events.ACTION_CLICKED, {action});\n      },\n      releaseFocus: () => {\n        this.focusTrap.releaseFocus();\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      setStyleProperty: (propertyName, value) => {\n        this.root.style.setProperty(propertyName, value);\n      },\n      trapFocus: () => {\n        this.focusTrap.trapFocus();\n      },\n    };\n    return new MDCBannerFoundation(adapter);\n  }\n\n  get isOpen(): boolean {\n    return this.foundation.isOpen();\n  }\n\n  getText(): string {\n    return this.textEl.textContent || '';\n  }\n\n  setText(text: string) {\n    this.textEl.textContent = text;\n  }\n\n  getPrimaryActionText(): string {\n    return this.primaryActionEl.textContent || '';\n  }\n\n  setPrimaryActionText(actionButtonText: string) {\n    this.primaryActionEl.textContent = actionButtonText;\n  }\n\n  /** Returns null if the banner has no secondary action. */\n  getSecondaryActionText(): string|null {\n    return this.secondaryActionEl ? this.secondaryActionEl.textContent || '' :\n                                    null;\n  }\n\n  setSecondaryActionText(actionButtonText: string) {\n    if (this.secondaryActionEl) {\n      this.secondaryActionEl.textContent = actionButtonText;\n    }\n  }\n\n  private registerContentClickHandler(handler: SpecificEventListener<'click'>) {\n    this.contentEl.addEventListener('click', handler as EventListener);\n  }\n\n  private deregisterContentClickHandler(handler:\n                                            SpecificEventListener<'click'>) {\n    this.contentEl.removeEventListener('click', handler as EventListener);\n  }\n}\n","/**\n * @license\n * Copyright 2020 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 {FocusOptions, FocusTrap} from '@material/dom/focus-trap';\n\n/** Banner element classes. */\nexport const cssClasses = {\n  CLOSING: 'mdc-banner--closing',\n  OPEN: 'mdc-banner--open',\n  OPENING: 'mdc-banner--opening',\n};\n\n/** Banner numbers. */\nexport const numbers = {\n  BANNER_ANIMATION_CLOSE_TIME_MS: 250,\n  BANNER_ANIMATION_OPEN_TIME_MS: 300,\n};\n\n/** Banner events. */\nexport const events = {\n  CLOSED: 'MDCBanner:closed',\n  CLOSING: 'MDCBanner:closing',\n  OPENED: 'MDCBanner:opened',\n  OPENING: 'MDCBanner:opening',\n  ACTION_CLICKED: 'MDCBanner:actionClicked',\n};\n\n/** Banner selectors. */\nexport const selectors = {\n  CONTENT: '.mdc-banner__content',\n  PRIMARY_ACTION: '.mdc-banner__primary-action',\n  SECONDARY_ACTION: '.mdc-banner__secondary-action',\n  TEXT: '.mdc-banner__text',\n};\n\n/** Reason as to why the banner was closed. */\nexport enum CloseReason {\n  // Indicates the banner was closed via primary action button.\n  PRIMARY,\n  // Indicates the banner was closed via secondary action button.\n  SECONDARY,\n  // Will never be used by the component. Provided for custom handling of\n  // programmatic closing of the banner.\n  UNSPECIFIED,\n}\n\n/**\n * Payload of actionClicked events to signify which action emitted the event.\n */\nexport enum Action {\n  PRIMARY,\n  SECONDARY,\n  UNKNOWN\n}\n\n/** Interface for the detail of the closing and closed events emitted. */\nexport interface MDCBannerCloseEventDetail {\n  reason: CloseReason;\n}\n\n/** Interface for the detail of the closing and closed events emitted. */\nexport interface MDCBannerActionEventDetail {\n  action: Action;\n}\n\n/**  */\nexport type MDCBannerFocusTrapFactory = (\n    element: HTMLElement,\n    options: FocusOptions,\n    ) => FocusTrap;\n","/**\n * @license\n * Copyright 2020 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';\n\nimport {MDCBannerAdapter} from './adapter';\nimport {Action, CloseReason, cssClasses, numbers} from './constants';\n\nconst {OPENING, OPEN, CLOSING} = cssClasses;\n\n/**\n * Foundation class for banner. Responsibilities include opening and closing the\n * banner.\n */\nexport class MDCBannerFoundation extends MDCFoundation<MDCBannerAdapter> {\n  static override get defaultAdapter(): MDCBannerAdapter {\n    return {\n      addClass: () => undefined,\n      getContentHeight: () => 0,\n      notifyClosed: () => undefined,\n      notifyClosing: () => undefined,\n      notifyOpened: () => undefined,\n      notifyOpening: () => undefined,\n      notifyActionClicked: () => undefined,\n      releaseFocus: () => undefined,\n      removeClass: () => undefined,\n      setStyleProperty: () => undefined,\n      trapFocus: () => undefined,\n    };\n  }\n\n  private isOpened = false;\n  // Request id for open animation, used to cancel the refresh callback\n  // request on close() and destroy().\n  private animationFrame = 0;\n  // Timer id for close and open animation, used to cancel the timer on\n  // close() and destroy().\n  private animationTimer = 0;\n\n  constructor(adapter?: Partial<MDCBannerAdapter>) {\n    super({...MDCBannerFoundation.defaultAdapter, ...adapter});\n  }\n\n  override destroy() {\n    cancelAnimationFrame(this.animationFrame);\n    this.animationFrame = 0;\n    clearTimeout(this.animationTimer);\n    this.animationTimer = 0;\n  }\n\n  open() {\n    this.isOpened = true;\n    this.adapter.removeClass(CLOSING);\n    this.adapter.addClass(OPENING);\n    this.adapter.notifyOpening();\n\n    const contentHeight = this.adapter.getContentHeight();\n    this.animationFrame = requestAnimationFrame(() => {\n      this.adapter.addClass(OPEN);\n      this.adapter.setStyleProperty('height', `${contentHeight}px`);\n\n      this.animationTimer = setTimeout(() => {\n        this.handleAnimationTimerEnd();\n        this.adapter.trapFocus();\n        this.adapter.notifyOpened();\n      }, numbers.BANNER_ANIMATION_OPEN_TIME_MS);\n    });\n  }\n\n  /**\n   * @param reason Why the banner was closed. Value will be passed to\n   *     events.CLOSING and events.CLOSED via the `event.detail.reason`\n   *     property. Standard values are CloseReason.PRIMARY and\n   *     CloseReason.SECONDARY, but CloseReason.UNSPECIFIED is provided for\n   *     custom handling of programmatic closing of the banner.\n   */\n  close(reason: CloseReason) {\n    if (!this.isOpened) {\n      // Avoid redundant close calls (and events), e.g. repeated interactions as\n      // the banner is animating closed\n      return;\n    }\n\n    cancelAnimationFrame(this.animationFrame);\n    this.animationFrame = 0;\n\n    this.isOpened = false;\n    this.adapter.notifyClosing(reason);\n    this.adapter.addClass(CLOSING);\n    this.adapter.setStyleProperty('height', '0');\n    this.adapter.removeClass(OPEN);\n    this.adapter.removeClass(OPENING);\n\n    clearTimeout(this.animationTimer);\n    this.animationTimer = setTimeout(() => {\n      this.adapter.releaseFocus();\n      this.handleAnimationTimerEnd();\n      this.adapter.notifyClosed(reason);\n    }, numbers.BANNER_ANIMATION_CLOSE_TIME_MS);\n  }\n\n  isOpen(): boolean {\n    return this.isOpened;\n  }\n\n  handlePrimaryActionClick(disableAutoClose = false) {\n    if (disableAutoClose) {\n      this.adapter.notifyActionClicked(Action.PRIMARY);\n    } else {\n      this.close(CloseReason.PRIMARY);\n    }\n  }\n\n  handleSecondaryActionClick(disableAutoClose = false) {\n    if (disableAutoClose) {\n      this.adapter.notifyActionClicked(Action.SECONDARY);\n\n    } else {\n      this.close(CloseReason.SECONDARY);\n    }\n  }\n\n  layout() {\n    const contentHeight = this.adapter.getContentHeight();\n    this.adapter.setStyleProperty('height', `${contentHeight}px`);\n  }\n\n  private handleAnimationTimerEnd() {\n    this.animationTimer = 0;\n    this.adapter.removeClass(OPENING);\n    this.adapter.removeClass(CLOSING);\n  }\n}\n","/**\n * @license\n * Copyright 2020 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 {safeAttrPrefix} from 'safevalues';\nimport {safeElement} from 'safevalues/dom';\n\nimport {MDCFoundation} from './foundation';\nimport {CustomEventListener, EventType, SpecificEventListener} from './types';\n\nfunction toCamelCase(str: string) {\n  // tslint:disable-next-line:enforce-name-casing\n  return String(str).replace(/\\-([a-z])/g, (_, match) => match.toUpperCase());\n}\n\n/** MDC Component base */\nexport class MDCComponent<FoundationType extends MDCFoundation> {\n  static attachTo(root: HTMLElement): MDCComponent<MDCFoundation<{}>> {\n    // Subclasses which extend MDCBase should provide an attachTo() method that\n    // takes a root element and returns an instantiated component with its root\n    // set to that element. Also note that in the cases of subclasses, an\n    // explicit foundation class will not have to be passed in; it will simply\n    // be initialized from getDefaultFoundation().\n    return new MDCComponent(root, new MDCFoundation({}));\n  }\n\n  protected foundation: FoundationType;\n\n  constructor(\n      public root: HTMLElement, foundation?: FoundationType,\n      ...args: unknown[]) {\n    this.initialize(...args);\n    // Note that we initialize foundation here and not within the constructor's\n    // default param so that this.root is defined and can be used within the\n    // foundation class.\n    this.foundation =\n        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\n   * not need to be unit tested */\n  // tslint:disable-next-line:enforce-name-casing\n  initialize(..._args: unknown[]) {\n    // Subclasses can override this to do any additional setup work that would\n    // be considered part of a \"constructor\". Essentially, it is a hook into the\n    // parent constructor before the foundation is initialized. Any additional\n    // 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\n    // foundation class for the component.\n    throw new Error(\n        '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\n    // synchronize with a host DOM object. An example of this would be a form\n    // control wrapper that needs to synchronize its internal state to some\n    // property or attribute of the host DOM. Please note: this is *not* the\n    // place to perform DOM reads/writes that would cause layout / paint, as\n    // this is called synchronously from within the constructor.\n  }\n\n  destroy() {\n    // Subclasses may implement this method to release any resources /\n    // deregister any listeners they have attached. An example of this might be\n    // 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.\n   * This is most useful when listening for custom events.\n   */\n  listen<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>,\n      options?: AddEventListenerOptions|boolean): void;\n  listen<E extends Event>(\n      eventType: string, handler: CustomEventListener<E>,\n      options?: AddEventListenerOptions|boolean): void;\n  listen(\n      eventType: string, handler: EventListener,\n      options?: AddEventListenerOptions|boolean) {\n    this.root.addEventListener(eventType, handler, options);\n  }\n\n  /**\n   * Wrapper method to remove an event listener to the component's root element.\n   * This is most useful when unlistening for custom events.\n   */\n  unlisten<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>,\n      options?: AddEventListenerOptions|boolean): void;\n  unlisten<E extends Event>(\n      eventType: string, handler: CustomEventListener<E>,\n      options?: AddEventListenerOptions|boolean): void;\n  unlisten(\n      eventType: string, handler: EventListener,\n      options?: AddEventListenerOptions|boolean) {\n    this.root.removeEventListener(eventType, handler, options);\n  }\n\n  /**\n   * Fires a cross-browser-compatible custom event from the component root of\n   * the given type, with the given data.\n   */\n  emit<T extends object>(eventType: string, eventData: T, shouldBubble = false) {\n    let event: CustomEvent<T>;\n    if (typeof CustomEvent === 'function') {\n      event = new CustomEvent<T>(eventType, {\n        bubbles: shouldBubble,\n        detail: eventData,\n      });\n    } else {\n      event = document.createEvent('CustomEvent');\n      event.initCustomEvent(eventType, shouldBubble, false, eventData);\n    }\n\n    this.root.dispatchEvent(event);\n  }\n\n  /**\n   * This is a intermediate fix to allow components to use safevalues. This\n   * limits setAttribute to setting tabindex, data attributes, and aria\n   * attributes.\n   *\n   * TODO(b/263990206): remove this method and add these directly in each\n   * component. This will remove this abstraction and make it clear that the\n   * caller can't set any attribute.\n   */\n  protected safeSetAttribute(\n      element: HTMLElement,\n      attribute: string,\n      value: string,\n  ) {\n    if (attribute.toLowerCase() === 'tabindex') {\n      element.tabIndex = Number(value);\n    } else if (attribute.indexOf('data-') === 0) {\n      const dataKey = toCamelCase(attribute.replace(/^data-/, ''));\n      element.dataset[dataKey] = value;\n    } else {\n      safeElement.setPrefixedAttribute(\n          [safeAttrPrefix`aria-`, safeAttrPrefix`role`],\n          element,\n          attribute,\n          value,\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 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\n/** MDC Foundation */\nexport class MDCFoundation<AdapterType extends {} = {}> {\n  static get cssClasses(): {[key: string]: string} {\n    // Classes extending MDCFoundation should implement this method to return an\n    // object which exports every CSS class the foundation class needs as a\n    // 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\n    // object which exports all semantic strings as constants. e.g. {ARIA_ROLE:\n    // 'tablist'}\n    return {};\n  }\n\n  static get numbers(): {[key: string]: number} {\n    // Classes extending MDCFoundation should implement this method to return an\n    // object which exports all of its semantic numbers as constants.\n    // 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\n    // order to provide a convenient way of viewing the necessary methods of an\n    // adapter. In the future, this could also be used for adapter validation.\n    return {};\n  }\n\n  constructor(protected adapter: AdapterType = {} as AdapterType) {}\n\n  init() {\n    // Subclasses should override this method to perform initialization routines\n    // (registering events, etc.)\n  }\n\n  destroy() {\n    // Subclasses should override this method to perform de-initialization\n    // routines (de-registering events, etc.)\n  }\n}\n\n/**\n * The constructor for MDCFoundation.\n */\nexport interface MDCFoundationConstructor<AdapterType extends object = any> {\n  new(adapter: AdapterType): MDCFoundation<AdapterType>;\n  readonly prototype: MDCFoundation<AdapterType>;\n}\n\n/**\n * The deprecated constructor for MDCFoundation.\n */\nexport interface MDCFoundationDeprecatedConstructor<\n    AdapterType extends object = any> {\n  readonly cssClasses: Record<string, string>;\n  readonly strings: Record<string, string>;\n  readonly numbers: Record<string, number>;\n  readonly defaultAdapter: AdapterType;\n\n  new(adapter?: Partial<AdapterType>): MDCFoundation<AdapterType>;\n  readonly prototype: MDCFoundation<AdapterType>;\n}\n\n/**\n * Retrieves the AdapaterType from the provided MDCFoundation generic type.\n */\nexport type MDCFoundationAdapter<T> =\n    T extends MDCFoundation<infer A>? A : never;\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 2021 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 {observeProperty, Observer, ObserverRecord, setObserversEnabled} from './observer';\n\n// @ts-ignore(go/ts48upgrade) Fix code and remove this comment. Error:\n// TS2344: Type 'Adapter' does not satisfy the constraint '{}'.\nexport class MDCObserverFoundation<Adapter> extends MDCFoundation<Adapter> {\n  /** A set of cleanup functions to unobserve changes. */\n  protected unobserves = new Set<Function>();\n\n  constructor(adapter: Adapter) {\n    super(adapter);\n  }\n\n  override destroy() {\n    super.destroy();\n    this.unobserve();\n  }\n\n  /**\n   * Observe a target's properties for changes using the provided map of\n   * property names and observer functions.\n   *\n   * @template T The target type.\n   * @param target - The target to observe.\n   * @param observers - An object whose keys are target properties and values\n   *     are observer functions that are called when the associated property\n   *     changes.\n   * @return A cleanup function that can be called to unobserve the\n   *     target.\n   */\n  protected observe<T extends object>(\n      target: T, observers: ObserverRecord<T, this>) {\n    const cleanup: Function[] = [];\n    for (const property of Object.keys(observers) as Array<keyof T>) {\n      const observer = observers[property]!.bind(this);\n      cleanup.push(this.observeProperty(target, property, observer));\n    }\n\n    const unobserve = () => {\n      for (const cleanupFn of cleanup) {\n        cleanupFn();\n      }\n\n      this.unobserves.delete(unobserve);\n    };\n\n    this.unobserves.add(unobserve);\n    return unobserve;\n  }\n\n  /**\n   * Observe a target's property for changes. When a property changes, the\n   * provided `Observer` function will be invoked with the properties current\n   * and previous values.\n   *\n   * The returned cleanup function will stop listening to changes for the\n   * provided `Observer`.\n   *\n   * @template T The observed target type.\n   * @template K The observed property.\n   * @param target - The target to observe.\n   * @param property - The property of the target to observe.\n   * @param observer - An observer function to invoke each time the property\n   *     changes.\n   * @return A cleanup function that will stop observing changes for the\n   *     provided `Observer`.\n   */\n  protected observeProperty<T extends object, K extends keyof T>(\n      target: T, property: K, observer: Observer<T, K>) {\n    return observeProperty(target, property, observer);\n  }\n\n  /**\n   * Enables or disables all observers for the provided target. Disabling\n   * observers will prevent them from being called until they are re-enabled.\n   *\n   * @param target - The target to enable or disable observers for.\n   * @param enabled - Whether or not observers should be called.\n   */\n  protected setObserversEnabled(target: object, enabled: boolean) {\n    setObserversEnabled(target, enabled);\n  }\n\n  /**\n   * Clean up all observers and stop listening for property changes.\n   */\n  protected unobserve() {\n    // Iterate over a copy since unobserve() will remove themselves from the set\n    for (const unobserve of [...this.unobserves]) {\n      unobserve();\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2021 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 {Constructor} from './types';\n\n/**\n * A class that can observe targets and perform cleanup logic. Classes may\n * implement this using the `mdcObserver()` mixin.\n */\nexport interface MDCObserver {\n  /**\n   * Observe a target's properties for changes using the provided map of\n   * property names and observer functions.\n   *\n   * @template T The target type.\n   * @param target - The target to observe.\n   * @param observers - An object whose keys are target properties and values\n   *     are observer functions that are called when the associated property\n   *     changes.\n   * @return A cleanup function that can be called to unobserve the\n   *     target.\n   */\n  observe<T extends object>(target: T, observers: ObserverRecord<T, this>):\n      () => void;\n\n  /**\n   * Enables or disables all observers for the provided target. Disabling\n   * observers will prevent them from being called until they are re-enabled.\n   *\n   * @param target - The target to enable or disable observers for.\n   * @param enabled - Whether or not observers should be called.\n   */\n  setObserversEnabled(target: object, enabled: boolean): void;\n\n  /**\n   * Clean up all observers and stop listening for property changes.\n   */\n  unobserve(): void;\n}\n\n/**\n * A function used to observe property changes on a target.\n *\n * @template T The observed target type.\n * @template K The observed property.\n * @template This The `this` context of the observer function.\n * @param current - The current value of the property.\n * @param previous - The previous value of the property.\n */\nexport type Observer<T extends object, K extends keyof T = keyof T,\n                                                 This = unknown> =\n    (this: This, current: T[K], previous: T[K]) => void;\n\n/**\n * An object map whose keys are properties of a target to observe and values\n * are `Observer` functions for each property.\n *\n * @template T The observed target type.\n * @template This The `this` context of observer functions.\n */\nexport type ObserverRecord<T extends object, This = unknown> = {\n  [K in keyof T]?: Observer<T, K, This>;\n};\n\n/**\n * Mixin to add `MDCObserver` functionality.\n *\n * @deprecated Prefer MDCObserverFoundation for stricter closure compliance.\n * @return A class with `MDCObserver` functionality.\n */\nexport function mdcObserver(): Constructor<MDCObserver>;\n\n/**\n * Mixin to add `MDCObserver` functionality to a base class.\n *\n * @deprecated Prefer MDCObserverFoundation for stricter closure compliance.\n * @template T Base class instance type. Specify this generic if the base class\n *     itself has generics that cannot be inferred.\n * @template C Base class constructor type.\n * @param baseClass - Base class.\n * @return A class that extends the optional base class with `MDCObserver`\n *     functionality.\n */\nexport function mdcObserver<T, C extends Constructor<T>>(baseClass: C):\n    Constructor<MDCObserver>&Constructor<T>&C;\n\n/**\n * Mixin to add `MDCObserver` functionality to an optional base class.\n *\n * @deprecated Prefer MDCObserverFoundation for stricter closure compliance.\n * @template C Optional base class constructor type.\n * @param baseClass - Optional base class.\n * @return A class that extends the optional base class with `MDCObserver`\n *     functionality.\n */\nexport function mdcObserver<C extends Constructor>(\n    baseClass: C = class {} as C) {\n  // Mixin classes cannot use private members and Symbol() cannot be used in 3P\n  // for IE11.\n  const unobserveMap = new WeakMap<MDCObserver, Function[]>();\n  return class MDCObserver extends baseClass implements MDCObserver {\n    observe<T extends object>(target: T, observers: ObserverRecord<T, this>) {\n      const cleanup: Function[] = [];\n      for (const property of Object.keys(observers) as Array<keyof T>) {\n        const observer = observers[property]!.bind(this);\n        cleanup.push(observeProperty(target, property, observer));\n      }\n\n      const unobserve = () => {\n        for (const cleanupFn of cleanup) {\n          cleanupFn();\n        }\n        const unobserves = unobserveMap.get(this) || [];\n        const index = unobserves.indexOf(unobserve);\n        if (index > -1) {\n          unobserves.splice(index, 1);\n        }\n      };\n\n      let unobserves = unobserveMap.get(this);\n      if (!unobserves) {\n        unobserves = [];\n        unobserveMap.set(this, unobserves);\n      }\n\n      unobserves.push(unobserve);\n      return unobserve;\n    }\n\n    setObserversEnabled(target: object, enabled: boolean) {\n      setObserversEnabled(target, enabled);\n    }\n\n    unobserve() {\n      // Iterate over a copy since unobserve() will remove themselves from the\n      // array\n      const unobserves = unobserveMap.get(this) || [];\n      for (const unobserve of [...unobserves]) {\n        unobserve();\n      }\n    }\n  };\n}\n\n/**\n * A manager for observers listening to a target. A target's `prototype` is its\n * `TargetObservers` instance.\n *\n * @template T The observed target type.\n */\ninterface TargetObservers<T extends object> {\n  /**\n   * Indicates whether or not observers for this target are enabled. If\n   * disabled, observers will not be called in response to target property\n   * changes.\n   */\n  isEnabled: boolean;\n\n  /**\n   * Retrieves all observers for a given target property.\n   *\n   * @template K The target property key.\n   * @param key - The property to retrieve observers for.\n   * @return An array of observers for the provided target property.\n   */\n  getObservers<K extends keyof T>(key: K): Array<Observer<T, K>>;\n\n  /**\n   * A Set of properties that have been installed (their getter/setter) replaced\n   * to connect with the `TargetObservers`. This prevents multiple installations\n   * of the same property.\n   */\n  installedProperties: Set<keyof T>;\n}\n\n/**\n * Observe a target's property for changes. When a property changes, the\n * provided `Observer` function will be invoked with the properties current and\n * previous values.\n *\n * The returned cleanup function will stop listening to changes for the\n * provided `Observer`.\n *\n * @template T The observed target type.\n * @template K The observed property.\n * @param target - The target to observe.\n * @param property - The property of the target to observe.\n * @param observer - An observer function to invoke each time the property\n *     changes.\n * @return A cleanup function that will stop observing changes for the provided\n *     `Observer`.\n */\nexport function observeProperty<T extends object, K extends keyof T>(\n    target: T, property: K, observer: Observer<T, K>) {\n  const targetObservers = installObserver(target, property);\n  const observers = targetObservers.getObservers(property);\n  observers.push(observer);\n  return () => {\n    observers.splice(observers.indexOf(observer), 1);\n  };\n}\n\n/**\n * A Map of all `TargetObservers` that have been installed.\n */\nconst allTargetObservers = new WeakMap<object, TargetObservers<any>>();\n\n/**\n * Installs a `TargetObservers` for the provided target (if not already\n * installed), and replaces the given property with a getter and setter that\n * will respond to changes and call `TargetObservers`.\n *\n * Subsequent calls to `installObserver()` with the same target and property\n * will not override the property's previously installed getter/setter.\n *\n * @template T The observed target type.\n * @template K The observed property to create a getter/setter for.\n * @param target - The target to observe.\n * @param property - The property to create a getter/setter for, if needed.\n * @return The installed `TargetObservers` for the provided target.\n */\nfunction installObserver<T extends object, K extends keyof T>(\n    target: T, property: K): TargetObservers<T> {\n  const observersMap = new Map<keyof T, Array<Observer<T>>>();\n\n  if (!allTargetObservers.has(target)) {\n    allTargetObservers.set(target, {\n      isEnabled: true,\n      getObservers(key) {\n        const observers = observersMap.get(key) || [];\n        if (!observersMap.has(key)) {\n          observersMap.set(key, observers);\n        }\n\n        return observers;\n      },\n      installedProperties: new Set()\n    } as TargetObservers<T>);\n  }\n\n  const targetObservers = allTargetObservers.get(target)!;\n  if (targetObservers.installedProperties.has(property)) {\n    // The getter/setter has already been replaced for this property\n    return targetObservers;\n  }\n\n  // Retrieve (or create if it's a plain property) the original descriptor from\n  // the target...\n  const descriptor = getDescriptor(target, property) || {\n    configurable: true,\n    enumerable: true,\n    value: target[property],\n    writable: true\n  };\n\n  // ...and create a copy that will be used for the observer.\n  const observedDescriptor = {...descriptor};\n  let {get: descGet, set: descSet} = descriptor;\n  if ('value' in descriptor) {\n    // The descriptor is a simple value (not a getter/setter).\n    // For our observer descriptor that we copied, delete the value/writable\n    // properties, since they are incompatible with the get/set properties\n    // for descriptors.\n    delete observedDescriptor.value;\n    delete observedDescriptor.writable;\n\n    // Set up a simple getter...\n    let value = descriptor.value as T[K];\n    descGet = () => value;\n\n    // ...and setter (if the original property was writable).\n    if (descriptor.writable) {\n      descSet = (newValue) => {\n        value = newValue;\n      };\n    }\n  }\n\n  if (descGet) {\n    observedDescriptor.get = function(this: T) {\n      // `this as T` needed for closure conformance\n      // tslint:disable-next-line:no-unnecessary-type-assertion\n      return descGet!.call(this as T);\n    };\n  }\n\n  if (descSet) {\n    observedDescriptor.set = function(this: T, newValue: T[K]) {\n      // `thus as T` needed for closure conformance\n      // tslint:disable-next-line:no-unnecessary-type-assertion\n      const previous = descGet ? descGet.call(this as T) : newValue;\n      // tslint:disable-next-line:no-unnecessary-type-assertion\n      descSet!.call(this as T, newValue);\n      if (targetObservers.isEnabled && (!descGet || newValue !== previous)) {\n        for (const observer of targetObservers.getObservers(property)) {\n          observer(newValue, previous);\n        }\n      }\n    };\n  }\n\n  targetObservers.installedProperties.add(property);\n  Object.defineProperty(target, property, observedDescriptor);\n  return targetObservers;\n}\n\n/**\n * Retrieves the descriptor for a property from the provided target. This\n * function will walk up the target's prototype chain to search for the\n * descriptor.\n *\n * @template T The target type.\n * @template K The property type.\n * @param target - The target to retrieve a descriptor from.\n * @param property - The name of the property to retrieve a descriptor for.\n * @return the descriptor, or undefined if it does not exist. Keep in mind that\n *     plain properties may not have a descriptor defined.\n */\nexport function getDescriptor<T extends object, K extends keyof T>(\n    target: T, property: K) {\n  let descriptorTarget: object|null = target;\n  let descriptor: TypedPropertyDescriptor<T[K]>|undefined;\n  while (descriptorTarget) {\n    descriptor = Object.getOwnPropertyDescriptor(descriptorTarget, property);\n    if (descriptor) {\n      break;\n    }\n\n    // Walk up the instance's prototype chain in case the property is declared\n    // on a superclass.\n    descriptorTarget = Object.getPrototypeOf(descriptorTarget);\n  }\n\n  return descriptor;\n}\n\n/**\n * Enables or disables all observers for a provided target. Changes to observed\n * properties will not call any observers when disabled.\n *\n * @template T The observed target type.\n * @param target - The target to enable or disable observers for.\n * @param enabled - True to enable or false to disable observers.\n */\nexport function setObserversEnabled<T extends object>(\n    target: T, enabled: boolean) {\n  const targetObservers = allTargetObservers.get(target);\n  if (targetObservers) {\n    targetObservers.isEnabled = enabled;\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 type EventType = keyof GlobalEventHandlersEventMap;\nexport type SpecificEventListener<K extends EventType> =\n    (event: GlobalEventHandlersEventMap[K]) => void;\nexport type CustomEventListener<E extends Event> = (event: E) => void;\nexport type WindowEventType = keyof WindowEventMap;\nexport type SpecificWindowEventListener<K extends WindowEventType> =\n    (event: WindowEventMap[K]) => void;\n\n// `any` is required for mixin constructors\n// tslint:disable:no-any\n/**\n * A generic type for the constructor of an instance type. Note that this type\n * does not preserve accurate constructor parameters.\n *\n * @template T The instance type.\n */\nexport type Constructor<T = any> = {\n  new (...args: any[]): T;\n};\n// tslint:enable:no-any\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/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCCheckboxAdapter {\n  addClass(className: string): void;\n  forceLayout(): void;\n  hasNativeControl(): boolean;\n  isAttachedToDOM(): boolean;\n  isChecked(): boolean;\n  isIndeterminate(): boolean;\n  removeClass(className: string): void;\n  removeNativeControlAttr(attr: string): void;\n  setNativeControlAttr(attr: string, value: string): void;\n  setNativeControlDisabled(disabled: boolean): void;\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 {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';\n\nimport {MDCCheckboxAdapter} from './adapter';\nimport {strings} from './constants';\nimport {MDCCheckboxFoundation} from './foundation';\n\nconst CB_PROTO_PROPS = ['checked', 'indeterminate'];\n\n/** MDC Checkbox Factory */\nexport type MDCCheckboxFactory =\n    (el: HTMLElement, foundation?: MDCCheckboxFoundation) => MDCCheckbox;\n\n/** MDC Checkbox */\nexport class MDCCheckbox extends MDCComponent<MDCCheckboxFoundation> implements\n    MDCRippleCapableSurface {\n  static override attachTo(root: HTMLElement) {\n    return new MDCCheckbox(root);\n  }\n\n  get ripple(): MDCRipple {\n    return this.rippleSurface;\n  }\n\n  get checked(): boolean {\n    return this.getNativeControl().checked;\n  }\n\n  set checked(checked: boolean) {\n    this.getNativeControl().checked = checked;\n  }\n\n  get indeterminate(): boolean {\n    return this.getNativeControl().indeterminate;\n  }\n\n  set indeterminate(indeterminate: boolean) {\n    this.getNativeControl().indeterminate = indeterminate;\n  }\n\n  get disabled(): boolean {\n    return this.getNativeControl().disabled;\n  }\n\n  set disabled(disabled: boolean) {\n    this.foundation.setDisabled(disabled);\n  }\n\n  get value(): string {\n    return this.getNativeControl().value;\n  }\n\n  set value(value: string) {\n    this.getNativeControl().value = value;\n  }\n\n  private readonly rippleSurface: MDCRipple = this.createRipple();\n  private handleChange!: EventListener;  // assigned in initialSyncWithDOM()\n  private handleAnimationEnd!:\n      EventListener;  // assigned in initialSyncWithDOM()\n\n  override initialize() {\n    const {DATA_INDETERMINATE_ATTR} = strings;\n    this.getNativeControl().indeterminate =\n        this.getNativeControl().getAttribute(DATA_INDETERMINATE_ATTR) ===\n        'true';\n    this.getNativeControl().removeAttribute(DATA_INDETERMINATE_ATTR);\n  }\n\n  override initialSyncWithDOM() {\n    this.handleChange = () => {\n      this.foundation.handleChange();\n    };\n    this.handleAnimationEnd = () => {\n      this.foundation.handleAnimationEnd();\n    };\n    this.getNativeControl().addEventListener('change', this.handleChange);\n    this.listen(\n        getCorrectEventName(window, 'animationend'), this.handleAnimationEnd);\n    this.installPropertyChangeHooks();\n  }\n\n  override destroy() {\n    this.rippleSurface.destroy();\n    this.getNativeControl().removeEventListener('change', this.handleChange);\n    this.unlisten(\n        getCorrectEventName(window, 'animationend'), this.handleAnimationEnd);\n    this.uninstallPropertyChangeHooks();\n    super.destroy();\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCCheckboxAdapter = {\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      forceLayout: () => this.root.offsetWidth,\n      hasNativeControl: () => !!this.getNativeControl(),\n      isAttachedToDOM: () => Boolean(this.root.parentNode),\n      isChecked: () => this.checked,\n      isIndeterminate: () => this.indeterminate,\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      removeNativeControlAttr: (attr) => {\n        this.getNativeControl().removeAttribute(attr);\n      },\n      setNativeControlAttr: (attr, value) => {\n        this.safeSetAttribute(this.getNativeControl(), attr, value);\n      },\n      setNativeControlDisabled: (disabled) => {\n        this.getNativeControl().disabled = disabled;\n      },\n    };\n    return new MDCCheckboxFoundation(adapter);\n  }\n\n  private createRipple(): MDCRipple {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCRippleAdapter = {\n      ...MDCRipple.createAdapter(this),\n      deregisterInteractionHandler: (eventType, handler) => {\n        this.getNativeControl().removeEventListener(\n            eventType, handler, applyPassive());\n      },\n      isSurfaceActive: () => matches(this.getNativeControl(), ':active'),\n      isUnbounded: () => true,\n      registerInteractionHandler: (eventType, handler) => {\n        this.getNativeControl().addEventListener(\n            eventType, handler, applyPassive());\n      },\n    };\n    return new MDCRipple(this.root, new MDCRippleFoundation(adapter));\n  }\n\n  private installPropertyChangeHooks() {\n    const nativeCb = this.getNativeControl();\n    const cbProto = Object.getPrototypeOf(nativeCb);\n\n    for (const controlState of CB_PROTO_PROPS) {\n      const desc = Object.getOwnPropertyDescriptor(cbProto, controlState);\n      // We have to check for this descriptor, since some browsers (Safari)\n      // don't support its return. See:\n      // https://bugs.webkit.org/show_bug.cgi?id=49739\n      if (!validDescriptor(desc)) {\n        return;\n      }\n\n      const nativeGetter = desc.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.getNativeControl();\n    const cbProto = Object.getPrototypeOf(nativeCb);\n\n    for (const controlState of CB_PROTO_PROPS) {\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 getNativeControl(): HTMLInputElement {\n    const {NATIVE_CONTROL_SELECTOR} = strings;\n    const el =\n        this.root.querySelector<HTMLInputElement>(NATIVE_CONTROL_SELECTOR);\n    if (!el) {\n      throw new Error(\n          `Checkbox component requires a ${NATIVE_CONTROL_SELECTOR} element`);\n    }\n    return el;\n  }\n}\n\nfunction validDescriptor(inputPropDesc: PropertyDescriptor|\n                         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  DATA_INDETERMINATE_ATTR: 'data-indeterminate',\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';\n\nimport {MDCCheckboxAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\n/** MDC Checkbox Foundation */\nexport class MDCCheckboxFoundation extends MDCFoundation<MDCCheckboxAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override get numbers() {\n    return numbers;\n  }\n\n  static override 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  override init() {\n    this.currentCheckState = this.determineCheckState();\n    this.updateAriaChecked();\n    this.adapter.addClass(cssClasses.UPGRADED);\n  }\n\n  override 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,\n    // in case for example the user interacted with the checkbox before the\n    // 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 =\n        this.getTransitionAnimationClass(oldState, newState);\n    this.currentCheckState = newState;\n\n    // Check for parentNode so that animations are only run when the element is\n    // attached to the DOM.\n    if (this.adapter.isAttachedToDOM() &&\n        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 :\n                                      TRANSITION_STATE_UNCHECKED;\n  }\n\n  private getTransitionAnimationClass(oldState: string, newState: string):\n      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 ?\n            ANIM_INDETERMINATE_CHECKED :\n            ANIM_INDETERMINATE_UNCHECKED;\n      case TRANSITION_STATE_UNCHECKED:\n        return newState === TRANSITION_STATE_CHECKED ?\n            ANIM_UNCHECKED_CHECKED :\n            ANIM_UNCHECKED_INDETERMINATE;\n      case TRANSITION_STATE_CHECKED:\n        return newState === TRANSITION_STATE_UNCHECKED ?\n            ANIM_CHECKED_UNCHECKED :\n            ANIM_CHECKED_INDETERMINATE;\n      default:  // TRANSITION_STATE_INDETERMINATE\n        return newState === TRANSITION_STATE_CHECKED ?\n            ANIM_INDETERMINATE_CHECKED :\n            ANIM_INDETERMINATE_UNCHECKED;\n    }\n  }\n\n  private updateAriaChecked() {\n    // Ensure aria-checked is set to mixed if checkbox is in indeterminate\n    // 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 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\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCChipSetAdapter {\n  /**\n   * @return true if the root element contains the given class name.\n   */\n  hasClass(className: string): boolean;\n\n  /**\n   * Removes the chip with the given index from the chip set.\n   * Make sure to remove it from the chip list, too.\n   */\n  removeChipAtIndex(index: number): void;\n\n  /**\n   * Sets the selected state of the chip at the given index.\n   */\n  selectChipAtIndex(\n      index: number, isSelected: boolean, shouldNotifyClients: boolean): void;\n\n  /**\n   * Returns the index of the chip at the given ID.\n   * @param chipId the unique ID of the chip\n   * @return the numerical index of the chip with the matching id or -1.\n   */\n  getIndexOfChipById(chipId: string): number;\n\n  /**\n   * Calls Chip#focusPrimaryAction() on the chip at the given index.\n   * @param index the index of the chip\n   */\n  focusChipPrimaryActionAtIndex(index: number): void;\n\n  /**\n   * Calls Chip#focusTrailingAction() on the chip at the given index.\n   * @param index the index of the chip\n   */\n  focusChipTrailingActionAtIndex(index: number): void;\n\n  /**\n   * Removes focus from the chip at the given index.\n   * @param index the index of the chip\n   */\n  removeFocusFromChipAtIndex(index: number): void;\n\n  /**\n   * @return true if the text direction is RTL.\n   */\n  isRTL(): boolean;\n\n  /**\n   * @return the number of chips in the chip set.\n   */\n  getChipListCount(): number;\n\n  /**\n   * Announces the message via an aria-live region.\n   */\n  announceMessage(message: string): void;\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 {announce} from '@material/dom/announce';\n\nimport {MDCChip, MDCChipFactory} from '../chip/component';\nimport {MDCChipFoundation} from '../chip/foundation';\nimport {MDCChipInteractionEvent, MDCChipNavigationEvent, MDCChipRemovalEvent, MDCChipSelectionEvent} from '../chip/types';\n\nimport {MDCChipSetAdapter} from './adapter';\nimport {MDCChipSetFoundation} from './foundation';\n\nconst {INTERACTION_EVENT, SELECTION_EVENT, REMOVAL_EVENT, NAVIGATION_EVENT} =\n    MDCChipFoundation.strings;\nconst {CHIP_SELECTOR} = MDCChipSetFoundation.strings;\n\nlet idCounter = 0;\n\n/** MDC Chip Set */\nexport class MDCChipSet extends MDCComponent<MDCChipSetFoundation> {\n  static override attachTo(root: HTMLElement) {\n    return new MDCChipSet(root);\n  }\n\n  get chips(): readonly MDCChip[] {\n    return this.chipsList.slice();\n  }\n\n  /**\n   * @return An array of the IDs of all selected chips.\n   */\n  get selectedChipIds(): readonly string[] {\n    return this.foundation.getSelectedChipIds();\n  }\n\n  private chipsList!: MDCChip[];  // assigned in initialize()\n  private chipFactory!:\n      (el: HTMLElement) => MDCChip;  // assigned in initialize()\n  private handleChipInteraction!: (event: MDCChipInteractionEvent) =>\n      void;  // assigned in initialSyncWithDOM()\n  private handleChipSelection!:\n      (event: MDCChipSelectionEvent) => void;  // assigned in initialSyncWithDOM()\n  private handleChipRemoval!:\n      (event: MDCChipRemovalEvent) => void;  // assigned in initialSyncWithDOM()\n  private handleChipNavigation!: (event: MDCChipNavigationEvent) =>\n      void;  // assigned in initialSyncWithDOM()\n\n  /**\n   * @param chipFactory A function which creates a new MDCChip.\n   */\n  override initialize(chipFactory: MDCChipFactory = (el) => new MDCChip(el)) {\n    this.chipFactory = chipFactory;\n    this.chipsList = this.instantiateChips(this.chipFactory);\n  }\n\n  override initialSyncWithDOM() {\n    for (const chip of this.chipsList) {\n      if (chip.id && chip.selected) {\n        this.foundation.select(chip.id);\n      }\n    }\n\n    this.handleChipInteraction = (event) => {\n      this.foundation.handleChipInteraction(event.detail);\n    };\n    this.handleChipSelection = (event) => {\n      this.foundation.handleChipSelection(event.detail);\n    };\n    this.handleChipRemoval = (event) => {\n      this.foundation.handleChipRemoval(event.detail);\n    };\n    this.handleChipNavigation = (event) => {\n      this.foundation.handleChipNavigation(event.detail);\n    };\n    this.listen(INTERACTION_EVENT, this.handleChipInteraction);\n    this.listen(SELECTION_EVENT, this.handleChipSelection);\n    this.listen(REMOVAL_EVENT, this.handleChipRemoval);\n    this.listen(NAVIGATION_EVENT, this.handleChipNavigation);\n  }\n\n  override destroy() {\n    for (const chip of this.chipsList) {\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    this.unlisten(NAVIGATION_EVENT, this.handleChipNavigation);\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: HTMLElement) {\n    chipEl.id = chipEl.id || `mdc-chip-${++idCounter}`;\n    this.chipsList.push(this.chipFactory(chipEl));\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCChipSetAdapter = {\n      announceMessage: (message) => {\n        announce(message);\n      },\n      focusChipPrimaryActionAtIndex: (index) => {\n        this.chipsList[index].focusPrimaryAction();\n      },\n      focusChipTrailingActionAtIndex: (index) => {\n        this.chipsList[index].focusTrailingAction();\n      },\n      getChipListCount: () => this.chips.length,\n      getIndexOfChipById: (chipId) => {\n        return this.findChipIndex(chipId);\n      },\n      hasClass: (className) => this.root.classList.contains(className),\n      isRTL: () => window.getComputedStyle(this.root).getPropertyValue(\n                       'direction') === 'rtl',\n      removeChipAtIndex: (index) => {\n        if (index >= 0 && index < this.chips.length) {\n          this.chipsList[index].destroy();\n          this.chipsList[index].remove();\n          this.chipsList.splice(index, 1);\n        }\n      },\n      removeFocusFromChipAtIndex: (index) => {\n        this.chipsList[index].removeFocus();\n      },\n      selectChipAtIndex: (index, selected, shouldNotifyClients) => {\n        if (index >= 0 && index < this.chips.length) {\n          this.chipsList[index].setSelectedFromChipSet(\n              selected, shouldNotifyClients);\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 =\n        Array.from(this.root.querySelectorAll<HTMLElement>(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\n   * exist.\n   */\n  private findChipIndex(chipId: string): number {\n    for (let i = 0; i < this.chips.length; i++) {\n      if (this.chipsList[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';\n\nimport {Direction, EventSource, jumpChipKeys, navigationKeys, strings as chipStrings} from '../chip/constants';\nimport {MDCChipInteractionEventDetail, MDCChipNavigationEventDetail, MDCChipRemovalEventDetail, MDCChipSelectionEventDetail} from '../chip/types';\n\nimport {MDCChipSetAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\n/** MDC Chip Set Foundation */\nexport class MDCChipSetFoundation extends MDCFoundation<MDCChipSetAdapter> {\n  static override get strings() {\n    return strings;\n  }\n\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get defaultAdapter(): MDCChipSetAdapter {\n    return {\n      announceMessage: () => undefined,\n      focusChipPrimaryActionAtIndex: () => undefined,\n      focusChipTrailingActionAtIndex: () => undefined,\n      getChipListCount: () => -1,\n      getIndexOfChipById: () => -1,\n      hasClass: () => false,\n      isRTL: () => false,\n      removeChipAtIndex: () => undefined,\n      removeFocusFromChipAtIndex: () => undefined,\n      selectChipAtIndex: () => undefined,\n    };\n  }\n\n  /**\n   * The ids of the selected chips in the set. Only used for choice chip set or\n   * 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(): readonly string[] {\n    return this.selectedChipIds.slice();\n  }\n\n  /**\n   * Selects the chip with the given id. Deselects all other chips if the chip\n   * set is of the choice variant. Does not notify clients of the updated\n   * selection state.\n   */\n  select(chipId: string) {\n    this.selectImpl(chipId, false);\n  }\n\n  /**\n   * Handles a chip interaction event\n   */\n  handleChipInteraction({chipId}: MDCChipInteractionEventDetail) {\n    const index = this.adapter.getIndexOfChipById(chipId);\n    this.removeFocusFromChipsExcept(index);\n    if (this.adapter.hasClass(cssClasses.CHOICE) ||\n        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\n   * state is set directly on the Chip.\n   */\n  handleChipSelection({chipId, selected, shouldIgnore}:\n                          MDCChipSelectionEventDetail) {\n    // Early exit if we should ignore the event\n    if (shouldIgnore) {\n      return;\n    }\n\n    const chipIsSelected = this.selectedChipIds.indexOf(chipId) >= 0;\n    if (selected && !chipIsSelected) {\n      this.select(chipId);\n    } else if (!selected && chipIsSelected) {\n      this.deselectImpl(chipId);\n    }\n  }\n\n  /**\n   * Handles the event when a chip is removed.\n   */\n  handleChipRemoval({chipId, removedAnnouncement}: MDCChipRemovalEventDetail) {\n    if (removedAnnouncement) {\n      this.adapter.announceMessage(removedAnnouncement);\n    }\n\n    const index = this.adapter.getIndexOfChipById(chipId);\n    this.deselectAndNotifyClients(chipId);\n    this.adapter.removeChipAtIndex(index);\n    const maxIndex = this.adapter.getChipListCount() - 1;\n    if (maxIndex < 0) {\n      return;\n    }\n    const nextIndex = Math.min(index, maxIndex);\n    this.removeFocusFromChipsExcept(nextIndex);\n    // After removing a chip, we should focus the trailing action for the next\n    // chip.\n    this.adapter.focusChipTrailingActionAtIndex(nextIndex);\n  }\n\n  /**\n   * Handles a chip navigation event.\n   */\n  handleChipNavigation({chipId, key, source}: MDCChipNavigationEventDetail) {\n    const maxIndex = this.adapter.getChipListCount() - 1;\n    let index = this.adapter.getIndexOfChipById(chipId);\n    // Early exit if the index is out of range or the key is unusable\n    if (index === -1 || !navigationKeys.has(key)) {\n      return;\n    }\n\n    const isRTL = this.adapter.isRTL();\n    const isLeftKey = key === chipStrings.ARROW_LEFT_KEY ||\n        key === chipStrings.IE_ARROW_LEFT_KEY;\n    const isRightKey = key === chipStrings.ARROW_RIGHT_KEY ||\n        key === chipStrings.IE_ARROW_RIGHT_KEY;\n    const isDownKey = key === chipStrings.ARROW_DOWN_KEY ||\n        key === chipStrings.IE_ARROW_DOWN_KEY;\n    const shouldIncrement =\n        !isRTL && isRightKey || isRTL && isLeftKey || isDownKey;\n    const isHome = key === chipStrings.HOME_KEY;\n    const isEnd = key === chipStrings.END_KEY;\n    if (shouldIncrement) {\n      index++;\n    } else if (isHome) {\n      index = 0;\n    } else if (isEnd) {\n      index = maxIndex;\n    } else {\n      index--;\n    }\n\n    // Early exit if the index is out of bounds\n    if (index < 0 || index > maxIndex) {\n      return;\n    }\n\n    this.removeFocusFromChipsExcept(index);\n    this.focusChipAction(index, key, source);\n  }\n\n  private focusChipAction(index: number, key: string, source: EventSource) {\n    const shouldJumpChips = jumpChipKeys.has(key);\n    if (shouldJumpChips && source === EventSource.PRIMARY) {\n      this.adapter.focusChipPrimaryActionAtIndex(index);\n      return;\n    }\n\n    if (shouldJumpChips && source === EventSource.TRAILING) {\n      this.adapter.focusChipTrailingActionAtIndex(index);\n      return;\n    }\n\n    const dir = this.getDirection(key);\n    if (dir === Direction.LEFT) {\n      this.adapter.focusChipTrailingActionAtIndex(index);\n      return;\n    }\n\n    if (dir === Direction.RIGHT) {\n      this.adapter.focusChipPrimaryActionAtIndex(index);\n      return;\n    }\n  }\n\n  private getDirection(key: string): Direction {\n    const isRTL = this.adapter.isRTL();\n    const isLeftKey = key === chipStrings.ARROW_LEFT_KEY ||\n        key === chipStrings.IE_ARROW_LEFT_KEY;\n    const isRightKey = key === chipStrings.ARROW_RIGHT_KEY ||\n        key === chipStrings.IE_ARROW_RIGHT_KEY;\n    if (!isRTL && isLeftKey || isRTL && isRightKey) {\n      return Direction.LEFT;\n    }\n\n    return Direction.RIGHT;\n  }\n\n  /**\n   * Deselects the chip with the given id and optionally notifies clients.\n   */\n  private deselectImpl(chipId: string, shouldNotifyClients = false) {\n    const index = this.selectedChipIds.indexOf(chipId);\n    if (index >= 0) {\n      this.selectedChipIds.splice(index, 1);\n      const chipIndex = this.adapter.getIndexOfChipById(chipId);\n      this.adapter.selectChipAtIndex(\n          chipIndex, /** isSelected */ false, shouldNotifyClients);\n    }\n  }\n\n  /**\n   * Deselects the chip with the given id and notifies clients.\n   */\n  private deselectAndNotifyClients(chipId: string) {\n    this.deselectImpl(chipId, true);\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.deselectAndNotifyClients(chipId);\n    } else {\n      this.selectAndNotifyClients(chipId);\n    }\n  }\n\n  private removeFocusFromChipsExcept(index: number) {\n    const chipCount = this.adapter.getChipListCount();\n    for (let i = 0; i < chipCount; i++) {\n      if (i !== index) {\n        this.adapter.removeFocusFromChipAtIndex(i);\n      }\n    }\n  }\n\n  private selectAndNotifyClients(chipId: string) {\n    this.selectImpl(chipId, true);\n  }\n\n  private selectImpl(chipId: string, shouldNotifyClients: boolean) {\n    if (this.selectedChipIds.indexOf(chipId) >= 0) {\n      return;\n    }\n\n    if (this.adapter.hasClass(cssClasses.CHOICE) &&\n        this.selectedChipIds.length > 0) {\n      const previouslySelectedChip = this.selectedChipIds[0];\n      const previouslySelectedIndex =\n          this.adapter.getIndexOfChipById(previouslySelectedChip);\n      this.selectedChipIds = [];\n      this.adapter.selectChipAtIndex(\n          previouslySelectedIndex, /** isSelected */ false,\n          shouldNotifyClients);\n    }\n    this.selectedChipIds.push(chipId);\n    const index = this.adapter.getIndexOfChipById(chipId);\n    this.adapter.selectChipAtIndex(\n        index, /** isSelected */ true, shouldNotifyClients);\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 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 {EventSource} from './constants';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCChipAdapter {\n  /**\n   * Adds a class to the root element.\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes a class from the root element.\n   */\n  removeClass(className: string): void;\n\n  /**\n   * @return true if the root element contains the given class.\n   */\n  hasClass(className: string): boolean;\n\n  /**\n   * Adds a class to the leading icon element.\n   */\n  addClassToLeadingIcon(className: string): void;\n\n  /**\n   * Removes a class from the leading icon element.\n   */\n  removeClassFromLeadingIcon(className: string): void;\n\n  /**\n   * @return true if target has className, false otherwise.\n   */\n  eventTargetHasClass(target: EventTarget|null, className: string): boolean;\n\n  /**\n   * @return the attribute string value if present, otherwise null\n   */\n  getAttribute(attr: string): string|null;\n\n  /**\n   * Emits a custom \"MDCChip:interaction\" event denoting the chip has been\n   * interacted with (typically on click or keydown).\n   */\n  notifyInteraction(): void;\n\n  /**\n   * Emits a custom \"MDCChip:selection\" event denoting the chip has been\n   * selected or deselected.\n   */\n  notifySelection(selected: boolean, chipSetShouldIgnore: boolean): void;\n\n  /**\n   * Emits a custom \"MDCChip:trailingIconInteraction\" event denoting the\n   * trailing icon has been interacted with (typically on click or keydown).\n   */\n  notifyTrailingIconInteraction(): void;\n\n  /**\n   * Emits a custom event \"MDCChip:removal\" denoting the chip will be removed.\n   */\n  notifyRemoval(removedAnnouncement: string|null): void;\n\n  /**\n   * Emits a custom event \"MDCChip:navigation\" denoting a focus navigation\n   * event.\n   */\n  notifyNavigation(key: string, source: EventSource): void;\n\n  /**\n   * Emits when editing starts.\n   */\n  notifyEditStart(): void;\n\n  /**\n   * Emits when editing finishes.\n   */\n  notifyEditFinish(): void;\n\n  /**\n   * @return The computed property value of the given style property on the root\n   *     element.\n   */\n  getComputedStyleValue(propertyName: string): string;\n\n  /**\n   * Sets the property value of the given style property on the root element.\n   */\n  setStyleProperty(propertyName: string, value: string): void;\n\n  /**\n   * @return Whether the chip has a leading icon.\n   */\n  hasLeadingIcon(): boolean;\n\n  /**\n   * @return The bounding client rect of the root element.\n   */\n  getRootBoundingClientRect(): DOMRect;\n\n  /**\n   * @return The bounding client rect of the checkmark element or null if it\n   *     doesn't exist.\n   */\n  getCheckmarkBoundingClientRect(): DOMRect|null;\n\n  /**\n   * Sets the value of the attribute on the primary action content.\n   */\n  setPrimaryActionAttr(attr: string, value: string): void;\n\n  /**\n   * Gives focus to the primary action.\n   */\n  focusPrimaryAction(): void;\n\n  /**\n   * Sets focus to the trailing action.\n   */\n  focusTrailingAction(): void;\n\n  /**\n   * Removes focus from the trailing action.\n   */\n  removeTrailingActionFocus(): void;\n\n  /**\n   * Returns true if the trailing action is navigable.\n   * Should return the value of MDCChipTrailingAction#isNavigable() or false.\n   */\n  isTrailingActionNavigable(): boolean;\n\n  /**\n   * @return true if the text direction is right-to-left.\n   */\n  isRTL(): boolean;\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 {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple, MDCRippleFactory} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\n\nimport {MDCChipTrailingAction, MDCChipTrailingActionFactory} from '../trailingaction/component';\nimport {strings as trailingActionStrings} from '../trailingaction/constants';\nimport {MDCChipTrailingActionInteractionEvent, MDCChipTrailingActionNavigationEvent} from '../trailingaction/types';\n\nimport {MDCChipAdapter} from './adapter';\nimport {strings} from './constants';\nimport {MDCChipFoundation} from './foundation';\nimport {MDCChipInteractionEventDetail, MDCChipNavigationEventDetail, MDCChipRemovalEventDetail, MDCChipSelectionEventDetail} from './types';\n\n/** MDC Chip Factory */\nexport type MDCChipFactory =\n    (el: HTMLElement, foundation?: MDCChipFoundation) => MDCChip;\n\n/** MDC Chip */\nexport class MDCChip extends MDCComponent<MDCChipFoundation> implements\n    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\n   *     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  /**\n   * Sets whether a clicking on the chip should focus the primary action.\n   */\n  set setShouldFocusPrimaryActionOnClick(shouldFocus: boolean) {\n    this.foundation.setShouldFocusPrimaryActionOnClick(shouldFocus);\n  }\n\n  get ripple(): MDCRipple {\n    return this.rippleSurface;\n  }\n\n  get id(): string {\n    return this.root.id;\n  }\n\n  static override attachTo(root: HTMLElement) {\n    return new MDCChip(root);\n  }\n\n  private leadingIcon!: HTMLElement|null;    // assigned in initialize()\n  private checkmark!: HTMLElement|null;      // assigned in initialize()\n  private primaryAction!: HTMLElement|null;  // assigned in initialize()\n  private trailingAction!: MDCChipTrailingAction|\n      null;                           // assigned in initialize()\n  private rippleSurface!: MDCRipple;  // assigned in initialize()\n\n  private handleTrailingActionInteraction!: CustomEventListener<\n      MDCChipTrailingActionInteractionEvent>;  // assigned in\n                                               // initialSyncWithDOM()\n  private handleTrailingActionNavigation!: CustomEventListener<\n      MDCChipTrailingActionNavigationEvent>;  // assigned in\n                                              // initialSyncWithDOM()\n  private handleTransitionEnd!:\n      SpecificEventListener<'transitionend'>;  // assigned in\n                                               // initialSyncWithDOM()\n  private handleClick!:\n      SpecificEventListener<'click'>;  // assigned in initialSyncWithDOM()\n  private handleKeydown!:\n      SpecificEventListener<'keydown'>;  // assigned in initialSyncWithDOM()\n  private handleFocusIn!:\n      SpecificEventListener<'focusin'>;  // assigned in initialSyncWIthDOM()\n  private handleFocusOut!:\n      SpecificEventListener<'focusout'>;  // assigned in initialSyncWIthDOM()\n\n  override initialize(\n      rippleFactory:\n          MDCRippleFactory = (el, foundation) => new MDCRipple(el, foundation),\n      trailingActionFactory:\n          MDCChipTrailingActionFactory = (el) => new MDCChipTrailingAction(el),\n  ) {\n    this.leadingIcon =\n        this.root.querySelector<HTMLElement>(strings.LEADING_ICON_SELECTOR);\n    this.checkmark =\n        this.root.querySelector<HTMLElement>(strings.CHECKMARK_SELECTOR);\n    this.primaryAction =\n        this.root.querySelector<HTMLElement>(strings.PRIMARY_ACTION_SELECTOR);\n\n    const trailingActionEl =\n        this.root.querySelector<HTMLElement>(strings.TRAILING_ACTION_SELECTOR);\n\n    if (trailingActionEl) {\n      this.trailingAction = trailingActionFactory(trailingActionEl);\n    }\n\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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.rippleSurface =\n        rippleFactory(this.root, new MDCRippleFoundation(rippleAdapter));\n  }\n\n  override initialSyncWithDOM() {\n    // Custom events\n    this.handleTrailingActionInteraction = () => {\n      this.foundation.handleTrailingActionInteraction();\n    };\n    this.handleTrailingActionNavigation =\n        (event: MDCChipTrailingActionNavigationEvent) => {\n          this.foundation.handleTrailingActionNavigation(event);\n        };\n    // Native events\n    this.handleClick = () => {\n      this.foundation.handleClick();\n    };\n    this.handleKeydown = (event: KeyboardEvent) => {\n      this.foundation.handleKeydown(event);\n    };\n    this.handleTransitionEnd = (event: TransitionEvent) => {\n      this.foundation.handleTransitionEnd(event);\n    };\n    this.handleFocusIn = (event: FocusEvent) => {\n      this.foundation.handleFocusIn(event);\n    };\n    this.handleFocusOut = (event: FocusEvent) => {\n      this.foundation.handleFocusOut(event);\n    };\n\n\n    this.listen('transitionend', this.handleTransitionEnd);\n    this.listen('click', this.handleClick);\n    this.listen('keydown', this.handleKeydown);\n    this.listen('focusin', this.handleFocusIn);\n    this.listen('focusout', this.handleFocusOut);\n\n    if (this.trailingAction) {\n      this.listen(\n          trailingActionStrings.INTERACTION_EVENT,\n          this.handleTrailingActionInteraction);\n      this.listen(\n          trailingActionStrings.NAVIGATION_EVENT,\n          this.handleTrailingActionNavigation);\n    }\n  }\n\n  override destroy() {\n    this.rippleSurface.destroy();\n\n    this.unlisten('transitionend', this.handleTransitionEnd);\n    this.unlisten('keydown', this.handleKeydown);\n    this.unlisten('click', this.handleClick);\n    this.unlisten('focusin', this.handleFocusIn);\n    this.unlisten('focusout', this.handleFocusOut);\n\n    if (this.trailingAction) {\n      this.unlisten(\n          trailingActionStrings.INTERACTION_EVENT,\n          this.handleTrailingActionInteraction);\n      this.unlisten(\n          trailingActionStrings.NAVIGATION_EVENT,\n          this.handleTrailingActionNavigation);\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  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCChipAdapter = {\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      addClassToLeadingIcon: (className) => {\n        if (this.leadingIcon) {\n          this.leadingIcon.classList.add(className);\n        }\n      },\n      eventTargetHasClass: (target, className) =>\n          target ? (target as Element).classList.contains(className) : false,\n      focusPrimaryAction: () => {\n        if (this.primaryAction) {\n          this.primaryAction.focus();\n        }\n      },\n      focusTrailingAction: () => {\n        if (this.trailingAction) {\n          this.trailingAction.focus();\n        }\n      },\n      getAttribute: (attr) => this.root.getAttribute(attr),\n      getCheckmarkBoundingClientRect: () =>\n          this.checkmark ? this.checkmark.getBoundingClientRect() : null,\n      getComputedStyleValue: (propertyName) =>\n          window.getComputedStyle(this.root).getPropertyValue(propertyName),\n      getRootBoundingClientRect: () => this.root.getBoundingClientRect(),\n      hasClass: (className) => this.root.classList.contains(className),\n      hasLeadingIcon: () => !!this.leadingIcon,\n      isRTL: () => window.getComputedStyle(this.root).getPropertyValue(\n                       'direction') === 'rtl',\n      isTrailingActionNavigable: () => {\n        if (this.trailingAction) {\n          return this.trailingAction.isNavigable();\n        }\n        return false;\n      },\n      notifyInteraction: () => {\n        this.emit<MDCChipInteractionEventDetail>(\n            strings.INTERACTION_EVENT, {chipId: this.id},\n            true /* shouldBubble */);\n      },\n      notifyNavigation: (key, source) => {\n        this.emit<MDCChipNavigationEventDetail>(\n            strings.NAVIGATION_EVENT, {chipId: this.id, key, source},\n            true /* shouldBubble */);\n      },\n      notifyRemoval: (removedAnnouncement) => {\n        this.emit<MDCChipRemovalEventDetail>(\n            strings.REMOVAL_EVENT, {chipId: this.id, removedAnnouncement},\n            true /* shouldBubble */);\n      },\n      notifySelection: (selected, shouldIgnore) => {\n        this.emit<MDCChipSelectionEventDetail>(\n            strings.SELECTION_EVENT, {chipId: this.id, selected, shouldIgnore},\n            true /* shouldBubble */);\n      },\n      notifyTrailingIconInteraction: () => {\n        this.emit<MDCChipInteractionEventDetail>(\n            strings.TRAILING_ICON_INTERACTION_EVENT, {chipId: this.id},\n            true /* shouldBubble */);\n      },\n      notifyEditStart: () => {/* Not Implemented. */},\n      notifyEditFinish: () => {/* Not Implemented. */},\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      removeClassFromLeadingIcon: (className) => {\n        if (this.leadingIcon) {\n          this.leadingIcon.classList.remove(className);\n        }\n      },\n      removeTrailingActionFocus: () => {\n        if (this.trailingAction) {\n          this.trailingAction.removeFocus();\n        }\n      },\n      setPrimaryActionAttr: (attr, value) => {\n        if (this.primaryAction) {\n          this.safeSetAttribute(this.primaryAction, attr, value);\n        }\n      },\n      setStyleProperty: (propertyName, value) => {\n        this.root.style.setProperty(propertyName, value);\n      },\n    };\n    return new MDCChipFoundation(adapter);\n  }\n\n  setSelectedFromChipSet(selected: boolean, shouldNotifyClients: boolean) {\n    this.foundation.setSelectedFromChipSet(selected, shouldNotifyClients);\n  }\n\n  focusPrimaryAction() {\n    this.foundation.focusPrimaryAction();\n  }\n\n  focusTrailingAction() {\n    this.foundation.focusTrailingAction();\n  }\n\n  removeFocus() {\n    this.foundation.removeFocus();\n  }\n\n  remove() {\n    const parent = this.root.parentNode;\n    if (parent !== null) {\n      parent.removeChild(this.root);\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\nexport enum Direction {\n  LEFT = 'left',\n  RIGHT = 'right',\n}\n\nexport enum EventSource {\n  PRIMARY = 'primary',\n  TRAILING = 'trailing',\n  NONE = 'none',\n}\n\nexport const strings = {\n  ADDED_ANNOUNCEMENT_ATTRIBUTE: 'data-mdc-chip-added-announcement',\n  ARIA_CHECKED: 'aria-checked',\n  ARROW_DOWN_KEY: 'ArrowDown',\n  ARROW_LEFT_KEY: 'ArrowLeft',\n  ARROW_RIGHT_KEY: 'ArrowRight',\n  ARROW_UP_KEY: 'ArrowUp',\n  BACKSPACE_KEY: 'Backspace',\n  CHECKMARK_SELECTOR: '.mdc-chip__checkmark',\n  DELETE_KEY: 'Delete',\n  END_KEY: 'End',\n  ENTER_KEY: 'Enter',\n  ENTRY_ANIMATION_NAME: 'mdc-chip-entry',\n  HOME_KEY: 'Home',\n  IE_ARROW_DOWN_KEY: 'Down',\n  IE_ARROW_LEFT_KEY: 'Left',\n  IE_ARROW_RIGHT_KEY: 'Right',\n  IE_ARROW_UP_KEY: 'Up',\n  IE_DELETE_KEY: 'Del',\n  INTERACTION_EVENT: 'MDCChip:interaction',\n  LEADING_ICON_SELECTOR: '.mdc-chip__icon--leading',\n  NAVIGATION_EVENT: 'MDCChip:navigation',\n  PRIMARY_ACTION_SELECTOR: '.mdc-chip__primary-action',\n  REMOVED_ANNOUNCEMENT_ATTRIBUTE: 'data-mdc-chip-removed-announcement',\n  REMOVAL_EVENT: 'MDCChip:removal',\n  SELECTION_EVENT: 'MDCChip:selection',\n  SPACEBAR_KEY: ' ',\n  TAB_INDEX: 'tabindex',\n  TRAILING_ACTION_SELECTOR: '.mdc-chip-trailing-action',\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  DELETABLE: 'mdc-chip--deletable',\n  EDITABLE: 'mdc-chip--editable',\n  EDITING: 'mdc-chip--editing',\n  HIDDEN_LEADING_ICON: 'mdc-chip__icon--leading-hidden',\n  LEADING_ICON: 'mdc-chip__icon--leading',\n  PRIMARY_ACTION: 'mdc-chip__primary-action',\n  PRIMARY_ACTION_FOCUSED: 'mdc-chip--primary-action-focused',\n  SELECTED: 'mdc-chip--selected',\n  TEXT: 'mdc-chip__text',\n  TRAILING_ACTION: 'mdc-chip__trailing-action',\n  TRAILING_ICON: 'mdc-chip__icon--trailing',\n};\n\nexport const navigationKeys = new Set<string>();\n// IE11 has no support for new Set with iterable so we need to initialize this\n// by hand\nnavigationKeys.add(strings.ARROW_LEFT_KEY);\nnavigationKeys.add(strings.ARROW_RIGHT_KEY);\nnavigationKeys.add(strings.ARROW_DOWN_KEY);\nnavigationKeys.add(strings.ARROW_UP_KEY);\nnavigationKeys.add(strings.END_KEY);\nnavigationKeys.add(strings.HOME_KEY);\nnavigationKeys.add(strings.IE_ARROW_LEFT_KEY);\nnavigationKeys.add(strings.IE_ARROW_RIGHT_KEY);\nnavigationKeys.add(strings.IE_ARROW_DOWN_KEY);\nnavigationKeys.add(strings.IE_ARROW_UP_KEY);\n\nexport const jumpChipKeys = new Set<string>();\n// IE11 has no support for new Set with iterable so we need to initialize this\n// by hand\njumpChipKeys.add(strings.ARROW_UP_KEY);\njumpChipKeys.add(strings.ARROW_DOWN_KEY);\njumpChipKeys.add(strings.HOME_KEY);\njumpChipKeys.add(strings.END_KEY);\njumpChipKeys.add(strings.IE_ARROW_UP_KEY);\njumpChipKeys.add(strings.IE_ARROW_DOWN_KEY);\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';\n\nimport {MDCChipTrailingActionNavigationEvent} from '../trailingaction/types';\n\nimport {MDCChipAdapter} from './adapter';\nimport {cssClasses, Direction, EventSource, jumpChipKeys, navigationKeys, 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} as any;\n\nenum FocusBehavior {\n  SHOULD_FOCUS,\n  SHOULD_NOT_FOCUS,\n}\n\n/** MDC Chip Foundation */\nexport class MDCChipFoundation extends MDCFoundation<MDCChipAdapter> {\n  static override get strings() {\n    return strings;\n  }\n\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get defaultAdapter(): MDCChipAdapter {\n    return {\n      addClass: () => undefined,\n      addClassToLeadingIcon: () => undefined,\n      eventTargetHasClass: () => false,\n      focusPrimaryAction: () => undefined,\n      focusTrailingAction: () => undefined,\n      getAttribute: () => null,\n      getCheckmarkBoundingClientRect: () => emptyClientRect,\n      getComputedStyleValue: () => '',\n      getRootBoundingClientRect: () => emptyClientRect,\n      hasClass: () => false,\n      hasLeadingIcon: () => false,\n      isRTL: () => false,\n      isTrailingActionNavigable: () => false,\n      notifyEditFinish: () => undefined,\n      notifyEditStart: () => undefined,\n      notifyInteraction: () => undefined,\n      notifyNavigation: () => undefined,\n      notifyRemoval: () => undefined,\n      notifySelection: () => undefined,\n      notifyTrailingIconInteraction: () => undefined,\n      removeClass: () => undefined,\n      removeClassFromLeadingIcon: () => undefined,\n      removeTrailingActionFocus: () => undefined,\n      setPrimaryActionAttr: () => undefined,\n      setStyleProperty: () => undefined,\n    };\n  }\n\n  /**\n   * Whether a trailing icon click should immediately trigger exit/removal of\n   * the chip.\n   */\n  private shouldRemoveOnTrailingIconClick = true;\n\n  /**\n   * Whether the primary action should receive focus on click. Should only be\n   * set to true for clients who programmatically give focus to a different\n   * element on the page when a chip is clicked (like a menu).\n   */\n  private shouldFocusPrimaryActionOnClick = 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  isEditable() {\n    return this.adapter.hasClass(cssClasses.EDITABLE);\n  }\n\n  isEditing() {\n    return this.adapter.hasClass(cssClasses.EDITING);\n  }\n\n  setSelected(selected: boolean) {\n    this.setSelectedImpl(selected);\n    this.notifySelection(selected);\n  }\n\n  setSelectedFromChipSet(selected: boolean, shouldNotifyClients: boolean) {\n    this.setSelectedImpl(selected);\n    if (shouldNotifyClients) {\n      this.notifyIgnoredSelection(selected);\n    }\n  }\n\n  getShouldRemoveOnTrailingIconClick() {\n    return this.shouldRemoveOnTrailingIconClick;\n  }\n\n  setShouldRemoveOnTrailingIconClick(shouldRemove: boolean) {\n    this.shouldRemoveOnTrailingIconClick = shouldRemove;\n  }\n\n  setShouldFocusPrimaryActionOnClick(shouldFocus: boolean) {\n    this.shouldFocusPrimaryActionOnClick = shouldFocus;\n  }\n\n  getDimensions(): DOMRect {\n    const getRootRect = () => this.adapter.getRootBoundingClientRect();\n    const getCheckmarkRect = () =>\n        this.adapter.getCheckmarkBoundingClientRect();\n\n    // When a chip has a checkmark and not a leading icon, the bounding rect\n    // changes in size depending on the current 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\n        // identical once the animation completes. However, the checkbox is\n        // initially hidden by setting the width to 0. To account for an initial\n        // width of 0, we use the checkbox's height instead (which equals the\n        // end-state width) 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        } as any;\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  handleClick() {\n    this.adapter.notifyInteraction();\n    this.setPrimaryActionFocusable(this.getFocusBehavior());\n  }\n\n  handleDoubleClick() {\n    if (this.isEditable()) {\n      this.startEditing();\n    }\n  }\n\n  /**\n   * Handles a transition end event on the root element.\n   */\n  handleTransitionEnd(event: TransitionEvent) {\n    // Handle transition end event on the chip when it is about to be removed.\n    const shouldHandle =\n        this.adapter.eventTargetHasClass(event.target, cssClasses.CHIP_EXIT);\n    const widthIsAnimating = event.propertyName === 'width';\n    const opacityIsAnimating = event.propertyName === 'opacity';\n\n    if (shouldHandle && opacityIsAnimating) {\n      // See:\n      // 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\n      // chip's width to its current pixel width, so we aren't transitioning out\n      // of 'auto'.\n      requestAnimationFrame(() => {\n        this.adapter.setStyleProperty('width', chipWidth);\n\n        // To mitigate jitter, start transitioning padding and margin before\n        // 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\n        // 0.\n        requestAnimationFrame(() => {\n          this.adapter.setStyleProperty('width', '0');\n        });\n      });\n      return;\n    }\n\n    if (shouldHandle && widthIsAnimating) {\n      this.removeFocus();\n      const removedAnnouncement =\n          this.adapter.getAttribute(strings.REMOVED_ANNOUNCEMENT_ATTRIBUTE);\n\n      this.adapter.notifyRemoval(removedAnnouncement);\n    }\n\n    // Handle a transition end event on the leading icon or checkmark, since the\n    // transition end event bubbles.\n    if (!opacityIsAnimating) {\n      return;\n    }\n\n    const shouldHideLeadingIcon =\n        this.adapter.eventTargetHasClass(event.target, cssClasses.LEADING_ICON) &&\n        this.adapter.hasClass(cssClasses.SELECTED);\n    const shouldShowLeadingIcon =\n        this.adapter.eventTargetHasClass(event.target, cssClasses.CHECKMARK) &&\n        !this.adapter.hasClass(cssClasses.SELECTED);\n\n    if (shouldHideLeadingIcon) {\n      this.adapter.addClassToLeadingIcon(cssClasses.HIDDEN_LEADING_ICON);\n      return;\n    }\n\n    if (shouldShowLeadingIcon) {\n      this.adapter.removeClassFromLeadingIcon(cssClasses.HIDDEN_LEADING_ICON);\n      return;\n    }\n  }\n\n  handleFocusIn(event: FocusEvent) {\n    // Early exit if the event doesn't come from the primary action\n    if (!this.eventFromPrimaryAction(event)) {\n      return;\n    }\n\n    this.adapter.addClass(cssClasses.PRIMARY_ACTION_FOCUSED);\n  }\n\n  handleFocusOut(event: FocusEvent) {\n    // Early exit if the event doesn't come from the primary action\n    if (!this.eventFromPrimaryAction(event)) {\n      return;\n    }\n\n    if (this.isEditing()) {\n      this.finishEditing();\n    }\n\n    this.adapter.removeClass(cssClasses.PRIMARY_ACTION_FOCUSED);\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  handleTrailingActionInteraction() {\n    this.adapter.notifyTrailingIconInteraction();\n    this.removeChip();\n  }\n\n  /**\n   * Handles a keydown event from the root element.\n   */\n  handleKeydown(event: KeyboardEvent) {\n    if (this.isEditing()) {\n      if (this.shouldFinishEditing(event)) {\n        event.preventDefault();\n        this.finishEditing();\n      }\n      // When editing, the foundation should only handle key events that finish\n      // the editing process.\n      return;\n    }\n\n    if (this.isEditable()) {\n      if (this.shouldStartEditing(event)) {\n        event.preventDefault();\n        this.startEditing();\n      }\n    }\n\n    if (this.shouldNotifyInteraction(event)) {\n      this.adapter.notifyInteraction();\n      this.setPrimaryActionFocusable(this.getFocusBehavior());\n      return;\n    }\n\n    if (this.isDeleteAction(event)) {\n      event.preventDefault();\n      this.removeChip();\n      return;\n    }\n\n    // Early exit if the key is not usable\n    if (!navigationKeys.has(event.key)) {\n      return;\n    }\n\n    // Prevent default behavior for movement keys which could include scrolling\n    event.preventDefault();\n    this.focusNextAction(event.key, EventSource.PRIMARY);\n  }\n\n  handleTrailingActionNavigation(event: MDCChipTrailingActionNavigationEvent) {\n    this.focusNextAction(event.detail.key, EventSource.TRAILING);\n  }\n\n  /**\n   * Called by the chip set to remove focus from the chip actions.\n   */\n  removeFocus() {\n    this.adapter.setPrimaryActionAttr(strings.TAB_INDEX, '-1');\n    this.adapter.removeTrailingActionFocus();\n  }\n\n  /**\n   * Called by the chip set to focus the primary action.\n   *\n   */\n  focusPrimaryAction() {\n    this.setPrimaryActionFocusable(FocusBehavior.SHOULD_FOCUS);\n  }\n\n  /**\n   * Called by the chip set to focus the trailing action (if present), otherwise\n   * gives focus to the trailing action.\n   */\n  focusTrailingAction() {\n    const trailingActionIsNavigable = this.adapter.isTrailingActionNavigable();\n    if (trailingActionIsNavigable) {\n      this.adapter.setPrimaryActionAttr(strings.TAB_INDEX, '-1');\n      this.adapter.focusTrailingAction();\n      return;\n    }\n\n    this.focusPrimaryAction();\n  }\n\n  private setPrimaryActionFocusable(focusBehavior: FocusBehavior) {\n    this.adapter.setPrimaryActionAttr(strings.TAB_INDEX, '0');\n    if (focusBehavior === FocusBehavior.SHOULD_FOCUS) {\n      this.adapter.focusPrimaryAction();\n    }\n    this.adapter.removeTrailingActionFocus();\n  }\n\n  private getFocusBehavior(): FocusBehavior {\n    if (this.shouldFocusPrimaryActionOnClick) {\n      return FocusBehavior.SHOULD_FOCUS;\n    }\n    return FocusBehavior.SHOULD_NOT_FOCUS;\n  }\n\n  private focusNextAction(key: string, source: EventSource) {\n    const isTrailingActionNavigable = this.adapter.isTrailingActionNavigable();\n    const dir = this.getDirection(key);\n\n    // Early exit if the key should jump chips\n    if (jumpChipKeys.has(key) || !isTrailingActionNavigable) {\n      this.adapter.notifyNavigation(key, source);\n      return;\n    }\n\n    if (source === EventSource.PRIMARY && dir === Direction.RIGHT) {\n      this.focusTrailingAction();\n      return;\n    }\n\n    if (source === EventSource.TRAILING && dir === Direction.LEFT) {\n      this.focusPrimaryAction();\n      return;\n    }\n\n    this.adapter.notifyNavigation(key, EventSource.NONE);\n  }\n\n  private getDirection(key: string): Direction {\n    const isRTL = this.adapter.isRTL();\n    const isLeftKey =\n        key === strings.ARROW_LEFT_KEY || key === strings.IE_ARROW_LEFT_KEY;\n    const isRightKey =\n        key === strings.ARROW_RIGHT_KEY || key === strings.IE_ARROW_RIGHT_KEY;\n    if (!isRTL && isLeftKey || isRTL && isRightKey) {\n      return Direction.LEFT;\n    }\n\n    return Direction.RIGHT;\n  }\n\n  private removeChip() {\n    if (this.shouldRemoveOnTrailingIconClick) {\n      this.beginExit();\n    }\n  }\n\n  private shouldStartEditing(event: KeyboardEvent): boolean {\n    return this.eventFromPrimaryAction(event) && event.key === strings.ENTER_KEY;\n  }\n\n  private shouldFinishEditing(event: KeyboardEvent): boolean {\n    return event.key === strings.ENTER_KEY;\n  }\n\n  private shouldNotifyInteraction(event: KeyboardEvent): boolean {\n    return event.key === strings.ENTER_KEY || event.key === strings.SPACEBAR_KEY;\n  }\n\n  private isDeleteAction(event: KeyboardEvent): boolean {\n    const isDeletable = this.adapter.hasClass(cssClasses.DELETABLE);\n    return isDeletable &&\n        (event.key === strings.BACKSPACE_KEY || event.key === strings.DELETE_KEY ||\n         event.key === strings.IE_DELETE_KEY);\n  }\n\n  private setSelectedImpl(selected: boolean) {\n    if (selected) {\n      this.adapter.addClass(cssClasses.SELECTED);\n      this.adapter.setPrimaryActionAttr(strings.ARIA_CHECKED, 'true');\n    } else {\n      this.adapter.removeClass(cssClasses.SELECTED);\n      this.adapter.setPrimaryActionAttr(strings.ARIA_CHECKED, 'false');\n    }\n  }\n\n  private notifySelection(selected: boolean) {\n    this.adapter.notifySelection(selected, false);\n  }\n\n  private notifyIgnoredSelection(selected: boolean) {\n    this.adapter.notifySelection(selected, true);\n  }\n\n  private eventFromPrimaryAction(event: Event) {\n    return this.adapter.eventTargetHasClass(\n        event.target, cssClasses.PRIMARY_ACTION);\n  }\n\n  private startEditing() {\n    this.adapter.addClass(cssClasses.EDITING);\n    this.adapter.notifyEditStart();\n  }\n\n  private finishEditing() {\n    this.adapter.removeClass(cssClasses.EDITING);\n    this.adapter.notifyEditFinish();\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\nimport {EventSource} from './constants';\n\nexport interface MDCChipInteractionEventDetail {\n  chipId: string;\n}\n\nexport interface MDCChipSelectionEventDetail extends\n    MDCChipInteractionEventDetail {\n  selected: boolean;\n  shouldIgnore: boolean;\n}\n\nexport interface MDCChipRemovalEventDetail extends\n    MDCChipInteractionEventDetail {\n  removedAnnouncement: string|null;\n}\n\nexport interface MDCChipNavigationEventDetail extends\n    MDCChipInteractionEventDetail {\n  key: string;\n  source: EventSource;\n}\n\n// Note: CustomEvent<T> is not supported by Closure Compiler.\n\nexport interface MDCChipInteractionEvent extends Event {\n  readonly detail: MDCChipInteractionEventDetail;\n}\n\nexport interface MDCChipSelectionEvent extends Event {\n  readonly detail: MDCChipSelectionEventDetail;\n}\n\nexport interface MDCChipRemovalEvent extends Event {\n  readonly detail: MDCChipRemovalEventDetail;\n}\n\nexport interface MDCChipNavigationEvent extends Event {\n  readonly detail: MDCChipNavigationEventDetail;\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 './trailingaction/index';\nexport * from './chip/index';\nexport * from './chip-set/index';\n","/**\n * @license\n * Copyright 2020 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 {InteractionTrigger} from './constants';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCChipTrailingActionAdapter {\n  focus(): void;\n\n  getAttribute(attr: string): string|null;\n\n  notifyInteraction(trigger: InteractionTrigger): void;\n\n  notifyNavigation(key: string): void;\n\n  setAttribute(attr: string, value: string): void;\n}\n","/**\n * @license\n * Copyright 2020 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';\n\nimport {MDCChipTrailingActionAdapter} from './adapter';\nimport {strings} from './constants';\nimport {MDCChipTrailingActionFoundation} from './foundation';\nimport {MDCChipTrailingActionInteractionEventDetail, MDCChipTrailingActionNavigationEventDetail} from './types';\n\n/**\n * Creates a trailing action component on the given element.\n */\nexport type MDCChipTrailingActionFactory =\n    (el: HTMLElement, foundation?: MDCChipTrailingActionFoundation) =>\n        MDCChipTrailingAction;\n\n/** MDC Chip Trailing Action */\nexport class MDCChipTrailingAction extends\n    MDCComponent<MDCChipTrailingActionFoundation> implements\n        MDCRippleCapableSurface {\n  get ripple(): MDCRipple {\n    return this.rippleSurface;\n  }\n\n  static override attachTo(root: HTMLElement) {\n    return new MDCChipTrailingAction(root);\n  }\n\n  private rippleSurface!: MDCRipple;  // assigned in initialize()\n  private handleClick!:\n      SpecificEventListener<'click'>;  // assigned in initialSyncWithDOM()\n  private handleKeydown!:\n      SpecificEventListener<'keydown'>;  // assigned in initialSyncWithDOM()\n\n  override initialize(\n      rippleFactory: MDCRippleFactory = (el, foundation) =>\n          new MDCRipple(el, foundation)) {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const rippleAdapter: MDCRippleAdapter = MDCRipple.createAdapter(this);\n    this.rippleSurface =\n        rippleFactory(this.root, new MDCRippleFoundation(rippleAdapter));\n  }\n\n  override initialSyncWithDOM() {\n    this.handleClick = (event: MouseEvent) => {\n      this.foundation.handleClick(event);\n    };\n    this.handleKeydown = (event: KeyboardEvent) => {\n      this.foundation.handleKeydown(event);\n    };\n\n    this.listen('click', this.handleClick);\n    this.listen('keydown', this.handleKeydown);\n  }\n\n  override destroy() {\n    this.rippleSurface.destroy();\n    this.unlisten('click', this.handleClick);\n    this.unlisten('keydown', this.handleKeydown);\n    super.destroy();\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCChipTrailingActionAdapter = {\n      focus: () => {\n        this.root.focus();\n      },\n      getAttribute: (attr) => this.root.getAttribute(attr),\n      notifyInteraction: (trigger) => {\n        this.emit<MDCChipTrailingActionInteractionEventDetail>(\n            strings.INTERACTION_EVENT, {trigger}, true /* shouldBubble */);\n      },\n      notifyNavigation: (key) => {\n        this.emit<MDCChipTrailingActionNavigationEventDetail>(\n            strings.NAVIGATION_EVENT, {key}, true /* shouldBubble */);\n      },\n      setAttribute: (attr, value) => {\n        this.safeSetAttribute(this.root, attr, value);\n      },\n    };\n    return new MDCChipTrailingActionFoundation(adapter);\n  }\n\n  isNavigable() {\n    return this.foundation.isNavigable();\n  }\n\n  focus() {\n    this.foundation.focus();\n  }\n\n  removeFocus() {\n    this.foundation.removeFocus();\n  }\n}\n","/**\n * @license\n * Copyright 2020 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 enum InteractionTrigger {\n  UNSPECIFIED,  // Default type\n  CLICK,\n  BACKSPACE_KEY,\n  DELETE_KEY,\n  SPACEBAR_KEY,\n  ENTER_KEY,\n}\n\nexport const strings = {\n  ARIA_HIDDEN: 'aria-hidden',\n  INTERACTION_EVENT: 'MDCChipTrailingAction:interaction',\n  NAVIGATION_EVENT: 'MDCChipTrailingAction:navigation',\n  TAB_INDEX: 'tabindex',\n};\n","/**\n * @license\n * Copyright 2020 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 {isNavigationEvent, KEY, normalizeKey} from '@material/dom/keyboard';\n\nimport {MDCChipTrailingActionAdapter} from './adapter';\nimport {InteractionTrigger, strings} from './constants';\n\n/** MDC Chip Trailing Action Foundation */\nexport class MDCChipTrailingActionFoundation extends\n    MDCFoundation<MDCChipTrailingActionAdapter> {\n  static override get strings() {\n    return strings;\n  }\n\n  static override get defaultAdapter(): MDCChipTrailingActionAdapter {\n    return {\n      focus: () => undefined,\n      getAttribute: () => null,\n      setAttribute: () => undefined,\n      notifyInteraction: () => undefined,\n      notifyNavigation: () => undefined,\n    };\n  }\n\n  constructor(adapter?: Partial<MDCChipTrailingActionAdapter>) {\n    super({...MDCChipTrailingActionFoundation.defaultAdapter, ...adapter});\n  }\n\n  handleClick(event: MouseEvent) {\n    event.stopPropagation();\n    this.adapter.notifyInteraction(InteractionTrigger.CLICK);\n  }\n\n  handleKeydown(event: KeyboardEvent) {\n    event.stopPropagation();\n    const key = normalizeKey(event);\n    if (this.shouldNotifyInteractionFromKey(key)) {\n      const trigger = this.getTriggerFromKey(key);\n      this.adapter.notifyInteraction(trigger);\n      return;\n    }\n\n    if (isNavigationEvent(event)) {\n      this.adapter.notifyNavigation(key);\n      return;\n    }\n  }\n\n  removeFocus() {\n    this.adapter.setAttribute(strings.TAB_INDEX, '-1');\n  }\n\n  focus() {\n    this.adapter.setAttribute(strings.TAB_INDEX, '0');\n    this.adapter.focus();\n  }\n\n  isNavigable() {\n    return this.adapter.getAttribute(strings.ARIA_HIDDEN) !== 'true';\n  }\n\n  private shouldNotifyInteractionFromKey(key: string): boolean {\n    const isFromActionKey = key === KEY.ENTER || key === KEY.SPACEBAR;\n    const isFromDeleteKey = key === KEY.BACKSPACE || key === KEY.DELETE;\n\n    return isFromActionKey || isFromDeleteKey;\n  }\n\n  private getTriggerFromKey(key: string): InteractionTrigger {\n    if (key === KEY.SPACEBAR) {\n      return InteractionTrigger.SPACEBAR_KEY;\n    }\n\n    if (key === KEY.ENTER) {\n      return InteractionTrigger.ENTER_KEY;\n    }\n\n    if (key === KEY.DELETE) {\n      return InteractionTrigger.DELETE_KEY;\n    }\n\n    if (key === KEY.BACKSPACE) {\n      return InteractionTrigger.BACKSPACE_KEY;\n    }\n\n    // Default case, should never be returned\n    return InteractionTrigger.UNSPECIFIED;\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 MDCChipTrailingActionFoundation;\n","/**\n * @license\n * Copyright 2020 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 {strings as trailingActionStrings} from './constants';\n","/**\n * @license\n * Copyright 2020 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 {InteractionTrigger} from './constants';\n\nexport interface MDCChipTrailingActionInteractionEventDetail {\n  trigger: InteractionTrigger;\n}\n\nexport interface MDCChipTrailingActionNavigationEventDetail {\n  key: string;\n}\n\n// Note: CustomEvent<T> is not supported by Closure Compiler.\n\nexport interface MDCChipTrailingActionInteractionEvent extends Event {\n  readonly detail: MDCChipTrailingActionInteractionEventDetail;\n}\n\nexport interface MDCChipTrailingActionNavigationEvent extends Event {\n  readonly detail: MDCChipTrailingActionNavigationEventDetail;\n}\n","/**\n * @license\n * Copyright 2020 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 * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCCircularProgressAdapter {\n  addClass(className: string): void;\n  getDeterminateCircleAttribute(attributeName: string): string|null;\n  hasClass(className: string): boolean;\n  removeClass(className: string): void;\n  removeAttribute(attributeName: string): void;\n  setAttribute(attributeName: string, value: string): void;\n  setDeterminateCircleAttribute(attributeName: string, value: string): void;\n}\n","/**\n * @license\n * Copyright 2020 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 {MDCProgressIndicator} from '@material/progress-indicator/component';\n\nimport {MDCCircularProgressAdapter} from './adapter';\nimport {MDCCircularProgressFoundation} from './foundation';\n\n/** MDC Circular Progress */\nexport class MDCCircularProgress extends\n    MDCComponent<MDCCircularProgressFoundation> implements\n        MDCProgressIndicator {\n  private determinateCircle!: HTMLElement;\n\n  override initialize() {\n    this.determinateCircle = this.root.querySelector<HTMLElement>(\n        MDCCircularProgressFoundation.strings.DETERMINATE_CIRCLE_SELECTOR)!;\n  }\n\n  static override attachTo(root: HTMLElement) {\n    return new MDCCircularProgress(root);\n  }\n\n  /**\n   * Sets whether the progress indicator is in determinate mode.\n   * @param value Whether the indicator should be determinate.\n   */\n  set determinate(value: boolean) {\n    this.foundation.setDeterminate(value);\n  }\n\n  /**\n   * Sets the current progress value. In indeterminate mode, this has no\n   * visual effect but will be reflected if the indicator is switched to\n   * determinate mode.\n   * @param value The current progress value, which must be between 0 and 1.\n   */\n  set progress(value: number) {\n    this.foundation.setProgress(value);\n  }\n\n  /**\n   * Whether the progress indicator is hidden.\n   */\n  get isClosed() {\n    return this.foundation.isClosed();\n  }\n\n  /**\n   * Shows the progress indicator.\n   */\n  open() {\n    this.foundation.open();\n  }\n\n  /**\n   * Hides the progress indicator.\n   */\n  close() {\n    this.foundation.close();\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCCircularProgressAdapter = {\n      addClass: (className: string) => {\n        this.root.classList.add(className);\n      },\n      getDeterminateCircleAttribute: (attributeName: string) =>\n          this.determinateCircle.getAttribute(attributeName),\n      hasClass: (className: string) => this.root.classList.contains(className),\n      removeClass: (className: string) => {\n        this.root.classList.remove(className);\n      },\n      removeAttribute: (attributeName: string) => {\n        this.root.removeAttribute(attributeName);\n      },\n      setAttribute: (attributeName: string, value: string) => {\n        this.safeSetAttribute(this.root, attributeName, value);\n      },\n      setDeterminateCircleAttribute: (attributeName: string, value: string) => {\n        this.determinateCircle.setAttribute(attributeName, value);\n      },\n    };\n    return new MDCCircularProgressFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2020 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 * CSS class names used in component.\n */\nexport const cssClasses = {\n  INDETERMINATE_CLASS: 'mdc-circular-progress--indeterminate',\n  CLOSED_CLASS: 'mdc-circular-progress--closed',\n};\n\n/**\n * Attributes and selectors used in component.\n */\nexport const strings = {\n  ARIA_HIDDEN: 'aria-hidden',\n  ARIA_VALUENOW: 'aria-valuenow',\n  DETERMINATE_CIRCLE_SELECTOR: '.mdc-circular-progress__determinate-circle',\n  RADIUS: 'r',\n  STROKE_DASHOFFSET: 'stroke-dashoffset',\n};\n","/**\n * @license\n * Copyright 2020 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 {MDCProgressIndicatorFoundation} from '@material/progress-indicator/foundation';\n\nimport {MDCCircularProgressAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\n/** MDC Circular Progress Foundation */\nexport class MDCCircularProgressFoundation extends\n    MDCFoundation<MDCCircularProgressAdapter> implements\n        MDCProgressIndicatorFoundation {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override get defaultAdapter(): MDCCircularProgressAdapter {\n    return {\n      addClass: () => undefined,\n      getDeterminateCircleAttribute: () => null,\n      hasClass: () => false,\n      removeClass: () => undefined,\n      removeAttribute: () => undefined,\n      setAttribute: () => undefined,\n      setDeterminateCircleAttribute: () => undefined,\n    };\n  }\n\n  private closed!: boolean;\n  private determinate!: boolean;\n  private progress!: number;\n  private radius!: number;\n\n  constructor(adapter?: Partial<MDCCircularProgressAdapter>) {\n    super({...MDCCircularProgressFoundation.defaultAdapter, ...adapter});\n  }\n\n  override init() {\n    this.closed = this.adapter.hasClass(cssClasses.CLOSED_CLASS);\n    this.determinate = !this.adapter.hasClass(cssClasses.INDETERMINATE_CLASS);\n    this.progress = 0;\n\n    if (this.determinate) {\n      this.adapter.setAttribute(\n          strings.ARIA_VALUENOW, this.progress.toString());\n    }\n\n    this.radius =\n        Number(this.adapter.getDeterminateCircleAttribute(strings.RADIUS));\n  }\n\n  /**\n   * Sets whether the progress indicator is in determinate mode.\n   * @param determinate Whether the indicator should be determinate.\n   */\n  setDeterminate(determinate: boolean) {\n    this.determinate = determinate;\n\n    if (this.determinate) {\n      this.adapter.removeClass(cssClasses.INDETERMINATE_CLASS);\n      this.setProgress(this.progress);\n    } else {\n      this.adapter.addClass(cssClasses.INDETERMINATE_CLASS);\n      this.adapter.removeAttribute(strings.ARIA_VALUENOW);\n    }\n  }\n\n  isDeterminate() {\n    return this.determinate;\n  }\n\n  /**\n   * Sets the current progress value. In indeterminate mode, this has no\n   * visual effect but will be reflected if the indicator is switched to\n   * determinate mode.\n   * @param value The current progress value, which must be between 0 and 1.\n   */\n  setProgress(value: number) {\n    this.progress = value;\n    if (this.determinate) {\n      const unfilledArcLength =\n          (1 - this.progress) * (2 * Math.PI * this.radius);\n\n      this.adapter.setDeterminateCircleAttribute(\n          strings.STROKE_DASHOFFSET, `${unfilledArcLength}`);\n      this.adapter.setAttribute(\n          strings.ARIA_VALUENOW, this.progress.toString());\n    }\n  }\n\n  getProgress() {\n    return this.progress;\n  }\n\n  /**\n   * Shows the progress indicator.\n   */\n  open() {\n    this.closed = false;\n    this.adapter.removeClass(cssClasses.CLOSED_CLASS);\n    this.adapter.removeAttribute(strings.ARIA_HIDDEN);\n  }\n\n  /**\n   * Hides the progress indicator\n   */\n  close() {\n    this.closed = true;\n    this.adapter.addClass(cssClasses.CLOSED_CLASS);\n    this.adapter.setAttribute(strings.ARIA_HIDDEN, 'true');\n  }\n\n  /**\n   * @return Returns whether the progress indicator is hidden.\n   */\n  isClosed() {\n    return this.closed;\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 MDCCircularProgressFoundation;\n","/**\n * @license\n * Copyright 2020 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 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\nimport {SortValue} from './constants';\nimport {MDCDataTableRowSelectionChangedEventDetail, ProgressIndicatorStyles, RowClickEventData, SortActionEventDetail} from './types';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCDataTableAdapter {\n  /**\n   * Adds CSS class name to root element.\n   *\n   * @param className CSS class name to add to root element.\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes CSS class name from root element.\n   *\n   * @param className CSS class name to add to root element.\n   */\n  removeClass(className: string): void;\n\n  /**\n   * Adds a class name to row element at given row index excluding header row.\n   *\n   * @param rowIndex Index of row element excluding header row.\n   * @param cssClasses CSS Class string to add.\n   */\n  addClassAtRowIndex(rowIndex: number, cssClasses: string): void;\n\n  /**\n   * @return Row count excluding header row.\n   */\n  getRowCount(): number;\n\n  /**\n   * @return Array of row elements excluding header row.\n   */\n  getRowElements(): HTMLElement[];\n\n  /**\n   * Returns row id of row element at given row index based on `data-row-id`\n   * attribute on row element `tr`.\n   *\n   * @param rowIndex Index of row element.\n   * @return Row id of row element, returns `null` in absence of `data-row-id`\n   *     attribute on row element.\n   */\n  getRowIdAtIndex(rowIndex: number): string|null;\n\n  /**\n   * Returns index of row element that contains give child element. Returns -1\n   * if element is not child of any row element.\n   *\n   * @param el Child element of row element.\n   * @return Index of row element.\n   */\n  getRowIndexByChildElement(el: Element): number;\n\n  /**\n   * @return Selected row count.\n   */\n  getSelectedRowCount(): number;\n\n  /**\n   * @param rowIndex Index of row element.\n   * @return True if row checkbox at given row index is checked.\n   */\n  isCheckboxAtRowIndexChecked(rowIndex: number): boolean;\n\n  /**\n   * @return True if header row checkbox is checked.\n   */\n  isHeaderRowCheckboxChecked(): boolean;\n\n  /**\n   * @return True if table rows are selectable.\n   */\n  isRowsSelectable(): boolean;\n\n  /**\n   * Notifies when row selection is changed.\n   *\n   * @param data Event detail data for row selection changed event.\n   */\n  notifyRowSelectionChanged(data: MDCDataTableRowSelectionChangedEventDetail):\n      void;\n\n  /**\n   * Notifies when header row is checked.\n   */\n  notifySelectedAll(): void;\n\n  /**\n   * Notifies when header row is unchecked.\n   */\n  notifyUnselectedAll(): void;\n\n  /**\n   * Notifies when data row is clicked.\n   */\n  notifyRowClick(detail: RowClickEventData): void;\n\n  /**\n   * Initializes header row checkbox. Destroys previous header row checkbox\n   * instance if any.\n   * @return Can return Promise only if registering checkbox is asynchronous.\n   */\n  registerHeaderRowCheckbox(): Promise<void>|void;\n\n  /**\n   * Initializes all row checkboxes. Destroys previous row checkbox instances if\n   * any. This is usually called when row checkboxes are added or removed from\n   * table.\n   * @return Can return Promise only if registering checkbox is asynchronous.\n   */\n  registerRowCheckboxes(): Promise<void>|void;\n\n  /**\n   * Removes class name from row element at give row index.\n   *\n   * @param rowIndex Index of row element excluding header row element.\n   * @param cssClasses Class name string.\n   */\n  removeClassAtRowIndex(rowIndex: number, cssClasses: string): void;\n\n  /**\n   * Sets attribute to row element at given row index.\n   *\n   * @param rowIndex Index of row element excluding header row element.\n   * @param attr Name of attribute.\n   * @param value Value of attribute.\n   */\n  setAttributeAtRowIndex(rowIndex: number, attr: string, value: string): void;\n\n  /**\n   * Sets header row checkbox checked or unchecked.\n   *\n   * @param checked True to set header row checkbox checked.\n   */\n  setHeaderRowCheckboxChecked(checked: boolean): void;\n\n  /**\n   * Sets header row checkbox to indeterminate.\n   *\n   * @param indeterminate True to set header row checkbox indeterminate.\n   */\n  setHeaderRowCheckboxIndeterminate(indeterminate: boolean): void;\n\n  /**\n   * Sets row checkbox to checked or unchecked at given row index.\n   *\n   * @param rowIndex Index of row element excluding header row element.\n   * @param checked True to set checked.\n   */\n  setRowCheckboxCheckedAtIndex(rowIndex: number, checked: boolean): void;\n\n  /**\n   * @return Total count of header cells.\n   */\n  getHeaderCellCount(): number;\n\n  /**\n   * @return Array of header cell elements.\n   */\n  getHeaderCellElements(): HTMLElement[];\n\n  /**\n   * @return Attribute value for given header cell index.\n   */\n  getAttributeByHeaderCellIndex(columnIndex: number, attribute: string): string\n      |null;\n\n  /**\n   * Sets attribute of a header cell by index.\n   */\n  setAttributeByHeaderCellIndex(\n      columnIndex: number, attribute: string, value: string): void;\n\n  /**\n   * Sets class name of a header cell by index.\n   */\n  setClassNameByHeaderCellIndex(columnIndex: number, className: string): void;\n\n  /**\n   * Removes a class name of a header cell by index.\n   */\n  removeClassNameByHeaderCellIndex(columnIndex: number, className: string):\n      void;\n\n  /**\n   * Notifies when column is sorted.\n   */\n  notifySortAction(data: SortActionEventDetail): void;\n\n  /**\n   * @return Returns computed styles height of table container element.\n   */\n  getTableContainerHeight(): number;\n\n  /**\n   * @return Returns computed styles height of table's header element.\n   */\n  getTableHeaderHeight(): number;\n\n  /**\n   * Sets progress indicator CSS styles to position it on top of table body.\n   */\n  setProgressIndicatorStyles(styles: ProgressIndicatorStyles): void;\n\n  /**\n   * Sets appropriate sort status label by header cell index. Skips setting sort\n   * status label if header cell is not sortable.\n   *\n   * Example status label to set for sortValue:\n   *\n   *   - `SortValue.ASCENDING`: 'Sorted in ascending order'\n   *   - `SortValue.DESCENDING`: 'Sorted in descending order'\n   *   - `SortValue.NONE`: '' (Empty string)\n   */\n  setSortStatusLabelByHeaderCellIndex(\n      columnIndex: number, sortValue: SortValue): void;\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 {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 {MDCLinearProgress} from '@material/linear-progress/component';\n\nimport {MDCDataTableAdapter} from './adapter';\nimport {cssClasses, dataAttributes, events, messages, selectors, SortValue} from './constants';\nimport {MDCDataTableFoundation} from './foundation';\nimport {MDCDataTableRowSelectionChangedEventDetail, RowClickEventData} from './types';\n\n/** MDC Data Table */\nexport class MDCDataTable extends MDCComponent<MDCDataTableFoundation> {\n  static override attachTo(root: HTMLElement): MDCDataTable {\n    return new MDCDataTable(root);\n  }\n\n  private headerRowCheckbox!: MDCCheckbox;\n  private rowCheckboxList!: MDCCheckbox[];\n  private checkboxFactory!: MDCCheckboxFactory;\n  private linearProgress!: MDCLinearProgress;\n  private headerRow!: HTMLElement;\n  private content!: HTMLElement;\n  private handleHeaderRowCheckboxChange!: SpecificEventListener<'change'>;\n  private handleRowCheckboxChange!: SpecificEventListener<'change'>;\n  private headerRowClickListener!:\n      SpecificEventListener<'click'>;  // Assigned in `initialSyncWithDOM()`\n  private handleContentClick!:\n      SpecificEventListener<'click'>;  // Assigned in `initialSyncWithDOM()`\n\n  override initialize(\n      checkboxFactory:\n          MDCCheckboxFactory = (el: HTMLElement) => new MDCCheckbox(el)) {\n    this.checkboxFactory = checkboxFactory;\n  }\n\n  override initialSyncWithDOM() {\n    this.headerRow =\n        this.root.querySelector<HTMLElement>(`.${cssClasses.HEADER_ROW}`)!;\n    this.handleHeaderRowCheckboxChange = () => {\n      this.foundation.handleHeaderRowCheckboxChange();\n    };\n    this.headerRow.addEventListener(\n        'change', this.handleHeaderRowCheckboxChange);\n\n    this.headerRowClickListener = (event) => {\n      this.handleHeaderRowClick(event);\n    };\n    this.headerRow.addEventListener('click', this.headerRowClickListener);\n\n\n    this.content =\n        this.root.querySelector<HTMLElement>(`.${cssClasses.CONTENT}`)!;\n    this.handleContentClick = (event) => {\n      const dataRowEl =\n          closest(event.target as Element, selectors.ROW) as HTMLElement;\n      if (!dataRowEl) return;\n\n      this.foundation.handleRowClick({\n        rowId: this.getRowIdByRowElement(dataRowEl),\n        row: dataRowEl,\n        altKey: event.altKey,\n        ctrlKey: event.ctrlKey,\n        metaKey: event.metaKey,\n        shiftKey: event.shiftKey,\n      });\n    };\n    this.content.addEventListener('click', this.handleContentClick);\n    this.handleRowCheckboxChange = (event) => {\n      this.foundation.handleRowCheckboxChange(event);\n    };\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\n   * are added or removed from table.\n   */\n  layout() {\n    this.foundation.layout();\n  }\n\n  /**\n   * @return Returns array of header row cell elements.\n   */\n  getHeaderCells() {\n    return Array.from(\n        this.root.querySelectorAll<HTMLElement>(selectors.HEADER_CELL));\n  }\n\n  /**\n   * @return Returns array of row elements.\n   */\n  getRows(): HTMLElement[] {\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  /**\n   * Shows progress indicator when data table is in loading state.\n   */\n  showProgress() {\n    this.getLinearProgress().open();\n    this.foundation.showProgress();\n  }\n\n  /**\n   * Hides progress indicator after data table is finished loading.\n   */\n  hideProgress() {\n    this.foundation.hideProgress();\n    this.getLinearProgress().close();\n  }\n\n  override destroy() {\n    if (this.handleHeaderRowCheckboxChange) {\n      this.headerRow.removeEventListener(\n          'change', this.handleHeaderRowCheckboxChange);\n    }\n    if (this.headerRowClickListener) {\n      this.headerRow.removeEventListener('click', this.headerRowClickListener);\n    }\n    if (this.handleRowCheckboxChange) {\n      this.content.removeEventListener('change', this.handleRowCheckboxChange);\n    }\n\n    if (this.headerRowCheckbox) {\n      this.headerRowCheckbox.destroy();\n    }\n    if (this.rowCheckboxList) {\n      for (const checkbox of this.rowCheckboxList) {\n        checkbox.destroy();\n      }\n    }\n    if (this.handleContentClick) {\n      this.content.removeEventListener('click', this.handleContentClick);\n    }\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      getHeaderCellElements: () => this.getHeaderCells(),\n      getHeaderCellCount: () => this.getHeaderCells().length,\n      getAttributeByHeaderCellIndex: (index, attribute) => {\n        return this.getHeaderCells()[index].getAttribute(attribute);\n      },\n      setAttributeByHeaderCellIndex: (index, attribute, value) => {\n        this.safeSetAttribute(this.getHeaderCells()[index], attribute, value);\n      },\n      setClassNameByHeaderCellIndex: (index, className) => {\n        this.getHeaderCells()[index].classList.add(className);\n      },\n      removeClassNameByHeaderCellIndex: (index, className) => {\n        this.getHeaderCells()[index].classList.remove(className);\n      },\n      notifySortAction: (data) => {\n        this.emit(events.SORTED, data, /** shouldBubble */ true);\n      },\n      getTableContainerHeight: () => {\n        const tableContainer = this.root.querySelector<HTMLElement>(\n            `.${cssClasses.TABLE_CONTAINER}`);\n\n        if (!tableContainer) {\n          throw new Error('MDCDataTable: Table container element not found.');\n        }\n\n        return tableContainer.getBoundingClientRect().height;\n      },\n      getTableHeaderHeight: () => {\n        const tableHeader =\n            this.root.querySelector<HTMLElement>(selectors.HEADER_ROW);\n\n        if (!tableHeader) {\n          throw new Error('MDCDataTable: Table header element not found.');\n        }\n\n        return tableHeader.getBoundingClientRect().height;\n      },\n      setProgressIndicatorStyles: (styles) => {\n        const progressIndicator =\n            this.root.querySelector<HTMLElement>(selectors.PROGRESS_INDICATOR);\n\n        if (!progressIndicator) {\n          throw new Error(\n              'MDCDataTable: Progress indicator element not found.');\n        }\n\n        progressIndicator.style.setProperty('height', styles.height);\n        progressIndicator.style.setProperty('top', styles.top);\n      },\n      addClassAtRowIndex: (rowIndex: number, className: string) => {\n        this.getRows()[rowIndex].classList.add(className);\n      },\n      getRowCount: () => this.getRows().length,\n      getRowElements: () =>\n          Array.from(this.root.querySelectorAll<HTMLElement>(selectors.ROW)),\n      getRowIdAtIndex: (rowIndex: number) =>\n          this.getRows()[rowIndex].getAttribute(dataAttributes.ROW_ID),\n      getRowIndexByChildElement: (el: Element) => {\n        return this.getRows().indexOf(\n            (closest(el, selectors.ROW) as HTMLElement));\n      },\n      getSelectedRowCount: () =>\n          this.root.querySelectorAll<HTMLElement>(selectors.ROW_SELECTED)\n              .length,\n      isCheckboxAtRowIndexChecked: (rowIndex: number) =>\n          this.rowCheckboxList[rowIndex].checked,\n      isHeaderRowCheckboxChecked: () => this.headerRowCheckbox.checked,\n      isRowsSelectable: () =>\n          !!this.root.querySelector<HTMLElement>(selectors.ROW_CHECKBOX) ||\n          !!this.root.querySelector<HTMLElement>(selectors.HEADER_ROW_CHECKBOX),\n      notifyRowSelectionChanged:\n          (data: MDCDataTableRowSelectionChangedEventDetail) => {\n            this.emit(\n                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: () => {\n        this.emit(events.SELECTED_ALL, {}, /** shouldBubble */ true);\n      },\n      notifyUnselectedAll: () => {\n        this.emit(events.UNSELECTED_ALL, {}, /** shouldBubble */ true);\n      },\n      notifyRowClick: (data: RowClickEventData) => {\n        this.emit(events.ROW_CLICK, data, /** shouldBubble */ true);\n      },\n      registerHeaderRowCheckbox: () => {\n        if (this.headerRowCheckbox) {\n          this.headerRowCheckbox.destroy();\n        }\n\n        const checkboxEl = this.root.querySelector<HTMLElement>(\n            selectors.HEADER_ROW_CHECKBOX)!;\n        this.headerRowCheckbox = this.checkboxFactory(checkboxEl);\n      },\n      registerRowCheckboxes: () => {\n        if (this.rowCheckboxList) {\n          this.rowCheckboxList.forEach((checkbox) => {\n            checkbox.destroy();\n          });\n        }\n\n        this.rowCheckboxList = [];\n        this.getRows().forEach((rowEl) => {\n          const checkbox = this.checkboxFactory(\n              rowEl.querySelector<HTMLElement>(selectors.ROW_CHECKBOX)!);\n          this.rowCheckboxList.push(checkbox);\n        });\n      },\n      removeClassAtRowIndex: (rowIndex: number, className: string) => {\n        this.getRows()[rowIndex].classList.remove(className);\n      },\n      setAttributeAtRowIndex:\n          (rowIndex: number, attr: string, value: string) => {\n            this.safeSetAttribute(this.getRows()[rowIndex], 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      setSortStatusLabelByHeaderCellIndex: (\n          columnIndex: number, sortValue: SortValue) => {\n        const headerCell = this.getHeaderCells()[columnIndex];\n        const sortStatusLabel =\n            headerCell.querySelector<HTMLElement>(selectors.SORT_STATUS_LABEL);\n\n        if (!sortStatusLabel) return;\n\n        sortStatusLabel.textContent =\n            this.getSortStatusMessageBySortValue(sortValue);\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(dataAttributes.ROW_ID);\n  }\n\n  private handleHeaderRowClick(event: Event): void {\n    const headerCell =\n        closest(event.target as Element, selectors.HEADER_CELL_WITH_SORT) as\n        HTMLElement;\n\n    if (!headerCell) {\n      return;\n    }\n\n    const columnId = headerCell.getAttribute(dataAttributes.COLUMN_ID);\n    const columnIndex = this.getHeaderCells().indexOf(headerCell);\n    if (columnIndex === -1) {\n      return;\n    }\n\n    this.foundation.handleSortAction({columnId, columnIndex, headerCell});\n  }\n\n  private getSortStatusMessageBySortValue(sortValue: SortValue): string {\n    switch (sortValue) {\n      case SortValue.ASCENDING:\n        return messages.SORTED_IN_ASCENDING;\n      case SortValue.DESCENDING:\n        return messages.SORTED_IN_DESCENDING;\n      default:\n        return '';\n    }\n  }\n\n  private getLinearProgressElement(): HTMLElement {\n    const el =\n        this.root.querySelector<HTMLElement>(`.${cssClasses.LINEAR_PROGRESS}`);\n    if (!el) {\n      throw new Error('MDCDataTable: linear progress element is not found.');\n    }\n\n    return el;\n  }\n\n  private getLinearProgress(): MDCLinearProgress {\n    if (!this.linearProgress) {\n      const el = this.getLinearProgressElement();\n      this.linearProgress = new MDCLinearProgress(el);\n    }\n\n    return this.linearProgress;\n  }\n\n  private getRowIdByRowElement(rowElement: HTMLElement): string|null {\n    return rowElement.getAttribute(dataAttributes.ROW_ID);\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\n/**\n * CSS class names used in component.\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_CELL: 'mdc-data-table__header-cell',\n  HEADER_CELL_LABEL: 'mdc-data-table__header-cell-label',\n  HEADER_CELL_SORTED: 'mdc-data-table__header-cell--sorted',\n  HEADER_CELL_SORTED_DESCENDING:\n      'mdc-data-table__header-cell--sorted-descending',\n  HEADER_CELL_WITH_SORT: 'mdc-data-table__header-cell--with-sort',\n  HEADER_CELL_WRAPPER: 'mdc-data-table__header-cell-wrapper',\n  HEADER_ROW: 'mdc-data-table__header-row',\n  HEADER_ROW_CHECKBOX: 'mdc-data-table__header-row-checkbox',\n  IN_PROGRESS: 'mdc-data-table--in-progress',\n  LINEAR_PROGRESS: 'mdc-data-table__linear-progress',\n  PAGINATION_ROWS_PER_PAGE_LABEL:\n      'mdc-data-table__pagination-rows-per-page-label',\n  PAGINATION_ROWS_PER_PAGE_SELECT:\n      'mdc-data-table__pagination-rows-per-page-select',\n  PROGRESS_INDICATOR: 'mdc-data-table__progress-indicator',\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  SORT_ICON_BUTTON: 'mdc-data-table__sort-icon-button',\n  SORT_STATUS_LABEL: 'mdc-data-table__sort-status-label',\n  TABLE_CONTAINER: 'mdc-data-table__table-container',\n};\n\n/**\n * DOM attributes used in component.\n */\nexport const attributes = {\n  ARIA_SELECTED: 'aria-selected',\n  ARIA_SORT: 'aria-sort',\n};\n\n/**\n * List of data attributes used in component.\n */\nexport const dataAttributes = {\n  COLUMN_ID: 'data-column-id',\n  ROW_ID: 'data-row-id',\n};\n\n/**\n * CSS selectors used in component.\n */\nexport const selectors = {\n  CONTENT: `.${cssClasses.CONTENT}`,\n  HEADER_CELL: `.${cssClasses.HEADER_CELL}`,\n  HEADER_CELL_WITH_SORT: `.${cssClasses.HEADER_CELL_WITH_SORT}`,\n  HEADER_ROW: `.${cssClasses.HEADER_ROW}`,\n  HEADER_ROW_CHECKBOX: `.${cssClasses.HEADER_ROW_CHECKBOX}`,\n  PROGRESS_INDICATOR: `.${cssClasses.PROGRESS_INDICATOR}`,\n  ROW: `.${cssClasses.ROW}`,\n  ROW_CHECKBOX: `.${cssClasses.ROW_CHECKBOX}`,\n  ROW_SELECTED: `.${cssClasses.ROW_SELECTED}`,\n  SORT_ICON_BUTTON: `.${cssClasses.SORT_ICON_BUTTON}`,\n  SORT_STATUS_LABEL: `.${cssClasses.SORT_STATUS_LABEL}`,\n};\n\n/**\n * Messages used in component.\n */\nexport const messages = {\n  SORTED_IN_DESCENDING: 'Sorted in descending order',\n  SORTED_IN_ASCENDING: 'Sorted in ascending order',\n};\n\n/**\n * Sort values defined by ARIA.\n * See https://www.w3.org/WAI/PF/aria/states_and_properties#aria-sort\n */\nexport enum SortValue {\n  // Items are sorted in ascending order by this column.\n  ASCENDING = 'ascending',\n\n  // Items are sorted in descending order by this column.\n  DESCENDING = 'descending',\n\n  // There is no defined sort applied to the column.\n  NONE = 'none',\n\n  // A sort algorithm other than ascending or descending has been applied.\n  OTHER = 'other',\n}\n\n/**\n * Event names used in component.\n */\nexport const events = {\n  ROW_CLICK: 'MDCDataTable:rowClick',\n  ROW_SELECTION_CHANGED: 'MDCDataTable:rowSelectionChanged',\n  SELECTED_ALL: 'MDCDataTable:selectedAll',\n  SORTED: 'MDCDataTable:sorted',\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';\n\nimport {MDCDataTableAdapter} from './adapter';\nimport {cssClasses, SortValue, attributes} from './constants';\nimport {RowClickEventData, SortActionEventData} from './types';\n\n/**\n * The Foundation of data table component containing pure business logic, any\n * logic requiring DOM manipulation are delegated to adapter methods.\n */\nexport class MDCDataTableFoundation extends MDCFoundation<MDCDataTableAdapter> {\n  static override get defaultAdapter(): MDCDataTableAdapter {\n    return {\n      addClass: () => undefined,\n      addClassAtRowIndex: () => undefined,\n      getAttributeByHeaderCellIndex: () => '',\n      getHeaderCellCount: () => 0,\n      getHeaderCellElements: () => [],\n      getRowCount: () => 0,\n      getRowElements: () => [],\n      getRowIdAtIndex: () => '',\n      getRowIndexByChildElement: () => 0,\n      getSelectedRowCount: () => 0,\n      getTableContainerHeight: () => 0,\n      getTableHeaderHeight: () => 0,\n      isCheckboxAtRowIndexChecked: () => false,\n      isHeaderRowCheckboxChecked: () => false,\n      isRowsSelectable: () => false,\n      notifyRowSelectionChanged: () => undefined,\n      notifySelectedAll: () => undefined,\n      notifySortAction: () => undefined,\n      notifyUnselectedAll: () => undefined,\n      notifyRowClick: () => undefined,\n      registerHeaderRowCheckbox: () => undefined,\n      registerRowCheckboxes: () => undefined,\n      removeClass: () => undefined,\n      removeClassAtRowIndex: () => undefined,\n      removeClassNameByHeaderCellIndex: () => undefined,\n      setAttributeAtRowIndex: () => undefined,\n      setAttributeByHeaderCellIndex: () => undefined,\n      setClassNameByHeaderCellIndex: () => undefined,\n      setHeaderRowCheckboxChecked: () => undefined,\n      setHeaderRowCheckboxIndeterminate: () => undefined,\n      setProgressIndicatorStyles: () => undefined,\n      setRowCheckboxCheckedAtIndex: () => undefined,\n      setSortStatusLabelByHeaderCellIndex: () => 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\n   * are added or removed from table. Use this if registering checkbox is\n   * 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\n   * are added or removed from table. Use this if registering checkbox is\n   * 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(): HTMLElement[] {\n    return this.adapter.getRowElements();\n  }\n\n  /**\n   * @return Array of header cell elements.\n   */\n  getHeaderCells(): Element[] {\n    return this.adapter.getHeaderCellElements();\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 all row ids.\n   */\n  getRowIds(): Array<string|null> {\n    const rowIds = [];\n    for (let rowIndex = 0; rowIndex < this.adapter.getRowCount(); rowIndex++) {\n      rowIds.push(this.adapter.getRowIdAtIndex(rowIndex));\n    }\n\n    return rowIds;\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(\n        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   * Handles sort action on sortable header cell.\n   */\n  handleSortAction(eventData: SortActionEventData) {\n    const {columnId, columnIndex, headerCell} = eventData;\n\n    // Reset sort attributes / classes on other header cells.\n    for (let index = 0; index < this.adapter.getHeaderCellCount(); index++) {\n      if (index === columnIndex) {\n        continue;\n      }\n\n      this.adapter.removeClassNameByHeaderCellIndex(\n          index, cssClasses.HEADER_CELL_SORTED);\n      this.adapter.removeClassNameByHeaderCellIndex(\n          index, cssClasses.HEADER_CELL_SORTED_DESCENDING);\n      this.adapter.setAttributeByHeaderCellIndex(\n          index, attributes.ARIA_SORT, SortValue.NONE);\n      this.adapter.setSortStatusLabelByHeaderCellIndex(index, SortValue.NONE);\n    }\n\n    // Set appropriate sort attributes / classes on target header cell.\n    this.adapter.setClassNameByHeaderCellIndex(\n        columnIndex, cssClasses.HEADER_CELL_SORTED);\n\n    const currentSortValue = this.adapter.getAttributeByHeaderCellIndex(\n        columnIndex, attributes.ARIA_SORT);\n    let sortValue = SortValue.NONE;\n\n    // Set to descending if sorted on ascending order.\n    if (currentSortValue === SortValue.ASCENDING) {\n      this.adapter.setClassNameByHeaderCellIndex(\n          columnIndex, cssClasses.HEADER_CELL_SORTED_DESCENDING);\n      this.adapter.setAttributeByHeaderCellIndex(\n          columnIndex, attributes.ARIA_SORT, SortValue.DESCENDING);\n      sortValue = SortValue.DESCENDING;\n      // Set to ascending if sorted on descending order.\n    } else if (currentSortValue === SortValue.DESCENDING) {\n      this.adapter.removeClassNameByHeaderCellIndex(\n          columnIndex, cssClasses.HEADER_CELL_SORTED_DESCENDING);\n      this.adapter.setAttributeByHeaderCellIndex(\n          columnIndex, attributes.ARIA_SORT, SortValue.ASCENDING);\n      sortValue = SortValue.ASCENDING;\n    } else {\n      // Set to ascending by default when not sorted.\n      this.adapter.setAttributeByHeaderCellIndex(\n          columnIndex, attributes.ARIA_SORT, SortValue.ASCENDING);\n      sortValue = SortValue.ASCENDING;\n    }\n\n    this.adapter.setSortStatusLabelByHeaderCellIndex(columnIndex, sortValue);\n\n    this.adapter.notifySortAction({\n      columnId,\n      columnIndex,\n      headerCell,\n      sortValue,\n    });\n  }\n\n  /**\n   * Handles data table row click event.\n   */\n  handleRowClick({rowId, row, altKey, ctrlKey, metaKey, shiftKey}:\n                     RowClickEventData) {\n    this.adapter.notifyRowClick({\n      rowId,\n      row,\n      altKey,\n      ctrlKey,\n      metaKey,\n      shiftKey,\n    });\n  }\n\n  /**\n   * Shows progress indicator blocking only the table body content when in\n   * loading state.\n   */\n  showProgress() {\n    const tableHeaderHeight = this.adapter.getTableHeaderHeight();\n    // Calculate the height of table content (Not scroll content) excluding\n    // header row height.\n    const height = this.adapter.getTableContainerHeight() - tableHeaderHeight;\n    const top = tableHeaderHeight;\n\n    this.adapter.setProgressIndicatorStyles({\n      height: `${height}px`,\n      top: `${top}px`,\n    });\n    this.adapter.addClass(cssClasses.IN_PROGRESS);\n  }\n\n  /**\n   * Hides progress indicator when data table is finished loading.\n   */\n  hideProgress() {\n    this.adapter.removeClass(cssClasses.IN_PROGRESS);\n  }\n\n  /**\n   * Updates header row checkbox state based on number of rows selected.\n   */\n  private setHeaderRowCheckboxState() {\n    if (this.adapter.getSelectedRowCount() === 0) {\n      this.adapter.setHeaderRowCheckboxChecked(false);\n      this.adapter.setHeaderRowCheckboxIndeterminate(false);\n    } else if (\n        this.adapter.getSelectedRowCount() === this.adapter.getRowCount()) {\n      this.adapter.setHeaderRowCheckboxChecked(true);\n      this.adapter.setHeaderRowCheckboxIndeterminate(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(\n          rowIndex, attributes.ARIA_SELECTED, 'true');\n    } else {\n      this.adapter.removeClassAtRowIndex(rowIndex, cssClasses.ROW_SELECTED);\n      this.adapter.setAttributeAtRowIndex(\n          rowIndex, attributes.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 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 {SortValue} from './constants';\n\nexport interface MDCDataTableRowSelectionChangedEventDetail {\n  rowIndex: number;\n  rowId: string|null;\n  selected: boolean;\n}\n\n/**\n * Event data required for sort action callback - `handleSortAction()`.\n * Component must send this data to foundation when sort action triggered on\n * sortable header cell.\n */\nexport interface SortActionEventData {\n  columnId: string|null;\n  columnIndex: number;\n  headerCell: HTMLElement;\n}\n\n/**\n * Event detail triggered by foundation on sort action. This event detail is\n * used to trigger DOM event by component.\n */\nexport interface SortActionEventDetail {\n  columnId: string|null;\n  columnIndex: number;\n  headerCell: HTMLElement;\n  sortValue: SortValue;\n}\n\n/**\n * Event data used for data table row click action.\n */\nexport interface RowClickEventData {\n  rowId: string|null;\n  row: HTMLElement;\n  altKey: boolean;\n  ctrlKey: boolean;\n  metaKey: boolean;\n  shiftKey: boolean;\n}\n\n/** Event details used for data table row click action. */\nexport interface RowClickEventDetail extends RowClickEventData {}\n\n/**\n * Styles used to dynamically set dimensions of progress indicator based on\n * table header & body.\n */\nexport interface ProgressIndicatorStyles {\n  height: string;\n  top: string;\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 {EventType, SpecificEventListener, SpecificWindowEventListener, WindowEventType} from '@material/base/types';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCDialogAdapter {\n  addClass(className: string): void;\n  removeClass(className: string): void;\n  hasClass(className: string): boolean;\n  addBodyClass(className: string): void;\n  removeBodyClass(className: string): void;\n  eventTargetMatches(target: EventTarget|null, selector: string): boolean;\n\n  isContentScrollable(): boolean;\n  areButtonsStacked(): boolean;\n  getActionFromEvent(event: Event): string|null;\n\n  trapFocus(focusElement: HTMLElement|null): void;\n  releaseFocus(): void;\n  // Element to focus on after dialog has opened.\n  getInitialFocusEl(): HTMLElement|null;\n  clickDefaultButton(): void;\n  reverseButtons(): void;\n\n  notifyOpening(): void;\n  notifyOpened(): void;\n  notifyClosing(action: string): void;\n  notifyClosed(action: string): void;\n\n  /**\n   * Registers an event listener on the dialog's content element (indicated\n   * with the 'mdc-dialog__content' class).\n   */\n  registerContentEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener on the dialog's content element.\n   */\n  deregisterContentEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * @return true if the content has been scrolled (that is, for\n   *     scrollable content, if it is at the \"top\"). This is used in full-screen\n   *     dialogs, where the scroll divider is expected only to appear once the\n   *     content has been scrolled \"underneath\" the header bar.\n   */\n  isScrollableContentAtTop(): boolean;\n\n  /**\n   * @return true if the content has been scrolled all\n   *     the way to the bottom. This is used in full-screen dialogs, where the\n   *     footer scroll divider is expected only to appear when the content is\n   *     \"cut-off\" by the footer bar.\n   */\n  isScrollableContentAtBottom(): boolean;\n\n  /**\n   * Registers an event listener to the window.\n   */\n  registerWindowEventHandler<K extends WindowEventType>(\n      eventType: K, handler: SpecificWindowEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener to the window.\n   */\n  deregisterWindowEventHandler<K extends WindowEventType>(\n      eventType: K, handler: SpecificWindowEventListener<K>): void;\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 {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {FocusTrap} from '@material/dom/focus-trap';\nimport {closest, matches} from '@material/dom/ponyfill';\nimport {MDCRipple} from '@material/ripple/component';\n\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\n/** MDC Dialog */\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 override attachTo(root: HTMLElement) {\n    return new MDCDialog(root);\n  }\n\n  private buttonRipples!: MDCRipple[];             // assigned in initialize()\n  private buttons!: HTMLButtonElement[];           // assigned in initialize()\n  private container!: HTMLElement;                 // assigned in initialize()\n  private content!: HTMLElement|null;              // assigned in initialize()\n  private defaultButton!: HTMLButtonElement|null;  // assigned in initialize()\n\n  private focusTrap!: FocusTrap;  // assigned in initialSyncWithDOM()\n  private focusTrapFactory!:\n      MDCDialogFocusTrapFactory;  // assigned in initialize()\n\n  private handleClick!:\n      SpecificEventListener<'click'>;  // assigned in initialSyncWithDOM()\n  private handleKeydown!:\n      SpecificEventListener<'keydown'>;  // assigned in initialSyncWithDOM()\n  private handleDocumentKeydown!:\n      SpecificEventListener<'keydown'>;   // assigned in initialSyncWithDOM()\n  private handleOpening!: EventListener;  // assigned in initialSyncWithDOM()\n  private handleClosing!: () => void;     // assigned in initialSyncWithDOM()\n\n  override initialize(\n      focusTrapFactory: MDCDialogFocusTrapFactory = (el, focusOptions) =>\n          new FocusTrap(el, focusOptions),\n  ) {\n    const container =\n        this.root.querySelector<HTMLElement>(strings.CONTAINER_SELECTOR);\n    if (!container) {\n      throw new Error(`Dialog component requires a ${\n          strings.CONTAINER_SELECTOR} container element`);\n    }\n    this.container = container;\n    this.content =\n        this.root.querySelector<HTMLElement>(strings.CONTENT_SELECTOR);\n    this.buttons = Array.from(\n        this.root.querySelectorAll<HTMLButtonElement>(strings.BUTTON_SELECTOR));\n    this.defaultButton = this.root.querySelector<HTMLButtonElement>(\n        `[${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  override initialSyncWithDOM() {\n    this.focusTrap = util.createFocusTrapInstance(\n        this.container, this.focusTrapFactory,\n        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 =\n        this.foundation.handleDocumentKeydown.bind(this.foundation);\n    // this.handleLayout = this.layout.bind(this);\n\n    this.handleOpening = () => {\n      document.addEventListener('keydown', this.handleDocumentKeydown);\n    };\n    this.handleClosing = () => {\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  override 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) => {\n      ripple.destroy();\n    });\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  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCDialogAdapter = {\n      addBodyClass: (className) => {\n        document.body.classList.add(className);\n      },\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      areButtonsStacked: () => util.areTopsMisaligned(this.buttons),\n      clickDefaultButton: () => {\n        if (this.defaultButton && !this.defaultButton.disabled) {\n          this.defaultButton.click();\n        }\n      },\n      eventTargetMatches: (target, selector) =>\n          target ? matches(target as Element, selector) : false,\n      getActionFromEvent: (event: Event) => {\n        if (!event.target) {\n          return '';\n        }\n        const element =\n            closest(event.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) => {\n        this.emit<MDCDialogCloseEventDetail>(\n            strings.CLOSED_EVENT, action ? {action} : {});\n      },\n      notifyClosing: (action) => {\n        this.emit<MDCDialogCloseEventDetail>(\n            strings.CLOSING_EVENT, action ? {action} : {});\n      },\n      notifyOpened: () => {\n        this.emit(strings.OPENED_EVENT, {});\n      },\n      notifyOpening: () => {\n        this.emit(strings.OPENING_EVENT, {});\n      },\n      releaseFocus: () => {\n        this.focusTrap.releaseFocus();\n      },\n      removeBodyClass: (className) => {\n        document.body.classList.remove(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      reverseButtons: () => {\n        this.buttons.reverse();\n        this.buttons.forEach((button) => {\n          button.parentElement!.appendChild(button);\n        });\n      },\n      trapFocus: () => {\n        this.focusTrap.trapFocus();\n      },\n      registerContentEventHandler: (event, handler) => {\n        if (this.content instanceof HTMLElement) {\n          this.content.addEventListener(event, handler);\n        }\n      },\n      deregisterContentEventHandler: (event, handler) => {\n        if (this.content instanceof HTMLElement) {\n          this.content.removeEventListener(event, handler);\n        }\n      },\n      isScrollableContentAtTop: () => {\n        return util.isScrollAtTop(this.content);\n      },\n      isScrollableContentAtBottom: () => {\n        return util.isScrollAtBottom(this.content);\n      },\n      registerWindowEventHandler: (event, handler) => {\n        window.addEventListener(event, handler);\n      },\n      deregisterWindowEventHandler: (event, handler) => {\n        window.removeEventListener(event, handler);\n      },\n    };\n    return new MDCDialogFoundation(adapter);\n  }\n\n  private getInitialFocusEl(): HTMLElement|null {\n    return this.root.querySelector<HTMLElement>(\n        `[${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  FULLSCREEN: 'mdc-dialog--fullscreen',\n  // Class for showing a scroll divider on full-screen dialog header element.\n  // Should only be displayed on scrollable content, when the dialog content is\n  // scrolled \"underneath\" the header.\n  SCROLL_DIVIDER_HEADER: 'mdc-dialog-scroll-divider-header',\n  // Class for showing a scroll divider on a full-screen dialog footer element.\n  // Should only be displayed on scrolalble content, when the dialog content is\n  // obscured \"underneath\" the footer.\n  SCROLL_DIVIDER_FOOTER: 'mdc-dialog-scroll-divider-footer',\n  // The \"surface scrim\" is a scrim covering only the surface of a dialog. This\n  // is used in situations where a confirmation dialog is shown over an already\n  // opened full-screen dialog. On larger screen-sizes, the full-screen dialog\n  // is sized as a modal and so in these situations we display a \"surface scrim\"\n  // to prevent a \"double scrim\" (where the scrim from the secondary\n  // confirmation dialog would overlap with the scrim from the full-screen\n  // dialog).\n  SURFACE_SCRIM_SHOWN: 'mdc-dialog__surface-scrim--shown',\n  // \"Showing\" animating class for the surface-scrim.\n  SURFACE_SCRIM_SHOWING: 'mdc-dialog__surface-scrim--showing',\n  // \"Hiding\" animating class for the surface-scrim.\n  SURFACE_SCRIM_HIDING: 'mdc-dialog__surface-scrim--hiding',\n  // Class to hide a dialog's scrim (used in conjunction with a surface-scrim).\n  // Note that we only hide the original scrim rather than removing it entirely\n  // to prevent interactions with the content behind this scrim, and to capture\n  // scrim clicks.\n  SCRIM_HIDDEN: 'mdc-dialog__scrim--hidden',\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    '.mdc-menu .mdc-deprecated-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 {AnimationFrame} from '@material/animation/animationframe';\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener, SpecificWindowEventListener} from '@material/base/types';\n\nimport {MDCDialogAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\nimport {DialogConfigOptions} from './types';\n\nenum AnimationKeys {\n  POLL_SCROLL_POS = 'poll_scroll_position',\n  POLL_LAYOUT_CHANGE = 'poll_layout_change'\n}\n\n/** MDC Dialog Foundation */\nexport class MDCDialogFoundation extends MDCFoundation<MDCDialogAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override get numbers() {\n    return numbers;\n  }\n\n  static override 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      registerContentEventHandler: () => undefined,\n      deregisterContentEventHandler: () => undefined,\n      isScrollableContentAtTop: () => false,\n      isScrollableContentAtBottom: () => false,\n      registerWindowEventHandler: () => undefined,\n      deregisterWindowEventHandler: () => undefined,\n    };\n  }\n\n  private dialogOpen = false;\n  private isFullscreen = false;\n  private animationFrame = 0;\n  private animationTimer = 0;\n  private escapeKeyAction = strings.CLOSE_ACTION;\n  private scrimClickAction = strings.CLOSE_ACTION;\n  private autoStackButtons = true;\n  private areButtonsStacked = false;\n  private suppressDefaultPressSelector =\n      strings.SUPPRESS_DEFAULT_PRESS_SELECTOR;\n  private readonly contentScrollHandler: SpecificEventListener<'scroll'>;\n  private readonly animFrame: AnimationFrame;\n  private readonly windowResizeHandler: SpecificWindowEventListener<'resize'>;\n  private readonly windowOrientationChangeHandler:\n      SpecificWindowEventListener<'orientationchange'>;\n\n  constructor(adapter?: Partial<MDCDialogAdapter>) {\n    super({...MDCDialogFoundation.defaultAdapter, ...adapter});\n\n    this.animFrame = new AnimationFrame();\n    this.contentScrollHandler = () => {\n      this.handleScrollEvent();\n    };\n\n    this.windowResizeHandler = () => {\n      this.layout();\n    };\n\n    this.windowOrientationChangeHandler = () => {\n      this.layout();\n    };\n  }\n\n  override init() {\n    if (this.adapter.hasClass(cssClasses.STACKED)) {\n      this.setAutoStackButtons(false);\n    }\n    this.isFullscreen = this.adapter.hasClass(cssClasses.FULLSCREEN);\n  }\n\n  override destroy() {\n    if (this.animationTimer) {\n      clearTimeout(this.animationTimer);\n      this.handleAnimationTimerEnd();\n    }\n\n    if (this.isFullscreen) {\n      this.adapter.deregisterContentEventHandler(\n          'scroll', this.contentScrollHandler);\n    }\n\n    this.animFrame.cancelAll();\n    this.adapter.deregisterWindowEventHandler(\n        'resize', this.windowResizeHandler);\n    this.adapter.deregisterWindowEventHandler(\n        'orientationchange', this.windowOrientationChangeHandler);\n  }\n\n  open(dialogOptions?: DialogConfigOptions) {\n    this.dialogOpen = true;\n    this.adapter.notifyOpening();\n    this.adapter.addClass(cssClasses.OPENING);\n    if (this.isFullscreen) {\n      // A scroll event listener is registered even if the dialog is not\n      // scrollable on open, since the window resize event, or orientation\n      // change may make the dialog scrollable after it is opened.\n      this.adapter.registerContentEventHandler(\n          'scroll', this.contentScrollHandler);\n    }\n    if (dialogOptions && dialogOptions.isAboveFullscreenDialog) {\n      this.adapter.addClass(cssClasses.SCRIM_HIDDEN);\n    }\n\n    this.adapter.registerWindowEventHandler('resize', this.windowResizeHandler);\n    this.adapter.registerWindowEventHandler(\n        'orientationchange', this.windowOrientationChangeHandler);\n\n    // Wait a frame once display is no longer \"none\", to establish basis for\n    // animation\n    this.runNextAnimationFrame(() => {\n      this.adapter.addClass(cssClasses.OPEN);\n      if (!dialogOptions || !dialogOptions.isScrimless) {\n        this.adapter.addBodyClass(cssClasses.SCROLL_LOCK);\n      }\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.dialogOpen) {\n      // Avoid redundant close calls (and events), e.g. from keydown on elements\n      // that inherently emit click\n      return;\n    }\n\n    this.dialogOpen = 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    if (this.isFullscreen) {\n      this.adapter.deregisterContentEventHandler(\n          'scroll', this.contentScrollHandler);\n    }\n    this.adapter.deregisterWindowEventHandler(\n        'resize', this.windowResizeHandler);\n    this.adapter.deregisterWindowEventHandler(\n        'orientationchange', this.windowOrientationChangeHandler);\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  /**\n   * Used only in instances of showing a secondary dialog over a full-screen\n   * dialog. Shows the \"surface scrim\" displayed over the full-screen dialog.\n   */\n  showSurfaceScrim() {\n    this.adapter.addClass(cssClasses.SURFACE_SCRIM_SHOWING);\n    this.runNextAnimationFrame(() => {\n      this.adapter.addClass(cssClasses.SURFACE_SCRIM_SHOWN);\n    });\n  }\n\n  /**\n   * Used only in instances of showing a secondary dialog over a full-screen\n   * dialog. Hides the \"surface scrim\" displayed over the full-screen dialog.\n   */\n  hideSurfaceScrim() {\n    this.adapter.removeClass(cssClasses.SURFACE_SCRIM_SHOWN);\n    this.adapter.addClass(cssClasses.SURFACE_SCRIM_HIDING);\n  }\n\n  /**\n   * Handles `transitionend` event triggered when surface scrim animation is\n   * finished.\n   */\n  handleSurfaceScrimTransitionEnd() {\n    this.adapter.removeClass(cssClasses.SURFACE_SCRIM_HIDING);\n    this.adapter.removeClass(cssClasses.SURFACE_SCRIM_SHOWING);\n  }\n\n  isOpen() {\n    return this.dialogOpen;\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  getSuppressDefaultPressSelector(): string {\n    return this.suppressDefaultPressSelector;\n  }\n\n  setSuppressDefaultPressSelector(selector: string) {\n    this.suppressDefaultPressSelector = selector;\n  }\n\n  layout() {\n    this.animFrame.request(AnimationKeys.POLL_LAYOUT_CHANGE, () => {\n      this.layoutInternal();\n    });\n  }\n\n  /** Handles click on the dialog root element. */\n  handleClick(event: MouseEvent) {\n    const isScrim =\n        this.adapter.eventTargetMatches(event.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(event);\n      if (action) {\n        this.close(action);\n      }\n    }\n  }\n\n  /** Handles keydown on the dialog root element. */\n  handleKeydown(event: KeyboardEvent) {\n    const isEnter = event.key === 'Enter' || event.keyCode === 13;\n    if (!isEnter) {\n      return;\n    }\n    const action = this.adapter.getActionFromEvent(event);\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    // `composedPath` is used here, when available, to account for use cases\n    // where a target meant to suppress the default press behaviour\n    // may exist in a shadow root.\n    // For example, a textarea inside a web component:\n    // <mwc-dialog>\n    //   <horizontal-layout>\n    //     #shadow-root (open)\n    //       <mwc-textarea>\n    //         #shadow-root (open)\n    //           <textarea></textarea>\n    //       </mwc-textarea>\n    //   </horizontal-layout>\n    // </mwc-dialog>\n    const target = event.composedPath ? event.composedPath()[0] : event.target;\n    const isDefault = this.suppressDefaultPressSelector ?\n        !this.adapter.eventTargetMatches(\n            target, this.suppressDefaultPressSelector) :\n        true;\n    if (isEnter && isDefault) {\n      this.adapter.clickDefaultButton();\n    }\n  }\n\n  /** Handles keydown on the document. */\n  handleDocumentKeydown(event: KeyboardEvent) {\n    const isEscape = event.key === 'Escape' || event.keyCode === 27;\n    if (isEscape && this.escapeKeyAction !== '') {\n      this.close(this.escapeKeyAction);\n    }\n  }\n\n  /**\n   * Handles scroll event on the dialog's content element -- showing a scroll\n   * divider on the header or footer based on the scroll position. This handler\n   * should only be registered on full-screen dialogs with scrollable content.\n   */\n  private handleScrollEvent() {\n    // Since scroll events can fire at a high rate, we throttle these events by\n    // using requestAnimationFrame.\n    this.animFrame.request(AnimationKeys.POLL_SCROLL_POS, () => {\n      this.toggleScrollDividerHeader();\n      this.toggleScrollDividerFooter();\n    });\n  }\n\n  private layoutInternal() {\n    if (this.autoStackButtons) {\n      this.detectStackedButtons();\n    }\n    this.toggleScrollableClasses();\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\n   * 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 toggleScrollableClasses() {\n    // Remove the class first to let us measure the natural height of the\n    // content.\n    this.adapter.removeClass(cssClasses.SCROLLABLE);\n    if (this.adapter.isContentScrollable()) {\n      this.adapter.addClass(cssClasses.SCROLLABLE);\n\n      if (this.isFullscreen) {\n        // If dialog is full-screen and scrollable, check if a scroll divider\n        // should be shown.\n        this.toggleScrollDividerHeader();\n        this.toggleScrollDividerFooter();\n      }\n    }\n  }\n\n  private toggleScrollDividerHeader() {\n    if (!this.adapter.isScrollableContentAtTop()) {\n      this.adapter.addClass(cssClasses.SCROLL_DIVIDER_HEADER);\n    } else if (this.adapter.hasClass(cssClasses.SCROLL_DIVIDER_HEADER)) {\n      this.adapter.removeClass(cssClasses.SCROLL_DIVIDER_HEADER);\n    }\n  }\n\n  private toggleScrollDividerFooter() {\n    if (!this.adapter.isScrollableContentAtBottom()) {\n      this.adapter.addClass(cssClasses.SCROLL_DIVIDER_FOOTER);\n    } else if (this.adapter.hasClass(cssClasses.SCROLL_DIVIDER_FOOTER)) {\n      this.adapter.removeClass(cssClasses.SCROLL_DIVIDER_FOOTER);\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","/**\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 interface MDCDialogCloseEventDetail {\n  action?: string;\n}\n\n// Note: CustomEvent<T> is not supported by Closure Compiler.\n\nexport interface MDCDialogCloseEvent extends Event {\n  readonly detail: MDCDialogCloseEventDetail;\n}\n\n\n/**\n * Options for how to configure the dialog.\n */\nexport interface DialogConfigOptions {\n  // Boolean indicating whether or not the dialog being opened is a confirmation\n  // dialog opened on top of a full-screen dialog (the only time multiple\n  // dialogs should be open on top of one another).\n  isAboveFullscreenDialog?: boolean;\n  // Boolean indicating whether or not the dialog blocks background document\n  // scrolling.\n  isScrimless?: boolean;\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 {FocusOptions, FocusTrap} from '@material/dom/focus-trap';\n\nexport type MDCDialogFocusTrapFactory = (\n    element: HTMLElement,\n    options: FocusOptions,\n    ) => FocusTrap;\n\nexport function createFocusTrapInstance(\n    surfaceEl: HTMLElement,\n    focusTrapFactory: MDCDialogFocusTrapFactory,\n    initialFocusEl?: HTMLElement,\n    ): FocusTrap {\n  return focusTrapFactory(surfaceEl, {initialFocusEl});\n}\n\nexport function isScrollable(el: HTMLElement|null): boolean {\n  return el ? el.scrollHeight > el.offsetHeight : false;\n}\n\n/**\n * For scrollable content, returns true if the content has not been scrolled\n * (that is, the scroll content is as the \"top\"). This is used in full-screen\n * dialogs, where the scroll divider is expected only to appear once the\n * content has been scrolled \"underneath\" the header bar.\n */\nexport function isScrollAtTop(el: HTMLElement|null) {\n  return el ? el.scrollTop === 0 : false;\n}\n\n/**\n * For scrollable content, returns true if the content has been scrolled all the\n * way to the bottom. This is used in full-screen dialogs, where the footer\n * scroll divider is expected only to appear when the content is \"cut-off\" by\n * the footer bar.\n */\nexport function isScrollAtBottom(el: HTMLElement|null) {\n  return el ? Math.ceil(el.scrollHeight - el.scrollTop) === el.clientHeight :\n              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 2020 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 * Priorities for the announce function.\n */\nexport enum AnnouncerPriority {\n  POLITE = 'polite',\n  ASSERTIVE = 'assertive',\n}\n\n/**\n * Options for the announce function.\n */\nexport interface AnnouncerMessageOptions {\n  priority?: AnnouncerPriority;\n  ownerDocument?: Document;\n}\n\n/**\n * Data attribute added to live region element.\n */\nexport const DATA_MDC_DOM_ANNOUNCE = 'data-mdc-dom-announce';\n\n/**\n * Announces the given message with optional priority, defaulting to \"polite\"\n */\nexport function announce(message: string, options?: AnnouncerMessageOptions) {\n  Announcer.getInstance().say(message, options);\n}\n\nclass Announcer {\n  private static instance: Announcer;\n  private readonly liveRegions: Map<Document, Map<AnnouncerPriority, Element>>;\n\n  static getInstance(): Announcer {\n    if (!Announcer.instance) {\n      Announcer.instance = new Announcer();\n    }\n\n    return Announcer.instance;\n  }\n\n  // Constructor made private to ensure only the singleton is used\n  private constructor() {\n    this.liveRegions = new Map();\n  }\n\n  say(message: string, options?: AnnouncerMessageOptions) {\n    const priority = options?.priority ?? AnnouncerPriority.POLITE;\n    const ownerDocument = options?.ownerDocument ?? document;\n    const liveRegion = this.getLiveRegion(priority, ownerDocument);\n    // Reset the region to pick up the message, even if the message is the\n    // exact same as before.\n    liveRegion.textContent = '';\n    // Timeout is necessary for screen readers like NVDA and VoiceOver.\n    setTimeout(() => {\n      liveRegion.textContent = message;\n      ownerDocument.addEventListener('click', clearLiveRegion);\n    }, 1);\n\n    function clearLiveRegion() {\n      liveRegion.textContent = '';\n      ownerDocument.removeEventListener('click', clearLiveRegion);\n    }\n  }\n\n  private getLiveRegion(priority: AnnouncerPriority, ownerDocument: Document):\n      Element {\n    let documentLiveRegions = this.liveRegions.get(ownerDocument);\n    if (!documentLiveRegions) {\n      documentLiveRegions = new Map();\n      this.liveRegions.set(ownerDocument, documentLiveRegions);\n    }\n\n    const existingLiveRegion = documentLiveRegions.get(priority);\n    if (existingLiveRegion && ownerDocument.body.contains(existingLiveRegion)) {\n      return existingLiveRegion;\n    }\n\n    const liveRegion = this.createLiveRegion(priority, ownerDocument);\n    documentLiveRegions.set(priority, liveRegion);\n    return liveRegion;\n  }\n\n  private createLiveRegion(\n      priority: AnnouncerPriority, ownerDocument: Document): HTMLDivElement {\n    const el = ownerDocument.createElement('div');\n    el.style.position = 'absolute';\n    el.style.top = '-9999px';\n    el.style.left = '-9999px';\n    el.style.height = '1px';\n    el.style.overflow = 'hidden';\n    el.setAttribute('aria-atomic', 'true');\n    el.setAttribute('aria-live', priority);\n    el.setAttribute(DATA_MDC_DOM_ANNOUNCE, 'true');\n    ownerDocument.body.appendChild(el);\n    return el;\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\n/**\n * Determine whether the current browser supports passive event listeners, and\n * if so, use them.\n */\nexport function applyPassive(globalObj: Window = window): boolean|\n    EventListenerOptions {\n  return supportsPassiveOption(globalObj) ?\n      {passive: true} as AddEventListenerOptions :\n      false;\n}\n\nfunction supportsPassiveOption(globalObj: Window = window): boolean {\n  // See\n  // https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener\n  let passiveSupported = false;\n\n  try {\n    const options = {\n      // This function will be called when the browser\n      // attempts to access the passive property.\n      get passive() {\n        passiveSupported = true;\n        return false;\n      }\n    };\n\n    const handler = () => {};\n    globalObj.document.addEventListener('test', handler, options);\n    globalObj.document.removeEventListener(\n        'test', handler, options as EventListenerOptions);\n  } catch (err) {\n    passiveSupported = false;\n  }\n\n  return passiveSupported;\n}\n","/**\n * @license\n * Copyright 2020 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 FOCUS_SENTINEL_CLASS = 'mdc-dom-focus-sentinel';\n\n/**\n * Utility to trap focus in a given root element, e.g. for modal components such\n * as dialogs. The root should have at least one focusable child element,\n * for setting initial focus when trapping focus.\n * Also tracks the previously focused element, and restores focus to that\n * element when releasing focus.\n */\nexport class FocusTrap {\n  // Previously focused element before trapping focus.\n  private elFocusedBeforeTrapFocus: HTMLElement|null = null;\n\n  constructor(\n      private readonly root: HTMLElement,\n      private readonly options: FocusOptions = {}) {}\n\n  /**\n   * Traps focus in `root`. Also focuses on either `initialFocusEl` if set;\n   * otherwises sets initial focus to the first focusable child element.\n   */\n  trapFocus() {\n    const focusableEls = this.getFocusableElements(this.root);\n    if (focusableEls.length === 0) {\n      throw new Error(\n          'FocusTrap: Element must have at least one focusable child.');\n    }\n\n    this.elFocusedBeforeTrapFocus =\n        document.activeElement instanceof HTMLElement ? document.activeElement :\n                                                        null;\n    this.wrapTabFocus(this.root);\n\n    if (!this.options.skipInitialFocus) {\n      this.focusInitialElement(focusableEls, this.options.initialFocusEl);\n    }\n  }\n\n  /**\n   * Releases focus from `root`. Also restores focus to the previously focused\n   * element.\n   */\n  releaseFocus() {\n    Array\n        .from(\n            this.root.querySelectorAll<HTMLElement>(`.${FOCUS_SENTINEL_CLASS}`))\n        .forEach((sentinelEl: HTMLElement) => {\n          sentinelEl.parentElement!.removeChild(sentinelEl);\n        });\n\n    if (!this.options.skipRestoreFocus && this.elFocusedBeforeTrapFocus) {\n      this.elFocusedBeforeTrapFocus.focus();\n    }\n  }\n\n  /**\n   * Wraps tab focus within `el` by adding two hidden sentinel divs which are\n   * used to mark the beginning and the end of the tabbable region. When\n   * focused, these sentinel elements redirect focus to the first/last\n   * children elements of the tabbable region, ensuring that focus is trapped\n   * within that region.\n   */\n  private wrapTabFocus(el: HTMLElement) {\n    const sentinelStart = this.createSentinel();\n    const sentinelEnd = this.createSentinel();\n\n    sentinelStart.addEventListener('focus', () => {\n      const focusableEls = this.getFocusableElements(el);\n      if (focusableEls.length > 0) {\n        focusableEls[focusableEls.length - 1].focus();\n      }\n    });\n    sentinelEnd.addEventListener('focus', () => {\n      const focusableEls = this.getFocusableElements(el);\n      if (focusableEls.length > 0) {\n        focusableEls[0].focus();\n      }\n    });\n\n    el.insertBefore(sentinelStart, el.children[0]);\n    el.appendChild(sentinelEnd);\n  }\n\n  /**\n   * Focuses on `initialFocusEl` if defined and a child of the root element.\n   * Otherwise, focuses on the first focusable child element of the root.\n   */\n  private focusInitialElement(\n      focusableEls: HTMLElement[], initialFocusEl?: HTMLElement) {\n    let focusIndex = 0;\n    if (initialFocusEl) {\n      focusIndex = Math.max(focusableEls.indexOf(initialFocusEl), 0);\n    }\n    focusableEls[focusIndex].focus();\n  }\n\n  private getFocusableElements(root: HTMLElement): HTMLElement[] {\n    const focusableEls = Array.from(root.querySelectorAll<HTMLElement>(\n        '[autofocus], [tabindex], a, input, textarea, select, button'));\n    return focusableEls.filter((el) => {\n      const isDisabledOrHidden = el.getAttribute('aria-disabled') === 'true' ||\n          el.getAttribute('disabled') != null ||\n          el.getAttribute('hidden') != null ||\n          el.getAttribute('aria-hidden') === 'true';\n      const isTabbableAndVisible = el.tabIndex >= 0 &&\n          el.getBoundingClientRect().width > 0 &&\n          !el.classList.contains(FOCUS_SENTINEL_CLASS) && !isDisabledOrHidden;\n\n      let isProgrammaticallyHidden = false;\n      if (isTabbableAndVisible) {\n        const style = getComputedStyle(el);\n        isProgrammaticallyHidden =\n            style.display === 'none' || style.visibility === 'hidden';\n      }\n      return isTabbableAndVisible && !isProgrammaticallyHidden;\n    });\n  }\n\n  private createSentinel() {\n    const sentinel = document.createElement('div');\n    sentinel.setAttribute('tabindex', '0');\n    // Don't announce in screen readers.\n    sentinel.setAttribute('aria-hidden', 'true');\n    sentinel.classList.add(FOCUS_SENTINEL_CLASS);\n    return sentinel;\n  }\n}\n\n/** Customization options. */\nexport interface FocusOptions {\n  // The element to focus initially when trapping focus.\n  //  Must be a child of the root element.\n  initialFocusEl?: HTMLElement;\n\n  // Whether to skip initially focusing on any element when trapping focus.\n  // By default, focus is set on the first focusable child element of the root.\n  // This is useful if the caller wants to handle setting initial focus.\n  skipInitialFocus?: boolean;\n\n  // Whether to restore focus on the previously focused element when releasing\n  // focus. This is useful if the caller wants to handle restoring focus.\n  skipRestoreFocus?: boolean;\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 focusTrap from './focus-trap';\nimport * as keyboard from './keyboard';\nimport * as ponyfill from './ponyfill';\n\nexport {events, focusTrap, keyboard, ponyfill};\n","/**\n * @license\n * Copyright 2020 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 * KEY provides normalized string values for keys.\n */\nexport const KEY = {\n  UNKNOWN: 'Unknown',\n  BACKSPACE: 'Backspace',\n  ENTER: 'Enter',\n  SPACEBAR: 'Spacebar',\n  PAGE_UP: 'PageUp',\n  PAGE_DOWN: 'PageDown',\n  END: 'End',\n  HOME: 'Home',\n  ARROW_LEFT: 'ArrowLeft',\n  ARROW_UP: 'ArrowUp',\n  ARROW_RIGHT: 'ArrowRight',\n  ARROW_DOWN: 'ArrowDown',\n  DELETE: 'Delete',\n  ESCAPE: 'Escape',\n  TAB: 'Tab',\n};\n\nconst normalizedKeys = new Set<string>();\n// IE11 has no support for new Map with iterable so we need to initialize this\n// by hand.\nnormalizedKeys.add(KEY.BACKSPACE);\nnormalizedKeys.add(KEY.ENTER);\nnormalizedKeys.add(KEY.SPACEBAR);\nnormalizedKeys.add(KEY.PAGE_UP);\nnormalizedKeys.add(KEY.PAGE_DOWN);\nnormalizedKeys.add(KEY.END);\nnormalizedKeys.add(KEY.HOME);\nnormalizedKeys.add(KEY.ARROW_LEFT);\nnormalizedKeys.add(KEY.ARROW_UP);\nnormalizedKeys.add(KEY.ARROW_RIGHT);\nnormalizedKeys.add(KEY.ARROW_DOWN);\nnormalizedKeys.add(KEY.DELETE);\nnormalizedKeys.add(KEY.ESCAPE);\nnormalizedKeys.add(KEY.TAB);\n\nconst KEY_CODE = {\n  BACKSPACE: 8,\n  ENTER: 13,\n  SPACEBAR: 32,\n  PAGE_UP: 33,\n  PAGE_DOWN: 34,\n  END: 35,\n  HOME: 36,\n  ARROW_LEFT: 37,\n  ARROW_UP: 38,\n  ARROW_RIGHT: 39,\n  ARROW_DOWN: 40,\n  DELETE: 46,\n  ESCAPE: 27,\n  TAB: 9,\n};\n\nconst mappedKeyCodes = new Map<number, string>();\n// IE11 has no support for new Map with iterable so we need to initialize this\n// by hand.\nmappedKeyCodes.set(KEY_CODE.BACKSPACE, KEY.BACKSPACE);\nmappedKeyCodes.set(KEY_CODE.ENTER, KEY.ENTER);\nmappedKeyCodes.set(KEY_CODE.SPACEBAR, KEY.SPACEBAR);\nmappedKeyCodes.set(KEY_CODE.PAGE_UP, KEY.PAGE_UP);\nmappedKeyCodes.set(KEY_CODE.PAGE_DOWN, KEY.PAGE_DOWN);\nmappedKeyCodes.set(KEY_CODE.END, KEY.END);\nmappedKeyCodes.set(KEY_CODE.HOME, KEY.HOME);\nmappedKeyCodes.set(KEY_CODE.ARROW_LEFT, KEY.ARROW_LEFT);\nmappedKeyCodes.set(KEY_CODE.ARROW_UP, KEY.ARROW_UP);\nmappedKeyCodes.set(KEY_CODE.ARROW_RIGHT, KEY.ARROW_RIGHT);\nmappedKeyCodes.set(KEY_CODE.ARROW_DOWN, KEY.ARROW_DOWN);\nmappedKeyCodes.set(KEY_CODE.DELETE, KEY.DELETE);\nmappedKeyCodes.set(KEY_CODE.ESCAPE, KEY.ESCAPE);\nmappedKeyCodes.set(KEY_CODE.TAB, KEY.TAB);\n\nconst navigationKeys = new Set<string>();\n// IE11 has no support for new Set with iterable so we need to initialize this\n// by hand.\nnavigationKeys.add(KEY.PAGE_UP);\nnavigationKeys.add(KEY.PAGE_DOWN);\nnavigationKeys.add(KEY.END);\nnavigationKeys.add(KEY.HOME);\nnavigationKeys.add(KEY.ARROW_LEFT);\nnavigationKeys.add(KEY.ARROW_UP);\nnavigationKeys.add(KEY.ARROW_RIGHT);\nnavigationKeys.add(KEY.ARROW_DOWN);\n\n/**\n * normalizeKey returns the normalized string for a navigational action.\n */\nexport function normalizeKey(event: KeyboardEvent): string {\n  const {key} = event;\n  // If the event already has a normalized key, return it\n  if (normalizedKeys.has(key)) {\n    return key;\n  }\n\n  // tslint:disable-next-line:deprecation\n  const mappedKey = mappedKeyCodes.get(event.keyCode);\n  if (mappedKey) {\n    return mappedKey;\n  }\n  return KEY.UNKNOWN;\n}\n\n/**\n * isNavigationEvent returns whether the event is a navigation event\n */\nexport function isNavigationEvent(event: KeyboardEvent): boolean {\n  return navigationKeys.has(normalizeKey(event));\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/**\n * @fileoverview A \"ponyfill\" is a polyfill that doesn't modify the global\n * prototype chain. This makes ponyfills safer than traditional polyfills,\n * 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\n/** Element.matches with support for webkit and IE. */\nexport function matches(element: Element, selector: string): boolean {\n  const nativeMatches = element.matches || element.webkitMatchesSelector ||\n      (element as any).msMatchesSelector;\n  return nativeMatches.call(element, selector);\n}\n\n/**\n * Used to compute the estimated scroll width of elements. When an element is\n * hidden due to display: none; being applied to a parent element, the width is\n * returned as 0. However, the element will have a true width once no longer\n * inside a display: none context. This method computes an estimated width when\n * the element is hidden or returns the true width when the element is visble.\n * @param {Element} element the element whose width to estimate\n */\nexport function estimateScrollWidth(element: Element): number {\n  // Check the offsetParent. If the element inherits display: none from any\n  // parent, the offsetParent property will be null (see\n  // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetParent).\n  // This check ensures we only clone the node when necessary.\n  const htmlEl = element as HTMLElement;\n  if (htmlEl.offsetParent !== null) {\n    return htmlEl.scrollWidth;\n  }\n\n  const clone = htmlEl.cloneNode(true) as HTMLElement;\n  clone.style.setProperty('position', 'absolute');\n  clone.style.setProperty('transform', 'translate(-9999px, -9999px)');\n  document.documentElement.appendChild(clone);\n  const scrollWidth = clone.scrollWidth;\n  document.documentElement.removeChild(clone);\n  return scrollWidth;\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/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCDrawerAdapter {\n  /**\n   * Adds a class to the root Element.\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes a class from the root Element.\n   */\n  removeClass(className: string): void;\n\n  /**\n   * Returns true if the root Element contains the given class.\n   */\n  hasClass(className: string): boolean;\n\n  /**\n   * Returns true if the element contains the given class.\n   * @param element target element to verify class name\n   * @param className class name\n   */\n  elementHasClass(element: Element, className: string): boolean;\n\n  /**\n   * Saves the focus of currently active element.\n   */\n  saveFocus(): void;\n\n  /**\n   * Restores focus to element previously saved with 'saveFocus'.\n   */\n  restoreFocus(): void;\n\n  /**\n   * Focuses the active / selected navigation item.\n   */\n  focusActiveNavigationItem(): void;\n\n  /**\n   * Emits a custom event \"MDCDrawer:closed\" denoting the drawer has closed.\n   */\n  notifyClose(): void;\n\n  /**\n   * Emits a custom event \"MDCDrawer:opened\" denoting the drawer has opened.\n   */\n  notifyOpen(): void;\n\n  /**\n   * Traps focus on root element and focuses the active navigation element.\n   */\n  trapFocus(): void;\n\n  /**\n   * Releases focus trap from root element which was set by `trapFocus`\n   * and restores focus to where it was prior to calling `trapFocus`.\n   */\n  releaseFocus(): void;\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 {FocusTrap} from '@material/dom/focus-trap';\nimport {MDCList, MDCListFactory} from '@material/list/component';\n\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 override attachTo(root: HTMLElement): 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 innerList?: MDCList;       // assigned in initialize()\n\n  private focusTrap?: FocusTrap;  // assigned in initialSyncWithDOM()\n  private focusTrapFactory!:\n      MDCDrawerFocusTrapFactory;  // assigned in initialize()\n\n  private handleScrimClick?:\n      SpecificEventListener<'click'>;  // initialized in initialSyncWithDOM()\n  private handleKeydown!:\n      SpecificEventListener<'keydown'>;  // initialized in initialSyncWithDOM()\n  private handleTransitionEnd!:\n      SpecificEventListener<'transitionend'>;  // initialized in\n                                               // initialSyncWithDOM()\n\n  get list(): MDCList|undefined {\n    return this.innerList;\n  }\n\n  override initialize(\n      focusTrapFactory: MDCDrawerFocusTrapFactory = (el) => new FocusTrap(el),\n      listFactory: MDCListFactory = (el) => new MDCList(el),\n  ) {\n    const listEl = this.root.querySelector<HTMLElement>(strings.LIST_SELECTOR);\n    if (listEl) {\n      this.innerList = listFactory(listEl);\n      this.innerList.wrapFocus = true;\n    }\n    this.focusTrapFactory = focusTrapFactory;\n  }\n\n  override initialSyncWithDOM() {\n    const {MODAL} = cssClasses;\n    const {SCRIM_SELECTOR} = strings;\n\n    this.scrim = (this.root.parentNode as Element)\n                     .querySelector<HTMLElement>(SCRIM_SELECTOR);\n\n    if (this.scrim && this.root.classList.contains(MODAL)) {\n      this.handleScrimClick = () => {\n        (this.foundation as MDCModalDrawerFoundation).handleScrimClick();\n      };\n      this.scrim.addEventListener('click', this.handleScrimClick);\n      this.focusTrap =\n          util.createFocusTrapInstance(this.root, this.focusTrapFactory);\n    }\n\n    this.handleKeydown = (event) => {\n      this.foundation.handleKeydown(event);\n    };\n    this.handleTransitionEnd = (event) => {\n      this.foundation.handleTransitionEnd(event);\n    };\n    this.listen('keydown', this.handleKeydown);\n    this.listen('transitionend', this.handleTransitionEnd);\n  }\n\n  override destroy() {\n    this.unlisten('keydown', this.handleKeydown);\n    this.unlisten('transitionend', this.handleTransitionEnd);\n\n    if (this.innerList) {\n      this.innerList.destroy();\n    }\n\n    const {MODAL} = cssClasses;\n    if (this.scrim && this.handleScrimClick &&\n        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  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      hasClass: (className) => this.root.classList.contains(className),\n      elementHasClass: (element, className) =>\n          element.classList.contains(className),\n      saveFocus: () => {\n        this.previousFocus = document.activeElement;\n      },\n      restoreFocus: () => {\n        const previousFocus = this.previousFocus as HTMLOrSVGElement | null;\n        if (previousFocus && previousFocus.focus &&\n            this.root.contains(document.activeElement)) {\n          previousFocus.focus();\n        }\n      },\n      focusActiveNavigationItem: () => {\n        const activeNavItemEl = this.root.querySelector<HTMLElement>(\n            strings.LIST_ITEM_ACTIVATED_SELECTOR);\n        if (activeNavItemEl) {\n          activeNavItemEl.focus();\n        }\n      },\n      notifyClose: () => {\n        this.emit(strings.CLOSE_EVENT, {}, true /* shouldBubble */);\n      },\n      notifyOpen: () => {\n        this.emit(strings.OPEN_EVENT, {}, true /* shouldBubble */);\n      },\n      trapFocus: () => {\n        this.focusTrap!.trapFocus();\n      },\n      releaseFocus: () => {\n        this.focusTrap!.releaseFocus();\n      },\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 ${\n              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  LIST_SELECTOR: '.mdc-list,.mdc-deprecated-list',\n  LIST_ITEM_ACTIVATED_SELECTOR:\n      '.mdc-list-item--activated,.mdc-deprecated-list-item--activated',\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';\n\nimport {MDCDrawerAdapter} from '../adapter';\nimport {cssClasses, strings} from '../constants';\n\n/** MDC Dismissible Drawer Foundation */\nexport class MDCDismissibleDrawerFoundation extends\n    MDCFoundation<MDCDrawerAdapter> {\n  static override get strings() {\n    return strings;\n  }\n\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override 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  override 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\n    // 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) ||\n        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(event: KeyboardEvent) {\n    const {keyCode, key} = event;\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(event: TransitionEvent) {\n    const {OPENING, CLOSING, OPEN, ANIMATE, ROOT} = cssClasses;\n\n    // In Edge, transitionend on ripple pseudo-elements yields a target without\n    // classList, so check for Element first.\n    const isRootElement = this.isElement(event.target) &&\n        this.adapter.elementHasClass(event.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\n   * 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\n    // 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 override opened() {\n    this.adapter.trapFocus();\n  }\n\n  /**\n   * Called when drawer finishes close animation.\n   */\n  protected override 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","/**\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 {FocusOptions, FocusTrap} from '@material/dom/focus-trap';\n\n/** MDC Drawer Focus Trap Factory */\nexport type MDCDrawerFocusTrapFactory = (\n    element: HTMLElement,\n    options: FocusOptions,\n    ) => FocusTrap;\n\nexport function createFocusTrapInstance(\n    surfaceEl: HTMLElement,\n    focusTrapFactory: MDCDrawerFocusTrapFactory,\n    ): FocusTrap {\n  return focusTrapFactory(surfaceEl, {\n    // Component handles focusing on active nav item.\n    skipInitialFocus: true,\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\nimport {EventType, SpecificEventListener} from '@material/base/types';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCFloatingLabelAdapter {\n  /**\n   * Adds a class to the label element.\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes a class from the label element.\n   */\n  removeClass(className: string): void;\n\n  /**\n   * Checks if the label element has the given class.\n   */\n  hasClass(className: string): boolean;\n\n  /**\n   * Returns the width of the label element.\n   */\n  getWidth(): number;\n\n  /**\n   * Registers an event listener on the root element for a given event.\n   */\n  registerInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener on the root element for a given event.\n   */\n  deregisterInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\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 {estimateScrollWidth} from '@material/dom/ponyfill';\n\nimport {MDCFloatingLabelAdapter} from './adapter';\nimport {MDCFloatingLabelFoundation} from './foundation';\n\n/** MDC Floating Label Factory */\nexport type MDCFloatingLabelFactory =\n    (el: HTMLElement, foundation?: MDCFloatingLabelFoundation) =>\n        MDCFloatingLabel;\n\n/** MDC Floating Label */\nexport class MDCFloatingLabel extends MDCComponent<MDCFloatingLabelFoundation> {\n  static override attachTo(root: HTMLElement): 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;\n   *     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;\n   *     otherwise, docks it by removing the class.\n   */\n  float(shouldFloat: boolean) {\n    this.foundation.float(shouldFloat);\n  }\n\n  /**\n   * Styles the label as required.\n   * @param isRequired If true, adds an asterisk to the label, indicating that\n   *     it is required.\n   */\n  setRequired(isRequired: boolean) {\n    this.foundation.setRequired(isRequired);\n  }\n\n  getWidth(): number {\n    return this.foundation.getWidth();\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      hasClass: (className) => this.root.classList.contains(className),\n      getWidth: () => estimateScrollWidth(this.root),\n      registerInteractionHandler: (eventType, handler) => {\n        this.listen(eventType, handler);\n      },\n      deregisterInteractionHandler: (eventType, handler) => {\n        this.unlisten(eventType, handler);\n      },\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_REQUIRED: 'mdc-floating-label--required',\n  LABEL_HIDE_REQUIRED_MARKER: 'mdc-floating-label--hide-required-marker',\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';\n\nimport {MDCFloatingLabelAdapter} from './adapter';\nimport {cssClasses} from './constants';\n\n/** MDC Floating Label Foundation */\nexport class MDCFloatingLabelFoundation extends\n    MDCFoundation<MDCFloatingLabelAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  /**\n   * See {@link MDCFloatingLabelAdapter} for typing information on parameters\n   * and return types.\n   */\n  static override 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      hasClass: () => false,\n      getWidth: () => 0,\n      registerInteractionHandler: () => undefined,\n      deregisterInteractionHandler: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private readonly shakeAnimationEndHandler:\n      SpecificEventListener<'animationend'>;\n\n  constructor(adapter?: Partial<MDCFloatingLabelAdapter>) {\n    super({...MDCFloatingLabelFoundation.defaultAdapter, ...adapter});\n\n    this.shakeAnimationEndHandler = () => {\n      this.handleShakeAnimationEnd();\n    };\n  }\n\n  override init() {\n    this.adapter.registerInteractionHandler(\n        'animationend', this.shakeAnimationEndHandler);\n  }\n\n  override destroy() {\n    this.adapter.deregisterInteractionHandler(\n        '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\n   *     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\n   *     float and shake classes to dock the label.\n   */\n  float(shouldFloat: boolean) {\n    const {LABEL_FLOAT_ABOVE, LABEL_SHAKE} =\n        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  /**\n   * Styles the label as required.\n   * @param isRequired If true, adds an asterisk to the label, indicating that\n   *     it is required.\n   */\n  setRequired(isRequired: boolean) {\n    const {LABEL_REQUIRED} = MDCFloatingLabelFoundation.cssClasses;\n    if (isRequired) {\n      this.adapter.addClass(LABEL_REQUIRED);\n    } else {\n      this.adapter.removeClass(LABEL_REQUIRED);\n    }\n  }\n\n  setHideRequiredMarker(hideRequiredMarker: boolean) {\n    const {LABEL_HIDE_REQUIRED_MARKER} = MDCFloatingLabelFoundation.cssClasses;\n    if (hideRequiredMarker) {\n      this.adapter.addClass(LABEL_HIDE_REQUIRED_MARKER);\n    } else {\n      this.adapter.removeClass(LABEL_HIDE_REQUIRED_MARKER);\n    }\n  }\n\n  getHideRequiredMarker(): boolean {\n    const {LABEL_HIDE_REQUIRED_MARKER} = MDCFloatingLabelFoundation.cssClasses;\n    return this.adapter.hasClass(LABEL_HIDE_REQUIRED_MARKER);\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 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 {EventType, SpecificEventListener} from '@material/base/types';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCFormFieldAdapter {\n  activateInputRipple(): void;\n  deactivateInputRipple(): void;\n  deregisterInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n  registerInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\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 {MDCComponent} from '@material/base/component';\nimport {MDCRipple} from '@material/ripple/component';\n\nimport {MDCFormFieldAdapter} from './adapter';\nimport {MDCFormFieldFoundation} from './foundation';\n\n/** MDC Form Field Input */\nexport interface MDCFormFieldInput {\n  readonly ripple: MDCRipple|undefined;\n}\n\n/** MDC Form Field */\nexport class MDCFormField extends MDCComponent<MDCFormFieldFoundation> {\n  static override attachTo(root: HTMLElement) {\n    return new MDCFormField(root);\n  }\n\n  input?: MDCFormFieldInput;\n\n  private labelEl() {\n    const {LABEL_SELECTOR} = MDCFormFieldFoundation.strings;\n    return this.root.querySelector<HTMLElement>(LABEL_SELECTOR);\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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: (eventType, handler) => {\n        this.labelEl()?.removeEventListener(eventType, handler);\n      },\n      registerInteractionHandler: (eventType, handler) => {\n        this.labelEl()?.addEventListener(eventType, handler);\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';\n\nimport {MDCFormFieldAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\n/** MDC Form Field Foundation */\nexport class MDCFormFieldFoundation extends MDCFoundation<MDCFormFieldAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override get defaultAdapter(): MDCFormFieldAdapter {\n    return {\n      activateInputRipple: () => undefined,\n      deactivateInputRipple: () => undefined,\n      deregisterInteractionHandler: () => undefined,\n      registerInteractionHandler: () => undefined,\n    };\n  }\n\n  private readonly click: () => void;\n\n  constructor(adapter?: Partial<MDCFormFieldAdapter>) {\n    super({...MDCFormFieldFoundation.defaultAdapter, ...adapter});\n\n    this.click = () => {\n      this.handleClick();\n    };\n  }\n\n  override init() {\n    this.adapter.registerInteractionHandler('click', this.click);\n  }\n\n  override destroy() {\n    this.adapter.deregisterInteractionHandler('click', this.click);\n  }\n\n  private handleClick() {\n    this.adapter.activateInputRipple();\n    requestAnimationFrame(() => {\n      this.adapter.deactivateInputRipple();\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 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 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 {MDCIconButtonToggleEventDetail} from './types';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCIconButtonToggleAdapter {\n  addClass(className: string): void;\n\n  removeClass(className: string): void;\n\n  hasClass(className: string): boolean;\n\n  /** Returns the given attribute value on the root element. */\n  getAttr(attrName: string): string|null;\n\n  setAttr(attrName: string, attrValue: string): void;\n\n  notifyChange(eventData: MDCIconButtonToggleEventDetail): void;\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} from '@material/ripple/component';\n\nimport {MDCIconButtonToggleAdapter} from './adapter';\nimport {MDCIconButtonToggleFoundation} from './foundation';\nimport {MDCIconButtonToggleEventDetail} from './types';\n\nconst {strings} = MDCIconButtonToggleFoundation;\n\n/** MDC Icon Button Toggle */\nexport class MDCIconButtonToggle extends\n    MDCComponent<MDCIconButtonToggleFoundation> {\n  static override attachTo(root: HTMLElement) {\n    return new MDCIconButtonToggle(root);\n  }\n\n  private readonly rippleComponent: MDCRipple = this.createRipple();\n  private handleClick!:\n      SpecificEventListener<'click'>;  // assigned in initialSyncWithDOM()\n\n  override initialSyncWithDOM() {\n    this.handleClick = () => {\n      this.foundation.handleClick();\n    };\n    this.listen('click', this.handleClick);\n  }\n\n  override destroy() {\n    this.unlisten('click', this.handleClick);\n    this.ripple.destroy();\n    super.destroy();\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCIconButtonToggleAdapter = {\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      hasClass: (className) => this.root.classList.contains(className),\n      notifyChange: (eventData) => {\n        this.emit<MDCIconButtonToggleEventDetail>(\n            strings.CHANGE_EVENT, eventData);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      getAttr: (attrName) => this.root.getAttribute(attrName),\n      setAttr: (attrName, attrValue) => {\n        this.safeSetAttribute(this.root, attrName, attrValue);\n      },\n    };\n    return new MDCIconButtonToggleFoundation(adapter);\n  }\n\n  get ripple(): MDCRipple {\n    return this.rippleComponent;\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_LABEL: 'aria-label',\n  ARIA_PRESSED: 'aria-pressed',\n  DATA_ARIA_LABEL_OFF: 'data-aria-label-off',\n  DATA_ARIA_LABEL_ON: 'data-aria-label-on',\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';\n\nimport {MDCIconButtonToggleAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\n/** MDC Icon Button Toggle Foundation */\nexport class MDCIconButtonToggleFoundation extends\n    MDCFoundation<MDCIconButtonToggleAdapter> {\n  /**\n   * Whether the icon button has an aria-label that changes depending on\n   * toggled state.\n   */\n  private hasToggledAriaLabel = false;\n\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override get defaultAdapter(): MDCIconButtonToggleAdapter {\n    return {\n      addClass: () => undefined,\n      hasClass: () => false,\n      notifyChange: () => undefined,\n      removeClass: () => undefined,\n      getAttr: () => null,\n      setAttr: () => undefined,\n    };\n  }\n\n  constructor(adapter?: Partial<MDCIconButtonToggleAdapter>) {\n    super({...MDCIconButtonToggleFoundation.defaultAdapter, ...adapter});\n  }\n\n  override init() {\n    const ariaLabelOn = this.adapter.getAttr(strings.DATA_ARIA_LABEL_ON);\n    const ariaLabelOff = this.adapter.getAttr(strings.DATA_ARIA_LABEL_OFF);\n    if (ariaLabelOn && ariaLabelOff) {\n      if (this.adapter.getAttr(strings.ARIA_PRESSED) !== null) {\n        throw new Error(\n            'MDCIconButtonToggleFoundation: Button should not set ' +\n            '`aria-pressed` if it has a toggled ARIA label.');\n      }\n\n      this.hasToggledAriaLabel = true;\n    } else {\n      this.adapter.setAttr(strings.ARIA_PRESSED, String(this.isOn()));\n    }\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    // Toggle UI based on state.\n    if (isOn) {\n      this.adapter.addClass(cssClasses.ICON_BUTTON_ON);\n    } else {\n      this.adapter.removeClass(cssClasses.ICON_BUTTON_ON);\n    }\n\n    // Toggle aria attributes based on state.\n    if (this.hasToggledAriaLabel) {\n      const ariaLabel = isOn ?\n          this.adapter.getAttr(strings.DATA_ARIA_LABEL_ON) :\n          this.adapter.getAttr(strings.DATA_ARIA_LABEL_OFF);\n      this.adapter.setAttr(strings.ARIA_LABEL, ariaLabel || '');\n    } else {\n      this.adapter.setAttr(strings.ARIA_PRESSED, `${isOn}`);\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 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 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 interface MDCIconButtonToggleEventDetail {\n  isOn: boolean;\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 {EventType, SpecificEventListener} from '@material/base/types';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCLineRippleAdapter {\n  /**\n   * Adds a class to the line ripple element.\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes a class from the line ripple element.\n   */\n  removeClass(className: string): void;\n\n  hasClass(className: string): boolean;\n\n  /**\n   * Sets the style property with propertyName to value on the root element.\n   */\n  setStyle(propertyName: string, value: string): void;\n\n  /**\n   * Registers an event listener on the line ripple element for a given event.\n   */\n  registerEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener on the line ripple element for a given event.\n   */\n  deregisterEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\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';\n\nimport {MDCLineRippleAdapter} from './adapter';\nimport {MDCLineRippleFoundation} from './foundation';\n\n/** MDC Line Ripple Factory */\nexport type MDCLineRippleFactory =\n    (el: HTMLElement, foundation?: MDCLineRippleFoundation) => MDCLineRipple;\n\n/** MDC Line Ripple */\nexport class MDCLineRipple extends MDCComponent<MDCLineRippleFoundation> {\n  static override attachTo(root: HTMLElement): 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  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      hasClass: (className) => this.root.classList.contains(className),\n      setStyle: (propertyName, value) => {\n        this.root.style.setProperty(propertyName, value);\n      },\n      registerEventHandler: (eventType, handler) => {\n        this.listen(eventType, handler);\n      },\n      deregisterEventHandler: (eventType, handler) => {\n        this.unlisten(eventType, handler);\n      },\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';\n\nimport {MDCLineRippleAdapter} from './adapter';\nimport {cssClasses} from './constants';\n\n/** MDC Line Ripple Foundation */\nexport class MDCLineRippleFoundation extends\n    MDCFoundation<MDCLineRippleAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  /**\n   * See {@link MDCLineRippleAdapter} for typing information on parameters and\n   * return types.\n   */\n  static override 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 = (event) => {\n      this.handleTransitionEnd(event);\n    };\n  }\n\n  override init() {\n    this.adapter.registerEventHandler(\n        'transitionend', this.transitionEndHandler);\n  }\n\n  override destroy() {\n    this.adapter.deregisterEventHandler(\n        '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(event: TransitionEvent) {\n    // Wait for the line ripple to be either transparent or opaque\n    // before emitting the animation end event\n    const isDeactivating =\n        this.adapter.hasClass(cssClasses.LINE_RIPPLE_DEACTIVATING);\n\n    if (event.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 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 * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\n\nimport {MDCResizeObserver, MDCResizeObserverCallback} from './types';\n\nexport interface MDCLinearProgressAdapter {\n  addClass(className: string): void;\n  /**\n   * If available, creates a `ResizeObserver` object, invokes the `#observe`\n   * method on the root element. This is used for an optional performance gains\n   * for the indeterminate animation on modern browsers.\n   *\n   * @param callback The callback to apply to the constructor of the\n   *    `ResizeObserver`\n   * @return Returns a `ResizeObserver` that has had `observe` called on the\n   *    root element with the given callback. `null` if `ResizeObserver` is not\n   *    implemented or polyfilled.\n   */\n  attachResizeObserver(callback: MDCResizeObserverCallback): MDCResizeObserver\n      |null;\n  forceLayout(): void;\n  setBufferBarStyle(styleProperty: string, value: string): void;\n  setPrimaryBarStyle(styleProperty: string, value: string): void;\n  /**\n   * Sets the inline style on the root element.\n   * @param styleProperty The style property to set.\n   * @param value The value the style property should be set to.\n   */\n  setStyle(styleProperty: string, value: string): void;\n  /**\n   * @return The width of the root element.\n   */\n  getWidth(): number;\n  hasClass(className: string): boolean;\n  removeClass(className: string): void;\n  removeAttribute(name: string): void;\n  setAttribute(name: string, value: string): void;\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 {MDCComponent} from '@material/base/component';\nimport {MDCProgressIndicator} from '@material/progress-indicator/component';\n\nimport {MDCLinearProgressAdapter} from './adapter';\nimport {MDCLinearProgressFoundation} from './foundation';\nimport {WithMDCResizeObserver} from './types';\n\n/** MDC Linear Progress */\nexport class MDCLinearProgress extends\n    MDCComponent<MDCLinearProgressFoundation> implements MDCProgressIndicator {\n  static override attachTo(root: HTMLElement) {\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  open() {\n    this.foundation.open();\n  }\n\n  close() {\n    this.foundation.close();\n  }\n\n  override initialSyncWithDOM() {\n    this.root.addEventListener('transitionend', () => {\n      this.foundation.handleTransitionEnd();\n    });\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCLinearProgressAdapter = {\n      addClass: (className: string) => {\n        this.root.classList.add(className);\n      },\n      forceLayout: () => {\n        this.root.getBoundingClientRect();\n      },\n      setBufferBarStyle: (styleProperty: string, value: string) => {\n        const bufferBar = this.root.querySelector<HTMLElement>(\n            MDCLinearProgressFoundation.strings.BUFFER_BAR_SELECTOR);\n        if (bufferBar) {\n          bufferBar.style.setProperty(styleProperty, value);\n        }\n      },\n      setPrimaryBarStyle: (styleProperty: string, value: string) => {\n        const primaryBar = this.root.querySelector<HTMLElement>(\n            MDCLinearProgressFoundation.strings.PRIMARY_BAR_SELECTOR);\n        if (primaryBar) {\n          primaryBar.style.setProperty(styleProperty, value);\n        }\n      },\n      hasClass: (className: string) => this.root.classList.contains(className),\n      removeAttribute: (attributeName: string) => {\n        this.root.removeAttribute(attributeName);\n      },\n      removeClass: (className: string) => {\n        this.root.classList.remove(className);\n      },\n      setAttribute: (attributeName: string, value: string) => {\n        this.safeSetAttribute(this.root, attributeName, value);\n      },\n      setStyle: (name: string, value: string) => {\n        this.root.style.setProperty(name, value);\n      },\n      attachResizeObserver: (callback) => {\n        const RO = (window as unknown as WithMDCResizeObserver).ResizeObserver;\n        if (RO) {\n          const ro = new RO(callback);\n          ro.observe(this.root);\n          return ro;\n        }\n\n        return null;\n      },\n      getWidth: () => this.root.offsetWidth,\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  CLOSED_ANIMATION_OFF_CLASS: 'mdc-linear-progress--closed-animation-off',\n  INDETERMINATE_CLASS: 'mdc-linear-progress--indeterminate',\n  REVERSED_CLASS: 'mdc-linear-progress--reversed',\n  ANIMATION_READY_CLASS: 'mdc-linear-progress--animation-ready',\n};\n\nexport const strings = {\n  ARIA_HIDDEN: 'aria-hidden',\n  ARIA_VALUEMAX: 'aria-valuemax',\n  ARIA_VALUEMIN: 'aria-valuemin',\n  ARIA_VALUENOW: 'aria-valuenow',\n  BUFFER_BAR_SELECTOR: '.mdc-linear-progress__buffer-bar',\n  FLEX_BASIS: 'flex-basis',\n  PRIMARY_BAR_SELECTOR: '.mdc-linear-progress__primary-bar',\n};\n\n// these are percentages pulled from keyframes.scss\nexport const animationDimensionPercentages = {\n  PRIMARY_HALF: .8367142,\n  PRIMARY_FULL: 2.00611057,\n  SECONDARY_QUARTER: .37651913,\n  SECONDARY_HALF: .84386165,\n  SECONDARY_FULL: 1.60277782,\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 {MDCProgressIndicatorFoundation} from '@material/progress-indicator/foundation';\n\nimport {MDCLinearProgressAdapter} from './adapter';\nimport {animationDimensionPercentages as percents, cssClasses, strings} from './constants';\nimport {MDCResizeObserver} from './types';\n\nexport class MDCLinearProgressFoundation extends\n    MDCFoundation<MDCLinearProgressAdapter> implements\n        MDCProgressIndicatorFoundation {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override get defaultAdapter(): MDCLinearProgressAdapter {\n    return {\n      addClass: () => undefined,\n      attachResizeObserver: () => null,\n      forceLayout: () => undefined,\n      getWidth: () => 0,\n      hasClass: () => false,\n      setBufferBarStyle: () => null,\n      setPrimaryBarStyle: () => null,\n      setStyle: () => undefined,\n      removeAttribute: () => undefined,\n      removeClass: () => undefined,\n      setAttribute: () => undefined,\n    };\n  }\n\n  private determinate!: boolean;\n  private progress!: number;\n  private buffer!: number;\n  private observer: MDCResizeObserver|null = null;\n\n  constructor(adapter?: Partial<MDCLinearProgressAdapter>) {\n    super({...MDCLinearProgressFoundation.defaultAdapter, ...adapter});\n  }\n\n  override init() {\n    this.determinate = !this.adapter.hasClass(cssClasses.INDETERMINATE_CLASS);\n    this.adapter.addClass(cssClasses.ANIMATION_READY_CLASS);\n    this.progress = 0;\n    this.buffer = 1;\n\n    this.observer = this.adapter.attachResizeObserver((entries) => {\n      if (this.determinate) {\n        return;\n      }\n\n      for (const entry of entries) {\n        if (entry.contentRect) {\n          this.calculateAndSetDimensions(entry.contentRect.width);\n        }\n      }\n    });\n\n    if (!this.determinate && this.observer) {\n      this.calculateAndSetDimensions(this.adapter.getWidth());\n    }\n  }\n\n  setDeterminate(isDeterminate: boolean) {\n    this.determinate = isDeterminate;\n\n    if (this.determinate) {\n      this.adapter.removeClass(cssClasses.INDETERMINATE_CLASS);\n      this.adapter.setAttribute(\n          strings.ARIA_VALUENOW, this.progress.toString());\n      this.adapter.setAttribute(strings.ARIA_VALUEMAX, '1');\n      this.adapter.setAttribute(strings.ARIA_VALUEMIN, '0');\n      this.setPrimaryBarProgress(this.progress);\n      this.setBufferBarProgress(this.buffer);\n\n      return;\n    }\n\n    if (this.observer) {\n      this.calculateAndSetDimensions(this.adapter.getWidth());\n    }\n\n    this.adapter.addClass(cssClasses.INDETERMINATE_CLASS);\n    this.adapter.removeAttribute(strings.ARIA_VALUENOW);\n    this.adapter.removeAttribute(strings.ARIA_VALUEMAX);\n    this.adapter.removeAttribute(strings.ARIA_VALUEMIN);\n    this.setPrimaryBarProgress(1);\n    this.setBufferBarProgress(1);\n  }\n\n  isDeterminate() {\n    return this.determinate;\n  }\n\n  setProgress(value: number) {\n    this.progress = value;\n    if (this.determinate) {\n      this.setPrimaryBarProgress(value);\n      this.adapter.setAttribute(strings.ARIA_VALUENOW, value.toString());\n    }\n  }\n\n  getProgress() {\n    return this.progress;\n  }\n\n  setBuffer(value: number) {\n    this.buffer = value;\n    if (this.determinate) {\n      this.setBufferBarProgress(value);\n    }\n  }\n\n  getBuffer() {\n    return this.buffer;\n  }\n\n  open() {\n    this.adapter.removeClass(cssClasses.CLOSED_CLASS);\n    this.adapter.removeClass(cssClasses.CLOSED_ANIMATION_OFF_CLASS);\n    this.adapter.removeAttribute(strings.ARIA_HIDDEN);\n  }\n\n  close() {\n    this.adapter.addClass(cssClasses.CLOSED_CLASS);\n    this.adapter.setAttribute(strings.ARIA_HIDDEN, 'true');\n  }\n\n  isClosed() {\n    return this.adapter.hasClass(cssClasses.CLOSED_CLASS);\n  }\n\n  /**\n   * Handles the transitionend event emitted after `close()` is called and the\n   * opacity fades out. This is so that animations are removed only after the\n   * progress indicator is completely hidden.\n   */\n  handleTransitionEnd() {\n    if (this.adapter.hasClass(cssClasses.CLOSED_CLASS)) {\n      this.adapter.addClass(cssClasses.CLOSED_ANIMATION_OFF_CLASS);\n    }\n  }\n\n  override destroy() {\n    super.destroy();\n\n    if (this.observer) {\n      this.observer.disconnect();\n    }\n  }\n\n  restartAnimation() {\n    this.adapter.removeClass(cssClasses.ANIMATION_READY_CLASS);\n    this.adapter.forceLayout();\n    this.adapter.addClass(cssClasses.ANIMATION_READY_CLASS);\n  }\n\n  private setPrimaryBarProgress(progressValue: number) {\n    const value = `scaleX(${progressValue})`;\n\n    // Accessing `window` without a `typeof` check will throw on Node\n    // environments.\n    const transformProp = typeof window !== 'undefined' ?\n        getCorrectPropertyName(window, 'transform') :\n        'transform';\n    this.adapter.setPrimaryBarStyle(transformProp, value);\n  }\n\n  private setBufferBarProgress(progressValue: number) {\n    const value = `${progressValue * 100}%`;\n    this.adapter.setBufferBarStyle(strings.FLEX_BASIS, value);\n  }\n\n  private calculateAndSetDimensions(width: number) {\n    const primaryHalf = width * percents.PRIMARY_HALF;\n    const primaryFull = width * percents.PRIMARY_FULL;\n    const secondaryQuarter = width * percents.SECONDARY_QUARTER;\n    const secondaryHalf = width * percents.SECONDARY_HALF;\n    const secondaryFull = width * percents.SECONDARY_FULL;\n\n    this.adapter.setStyle(\n        '--mdc-linear-progress-primary-half', `${primaryHalf}px`);\n    this.adapter.setStyle(\n        '--mdc-linear-progress-primary-half-neg', `${- primaryHalf}px`);\n    this.adapter.setStyle(\n        '--mdc-linear-progress-primary-full', `${primaryFull}px`);\n    this.adapter.setStyle(\n        '--mdc-linear-progress-primary-full-neg', `${- primaryFull}px`);\n    this.adapter.setStyle(\n        '--mdc-linear-progress-secondary-quarter', `${secondaryQuarter}px`);\n    this.adapter.setStyle(\n        '--mdc-linear-progress-secondary-quarter-neg',\n        `${- secondaryQuarter}px`);\n    this.adapter.setStyle(\n        '--mdc-linear-progress-secondary-half', `${secondaryHalf}px`);\n    this.adapter.setStyle(\n        '--mdc-linear-progress-secondary-half-neg', `${- secondaryHalf}px`);\n    this.adapter.setStyle(\n        '--mdc-linear-progress-secondary-full', `${secondaryFull}px`);\n    this.adapter.setStyle(\n        '--mdc-linear-progress-secondary-full-neg', `${- secondaryFull}px`);\n\n    // need to restart animation for custom props to apply to keyframes\n    this.restartAnimation();\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';\nexport * from './types';\n","/**\n * @license\n * Copyright 2021 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// Opt-in resize observer types\n\nexport interface MDCResizeObserverEntry {\n  contentRect: DOMRectReadOnly;\n}\n\nexport interface MDCResizeObserver {\n  new(callback: MDCResizeObserverCallback): MDCResizeObserver;\n  disconnect(): void;\n  observe(target: Element): void;\n}\n\nexport interface WithMDCResizeObserver {\n  ResizeObserver: MDCResizeObserver;\n}\n\nexport type MDCResizeObserverCallback =\n    (entries: MDCResizeObserverEntry[], observer: MDCResizeObserver) => void;\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 * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCListAdapter {\n  /**\n   * Returns the attribute value of list item at given `index`.\n   */\n  getAttributeForElementIndex(index: number, attr: string): string|null;\n\n  getListItemCount(): number;\n\n  getFocusedElementIndex(): number;\n\n  setAttributeForElementIndex(index: number, attribute: string, value: string):\n      void;\n\n  addClassForElementIndex(index: number, className: string): void;\n\n  removeClassForElementIndex(index: number, className: string): void;\n\n  /**\n   * Focuses list item at the index specified.\n   */\n  focusItemAtIndex(index: number): void;\n\n  /**\n   * Sets the tabindex to the value specified for all button/a element children\n   * of the list item at the index specified.\n   */\n  setTabIndexForListItemChildren(listItemIndex: number, tabIndexValue: string):\n      void;\n\n  /**\n   * @return true if radio button is present at given list item index.\n   */\n  hasRadioAtIndex(index: number): boolean;\n\n  /**\n   * @return true if checkbox is present at given list item index.\n   */\n  hasCheckboxAtIndex(index: number): boolean;\n\n  /**\n   * @return true if checkbox inside a list item is checked.\n   */\n  isCheckboxCheckedAtIndex(index: number): boolean;\n\n  /**\n   * @return true if root element is focused.\n   */\n  isRootFocused(): boolean;\n\n  /**\n   * @param index list item index.\n   * @param className the name of the class whose presence is to be checked.\n   * @return true if list item at `index` has class `className`.\n   */\n  listItemAtIndexHasClass(index: number, className: string): boolean;\n\n  /**\n   * Sets the checked status of checkbox or radio at given list item index.\n   */\n  setCheckedCheckboxOrRadioAtIndex(index: number, isChecked: boolean): void;\n\n  /**\n   * Notifies user action on list item.\n   */\n  notifyAction(index: number): void;\n\n  /**\n   * Notifies that items at the given indices have changed its\n   * selection state through user interaction (e.g. click).\n   *\n   * This is invoked only for changes caused by user interaction\n   * to match with the native `change` event semantics.\n   */\n  notifySelectionChange(changedIndices: number[]): void;\n\n  /**\n   * @return true when the current focused element is inside list root.\n   */\n  isFocusInsideList(): boolean;\n\n  /**\n   * @return the primary text content of the list item at index.\n   */\n  getPrimaryTextAtIndex(index: number): string;\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 {closest, matches} from '@material/dom/ponyfill';\n\nimport {MDCListAdapter} from './adapter';\nimport {cssClasses, deprecatedClassNameMap, evolutionAttribute, evolutionClassNameMap, numbers, strings} from './constants';\nimport {MDCListFoundation} from './foundation';\nimport {MDCListActionEventDetail, MDCListIndex, MDCListSelectionChangeDetail} from './types';\n\n/** MDC List Factory */\nexport type MDCListFactory =\n    (el: HTMLElement, foundation?: MDCListFoundation) => MDCList;\n\n/** MDC List */\nexport class MDCList extends MDCComponent<MDCListFoundation> {\n  set vertical(value: boolean) {\n    this.foundation.setVerticalOrientation(value);\n  }\n\n  get listElements() {\n    return Array.from(this.root.querySelectorAll<HTMLElement>(\n        `.${this.classNameMap[cssClasses.LIST_ITEM_CLASS]}`));\n  }\n\n  set wrapFocus(value: boolean) {\n    this.foundation.setWrapFocus(value);\n  }\n\n  /**\n   * @return Whether typeahead is currently matching a user-specified prefix.\n   */\n  get typeaheadInProgress(): boolean {\n    return this.foundation.isTypeaheadInProgress();\n  }\n\n  /**\n   * Sets whether typeahead functionality is enabled on the list.\n   * @param hasTypeahead Whether typeahead is enabled.\n   */\n  set hasTypeahead(hasTypeahead: boolean) {\n    this.foundation.setHasTypeahead(hasTypeahead);\n  }\n\n  set singleSelection(isSingleSelectionList: boolean) {\n    this.foundation.setSingleSelection(isSingleSelectionList);\n  }\n\n  set disabledItemsFocusable(areDisabledItemsFocusable: boolean) {\n    this.foundation.setDisabledItemsFocusable(areDisabledItemsFocusable);\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 override attachTo(root: HTMLElement) {\n    return new MDCList(root);\n  }\n\n  // The follow are assigned in initialSyncWithDOM().\n  private handleKeydown!: SpecificEventListener<'keydown'>;\n  private handleClick!: SpecificEventListener<'click'>;\n  private focusInEventListener!: SpecificEventListener<'focus'>;\n  private focusOutEventListener!: SpecificEventListener<'focus'>;\n\n  // This mapping provides a layer of indirection from legacy classes to\n  // evolution classes, since there are some inconsistencies between the\n  // two.\n  // TODO(b/176814973): remove this map when evolution is launched.\n  private classNameMap!: {[className: string]: string};\n  private isEvolutionEnabled!: boolean;\n  private isInteractive!: boolean;\n\n  override initialSyncWithDOM() {\n    this.isEvolutionEnabled = evolutionAttribute in this.root.dataset;\n\n    if (this.isEvolutionEnabled) {\n      this.classNameMap = evolutionClassNameMap;\n    } else if (matches(this.root, strings.DEPRECATED_SELECTOR)) {\n      this.classNameMap = deprecatedClassNameMap;\n    } else {\n      this.classNameMap =\n          Object.values(cssClasses)\n              .reduce((obj: {[className: string]: string}, className) => {\n                obj[className] = className;\n                return obj;\n              }, {});\n    }\n\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    this.ensureFocusable();\n  }\n\n  override 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    const itemSelector =\n        `.${this.classNameMap[cssClasses.LIST_ITEM_CLASS]}:not([tabindex])`;\n    const childSelector = strings.FOCUSABLE_CHILD_ELEMENTS;\n\n    // List items need to have at least tabindex=-1 to be focusable.\n    const itemEls = this.root.querySelectorAll<HTMLElement>(itemSelector);\n    if (itemEls.length) {\n      Array.prototype.forEach.call(itemEls, (el: Element) => {\n        el.setAttribute('tabindex', '-1');\n      });\n    }\n\n    // Child button/a elements are not tabbable until the list item is focused.\n    const focusableChildEls =\n        this.root.querySelectorAll<HTMLElement>(childSelector);\n    if (focusableChildEls.length) {\n      Array.prototype.forEach.call(focusableChildEls, (el: Element) => {\n        el.setAttribute('tabindex', '-1');\n      });\n    }\n\n    if (this.isEvolutionEnabled) {\n      this.foundation.setUseSelectedAttribute(true);\n    }\n    this.foundation.layout();\n  }\n\n  /**\n   * Extracts the primary text from a list item.\n   * @param item The list item element.\n   * @return The primary text in the element.\n   */\n  getPrimaryText(item: Element): string {\n    const primaryText = item.querySelector<HTMLElement>(\n        `.${this.classNameMap[cssClasses.LIST_ITEM_PRIMARY_TEXT_CLASS]}`);\n    if (this.isEvolutionEnabled || primaryText) {\n      return primaryText?.textContent ?? '';\n    }\n\n    const singleLineText = item.querySelector<HTMLElement>(\n        `.${this.classNameMap[cssClasses.LIST_ITEM_TEXT_CLASS]}`);\n    return (singleLineText && singleLineText.textContent) || '';\n  }\n\n  /**\n   * Initialize selectedIndex value based on pre-selected list items.\n   */\n  initializeListType() {\n    this.isInteractive =\n        matches(this.root, strings.ARIA_INTERACTIVE_ROLES_SELECTOR);\n\n    if (this.isEvolutionEnabled && this.isInteractive) {\n      const selection = Array.from(\n          this.root.querySelectorAll<HTMLElement>(\n              strings.SELECTED_ITEM_SELECTOR),\n          (listItem) => this.listElements.indexOf(listItem));\n\n      if (matches(this.root, strings.ARIA_MULTI_SELECTABLE_SELECTOR)) {\n        this.selectedIndex = selection;\n      } else if (selection.length > 0) {\n        this.selectedIndex = selection[0];\n      }\n      return;\n    }\n\n    const checkboxListItems = this.root.querySelectorAll<HTMLElement>(\n        strings.ARIA_ROLE_CHECKBOX_SELECTOR);\n    const radioSelectedListItem = this.root.querySelector<HTMLElement>(\n        strings.ARIA_CHECKED_RADIO_SELECTOR);\n\n    if (checkboxListItems.length) {\n      const preselectedItems = this.root.querySelectorAll<HTMLElement>(\n          strings.ARIA_CHECKED_CHECKBOX_SELECTOR);\n      this.selectedIndex = Array.from(\n          preselectedItems, (listItem) => this.listElements.indexOf(listItem));\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  /**\n   * Given the next desired character from the user, adds it to the typeahead\n   * buffer. Then, attempts to find the next option matching the buffer. Wraps\n   * around if at the end of options.\n   *\n   * @param nextChar The next character to add to the prefix buffer.\n   * @param startingIndex The index from which to start matching. Defaults to\n   *     the currently focused index.\n   * @return The index of the matched item.\n   */\n  typeaheadMatchItem(nextChar: string, startingIndex?: number): number {\n    return this.foundation.typeaheadMatchItem(\n        nextChar, startingIndex, /** skipFocus */ true);\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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(this.classNameMap[className]);\n        }\n      },\n      focusItemAtIndex: (index) => {\n        this.listElements[index]?.focus();\n      },\n      getAttributeForElementIndex: (index, attr) =>\n          this.listElements[index].getAttribute(attr),\n      getFocusedElementIndex: () =>\n          this.listElements.indexOf(document.activeElement as HTMLElement),\n      getListItemCount: () => this.listElements.length,\n      getPrimaryTextAtIndex: (index) =>\n          this.getPrimaryText(this.listElements[index]),\n      hasCheckboxAtIndex: (index) => {\n        const listItem = this.listElements[index];\n        return !!listItem.querySelector<HTMLElement>(strings.CHECKBOX_SELECTOR);\n      },\n      hasRadioAtIndex: (index) => {\n        const listItem = this.listElements[index];\n        return !!listItem.querySelector<HTMLElement>(strings.RADIO_SELECTOR);\n      },\n      isCheckboxCheckedAtIndex: (index) => {\n        const listItem = this.listElements[index];\n        const toggleEl =\n            listItem.querySelector<HTMLInputElement>(strings.CHECKBOX_SELECTOR);\n        return toggleEl!.checked;\n      },\n      isFocusInsideList: () => {\n        return this.root !== document.activeElement &&\n            this.root.contains(document.activeElement);\n      },\n      isRootFocused: () => document.activeElement === this.root,\n      listItemAtIndexHasClass: (index, className) =>\n          this.listElements[index].classList.contains(\n              this.classNameMap[className]),\n      notifyAction: (index) => {\n        this.emit<MDCListActionEventDetail>(\n            strings.ACTION_EVENT, {index}, /** shouldBubble */ true);\n      },\n      notifySelectionChange: (changedIndices: number[]) => {\n        this.emit<MDCListSelectionChangeDetail>(\n            strings.SELECTION_CHANGE_EVENT, {changedIndices},\n            /** shouldBubble */ true);\n      },\n      removeClassForElementIndex: (index, className) => {\n        const element = this.listElements[index];\n        if (element) {\n          element.classList.remove(this.classNameMap[className]);\n        }\n      },\n      setAttributeForElementIndex: (index, attr, value) => {\n        const element = this.listElements[index];\n        if (element) {\n          this.safeSetAttribute(element, attr, value);\n        }\n      },\n      setCheckedCheckboxOrRadioAtIndex: (index, isChecked) => {\n        const listItem = this.listElements[index];\n        const toggleEl = listItem.querySelector<HTMLInputElement>(\n            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 selector = strings.CHILD_ELEMENTS_TO_TOGGLE_TABINDEX;\n        Array.prototype.forEach.call(\n            element.querySelectorAll<HTMLElement>(selector),\n            (el: HTMLElement) => {\n              el.tabIndex = Number(tabIndexValue);\n            });\n      },\n    };\n    return new MDCListFoundation(adapter);\n  }\n\n  /**\n   * Ensures that at least one item is focusable if the list is interactive and\n   * doesn't specify a suitable tabindex.\n   */\n  private ensureFocusable() {\n    if (this.isEvolutionEnabled && this.isInteractive) {\n      if (!this.root.querySelector(`.${\n              this.classNameMap[cssClasses.LIST_ITEM_CLASS]}[tabindex=\"0\"]`)) {\n        const index = this.initialFocusIndex();\n        if (index !== -1) {\n          this.listElements[index].tabIndex = 0;\n        }\n      }\n    }\n  }\n\n  private initialFocusIndex(): number {\n    if (this.selectedIndex instanceof Array && this.selectedIndex.length > 0) {\n      return this.selectedIndex[0];\n    }\n    if (typeof this.selectedIndex === 'number' &&\n        this.selectedIndex !== numbers.UNSET_INDEX) {\n      return this.selectedIndex;\n    }\n    const el = this.root.querySelector<HTMLElement>(\n        `.${this.classNameMap[cssClasses.LIST_ITEM_CLASS]}:not(.${\n            this.classNameMap[cssClasses.LIST_ITEM_DISABLED_CLASS]})`);\n    if (el === null) {\n      return -1;\n    }\n    return this.getListItemIndex(el);\n  }\n\n  /**\n   * Used to figure out which list item this event is targeting. Or returns -1\n   * if there is no list item\n   */\n  private getListItemIndex(el: Element) {\n    const nearestParent = closest(\n        el,\n        `.${this.classNameMap[cssClasses.LIST_ITEM_CLASS]}, .${\n            this.classNameMap[cssClasses.ROOT]}`);\n\n    // Get the index of the element if it is a list item.\n    if (nearestParent &&\n        matches(\n            nearestParent,\n            `.${this.classNameMap[cssClasses.LIST_ITEM_CLASS]}`)) {\n      return this.listElements.indexOf(nearestParent as HTMLElement);\n    }\n\n    return -1;\n  }\n\n  /**\n   * Used to figure out which element was clicked before sending the event to\n   * the foundation.\n   */\n  private handleFocusInEvent(event: FocusEvent) {\n    const index = this.getListItemIndex(event.target as Element);\n    this.foundation.handleFocusIn(index);\n  }\n\n  /**\n   * Used to figure out which element was clicked before sending the event to\n   * the foundation.\n   */\n  private handleFocusOutEvent(event: FocusEvent) {\n    const index = this.getListItemIndex(event.target as Element);\n    this.foundation.handleFocusOut(index);\n  }\n\n  /**\n   * Used to figure out which element was focused when keydown event occurred\n   * before sending the event to the foundation.\n   */\n  private handleKeydownEvent(event: KeyboardEvent) {\n    const index = this.getListItemIndex(event.target as Element);\n    const target = event.target as Element;\n    this.foundation.handleKeydown(\n        event,\n        target.classList.contains(\n            this.classNameMap[cssClasses.LIST_ITEM_CLASS]),\n        index);\n  }\n\n  /**\n   * Used to figure out which element was clicked before sending the event to\n   * the foundation.\n   */\n  private handleClickEvent(event: MouseEvent) {\n    const index = this.getListItemIndex(event.target as Element);\n    const target = event.target as Element;\n    this.foundation.handleClick(\n        index, matches(target, strings.CHECKBOX_RADIO_SELECTOR), event);\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  LIST_ITEM_TEXT_CLASS: 'mdc-list-item__text',\n  LIST_ITEM_PRIMARY_TEXT_CLASS: 'mdc-list-item__primary-text',\n  ROOT: 'mdc-list',\n};\n\nconst evolutionClassNameMap = {\n  [`${cssClasses.LIST_ITEM_ACTIVATED_CLASS}`]: 'mdc-list-item--activated',\n  [`${cssClasses.LIST_ITEM_CLASS}`]: 'mdc-list-item',\n  [`${cssClasses.LIST_ITEM_DISABLED_CLASS}`]: 'mdc-list-item--disabled',\n  [`${cssClasses.LIST_ITEM_SELECTED_CLASS}`]: 'mdc-list-item--selected',\n  [`${cssClasses.LIST_ITEM_PRIMARY_TEXT_CLASS}`]: 'mdc-list-item__primary-text',\n  [`${cssClasses.ROOT}`]: 'mdc-list',\n};\n\nconst deprecatedClassNameMap = {\n  [`${cssClasses.LIST_ITEM_ACTIVATED_CLASS}`]:\n      'mdc-deprecated-list-item--activated',\n  [`${cssClasses.LIST_ITEM_CLASS}`]: 'mdc-deprecated-list-item',\n  [`${cssClasses.LIST_ITEM_DISABLED_CLASS}`]:\n      'mdc-deprecated-list-item--disabled',\n  [`${cssClasses.LIST_ITEM_SELECTED_CLASS}`]:\n      'mdc-deprecated-list-item--selected',\n  [`${cssClasses.LIST_ITEM_TEXT_CLASS}`]: 'mdc-deprecated-list-item__text',\n  [`${cssClasses.LIST_ITEM_PRIMARY_TEXT_CLASS}`]:\n      'mdc-deprecated-list-item__primary-text',\n  [`${cssClasses.ROOT}`]: 'mdc-deprecated-list',\n};\n\nconst strings = {\n  ACTION_EVENT: 'MDCList:action',\n  SELECTION_CHANGE_EVENT: 'MDCList:selectionChange',\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  ARIA_INTERACTIVE_ROLES_SELECTOR: '[role=\"listbox\"], [role=\"menu\"]',\n  ARIA_MULTI_SELECTABLE_SELECTOR: '[aria-multiselectable=\"true\"]',\n  CHECKBOX_RADIO_SELECTOR: 'input[type=\"checkbox\"], input[type=\"radio\"]',\n  CHECKBOX_SELECTOR: 'input[type=\"checkbox\"]',\n  CHILD_ELEMENTS_TO_TOGGLE_TABINDEX: `\n    .${cssClasses.LIST_ITEM_CLASS} button:not(:disabled),\n    .${cssClasses.LIST_ITEM_CLASS} a,\n    .${\n      deprecatedClassNameMap[cssClasses.LIST_ITEM_CLASS]} button:not(:disabled),\n    .${deprecatedClassNameMap[cssClasses.LIST_ITEM_CLASS]} a\n  `,\n  DEPRECATED_SELECTOR: '.mdc-deprecated-list',\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      deprecatedClassNameMap[cssClasses.LIST_ITEM_CLASS]} button:not(:disabled),\n    .${deprecatedClassNameMap[cssClasses.LIST_ITEM_CLASS]} a,\n    .${\n      deprecatedClassNameMap\n          [cssClasses.LIST_ITEM_CLASS]} input[type=\"radio\"]:not(:disabled),\n    .${\n      deprecatedClassNameMap\n          [cssClasses.LIST_ITEM_CLASS]} input[type=\"checkbox\"]:not(:disabled)\n  `,\n  RADIO_SELECTOR: 'input[type=\"radio\"]',\n  SELECTED_ITEM_SELECTOR: '[aria-selected=\"true\"], [aria-current=\"true\"]',\n};\n\nconst numbers = {\n  UNSET_INDEX: -1,\n  TYPEAHEAD_BUFFER_CLEAR_TIMEOUT_MS: 300\n};\n\nconst evolutionAttribute = 'evolution';\n\nexport {\n  strings,\n  cssClasses,\n  numbers,\n  deprecatedClassNameMap,\n  evolutionAttribute,\n  evolutionClassNameMap\n};\n","/**\n * @license\n * Copyright 2020 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 ELEMENTS_KEY_ALLOWED_IN = ['input', 'button', 'textarea', 'select'];\n\n/**\n * Ensures that preventDefault is only called if the containing element\n * doesn't consume the event, and it will cause an unintended scroll.\n *\n * @param event keyboard event to be prevented.\n */\nexport const preventDefaultEvent = (event: KeyboardEvent) => {\n  const target = event.target as Element;\n  if (!target) {\n    return;\n  }\n  const tagName = `${target.tagName}`.toLowerCase();\n  if (ELEMENTS_KEY_ALLOWED_IN.indexOf(tagName) === -1) {\n    event.preventDefault();\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\nimport {MDCFoundation} from '@material/base/foundation';\nimport {normalizeKey} from '@material/dom/keyboard';\n\nimport {MDCListAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\nimport {preventDefaultEvent} from './events';\nimport * as typeahead from './typeahead';\nimport {MDCListIndex, MDCListTextAndIndex} from './types';\n\nfunction isNumberArray(selectedIndex: MDCListIndex): selectedIndex is number[] {\n  return selectedIndex instanceof Array;\n}\n\n/**\n * Options for configuring how to update a selectable list item.\n */\ninterface SelectionUpdateOptions {\n  /** Whether the update was triggered by a user interaction. */\n  isUserInteraction?: boolean;\n  /**\n   * Whether the UI should be updated regardless of whether the\n   * selection would be a noop according to the foundation state.\n   * https://github.com/material-components/material-components-web/commit/5d060518804437aa1ae3152562f1bb78b1af4aa6.\n   */\n  forceUpdate?: boolean;\n  /**\n   * Whether disabled items should be omitted from updates. This is most\n   * relevant when trying to update all the items in a selection list.\n   */\n  omitDisabledItems?: boolean;\n}\n\n/** List of modifier keys to consider while handling keyboard events. */\nconst handledModifierKeys = ['Alt', 'Control', 'Meta', 'Shift'] as const;\n\n/** Type representing a modifier key we handle. */\ntype ModifierKey = NonNullable<(typeof handledModifierKeys)[number]>;\n\n/** Checks if the event has the given modifier keys. */\nfunction createModifierChecker(event?: KeyboardEvent|MouseEvent) {\n  const eventModifiers = new Set(\n      event ? handledModifierKeys.filter(m => event.getModifierState(m)) : []);\n  return (modifiers: ModifierKey[]) =>\n             modifiers.every(m => eventModifiers.has(m)) &&\n      modifiers.length === eventModifiers.size;\n}\n\n/** MDC List Foundation */\nexport class MDCListFoundation extends MDCFoundation<MDCListAdapter> {\n  static override get strings() {\n    return strings;\n  }\n\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get numbers() {\n    return numbers;\n  }\n\n  static override 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      listItemAtIndexHasClass: () => false,\n      notifyAction: () => undefined,\n      notifySelectionChange: () => {},\n      removeClassForElementIndex: () => undefined,\n      setAttributeForElementIndex: () => undefined,\n      setCheckedCheckboxOrRadioAtIndex: () => undefined,\n      setTabIndexForListItemChildren: () => undefined,\n      getPrimaryTextAtIndex: () => '',\n    };\n  }\n\n  private wrapFocus = false;\n  private isVertical = true;\n  private isSingleSelectionList = false;\n  private areDisabledItemsFocusable = false;\n  private selectedIndex: MDCListIndex = numbers.UNSET_INDEX;\n  private focusedItemIndex = numbers.UNSET_INDEX;\n  private useActivatedClass = false;\n  private useSelectedAttr = false;\n  private ariaCurrentAttrValue: string|null = null;\n  private isCheckboxList = false;\n  private isRadioList = false;\n  private lastSelectedIndex: number|null = null;\n\n  private hasTypeahead = false;\n  // Transiently holds current typeahead prefix from user.\n  private readonly typeaheadState = typeahead.initState();\n  private sortedIndexByFirstChar = new Map<string, MDCListTextAndIndex[]>();\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    // TODO(b/172274142): consider all items when determining the list's type.\n    if (this.adapter.hasCheckboxAtIndex(0)) {\n      this.isCheckboxList = true;\n      this.selectedIndex = [];\n    } else if (this.adapter.hasRadioAtIndex(0)) {\n      this.isRadioList = true;\n    } else {\n      this.maybeInitializeSingleSelection();\n    }\n\n    if (this.hasTypeahead) {\n      this.sortedIndexByFirstChar = this.typeaheadInitSortedIndex();\n    }\n  }\n\n  /** Returns the index of the item that was last focused. */\n  getFocusedItemIndex() {\n    return this.focusedItemIndex;\n  }\n\n  /** Toggles focus wrapping with keyboard navigation. */\n  setWrapFocus(value: boolean) {\n    this.wrapFocus = value;\n  }\n\n  /**\n   * Toggles orientation direction for keyboard navigation (true for vertical,\n   * false for horizontal).\n   */\n  setVerticalOrientation(value: boolean) {\n    this.isVertical = value;\n  }\n\n  /** Toggles single-selection behavior. */\n  setSingleSelection(value: boolean) {\n    this.isSingleSelectionList = value;\n    if (value) {\n      this.maybeInitializeSingleSelection();\n      this.selectedIndex = this.getSelectedIndexFromDOM();\n    }\n  }\n\n  setDisabledItemsFocusable(value: boolean) {\n    this.areDisabledItemsFocusable = value;\n  }\n\n  /**\n   * Automatically determines whether the list is single selection list. If so,\n   * initializes the internal state to match the selected item.\n   */\n  private maybeInitializeSingleSelection() {\n    const selectedItemIndex = this.getSelectedIndexFromDOM();\n    if (selectedItemIndex === numbers.UNSET_INDEX) return;\n\n    const hasActivatedClass = this.adapter.listItemAtIndexHasClass(\n        selectedItemIndex, cssClasses.LIST_ITEM_ACTIVATED_CLASS);\n    if (hasActivatedClass) {\n      this.setUseActivatedClass(true);\n    }\n    this.isSingleSelectionList = true;\n    this.selectedIndex = selectedItemIndex;\n  }\n\n  /** @return Index of the first selected item based on the DOM state. */\n  private getSelectedIndexFromDOM() {\n    let selectedIndex = numbers.UNSET_INDEX;\n    const listItemsCount = this.adapter.getListItemCount();\n    for (let i = 0; i < listItemsCount; i++) {\n      const hasSelectedClass = this.adapter.listItemAtIndexHasClass(\n          i, cssClasses.LIST_ITEM_SELECTED_CLASS);\n      const hasActivatedClass = this.adapter.listItemAtIndexHasClass(\n          i, cssClasses.LIST_ITEM_ACTIVATED_CLASS);\n      if (!(hasSelectedClass || hasActivatedClass)) {\n        continue;\n      }\n\n      selectedIndex = i;\n      break;\n    }\n\n    return selectedIndex;\n  }\n\n  /**\n   * Sets whether typeahead is enabled on the list.\n   * @param hasTypeahead Whether typeahead is enabled.\n   */\n  setHasTypeahead(hasTypeahead: boolean) {\n    this.hasTypeahead = hasTypeahead;\n    if (hasTypeahead) {\n      this.sortedIndexByFirstChar = this.typeaheadInitSortedIndex();\n    }\n  }\n\n  /**\n   * @return Whether typeahead is currently matching a user-specified prefix.\n   */\n  isTypeaheadInProgress(): boolean {\n    return this.hasTypeahead &&\n        typeahead.isTypingInProgress(this.typeaheadState);\n  }\n\n  /** Toggle use of the \"activated\" CSS class. */\n  setUseActivatedClass(useActivated: boolean) {\n    this.useActivatedClass = useActivated;\n  }\n\n  /**\n   * Toggles use of the selected attribute (true for aria-selected, false for\n   * aria-checked).\n   */\n  setUseSelectedAttribute(useSelected: boolean) {\n    this.useSelectedAttr = useSelected;\n  }\n\n  getSelectedIndex(): MDCListIndex {\n    return this.selectedIndex;\n  }\n\n  setSelectedIndex(index: MDCListIndex, options: SelectionUpdateOptions = {}) {\n    if (!this.isIndexValid(index)) {\n      return;\n    }\n\n    if (this.isCheckboxList) {\n      this.setCheckboxAtIndex(index as number[], options);\n    } else if (this.isRadioList) {\n      this.setRadioAtIndex(index as number, options);\n    } else {\n      this.setSingleSelectionAtIndex(index as number, options);\n    }\n  }\n\n  /**\n   * Focus in handler for the list items.\n   */\n  handleFocusIn(listItemIndex: number) {\n    if (listItemIndex >= 0) {\n      this.focusedItemIndex = listItemIndex;\n      this.adapter.setAttributeForElementIndex(listItemIndex, 'tabindex', '0');\n      this.adapter.setTabIndexForListItemChildren(listItemIndex, '0');\n    }\n  }\n\n  /**\n   * Focus out handler for the list items.\n   */\n  handleFocusOut(listItemIndex: number) {\n    if (listItemIndex >= 0) {\n      this.adapter.setAttributeForElementIndex(listItemIndex, 'tabindex', '-1');\n      this.adapter.setTabIndexForListItemChildren(listItemIndex, '-1');\n    }\n\n    /**\n     * Between Focusout & Focusin some browsers do not have focus on any\n     * element. Setting a delay to wait till the focus is moved to next element.\n     */\n    setTimeout(() => {\n      if (!this.adapter.isFocusInsideList()) {\n        this.setTabindexToFirstSelectedOrFocusedItem();\n      }\n    }, 0);\n  }\n\n  private isIndexDisabled(index: number) {\n    return this.adapter.listItemAtIndexHasClass(\n        index, cssClasses.LIST_ITEM_DISABLED_CLASS);\n  }\n\n  /**\n   * Key handler for the list.\n   */\n  handleKeydown(\n      event: KeyboardEvent, isRootListItem: boolean, listItemIndex: number) {\n    const isArrowLeft = normalizeKey(event) === 'ArrowLeft';\n    const isArrowUp = normalizeKey(event) === 'ArrowUp';\n    const isArrowRight = normalizeKey(event) === 'ArrowRight';\n    const isArrowDown = normalizeKey(event) === 'ArrowDown';\n    const isHome = normalizeKey(event) === 'Home';\n    const isEnd = normalizeKey(event) === 'End';\n    const isEnter = normalizeKey(event) === 'Enter';\n    const isSpace = normalizeKey(event) === 'Spacebar';\n\n    // The keys for forward and back differ based on list orientation.\n    const isForward =\n        (this.isVertical && isArrowDown) || (!this.isVertical && isArrowRight);\n    const isBack =\n        (this.isVertical && isArrowUp) || (!this.isVertical && isArrowLeft);\n\n    // Have to check both upper and lower case, because having caps lock on\n    // affects the value.\n    const isLetterA = event.key === 'A' || event.key === 'a';\n\n    const eventHasModifiers = createModifierChecker(event);\n\n    if (this.adapter.isRootFocused()) {\n      if ((isBack || isEnd) && eventHasModifiers([])) {\n        event.preventDefault();\n        this.focusLastElement();\n      } else if ((isForward || isHome) && eventHasModifiers([])) {\n        event.preventDefault();\n        this.focusFirstElement();\n      } else if (\n          isBack && eventHasModifiers(['Shift']) && this.isCheckboxList) {\n        event.preventDefault();\n        const focusedIndex = this.focusLastElement();\n        if (focusedIndex !== -1) {\n          this.setSelectedIndexOnAction(focusedIndex, false);\n        }\n      } else if (\n          isForward && eventHasModifiers(['Shift']) && this.isCheckboxList) {\n        event.preventDefault();\n        const focusedIndex = this.focusFirstElement();\n        if (focusedIndex !== -1) {\n          this.setSelectedIndexOnAction(focusedIndex, false);\n        }\n      }\n\n      if (this.hasTypeahead) {\n        const handleKeydownOpts: typeahead.HandleKeydownOpts = {\n          event,\n          focusItemAtIndex: (index) => {\n            this.focusItemAtIndex(index);\n          },\n          focusedItemIndex: -1,\n          isTargetListItem: isRootListItem,\n          sortedIndexByFirstChar: this.sortedIndexByFirstChar,\n          isItemAtIndexDisabled: (index) => this.isIndexDisabled(index),\n        };\n\n        typeahead.handleKeydown(handleKeydownOpts, this.typeaheadState);\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    if (isForward && eventHasModifiers([])) {\n      preventDefaultEvent(event);\n      this.focusNextElement(currentIndex);\n    } else if (isBack && eventHasModifiers([])) {\n      preventDefaultEvent(event);\n      this.focusPrevElement(currentIndex);\n    } else if (\n        isForward && eventHasModifiers(['Shift']) && this.isCheckboxList) {\n      preventDefaultEvent(event);\n      const focusedIndex = this.focusNextElement(currentIndex);\n      if (focusedIndex !== -1) {\n        this.setSelectedIndexOnAction(focusedIndex, false);\n      }\n    } else if (isBack && eventHasModifiers(['Shift']) && this.isCheckboxList) {\n      preventDefaultEvent(event);\n      const focusedIndex = this.focusPrevElement(currentIndex);\n      if (focusedIndex !== -1) {\n        this.setSelectedIndexOnAction(focusedIndex, false);\n      }\n    } else if (isHome && eventHasModifiers([])) {\n      preventDefaultEvent(event);\n      this.focusFirstElement();\n    } else if (isEnd && eventHasModifiers([])) {\n      preventDefaultEvent(event);\n      this.focusLastElement();\n    } else if (\n        isHome && eventHasModifiers(['Control', 'Shift']) &&\n        this.isCheckboxList) {\n      preventDefaultEvent(event);\n      if (this.isIndexDisabled(currentIndex)) {\n        return;\n      }\n      this.focusFirstElement();\n      this.toggleCheckboxRange(0, currentIndex, currentIndex);\n    } else if (\n        isEnd && eventHasModifiers(['Control', 'Shift']) &&\n        this.isCheckboxList) {\n      preventDefaultEvent(event);\n      if (this.isIndexDisabled(currentIndex)) {\n        return;\n      }\n      this.focusLastElement();\n      this.toggleCheckboxRange(\n          currentIndex, this.adapter.getListItemCount() - 1, currentIndex);\n    } else if (\n        isLetterA && eventHasModifiers(['Control']) && this.isCheckboxList) {\n      event.preventDefault();\n      this.checkboxListToggleAll(\n          this.selectedIndex === numbers.UNSET_INDEX ?\n              [] :\n              this.selectedIndex as number[],\n          true);\n    } else if (\n        (isEnter || isSpace) &&\n        (eventHasModifiers([]) || eventHasModifiers(['Alt']))) {\n      if (isRootListItem) {\n        // Return early if enter key is pressed on anchor element which triggers\n        // synthetic MouseEvent event.\n        const target = event.target as Element | null;\n        if (target && target.tagName === 'A' && isEnter) {\n          return;\n        }\n        preventDefaultEvent(event);\n\n        if (this.isIndexDisabled(currentIndex)) {\n          return;\n        }\n\n        if (!this.isTypeaheadInProgress()) {\n          if (this.isSelectableList()) {\n            this.setSelectedIndexOnAction(currentIndex, false);\n          }\n          this.adapter.notifyAction(currentIndex);\n        }\n      }\n    } else if (\n        (isEnter || isSpace) && eventHasModifiers(['Shift']) &&\n        this.isCheckboxList) {\n      // Return early if enter key is pressed on anchor element which triggers\n      // synthetic MouseEvent event.\n      const target = event.target as Element | null;\n      if (target && target.tagName === 'A' && isEnter) {\n        return;\n      }\n      preventDefaultEvent(event);\n\n      if (this.isIndexDisabled(currentIndex)) {\n        return;\n      }\n\n      if (!this.isTypeaheadInProgress()) {\n        this.toggleCheckboxRange(\n            this.lastSelectedIndex ?? currentIndex, currentIndex, currentIndex);\n        this.adapter.notifyAction(currentIndex);\n      }\n    }\n\n    if (this.hasTypeahead) {\n      const handleKeydownOpts: typeahead.HandleKeydownOpts = {\n        event,\n        focusItemAtIndex: (index) => {this.focusItemAtIndex(index)},\n        focusedItemIndex: this.focusedItemIndex,\n        isTargetListItem: isRootListItem,\n        sortedIndexByFirstChar: this.sortedIndexByFirstChar,\n        isItemAtIndexDisabled: (index) => this.isIndexDisabled(index),\n      };\n\n      typeahead.handleKeydown(handleKeydownOpts, this.typeaheadState);\n    }\n  }\n\n  /**\n   * Click handler for the list.\n   *\n   * @param index Index for the item that has been clicked.\n   * @param isCheckboxAlreadyUpdatedInAdapter Whether the checkbox for\n   *   the list item has already been updated in the adapter. This attribute\n   *   should be set to `true` when e.g. the click event directly landed on\n   *   the underlying native checkbox element which would cause the checked\n   *   state to be already toggled within `adapter.isCheckboxCheckedAtIndex`.\n   */\n  handleClick(\n      index: number, isCheckboxAlreadyUpdatedInAdapter: boolean,\n      event?: MouseEvent) {\n    const eventHasModifiers = createModifierChecker(event);\n\n    if (index === numbers.UNSET_INDEX) {\n      return;\n    }\n\n    if (this.isIndexDisabled(index)) {\n      return;\n    }\n\n    if (eventHasModifiers([])) {\n      if (this.isSelectableList()) {\n        this.setSelectedIndexOnAction(index, isCheckboxAlreadyUpdatedInAdapter);\n      }\n      this.adapter.notifyAction(index);\n    } else if (this.isCheckboxList && eventHasModifiers(['Shift'])) {\n      this.toggleCheckboxRange(this.lastSelectedIndex ?? index, index, index);\n      this.adapter.notifyAction(index);\n    }\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;\n    let firstChecked = null;\n\n    do {\n      nextIndex++;\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      if (nextIndex === firstChecked) {\n        return -1;\n      }\n      firstChecked = firstChecked ?? nextIndex;\n    } while (!this.areDisabledItemsFocusable &&\n             this.isIndexDisabled(nextIndex));\n\n    this.focusItemAtIndex(nextIndex);\n    return nextIndex;\n  }\n\n  /**\n   * Focuses the previous element on the list.\n   */\n  focusPrevElement(index: number) {\n    const count = this.adapter.getListItemCount();\n    let prevIndex = index;\n    let firstChecked = null;\n\n    do {\n      prevIndex--;\n      if (prevIndex < 0) {\n        if (this.wrapFocus) {\n          prevIndex = count - 1;\n        } else {\n          // Return early because first item is already focused.\n          return index;\n        }\n      }\n      if (prevIndex === firstChecked) {\n        return -1;\n      }\n      firstChecked = firstChecked ?? prevIndex;\n    } while (!this.areDisabledItemsFocusable &&\n             this.isIndexDisabled(prevIndex));\n\n    this.focusItemAtIndex(prevIndex);\n    return prevIndex;\n  }\n\n  focusFirstElement() {\n    // Pass -1 to `focusNextElement`, since it will incremement to 0 and focus\n    // the first element.\n    return this.focusNextElement(-1);\n  }\n\n  focusLastElement() {\n    // Pass the length of the list to `focusNextElement` since it will decrement\n    // to length - 1 and focus the last element.\n    return this.focusPrevElement(this.adapter.getListItemCount());\n  }\n\n  focusInitialElement() {\n    const initialIndex = this.getFirstSelectedOrFocusedItemIndex();\n    if (initialIndex !== numbers.UNSET_INDEX) {\n      this.focusItemAtIndex(initialIndex);\n    }\n    return initialIndex;\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, false)) {\n      return;\n    }\n\n    if (isEnabled) {\n      this.adapter.removeClassForElementIndex(\n          itemIndex, cssClasses.LIST_ITEM_DISABLED_CLASS);\n      this.adapter.setAttributeForElementIndex(\n          itemIndex, strings.ARIA_DISABLED, 'false');\n    } else {\n      this.adapter.addClassForElementIndex(\n          itemIndex, cssClasses.LIST_ITEM_DISABLED_CLASS);\n      this.adapter.setAttributeForElementIndex(\n          itemIndex, strings.ARIA_DISABLED, 'true');\n    }\n  }\n\n  private setSingleSelectionAtIndex(\n      index: number, options: SelectionUpdateOptions = {}) {\n    if (this.selectedIndex === index && !options.forceUpdate) {\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(\n          this.selectedIndex as number, selectedClassName);\n    }\n\n    this.setAriaForSingleSelectionAtIndex(index);\n    this.setTabindexAtIndex(index);\n    if (index !== numbers.UNSET_INDEX) {\n      this.adapter.addClassForElementIndex(index, selectedClassName);\n    }\n\n    this.selectedIndex = index;\n\n    // If the selected value has changed through user interaction,\n    // we want to notify the selection change to the adapter.\n    if (options.isUserInteraction && !options.forceUpdate) {\n      this.adapter.notifySelectionChange([index]);\n    }\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\n    // initialization when it is in unset state.\n    if (this.selectedIndex === numbers.UNSET_INDEX &&\n        index !== 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 =\n        isAriaCurrent ? strings.ARIA_CURRENT : strings.ARIA_SELECTED;\n\n    if (this.selectedIndex !== numbers.UNSET_INDEX) {\n      this.adapter.setAttributeForElementIndex(\n          this.selectedIndex as number, ariaAttribute, 'false');\n    }\n\n    if (index !== numbers.UNSET_INDEX) {\n      const ariaAttributeValue =\n          isAriaCurrent ? this.ariaCurrentAttrValue : 'true';\n      this.adapter.setAttributeForElementIndex(\n          index, ariaAttribute, ariaAttributeValue as string);\n    }\n  }\n\n  /**\n   * Returns the attribute to use for indicating selection status.\n   */\n  private getSelectionAttribute(): string {\n    return this.useSelectedAttr ? strings.ARIA_SELECTED : strings.ARIA_CHECKED;\n  }\n\n  /**\n   * Toggles radio at give index. Radio doesn't change the checked state if it\n   * is already checked.\n   */\n  private setRadioAtIndex(index: number, options: SelectionUpdateOptions = {}) {\n    const selectionAttribute = this.getSelectionAttribute();\n    this.adapter.setCheckedCheckboxOrRadioAtIndex(index, true);\n\n    if (this.selectedIndex === index && !options.forceUpdate) {\n      return;\n    }\n\n    if (this.selectedIndex !== numbers.UNSET_INDEX) {\n      this.adapter.setAttributeForElementIndex(\n          this.selectedIndex as number, selectionAttribute, 'false');\n    }\n\n    this.adapter.setAttributeForElementIndex(index, selectionAttribute, 'true');\n\n    this.selectedIndex = index;\n\n    // If the selected value has changed through user interaction,\n    // we want to notify the selection change to the adapter.\n    if (options.isUserInteraction && !options.forceUpdate) {\n      this.adapter.notifySelectionChange([index]);\n    }\n  }\n\n  private setCheckboxAtIndex(\n      indices: number[], options: SelectionUpdateOptions = {}) {\n    const currentIndex = this.selectedIndex;\n    // If this update is not triggered by a user interaction, we do not\n    // need to know about the currently selected indices and can avoid\n    // constructing the `Set` for performance reasons.\n    const currentlySelected = options.isUserInteraction ?\n        new Set(\n            currentIndex === numbers.UNSET_INDEX ? [] :\n                                                   currentIndex as number[]) :\n        null;\n    const selectionAttribute = this.getSelectionAttribute();\n    const changedIndices = [];\n\n    for (let i = 0; i < this.adapter.getListItemCount(); i++) {\n      if (options.omitDisabledItems && this.isIndexDisabled(i)) {\n        continue;\n      }\n      const previousIsChecked = currentlySelected?.has(i);\n      const newIsChecked = indices.indexOf(i) >= 0;\n\n      // If the selection has changed for this item, we keep track of it\n      // so that we can notify the adapter.\n      if (newIsChecked !== previousIsChecked) {\n        changedIndices.push(i);\n      }\n\n      this.adapter.setCheckedCheckboxOrRadioAtIndex(i, newIsChecked);\n      this.adapter.setAttributeForElementIndex(\n          i, selectionAttribute, newIsChecked ? 'true' : 'false');\n    }\n\n    this.selectedIndex = options.omitDisabledItems ?\n        this.resolveSelectedIndices(indices) :\n        indices;\n\n    // If the selected value has changed through user interaction,\n    // we want to notify the selection change to the adapter.\n    if (options.isUserInteraction && changedIndices.length) {\n      this.adapter.notifySelectionChange(changedIndices);\n    }\n  }\n\n  /**\n   * Helper method for ensuring that the list of selected indices remains\n   * accurate when calling setCheckboxAtIndex with omitDisabledItems set to\n   * true.\n   */\n  private resolveSelectedIndices(setCheckedItems: number[]): number[] {\n    const currentlySelectedItems = this.selectedIndex === numbers.UNSET_INDEX ?\n        [] :\n        this.selectedIndex as number[];\n\n    const currentlySelectedDisabledItems =\n        currentlySelectedItems.filter(i => this.isIndexDisabled(i));\n    const enabledSetCheckedItems =\n        setCheckedItems.filter(i => !this.isIndexDisabled(i));\n\n    // Updated selectedIndex should be the enabled setCheckedItems + any missing\n    // selected disabled items.\n    const updatedSelectedItems = [...new Set(\n        [...enabledSetCheckedItems, ...currentlySelectedDisabledItems])];\n    return updatedSelectedItems.sort((a, b) => a - b);\n  }\n\n  /**\n   * Toggles the state of all checkboxes in the given range (inclusive) based\n   * on the state of the checkbox at the `toggleIndex`. To determine whether\n   * to set the given range to checked or unchecked, read the value of the\n   * checkbox at the `toggleIndex` and negate it. Then apply that new checked\n   * state to all checkboxes in the range.\n   * @param fromIndex The start of the range of checkboxes to toggle\n   * @param toIndex The end of the range of checkboxes to toggle\n   * @param toggleIndex The index that will be used to determine the new state\n   *     of the given checkbox range.\n   */\n  private toggleCheckboxRange(\n      fromIndex: number, toIndex: number, toggleIndex: number) {\n    this.lastSelectedIndex = toggleIndex;\n    const currentlySelected = new Set(\n        this.selectedIndex === numbers.UNSET_INDEX ?\n            [] :\n            this.selectedIndex as number[]);\n    const newIsChecked = !currentlySelected?.has(toggleIndex);\n\n    const [startIndex, endIndex] = [fromIndex, toIndex].sort();\n    const selectionAttribute = this.getSelectionAttribute();\n    const changedIndices = [];\n\n    for (let i = startIndex; i <= endIndex; i++) {\n      if (this.isIndexDisabled(i)) {\n        continue;\n      }\n      const previousIsChecked = currentlySelected.has(i);\n\n      // If the selection has changed for this item, we keep track of it\n      // so that we can notify the adapter.\n      if (newIsChecked !== previousIsChecked) {\n        changedIndices.push(i);\n        this.adapter.setCheckedCheckboxOrRadioAtIndex(i, newIsChecked);\n        this.adapter.setAttributeForElementIndex(\n            i, selectionAttribute, `${newIsChecked}`);\n        if (newIsChecked) {\n          currentlySelected.add(i);\n        } else {\n          currentlySelected.delete(i);\n        }\n      }\n    }\n\n    // If the selected value has changed, update and notify the selection\n    // change to the adapter.\n    if (changedIndices.length) {\n      this.selectedIndex = [...currentlySelected];\n      this.adapter.notifySelectionChange(changedIndices);\n    }\n  }\n\n  private setTabindexAtIndex(index: number) {\n    if (this.focusedItemIndex === numbers.UNSET_INDEX && index !== 0 &&\n        index !== numbers.UNSET_INDEX) {\n      // If some 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\n      // no preselected items.\n      this.adapter.setAttributeForElementIndex(0, 'tabindex', '-1');\n    } else if (this.focusedItemIndex >= 0 && this.focusedItemIndex !== index) {\n      this.adapter.setAttributeForElementIndex(\n          this.focusedItemIndex, 'tabindex', '-1');\n    }\n\n    // Set the previous selection's tabindex to -1. We need this because\n    // in selection menus that are not visible, programmatically setting an\n    // option will not change focus but will change where tabindex should be\n    // 0.\n    if (!(this.selectedIndex instanceof Array) &&\n        this.selectedIndex !== index &&\n        this.focusedItemIndex !== numbers.UNSET_INDEX) {\n      this.adapter.setAttributeForElementIndex(\n          this.selectedIndex, 'tabindex', '-1');\n    }\n\n    if (index !== numbers.UNSET_INDEX) {\n      this.adapter.setAttributeForElementIndex(index, 'tabindex', '0');\n    }\n  }\n\n  /**\n   * @return Return true if it is single selectin list, checkbox list or radio\n   *     list.\n   */\n  private isSelectableList() {\n    return this.isSingleSelectionList || this.isCheckboxList ||\n        this.isRadioList;\n  }\n\n  private setTabindexToFirstSelectedOrFocusedItem() {\n    const targetIndex = this.getFirstSelectedOrFocusedItemIndex();\n    this.setTabindexAtIndex(targetIndex);\n  }\n\n  private getFirstSelectedOrFocusedItemIndex(): number {\n    const firstFocusableListItem = this.getFirstEnabledItem();\n\n    if (this.adapter.getListItemCount() === 0) {\n      return numbers.UNSET_INDEX;\n    }\n\n    // Action lists retain focus on the most recently focused item.\n    if (!this.isSelectableList()) {\n      return Math.max(this.focusedItemIndex, firstFocusableListItem);\n    }\n\n    // Single-selection lists focus the selected item.\n    if (typeof this.selectedIndex === 'number' &&\n        this.selectedIndex !== numbers.UNSET_INDEX) {\n      return this.areDisabledItemsFocusable &&\n              this.isIndexDisabled(this.selectedIndex) ?\n          firstFocusableListItem :\n          this.selectedIndex;\n    }\n\n    // Multiple-selection lists focus the first enabled selected item.\n    if (isNumberArray(this.selectedIndex) && this.selectedIndex.length > 0) {\n      const sorted = [...this.selectedIndex].sort((a, b) => a - b);\n      for (const index of sorted) {\n        if (this.isIndexDisabled(index) && !this.areDisabledItemsFocusable) {\n          continue;\n        } else {\n          return index;\n        }\n      }\n    }\n\n    // Selection lists without a selection focus the first item.\n    return firstFocusableListItem;\n  }\n\n\n  private getFirstEnabledItem(): number {\n    const listSize = this.adapter.getListItemCount();\n    let i = 0;\n    while (i < listSize) {\n      if (!this.isIndexDisabled(i)) {\n        break;\n      }\n      i++;\n    }\n    return i === listSize ? numbers.UNSET_INDEX : i;\n  }\n\n  private isIndexValid(index: MDCListIndex, validateListType = true) {\n    if (index instanceof Array) {\n      if (!this.isCheckboxList && validateListType) {\n        throw new Error(\n            '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 && validateListType) {\n        throw new Error(\n            `MDCListFoundation: Expected array of index for checkbox based list but got number: ${\n                index}`);\n      }\n      return this.isIndexInRange(index) ||\n          this.isSingleSelectionList && index === numbers.UNSET_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  /**\n   * Sets selected index on user action, toggles checkboxes in checkbox lists\n   * by default, unless `isCheckboxAlreadyUpdatedInAdapter` is set to `true`.\n   *\n   * In cases where `isCheckboxAlreadyUpdatedInAdapter` is set to `true`, the\n   * UI is just updated to reflect the value returned by the adapter.\n   *\n   * When calling this, make sure user interaction does not toggle disabled\n   * list items.\n   */\n  private setSelectedIndexOnAction(\n      index: number, isCheckboxAlreadyUpdatedInAdapter: boolean) {\n    this.lastSelectedIndex = index;\n    if (this.isCheckboxList) {\n      this.toggleCheckboxAtIndex(index, isCheckboxAlreadyUpdatedInAdapter);\n      this.adapter.notifySelectionChange([index]);\n    } else {\n      this.setSelectedIndex(index, {isUserInteraction: true});\n    }\n  }\n\n  private toggleCheckboxAtIndex(\n      index: number, isCheckboxAlreadyUpdatedInAdapter: boolean) {\n    const selectionAttribute = this.getSelectionAttribute();\n    const adapterIsChecked = this.adapter.isCheckboxCheckedAtIndex(index);\n\n    // By default the checked value from the adapter is toggled unless the\n    // checked state in the adapter has already been updated beforehand.\n    // This can be happen when the underlying native checkbox has already\n    // been updated through the native click event.\n    let newCheckedValue;\n    if (isCheckboxAlreadyUpdatedInAdapter) {\n      newCheckedValue = adapterIsChecked;\n    } else {\n      newCheckedValue = !adapterIsChecked;\n      this.adapter.setCheckedCheckboxOrRadioAtIndex(index, newCheckedValue)\n    }\n\n    this.adapter.setAttributeForElementIndex(\n        index, selectionAttribute, newCheckedValue ? 'true' : 'false');\n\n    // If none of the checkbox items are selected and selectedIndex is not\n    // initialized then provide a default value.\n    let selectedIndexes = this.selectedIndex === numbers.UNSET_INDEX ?\n        [] :\n        (this.selectedIndex as number[]).slice();\n\n    if (newCheckedValue) {\n      selectedIndexes.push(index);\n    } else {\n      selectedIndexes = selectedIndexes.filter((i) => i !== index);\n    }\n\n    this.selectedIndex = selectedIndexes;\n  }\n\n  private focusItemAtIndex(index: number) {\n    this.adapter.focusItemAtIndex(index);\n    this.focusedItemIndex = index;\n  }\n\n  private getEnabledListItemCount(): number {\n    const listSize = this.adapter.getListItemCount();\n    let adjustedCount = 0;\n    for (let i = 0; i < listSize; i++) {\n      if (!this.isIndexDisabled(i)) {\n        adjustedCount++;\n      }\n    }\n    return adjustedCount;\n  }\n\n  private checkboxListToggleAll(\n      currentlySelectedIndices: number[], isUserInteraction: boolean) {\n    const enabledListItemCount = this.getEnabledListItemCount();\n    const totalListItemCount = this.adapter.getListItemCount();\n    const currentlyEnabledSelectedIndices =\n        currentlySelectedIndices.filter(i => !this.isIndexDisabled(i));\n\n    // If all items are selected, deselect everything.\n    // We check >= rather than === to `enabledListItemCount` since a disabled\n    // item could be selected, and we don't take that into consideration when\n    // toggling the other checkbox values.\n    if (currentlyEnabledSelectedIndices.length >= enabledListItemCount) {\n      // Use omitDisabledItems option to ensure disabled selected items are not\n      // de-selected.\n      this.setCheckboxAtIndex([], {isUserInteraction, omitDisabledItems: true});\n    } else {\n      // Otherwise select all enabled options.\n      const allIndexes: number[] = [];\n      for (let i = 0; i < totalListItemCount; i++) {\n        if (!this.isIndexDisabled(i) ||\n            currentlySelectedIndices.indexOf(i) > -1) {\n          allIndexes.push(i);\n        }\n      }\n      // Use omitDisabledItems option to ensure disabled selected items are not\n      // de-selected.\n      this.setCheckboxAtIndex(\n          allIndexes, {isUserInteraction, omitDisabledItems: true});\n    }\n  }\n\n  /**\n   * Given the next desired character from the user, adds it to the typeahead\n   * buffer. Then, attempts to find the next option matching the buffer. Wraps\n   * around if at the end of options.\n   *\n   * @param nextChar The next character to add to the prefix buffer.\n   * @param startingIndex The index from which to start matching. Only\n   *     relevant when starting a new match sequence. To start a new match\n   *     sequence, clear the buffer using `clearTypeaheadBuffer`, or wait for\n   *     the buffer to clear after a set interval defined in list foundation.\n   *     Defaults to the currently focused index.\n   * @return The index of the matched item, or -1 if no match.\n   */\n  typeaheadMatchItem(\n      nextChar: string, startingIndex?: number, skipFocus = false) {\n    const opts: typeahead.TypeaheadMatchItemOpts = {\n      focusItemAtIndex: (index) => {\n        this.focusItemAtIndex(index);\n      },\n      focusedItemIndex: startingIndex ? startingIndex : this.focusedItemIndex,\n      nextChar,\n      sortedIndexByFirstChar: this.sortedIndexByFirstChar,\n      skipFocus,\n      isItemAtIndexDisabled: (index) => this.isIndexDisabled(index)\n    };\n    return typeahead.matchItem(opts, this.typeaheadState);\n  }\n\n  /**\n   * Initializes the MDCListTextAndIndex data structure by indexing the\n   * current list items by primary text.\n   *\n   * @return The primary texts of all the list items sorted by first\n   *     character.\n   */\n  private typeaheadInitSortedIndex() {\n    return typeahead.initSortedIndex(\n        this.adapter.getListItemCount(), this.adapter.getPrimaryTextAtIndex);\n  }\n\n  /**\n   * Clears the typeahead buffer.\n   */\n  clearTypeaheadBuffer() {\n    typeahead.clearBuffer(this.typeaheadState);\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 2020 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 {normalizeKey} from '@material/dom/keyboard';\n\nimport {numbers} from './constants';\nimport {preventDefaultEvent} from './events';\nimport {MDCListTextAndIndex} from './types';\n\n/**\n * State of a typeahead instance.\n */\nexport interface TypeaheadState {\n  typeaheadBuffer: string;\n  currentFirstChar: string;\n  sortedIndexCursor: number;\n  bufferClearTimeout: number;\n}\n\n/**\n * Initializes a state object for typeahead. Use the same reference for calls to\n * typeahead functions.\n *\n * @return The current state of the typeahead process. Each state reference\n *     represents a typeahead instance as the reference is typically mutated\n *     in-place.\n */\nexport function initState(): TypeaheadState {\n  const state: TypeaheadState = {\n    bufferClearTimeout: 0,\n    currentFirstChar: '',\n    sortedIndexCursor: 0,\n    typeaheadBuffer: '',\n  };\n  return state;\n}\n\n/**\n * Initializes typeahead state by indexing the current list items by primary\n * text into the sortedIndexByFirstChar data structure.\n *\n * @param listItemCount numer of items in the list\n * @param getPrimaryTextByItemIndex function that returns the primary text at a\n *     given index\n *\n * @return Map that maps the first character of the primary text to the full\n *     list text and its index\n */\nexport function initSortedIndex(\n    listItemCount: number,\n    getPrimaryTextByItemIndex: (index: number) =>\n        string): Map<string, MDCListTextAndIndex[]> {\n  const sortedIndexByFirstChar = new Map<string, MDCListTextAndIndex[]>();\n\n  // Aggregate item text to index mapping\n  for (let i = 0; i < listItemCount; i++) {\n    const primaryText = getPrimaryTextByItemIndex(i).trim();\n    if (!primaryText) {\n      continue;\n    }\n\n    const firstChar = primaryText[0].toLowerCase();\n    if (!sortedIndexByFirstChar.has(firstChar)) {\n      sortedIndexByFirstChar.set(firstChar, []);\n    }\n    sortedIndexByFirstChar.get(firstChar)!.push(\n        {text: primaryText.toLowerCase(), index: i});\n  }\n\n  // Sort the mapping\n  // TODO(b/157162694): Investigate replacing forEach with Map.values()\n  sortedIndexByFirstChar.forEach((values) => {\n    values.sort((first: MDCListTextAndIndex, second: MDCListTextAndIndex) => {\n      return first.index - second.index;\n    });\n  });\n\n  return sortedIndexByFirstChar;\n}\n\n/**\n * Arguments for matchItem\n */\nexport interface TypeaheadMatchItemOpts {\n  focusItemAtIndex: (index: number) => void;\n  nextChar: string;\n  focusedItemIndex: number;\n  sortedIndexByFirstChar: Map<string, MDCListTextAndIndex[]>;\n  skipFocus: boolean;\n  isItemAtIndexDisabled: (index: number) => boolean;\n}\n\n/**\n * Given the next desired character from the user, it attempts to find the next\n * list option matching the buffer. Wraps around if at the end of options.\n *\n * @param opts Options and accessors\n *   - nextChar - the next character to match against items\n *   - sortedIndexByFirstChar - output of `initSortedIndex(...)`\n *   - focusedItemIndex - the index of the currently focused item\n *   - focusItemAtIndex - function that focuses a list item at given index\n *   - skipFocus - whether or not to focus the matched item\n *   - isItemAtIndexDisabled - function that determines whether an item at a\n *        given index is disabled\n * @param state The typeahead state instance. See `initState`.\n *\n * @return The index of the matched item, or -1 if no match.\n */\nexport function matchItem(\n    opts: TypeaheadMatchItemOpts, state: TypeaheadState): number {\n  const {\n    nextChar,\n    focusItemAtIndex,\n    sortedIndexByFirstChar,\n    focusedItemIndex,\n    skipFocus,\n    isItemAtIndexDisabled,\n  } = opts;\n\n  clearTimeout(state.bufferClearTimeout);\n\n  state.bufferClearTimeout = setTimeout(() => {\n    clearBuffer(state);\n  }, numbers.TYPEAHEAD_BUFFER_CLEAR_TIMEOUT_MS);\n\n  state.typeaheadBuffer = state.typeaheadBuffer + nextChar;\n\n  let index: number;\n  if (state.typeaheadBuffer.length === 1) {\n    index = matchFirstChar(\n        sortedIndexByFirstChar, focusedItemIndex, isItemAtIndexDisabled, state);\n  } else {\n    index = matchAllChars(sortedIndexByFirstChar, isItemAtIndexDisabled, state);\n  }\n\n  if (index !== -1 && !skipFocus) {\n    focusItemAtIndex(index);\n  }\n  return index;\n}\n\n/**\n * Matches the user's single input character in the buffer to the\n * next option that begins with such character. Wraps around if at\n * end of options. Returns -1 if no match is found.\n */\nfunction matchFirstChar(\n    sortedIndexByFirstChar: Map<string, MDCListTextAndIndex[]>,\n    focusedItemIndex: number, isItemAtIndexDisabled: (index: number) => boolean,\n    state: TypeaheadState): number {\n  const firstChar = state.typeaheadBuffer[0];\n  const itemsMatchingFirstChar = sortedIndexByFirstChar.get(firstChar);\n  if (!itemsMatchingFirstChar) {\n    return -1;\n  }\n\n  // Has the same firstChar been recently matched?\n  // Also, did starting index remain the same between key presses?\n  // If both hold true, simply increment index.\n  if (firstChar === state.currentFirstChar &&\n      itemsMatchingFirstChar[state.sortedIndexCursor].index ===\n          focusedItemIndex) {\n    state.sortedIndexCursor =\n        (state.sortedIndexCursor + 1) % itemsMatchingFirstChar.length;\n\n    const newIndex = itemsMatchingFirstChar[state.sortedIndexCursor].index;\n    if (!isItemAtIndexDisabled(newIndex)) {\n      return newIndex;\n    }\n  }\n\n  // If we're here, it means one of the following happened:\n  // - either firstChar or startingIndex has changed, invalidating the\n  // cursor.\n  // - The next item of typeahead is disabled, so we have to look further.\n  state.currentFirstChar = firstChar;\n\n  let newCursorPosition = -1;\n  let cursorPosition;\n  // Find the first non-disabled item as a fallback.\n  for (cursorPosition = 0; cursorPosition < itemsMatchingFirstChar.length;\n       cursorPosition++) {\n    if (!isItemAtIndexDisabled(itemsMatchingFirstChar[cursorPosition].index)) {\n      newCursorPosition = cursorPosition;\n      break;\n    }\n  }\n\n  // Advance cursor to first item matching the firstChar that is positioned\n  // after starting item. Cursor is unchanged from fallback if there's no\n  // such item.\n  for (; cursorPosition < itemsMatchingFirstChar.length; cursorPosition++) {\n    if (itemsMatchingFirstChar[cursorPosition].index > focusedItemIndex &&\n        !isItemAtIndexDisabled(itemsMatchingFirstChar[cursorPosition].index)) {\n      newCursorPosition = cursorPosition;\n      break;\n    }\n  }\n\n  if (newCursorPosition !== -1) {\n    state.sortedIndexCursor = newCursorPosition;\n    return itemsMatchingFirstChar[state.sortedIndexCursor].index;\n  }\n\n  return -1;\n}\n\n/**\n * Attempts to find the next item that matches all of the typeahead buffer.\n * Wraps around if at end of options. Returns -1 if no match is found.\n */\nfunction matchAllChars(\n    sortedIndexByFirstChar: Map<string, MDCListTextAndIndex[]>,\n    isItemAtIndexDisabled: (index: number) => boolean,\n    state: TypeaheadState): number {\n  const firstChar = state.typeaheadBuffer[0];\n  const itemsMatchingFirstChar = sortedIndexByFirstChar.get(firstChar);\n  if (!itemsMatchingFirstChar) {\n    return -1;\n  }\n\n  // Do nothing if text already matches\n  const startingItem = itemsMatchingFirstChar[state.sortedIndexCursor];\n  if (startingItem.text.lastIndexOf(state.typeaheadBuffer, 0) === 0 &&\n      !isItemAtIndexDisabled(startingItem.index)) {\n    return startingItem.index;\n  }\n\n  // Find next item that matches completely; if no match, we'll eventually\n  // loop around to same position\n  let cursorPosition =\n      (state.sortedIndexCursor + 1) % itemsMatchingFirstChar.length;\n  let nextCursorPosition = -1;\n  while (cursorPosition !== state.sortedIndexCursor) {\n    const currentItem = itemsMatchingFirstChar[cursorPosition];\n\n    const matches =\n        currentItem.text.lastIndexOf(state.typeaheadBuffer, 0) === 0;\n    const isEnabled = !isItemAtIndexDisabled(currentItem.index);\n    if (matches && isEnabled) {\n      nextCursorPosition = cursorPosition;\n      break;\n    }\n\n    cursorPosition = (cursorPosition + 1) % itemsMatchingFirstChar.length;\n  }\n\n  if (nextCursorPosition !== -1) {\n    state.sortedIndexCursor = nextCursorPosition;\n    return itemsMatchingFirstChar[state.sortedIndexCursor].index;\n  }\n\n  return -1;\n}\n\n/**\n * Whether or not the given typeahead instaance state is currently typing.\n *\n * @param state The typeahead state instance. See `initState`.\n */\nexport function isTypingInProgress(state: TypeaheadState) {\n  return state.typeaheadBuffer.length > 0;\n}\n\n/**\n * Options for handleKeydown.\n */\nexport interface HandleKeydownOpts {\n  event: KeyboardEvent;\n  isTargetListItem: boolean;\n  focusItemAtIndex: (index: number) => void;\n  focusedItemIndex: number;\n  sortedIndexByFirstChar: Map<string, MDCListTextAndIndex[]>;\n  isItemAtIndexDisabled: (index: number) => boolean;\n}\n\n/**\n * Clears the typeahaed buffer so that it resets item matching to the first\n * character.\n *\n * @param state The typeahead state instance. See `initState`.\n */\nexport function clearBuffer(state: TypeaheadState) {\n  state.typeaheadBuffer = '';\n}\n\n/**\n * Given a keydown event, it calculates whether or not to automatically focus a\n * list item depending on what was typed mimicking the typeahead functionality\n * of a standard <select> element that is open.\n *\n * @param opts Options and accessors\n *   - event - the KeyboardEvent to handle and parse\n *   - sortedIndexByFirstChar - output of `initSortedIndex(...)`\n *   - focusedItemIndex - the index of the currently focused item\n *   - focusItemAtIndex - function that focuses a list item at given index\n *   - isItemAtFocusedIndexDisabled - whether or not the currently focused item\n *      is disabled\n *   - isTargetListItem - whether or not the event target is a list item\n * @param state The typeahead state instance. See `initState`.\n *\n * @return index of the item matched by the keydown. -1 if not matched.\n */\nexport function handleKeydown(opts: HandleKeydownOpts, state: TypeaheadState) {\n  const {\n    event,\n    isTargetListItem,\n    focusedItemIndex,\n    focusItemAtIndex,\n    sortedIndexByFirstChar,\n    isItemAtIndexDisabled,\n  } = opts;\n\n  const isArrowLeft = normalizeKey(event) === 'ArrowLeft';\n  const isArrowUp = normalizeKey(event) === 'ArrowUp';\n  const isArrowRight = normalizeKey(event) === 'ArrowRight';\n  const isArrowDown = normalizeKey(event) === 'ArrowDown';\n  const isHome = normalizeKey(event) === 'Home';\n  const isEnd = normalizeKey(event) === 'End';\n  const isEnter = normalizeKey(event) === 'Enter';\n  const isSpace = normalizeKey(event) === 'Spacebar';\n\n  if (event.altKey || event.ctrlKey || event.metaKey || isArrowLeft ||\n      isArrowUp || isArrowRight || isArrowDown || isHome || isEnd || isEnter) {\n    return -1;\n  }\n\n  const isCharacterKey = !isSpace && event.key.length === 1;\n\n  if (isCharacterKey) {\n    preventDefaultEvent(event);\n    const matchItemOpts: TypeaheadMatchItemOpts = {\n      focusItemAtIndex,\n      focusedItemIndex,\n      nextChar: event.key.toLowerCase(),\n      sortedIndexByFirstChar,\n      skipFocus: false,\n      isItemAtIndexDisabled,\n    };\n    return matchItem(matchItemOpts, state);\n  }\n\n  if (!isSpace) {\n    return -1;\n  }\n\n  if (isTargetListItem) {\n    preventDefaultEvent(event);\n  }\n\n  const typeaheadOnListItem = isTargetListItem && isTypingInProgress(state);\n\n  if (typeaheadOnListItem) {\n    const matchItemOpts: TypeaheadMatchItemOpts = {\n      focusItemAtIndex,\n      focusedItemIndex,\n      nextChar: ' ',\n      sortedIndexByFirstChar,\n      skipFocus: false,\n      isItemAtIndexDisabled,\n    };\n    // space participates in typeahead matching if in rapid typing mode\n    return matchItem(matchItemOpts, state);\n  }\n\n  return -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\nexport interface MDCListActionEventDetail {\n  /**\n   * Index of the list item that was activated.\n   */\n  index: number;\n}\n\nexport interface MDCListActionEvent extends Event {\n  detail: MDCListActionEventDetail;\n}\n\n\nexport interface MDCListSelectionChangeDetail {\n  /** Indices of the list items for which the selection changed. */\n  changedIndices: number[];\n}\n\nexport interface MDCListSelectionChangeEvent extends Event {\n  detail: MDCListSelectionChangeDetail;\n}\n\nexport type MDCListIndex = number|number[];\n\n/**\n * Type used by the typeahead mechanism to keep track of the index associated\n * with list item text.\n */\nexport interface MDCListTextAndIndex {\n  text: string;\n  index: number;\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 {EventType, SpecificEventListener} from '@material/base/types';\n\nimport {MDCMenuDimensions, MDCMenuDistance, MDCMenuPoint} from './types';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCMenuSurfaceAdapter {\n  addClass(className: string): void;\n  removeClass(className: string): void;\n  hasClass(className: string): boolean;\n  hasAnchor(): boolean;\n\n  isElementInContainer(el: Element): boolean;\n  isFocused(): boolean;\n  isRtl(): boolean;\n\n  getInnerDimensions(): MDCMenuDimensions;\n  getAnchorDimensions(): DOMRect|null;\n  getViewportDimensions(): MDCMenuDimensions;\n  getBodyDimensions(): MDCMenuDimensions;\n  getWindowScroll(): MDCMenuPoint;\n  setPosition(position: Partial<MDCMenuDistance>): void;\n  setMaxHeight(height: string): void;\n  setTransformOrigin(origin: string): void;\n  getOwnerDocument?(): Document;\n\n  /** Saves the element that was focused before the menu surface was opened. */\n  saveFocus(): void;\n\n  /**\n   * Restores focus to the element that was focused before the menu surface was\n   * opened.\n   */\n  restoreFocus(): void;\n\n  /** Emits an event when the menu surface is closed. */\n  notifyClose(): void;\n\n  /** Emits an event when the menu surface is closing. */\n  notifyClosing(): void;\n\n  /** Emits an event when the menu surface is opened. */\n  notifyOpen(): void;\n\n  /** Emits an event when the menu surface is opening. */\n  notifyOpening(): void;\n\n  /** Registers an event listener on the window. */\n  registerWindowEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /** Deregisters an event listener on the window. */\n  deregisterWindowEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\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 {getCorrectPropertyName} from '@material/animation/util';\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\n\nimport {MDCMenuSurfaceAdapter} from './adapter';\nimport {Corner, cssClasses, strings} from './constants';\nimport {MDCMenuSurfaceFoundation} from './foundation';\nimport {MDCMenuDistance} from './types';\n\ntype RegisterFunction = () => void;\n\n/** MDC Menu Surface Factory */\nexport type MDCMenuSurfaceFactory =\n    (el: HTMLElement, foundation?: MDCMenuSurfaceFoundation) => MDCMenuSurface;\n\n/** MDC Menu Surface */\nexport class MDCMenuSurface extends MDCComponent<MDCMenuSurfaceFoundation> {\n  static override attachTo(root: HTMLElement): MDCMenuSurface {\n    return new MDCMenuSurface(root);\n  }\n\n  anchorElement!: Element|null;  // assigned in initialSyncWithDOM()\n\n  private previousFocus?: HTMLElement|SVGElement|null;\n\n  private handleKeydown!:\n      SpecificEventListener<'keydown'>;  // assigned in initialSyncWithDOM()\n  private handleBodyClick!:\n      SpecificEventListener<'click'>;  // assigned in initialSyncWithDOM()\n\n  private registerBodyClickListener!:\n      RegisterFunction;  // assigned in initialSyncWithDOM()\n  private deregisterBodyClickListener!:\n      RegisterFunction;  // assigned in initialSyncWithDOM()\n\n  override initialSyncWithDOM() {\n    const parentEl = this.root.parentElement;\n    this.anchorElement =\n        parentEl && parentEl.classList.contains(cssClasses.ANCHOR) ? parentEl :\n                                                                     null;\n\n    if (this.root.classList.contains(cssClasses.FIXED)) {\n      this.setFixedPosition(true);\n    }\n\n    this.handleKeydown = (event) => {\n      this.foundation.handleKeydown(event);\n    };\n    this.handleBodyClick = (event) => {\n      this.foundation.handleBodyClick(event);\n    };\n\n    // capture so that no race between handleBodyClick and quickOpen when\n    // menusurface opened on button click which registers this listener\n    this.registerBodyClickListener = () => {\n      document.body.addEventListener(\n          'click', this.handleBodyClick, {capture: true});\n    };\n    this.deregisterBodyClickListener = () => {\n      document.body.removeEventListener(\n          'click', this.handleBodyClick, {capture: true});\n    };\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  override 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   * Sets the foundation to use page offsets for a positioning when the menu is\n   * hoisted to the body.\n   */\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  /**\n   * Sets the absolute x/y position to position based on. Requires the menu to\n   * be hoisted.\n   */\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  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      hasClass: (className) => this.root.classList.contains(className),\n      hasAnchor: () => !!this.anchorElement,\n      notifyClose: () => {\n        this.emit(MDCMenuSurfaceFoundation.strings.CLOSED_EVENT, {});\n      },\n      notifyClosing: () => {\n        this.emit(MDCMenuSurfaceFoundation.strings.CLOSING_EVENT, {});\n      },\n      notifyOpen: () => {\n        this.emit(MDCMenuSurfaceFoundation.strings.OPENED_EVENT, {});\n      },\n      notifyOpening: () => {\n        this.emit(MDCMenuSurfaceFoundation.strings.OPENING_EVENT, {});\n      },\n      isElementInContainer: (el) => this.root.contains(el),\n      isRtl: () =>\n          getComputedStyle(this.root).getPropertyValue('direction') === 'rtl',\n      setTransformOrigin: (origin) => {\n        const propertyName =\n            `${getCorrectPropertyName(window, 'transform')}-origin`;\n        this.root.style.setProperty(propertyName, origin);\n      },\n\n      isFocused: () => document.activeElement === this.root,\n      saveFocus: () => {\n        this.previousFocus =\n            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      getInnerDimensions: () => {\n        return {width: this.root.offsetWidth, height: this.root.offsetHeight};\n      },\n      getAnchorDimensions: () => this.anchorElement ?\n          this.anchorElement.getBoundingClientRect() :\n          null,\n      getViewportDimensions: () => {\n        return {width: window.innerWidth, height: window.innerHeight};\n      },\n      getBodyDimensions: () => {\n        return {\n          width: document.body.clientWidth,\n          height: document.body.clientHeight\n        };\n      },\n      getWindowScroll: () => {\n        return {x: window.pageXOffset, y: window.pageYOffset};\n      },\n      setPosition: (position) => {\n        const rootHTML = this.root;\n        rootHTML.style.left = 'left' in position ? `${position.left}px` : '';\n        rootHTML.style.right = 'right' in position ? `${position.right}px` : '';\n        rootHTML.style.top = 'top' in position ? `${position.top}px` : '';\n        rootHTML.style.bottom =\n            'bottom' in position ? `${position.bottom}px` : '';\n      },\n      setMaxHeight: (height) => {\n        this.root.style.maxHeight = height;\n      },\n      registerWindowEventHandler: (eventType, handler) => {\n        window.addEventListener(eventType, handler);\n      },\n      deregisterWindowEventHandler: (eventType, handler) => {\n        window.removeEventListener(eventType, handler);\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  IS_OPEN_BELOW: 'mdc-menu-surface--is-open-below',\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  CLOSING_EVENT: 'MDCMenuSurface:closing',\n  OPENED_EVENT: 'MDCMenuSurface:opened',\n  OPENING_EVENT: 'MDCMenuSurface:opening',\n  FOCUSABLE_ELEMENTS: [\n    'button:not(:disabled)',\n    '[href]:not([aria-disabled=\"true\"])',\n    'input:not(:disabled)',\n    'select:not(:disabled)',\n    'textarea:not(:disabled)',\n    '[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  /**\n   * Margin left to the edge of the viewport when menu-surface is at maximum\n   * possible height. Also used as a viewport margin.\n   */\n  MARGIN_TO_EDGE: 32,\n\n  /**\n   * Ratio of anchor width to menu-surface width for switching from corner\n   * positioning to center positioning.\n   */\n  ANCHOR_TO_MENU_SURFACE_WIDTH_RATIO: 0.67,\n\n  /**\n   * Amount of time to wait before restoring focus when closing the menu\n   * surface. This is important because if a touch event triggered the menu\n   * close, and the subsequent mouse event occurs after focus is restored, then\n   * the restored focus would be lost.\n   */\n  TOUCH_EVENT_WAIT_MS: 30,\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 =\n      CornerBit.BOTTOM | CornerBit.RIGHT,  // tslint:disable-line:no-bitwise\n  TOP_START = CornerBit.FLIP_RTL,\n  TOP_END =\n      CornerBit.FLIP_RTL | CornerBit.RIGHT,  // tslint:disable-line:no-bitwise\n  BOTTOM_START =\n      CornerBit.BOTTOM | CornerBit.FLIP_RTL,  // tslint:disable-line:no-bitwise\n  BOTTOM_END = CornerBit.BOTTOM | CornerBit.RIGHT |\n      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 {SpecificEventListener} from '@material/base/types';\n\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\n/** MDC Menu Surface Foundation */\nexport class MDCMenuSurfaceFoundation extends\n    MDCFoundation<MDCMenuSurfaceAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override 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 override 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      getViewportDimensions: () => ({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      notifyClosing: () => undefined,\n      notifyOpen: () => undefined,\n      notifyOpening: () => undefined,\n      registerWindowEventHandler: () => undefined,\n      deregisterWindowEventHandler: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private isSurfaceOpen = false;\n  private isQuickOpen = false;\n  private isHoistedElement = false;\n  private isFixedPosition = false;\n  private isHorizontallyCenteredOnViewport = false;\n\n  private maxHeight = 0;\n  private openBottomBias = 0;\n\n  private openAnimationEndTimerId = 0;\n  private closeAnimationEndTimerId = 0;\n  private animationRequestId = 0;\n\n  private anchorCorner: Corner = Corner.TOP_START;\n\n  private resizeListener!:\n      SpecificEventListener<'resize'>;  // Assigned in #initialize.\n\n  /**\n   * Corner of the menu surface to which menu surface is attached to anchor.\n   *\n   *  Anchor corner --->+----------+\n   *                    |  ANCHOR  |\n   *                    +----------+\n   *  Origin corner --->+--------------+\n   *                    |              |\n   *                    |              |\n   *                    | MENU SURFACE |\n   *                    |              |\n   *                    |              |\n   *                    +--------------+\n   */\n  private originCorner: Corner = Corner.TOP_START;\n  private readonly anchorMargin:\n      MDCMenuDistance = {top: 0, right: 0, bottom: 0, left: 0};\n  private readonly 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  override 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.isSurfaceOpen = true;\n    }\n\n    this.resizeListener = this.handleResize.bind(this);\n    this.adapter.registerWindowEventHandler('resize', this.resizeListener);\n  }\n\n  override destroy() {\n    clearTimeout(this.openAnimationEndTimerId);\n    clearTimeout(this.closeAnimationEndTimerId);\n    // Cancel any currently running animations.\n    cancelAnimationFrame(this.animationRequestId);\n\n    this.adapter.deregisterWindowEventHandler('resize', this.resizeListener);\n  }\n\n  /**\n   * @param corner Default anchor corner alignment of top-left menu surface\n   *     corner.\n   */\n  setAnchorCorner(corner: Corner) {\n    this.anchorCorner = corner;\n  }\n\n  /**\n   * Flip menu corner horizontally.\n   */\n  flipCornerHorizontally() {\n    this.originCorner = this.originCorner ^ CornerBit.RIGHT;\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  /**\n   * Used to set the menu-surface calculations based on a fixed position menu.\n   */\n  setFixedPosition(isFixedPosition: boolean) {\n    this.isFixedPosition = isFixedPosition;\n  }\n\n  /**\n   * @return Returns true if menu is in fixed (`position: fixed`) position.\n   */\n  isFixed() {\n    return this.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  /** Sets whether menu-surface should be horizontally centered to viewport. */\n  setIsHorizontallyCenteredOnViewport(isCentered: boolean) {\n    this.isHorizontallyCenteredOnViewport = isCentered;\n  }\n\n  setQuickOpen(quickOpen: boolean) {\n    this.isQuickOpen = quickOpen;\n  }\n\n  /**\n   * Sets maximum menu-surface height on open.\n   * @param maxHeight The desired max-height. Set to 0 (default) to\n   *     automatically calculate max height based on available viewport space.\n   */\n  setMaxHeight(maxHeight: number) {\n    this.maxHeight = maxHeight;\n  }\n\n  /**\n   * Set to a positive integer to influence the menu to preferentially open\n   * below the anchor instead of above.\n   * @param bias A value of `x` simulates an extra `x` pixels of available space\n   *     below the menu during positioning calculations.\n   */\n  setOpenBottomBias(bias: number) {\n    this.openBottomBias = bias;\n  }\n\n  isOpen() {\n    return this.isSurfaceOpen;\n  }\n\n  /**\n   * Open the menu surface.\n   */\n  open() {\n    if (this.isSurfaceOpen) {\n      return;\n    }\n\n    this.adapter.notifyOpening();\n    this.adapter.saveFocus();\n\n    if (this.isQuickOpen) {\n      this.isSurfaceOpen = true;\n      this.adapter.addClass(MDCMenuSurfaceFoundation.cssClasses.OPEN);\n      this.dimensions = this.adapter.getInnerDimensions();\n      this.autoposition();\n      this.adapter.notifyOpen();\n    } else {\n      this.adapter.addClass(MDCMenuSurfaceFoundation.cssClasses.ANIMATING_OPEN);\n      this.animationRequestId = requestAnimationFrame(() => {\n        this.dimensions = this.adapter.getInnerDimensions();\n        this.autoposition();\n        this.adapter.addClass(MDCMenuSurfaceFoundation.cssClasses.OPEN);\n        this.openAnimationEndTimerId = setTimeout(() => {\n          this.openAnimationEndTimerId = 0;\n          this.adapter.removeClass(\n              MDCMenuSurfaceFoundation.cssClasses.ANIMATING_OPEN);\n          this.adapter.notifyOpen();\n        }, numbers.TRANSITION_OPEN_DURATION);\n      });\n\n      this.isSurfaceOpen = true;\n    }\n\n    this.adapter.registerWindowEventHandler('resize', this.resizeListener);\n  }\n\n  /**\n   * Closes the menu surface.\n   */\n  close(skipRestoreFocus = false) {\n    if (!this.isSurfaceOpen) {\n      return;\n    }\n\n    this.adapter.notifyClosing();\n    this.adapter.deregisterWindowEventHandler('resize', this.resizeListener);\n\n    if (this.isQuickOpen) {\n      this.isSurfaceOpen = false;\n      if (!skipRestoreFocus) {\n        this.maybeRestoreFocus();\n      }\n\n      this.adapter.removeClass(MDCMenuSurfaceFoundation.cssClasses.OPEN);\n      this.adapter.removeClass(\n          MDCMenuSurfaceFoundation.cssClasses.IS_OPEN_BELOW);\n      this.adapter.notifyClose();\n\n      return;\n    }\n\n    this.adapter.addClass(MDCMenuSurfaceFoundation.cssClasses.ANIMATING_CLOSED);\n    requestAnimationFrame(() => {\n      this.adapter.removeClass(MDCMenuSurfaceFoundation.cssClasses.OPEN);\n      this.adapter.removeClass(\n          MDCMenuSurfaceFoundation.cssClasses.IS_OPEN_BELOW);\n      this.closeAnimationEndTimerId = setTimeout(() => {\n        this.closeAnimationEndTimerId = 0;\n        this.adapter.removeClass(\n            MDCMenuSurfaceFoundation.cssClasses.ANIMATING_CLOSED);\n        this.adapter.notifyClose();\n      }, numbers.TRANSITION_CLOSE_DURATION);\n    });\n\n    this.isSurfaceOpen = false;\n    if (!skipRestoreFocus) {\n      this.maybeRestoreFocus();\n    }\n  }\n\n  /** Handle clicks and close if not within menu-surface element. */\n  handleBodyClick(event: MouseEvent) {\n    const el = event.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(event: KeyboardEvent) {\n    const {keyCode, key} = event;\n\n    const isEscape = key === 'Escape' || keyCode === 27;\n    if (isEscape) {\n      this.close();\n    }\n  }\n\n  /** Handles resize events on the window. */\n  private handleResize() {\n    this.dimensions = this.adapter.getInnerDimensions();\n    this.autoposition();\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 =\n        this.hasBit(corner, CornerBit.BOTTOM) ? 'bottom' : 'top';\n    let horizontalAlignment =\n        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\n    // surface, otherwise keep corner.\n    if (anchorSize.width / surfaceSize.width >\n        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\n    // to the anchor element\n    if (this.isHoistedElement || this.isFixedPosition) {\n      this.adjustPositionForHoistedElement(position);\n    }\n\n    this.adapter.setTransformOrigin(\n        `${horizontalAlignment} ${verticalAlignment}`);\n    this.adapter.setPosition(position);\n    this.adapter.setMaxHeight(\n        maxMenuSurfaceHeight ? maxMenuSurfaceHeight + 'px' : '');\n\n    // If it is opened from the top then add is-open-below class\n    if (!this.hasBit(corner, CornerBit.BOTTOM)) {\n      this.adapter.addClass(MDCMenuSurfaceFoundation.cssClasses.IS_OPEN_BELOW);\n    }\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.getViewportDimensions();\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      } as any;\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\n   * menu surface.\n   *\n   * Only LEFT or RIGHT bit is used to position the menu surface ignoring RTL\n   * context. E.g., menu surface will be positioned from right side on TOP_END.\n   */\n  private getoriginCorner(): Corner {\n    let corner = this.originCorner;\n\n    const {viewportDistance, anchorSize, surfaceSize} = this.measurements;\n    const {MARGIN_TO_EDGE} = MDCMenuSurfaceFoundation.numbers;\n\n    const isAnchoredToBottom = this.hasBit(this.anchorCorner, CornerBit.BOTTOM);\n\n    let availableTop;\n    let availableBottom;\n    if (isAnchoredToBottom) {\n      availableTop =\n          viewportDistance.top - MARGIN_TO_EDGE + this.anchorMargin.bottom;\n      availableBottom =\n          viewportDistance.bottom - MARGIN_TO_EDGE - this.anchorMargin.bottom;\n    } else {\n      availableTop =\n          viewportDistance.top - MARGIN_TO_EDGE + this.anchorMargin.top;\n      availableBottom = viewportDistance.bottom - MARGIN_TO_EDGE +\n          anchorSize.height - this.anchorMargin.top;\n    }\n\n    const isAvailableBottom = availableBottom - surfaceSize.height > 0;\n    if (!isAvailableBottom &&\n        availableTop > availableBottom + this.openBottomBias) {\n      // Attach bottom side of surface to the anchor.\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 hasRightBit = this.hasBit(this.anchorCorner, CornerBit.RIGHT) ||\n        this.hasBit(corner, CornerBit.RIGHT);\n\n    // Whether surface attached to right side of anchor element.\n    let isAnchoredToRight = false;\n\n    // Anchored to start\n    if (isRtl && isFlipRtl) {\n      isAnchoredToRight = !hasRightBit;\n    } else {\n      // Anchored to right\n      isAnchoredToRight = hasRightBit;\n    }\n\n    let availableLeft;\n    let availableRight;\n    if (isAnchoredToRight) {\n      availableLeft =\n          viewportDistance.left + anchorSize.width + this.anchorMargin.left;\n      availableRight = viewportDistance.right - this.anchorMargin.left;\n    } else {\n      availableLeft = viewportDistance.left + this.anchorMargin.left;\n      availableRight =\n          viewportDistance.right + anchorSize.width - this.anchorMargin.left;\n    }\n\n    const isAvailableLeft = availableLeft - surfaceSize.width > 0;\n    const isAvailableRight = availableRight - surfaceSize.width > 0;\n    const isOriginCornerAlignedToEnd =\n        this.hasBit(corner, CornerBit.FLIP_RTL) &&\n        this.hasBit(corner, CornerBit.RIGHT);\n\n    if (isAvailableRight && isOriginCornerAlignedToEnd && isRtl ||\n        !isAvailableLeft && isOriginCornerAlignedToEnd) {\n      // Attach left side of surface to the anchor.\n      corner = this.unsetBit(corner, CornerBit.RIGHT);\n    } else if (\n        isAvailableLeft && isAnchoredToRight && isRtl ||\n        (isAvailableLeft && !isAnchoredToRight && hasRightBit) ||\n        (!isAvailableRight && availableLeft >= availableRight)) {\n      // Attach right side of surface to the anchor.\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\n   *     indicates should not be set.\n   */\n  private getMenuSurfaceMaxHeight(corner: Corner): number {\n    if (this.maxHeight > 0) {\n      return this.maxHeight;\n    }\n\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 = viewportDistance.bottom - this.anchorMargin.bottom +\n          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\n   *     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 =\n        this.hasBit(this.anchorCorner, CornerBit.RIGHT);\n\n    if (isRightAligned) {\n      const rightOffset = avoidHorizontalOverlap ?\n          anchorSize.width - this.anchorMargin.left :\n          this.anchorMargin.right;\n\n      // For hoisted or fixed elements, adjust the offset by the difference\n      // between viewport width and body width so when we calculate the right\n      // value (`adjustPositionForHoistedElement`) based on the element\n      // position, the right property is correct.\n      if (this.isHoistedElement || this.isFixedPosition) {\n        return rightOffset -\n            (this.measurements.viewportSize.width -\n             this.measurements.bodySize.width);\n      }\n\n      return rightOffset;\n    }\n\n    return avoidHorizontalOverlap ? anchorSize.width - this.anchorMargin.right :\n                                    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\n   *     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 =\n        this.hasBit(this.anchorCorner, CornerBit.BOTTOM);\n\n    let y = 0;\n    if (isBottomAligned) {\n      y = avoidVerticalOverlap ? anchorSize.height - this.anchorMargin.top :\n                                 -this.anchorMargin.bottom;\n    } else {\n      y = avoidVerticalOverlap ?\n          (anchorSize.height + this.anchorMargin.bottom) :\n          this.anchorMargin.top;\n    }\n    return y;\n  }\n\n  /**\n   * Calculates the offsets for positioning the menu-surface when the\n   * menu-surface has been hoisted to the body.\n   */\n  private adjustPositionForHoistedElement(position: Partial<MDCMenuDistance>) {\n    const {windowScroll, viewportDistance, surfaceSize, viewportSize} =\n        this.measurements;\n\n    const props =\n        Object.keys(position) as Array<keyof Partial<MDCMenuDistance>>;\n\n    for (const prop of props) {\n      let value = position[prop] || 0;\n\n      if (this.isHorizontallyCenteredOnViewport &&\n          (prop === 'left' || prop === 'right')) {\n        position[prop] = (viewportSize.width - surfaceSize.width) / 2;\n        continue;\n      }\n\n      // Hoisted surfaces need to have the anchor elements location on the page\n      // added to the position properties for proper alignment on the body.\n      value += viewportDistance[prop];\n\n      // Surfaces that are absolutely positioned need to have additional\n      // calculations for scroll 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\n   * focus, if the user is focused on or within the menu surface when it is\n   * closed.\n   */\n  private maybeRestoreFocus() {\n    const isRootFocused = this.adapter.isFocused();\n    const ownerDocument = this.adapter.getOwnerDocument ?\n        this.adapter.getOwnerDocument() :\n        document;\n    const childHasFocus = ownerDocument.activeElement &&\n        this.adapter.isElementInContainer(ownerDocument.activeElement);\n    if (isRootFocused || childHasFocus) {\n      // Wait before restoring focus when closing the menu surface. This is\n      // important because if a touch event triggered the menu close, and the\n      // subsequent mouse event occurs after focus is restored, then the\n      // restored focus would be lost.\n      setTimeout(() => {\n        this.adapter.restoreFocus();\n      }, numbers.TOUCH_EVENT_WAIT_MS);\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  private unsetBit(corner: Corner, bit: CornerBit): Corner {\n    return corner ^ bit;\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\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\nexport interface MDCMenuDimensions {\n  width: number;\n  height: number;\n}\n\nexport interface MDCMenuDistance {\n  top: number;\n  right: number;\n  bottom: number;\n  left: number;\n}\n\nexport interface MDCMenuPoint {\n  x: number;\n  y: number;\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 {MDCMenuItemEventDetail} from './types';\n\n/**\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCMenuAdapter {\n  /**\n   * Adds a class to the element at the index provided.\n   */\n  addClassToElementAtIndex(index: number, className: string): void;\n\n  /**\n   * Removes a class from the element at the index provided\n   */\n  removeClassFromElementAtIndex(index: number, className: string): void;\n\n  /**\n   * Adds an attribute, with value, to the element at the index provided.\n   */\n  addAttributeToElementAtIndex(index: number, attr: string, value: string):\n      void;\n\n  /**\n   * Removes an attribute from an element at the index provided.\n   */\n  removeAttributeFromElementAtIndex(index: number, attr: string): void;\n\n  /**\n   * @return the attribute string if present on an element at the index\n   * provided, null otherwise.\n   */\n  getAttributeFromElementAtIndex(index: number, attr: string): string|null;\n\n  /**\n   * @return true if the element contains the className.\n   */\n  elementContainsClass(element: Element, className: string): boolean;\n\n  /**\n   * Closes the menu-surface.\n   * @param skipRestoreFocus Whether to skip restoring focus to the previously\n   *    focused element after the surface has been closed.\n   */\n  closeSurface(skipRestoreFocus?: boolean): void;\n\n  /**\n   * @return Index of the element in the list or -1 if it is not in the list.\n   */\n  getElementIndex(element: HTMLElement): number;\n\n  /**\n   * Emit an event when a menu item is selected.\n   */\n  notifySelected(eventData: MDCMenuItemEventDetail): void;\n\n  /** @return Returns the menu item count. */\n  getMenuItemCount(): number;\n\n  /**\n   * Focuses the menu item at given index.\n   * @param index Index of the menu item that will be focused every time the\n   *     menu opens.\n   */\n  focusItemAtIndex(index: number): void;\n\n  /** Focuses the list root element. */\n  focusListRoot(): void;\n\n  /**\n   * @return Returns selected list item index within the same selection group\n   *     which is\n   * a sibling of item at given `index`.\n   * @param index Index of the menu item with possible selected sibling.\n   */\n  getSelectedSiblingOfItemAtIndex(index: number): number;\n\n  /**\n   * @return Returns true if item at specified index is contained within an\n   *     `.mdc-menu__selection-group` element.\n   * @param index Index of the selectable menu item.\n   */\n  isSelectableItemAtIndex(index: number): boolean;\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 {CustomEventListener, SpecificEventListener} from '@material/base/types';\nimport {closest} from '@material/dom/ponyfill';\nimport {MDCList, MDCListFactory} from '@material/list/component';\nimport {numbers as listConstants} from '@material/list/constants';\nimport {MDCListFoundation} from '@material/list/foundation';\nimport {MDCListActionEvent, MDCListIndex} 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';\n\nimport {MDCMenuAdapter} from './adapter';\nimport {cssClasses, DefaultFocusState, strings} from './constants';\nimport {MDCMenuFoundation} from './foundation';\nimport {MDCMenuItemComponentEventDetail} from './types';\n\n/** MDC Menu Factory */\nexport type MDCMenuFactory =\n    (el: HTMLElement, foundation?: MDCMenuFoundation) => MDCMenu;\n\n/** MDC Menu */\nexport class MDCMenu extends MDCComponent<MDCMenuFoundation> {\n  static override attachTo(root: HTMLElement) {\n    return new MDCMenu(root);\n  }\n\n  private menuSurfaceFactory!:\n      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!:\n      SpecificEventListener<'keydown'>;  // assigned in initialSyncWithDOM()\n  private handleItemAction!:\n      CustomEventListener<MDCListActionEvent>;  // assigned in\n                                                // initialSyncWithDOM()\n  private handleMenuSurfaceOpened!:\n      EventListener;  // assigned in initialSyncWithDOM()\n\n  override initialize(\n      menuSurfaceFactory:\n          MDCMenuSurfaceFactory = (el) => new MDCMenuSurface(el),\n      listFactory: MDCListFactory = (el) => new MDCList(el)) {\n    this.menuSurfaceFactory = menuSurfaceFactory;\n    this.listFactory = listFactory;\n  }\n\n  override initialSyncWithDOM() {\n    this.menuSurface = this.menuSurfaceFactory(this.root);\n\n    const list = this.root.querySelector<HTMLElement>(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 = (event) => {\n      this.foundation.handleKeydown(event);\n    };\n    this.handleItemAction = (event) => {\n      this.foundation.handleItemAction(this.items[event.detail.index]);\n    };\n    this.handleMenuSurfaceOpened = () => {\n      this.foundation.handleMenuSurfaceOpened();\n    };\n\n    this.menuSurface.listen(\n        MDCMenuSurfaceFoundation.strings.OPENED_EVENT,\n        this.handleMenuSurfaceOpened);\n    this.listen('keydown', this.handleKeydown);\n    this.listen(MDCListFoundation.strings.ACTION_EVENT, this.handleItemAction);\n  }\n\n  override destroy() {\n    if (this.list) {\n      this.list.destroy();\n    }\n\n    this.menuSurface.destroy();\n    this.menuSurface.unlisten(\n        MDCMenuSurfaceFoundation.strings.OPENED_EVENT,\n        this.handleMenuSurfaceOpened);\n    this.unlisten('keydown', this.handleKeydown);\n    this.unlisten(\n        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   * Sets whether the menu has typeahead functionality.\n   * @param value Whether typeahead is enabled.\n   */\n  set hasTypeahead(value: boolean) {\n    if (this.list) {\n      this.list.hasTypeahead = value;\n    }\n  }\n\n  /**\n   * @return Whether typeahead logic is currently matching some user prefix.\n   */\n  get typeaheadInProgress() {\n    return this.list ? this.list.typeaheadInProgress : false;\n  }\n\n  /**\n   * Given the next desired character from the user, adds it to the typeahead\n   * buffer. Then, attempts to find the next option matching the buffer. Wraps\n   * around if at the end of options.\n   *\n   * @param nextChar The next character to add to the prefix buffer.\n   * @param startingIndex The index from which to start matching. Only relevant\n   *     when starting a new match sequence. To start a new match sequence,\n   *     clear the buffer using `clearTypeaheadBuffer`, or wait for the buffer\n   *     to clear after a set interval defined in list foundation. Defaults to\n   *     the currently focused index.\n   * @return The index of the matched item, or -1 if no match.\n   */\n  typeaheadMatchItem(nextChar: string, startingIndex?: number): number {\n    if (this.list) {\n      return this.list.typeaheadMatchItem(nextChar, startingIndex);\n    }\n    return -1;\n  }\n\n  /**\n   * Layout the underlying list element in the case of any dynamic updates\n   * to its structure.\n   */\n  layout() {\n    if (this.list) {\n      this.list.layout();\n    }\n  }\n\n  /**\n   * Return the items within the menu. Note that this only contains the set of\n   * elements within the items container that are proper list items, and not\n   * supplemental / presentational DOM elements.\n   */\n  get items(): HTMLElement[] {\n    return this.list ? this.list.listElements : [];\n  }\n\n  /**\n   * Turns on/off the underlying list's single selection mode. Used mainly\n   * by select menu.\n   *\n   * @param singleSelection Whether to enable single selection mode.\n   */\n  set singleSelection(singleSelection: boolean) {\n    if (this.list) {\n      this.list.singleSelection = singleSelection;\n    }\n  }\n\n  /**\n   * Retrieves the selected index. Only applicable to select menus.\n   * @return The selected index, which is a number for single selection and\n   *     radio lists, and an array of numbers for checkbox lists.\n   */\n  get selectedIndex(): MDCListIndex {\n    return this.list ? this.list.selectedIndex : listConstants.UNSET_INDEX;\n  }\n\n  /**\n   * Sets the selected index of the list. Only applicable to select menus.\n   * @param index The selected index, which is a number for single selection and\n   *     radio lists, and an array of numbers for checkbox lists.\n   */\n  set selectedIndex(index: MDCListIndex) {\n    if (this.list) {\n      this.list.selectedIndex = index;\n    }\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  /**\n   * @param index A menu item's index.\n   * @return The primary text within the menu at the index specified.\n   */\n  getPrimaryTextAtIndex(index: number): string {\n    const item = this.getOptionByIndex(index);\n    if (item && this.list) {\n      return this.list.getPrimaryText(item) || '';\n    }\n    return '';\n  }\n\n  setFixedPosition(isFixed: boolean) {\n    this.menuSurface.setFixedPosition(isFixed);\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  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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        this.safeSetAttribute(list[index], attr, value);\n      },\n      removeAttributeFromElementAtIndex: (index, attr) => {\n        const list = this.items;\n        list[index].removeAttribute(attr);\n      },\n      getAttributeFromElementAtIndex: (index, attr) => {\n        const list = this.items;\n        return list[index].getAttribute(attr);\n      },\n      elementContainsClass: (element, className) =>\n          element.classList.contains(className),\n      closeSurface: (skipRestoreFocus: boolean) => {\n        this.menuSurface.close(skipRestoreFocus);\n      },\n      getElementIndex: (element) => this.items.indexOf(element),\n      notifySelected: (eventData) => {\n        this.emit<MDCMenuItemComponentEventDetail>(strings.SELECTED_EVENT, {\n          index: eventData.index,\n          item: this.items[eventData.index],\n        });\n      },\n      getMenuItemCount: () => this.items.length,\n      focusItemAtIndex: (index) => {\n        this.items[index].focus();\n      },\n      focusListRoot: () => {\n        this.root.querySelector<HTMLElement>(strings.LIST_SELECTOR)!.focus();\n      },\n      isSelectableItemAtIndex: (index) =>\n          !!closest(this.items[index], `.${cssClasses.MENU_SELECTION_GROUP}`),\n      getSelectedSiblingOfItemAtIndex: (index) => {\n        const selectionGroupEl =\n            closest(this.items[index], `.${cssClasses.MENU_SELECTION_GROUP}`) as\n            HTMLElement;\n        const selectedItemEl = selectionGroupEl.querySelector<HTMLElement>(\n            `.${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,.mdc-deprecated-list',\n  SELECTED_EVENT: 'MDCMenu:selected',\n  SKIP_RESTORE_FOCUS: 'data-menu-item-skip-restore-focus',\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';\n\nimport {MDCMenuAdapter} from './adapter';\nimport {cssClasses, DefaultFocusState, numbers, strings} from './constants';\n\n/** MDC Menu Foundation */\nexport class MDCMenuFoundation extends MDCFoundation<MDCMenuAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override get numbers() {\n    return numbers;\n  }\n\n  private defaultFocusState = DefaultFocusState.LIST_ROOT;\n  private selectedIndex = -1;\n\n  /**\n   * @see {@link MDCMenuAdapter} for typing information on parameters and return types.\n   */\n  static override 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      getAttributeFromElementAtIndex: () => null,\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  override destroy() {\n    this.adapter.closeSurface();\n  }\n\n  handleKeydown(event: KeyboardEvent) {\n    const {key, keyCode} = event;\n    const isTab = key === 'Tab' || keyCode === 9;\n\n    if (isTab) {\n      this.adapter.closeSurface(/** skipRestoreFocus */ true);\n    }\n  }\n\n  handleItemAction(listItem: HTMLElement) {\n    const index = this.adapter.getElementIndex(listItem);\n    if (index < 0) {\n      return;\n    }\n\n    this.adapter.notifySelected({index});\n    const skipRestoreFocus = this.adapter.getAttributeFromElementAtIndex(\n                                 index, strings.SKIP_RESTORE_FOCUS) === 'true';\n    this.adapter.closeSurface(skipRestoreFocus);\n\n    if (this.adapter.isSelectableItemAtIndex(index)) {\n      this.setSelectedIndex(index);\n    }\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  /** @return Index of the currently selected list item within the menu. */\n  getSelectedIndex() {\n    return this.selectedIndex;\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(\n          'MDCMenuFoundation: No selection group at specified index.');\n    }\n\n    const prevSelectedIndex =\n        this.adapter.getSelectedSiblingOfItemAtIndex(index);\n    if (prevSelectedIndex >= 0) {\n      this.adapter.removeAttributeFromElementAtIndex(\n          prevSelectedIndex, strings.ARIA_CHECKED_ATTR);\n      this.adapter.removeClassFromElementAtIndex(\n          prevSelectedIndex, cssClasses.MENU_SELECTED_LIST_ITEM);\n    }\n\n    this.adapter.addClassToElementAtIndex(\n        index, cssClasses.MENU_SELECTED_LIST_ITEM);\n    this.adapter.addAttributeToElementAtIndex(\n        index, strings.ARIA_CHECKED_ATTR, 'true');\n\n    this.selectedIndex = 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.validatedIndex(index);\n\n    if (isEnabled) {\n      this.adapter.removeClassFromElementAtIndex(\n          index, listCssClasses.LIST_ITEM_DISABLED_CLASS);\n      this.adapter.addAttributeToElementAtIndex(\n          index, strings.ARIA_DISABLED_ATTR, 'false');\n    } else {\n      this.adapter.addClassToElementAtIndex(\n          index, listCssClasses.LIST_ITEM_DISABLED_CLASS);\n      this.adapter.addAttributeToElementAtIndex(\n          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 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 * Event properties used by the adapter and foundation.\n */\nexport interface MDCMenuItemEventDetail {\n  index: number;\n}\n\n/**\n * Event properties specific to the default component implementation.\n */\nexport interface MDCMenuItemComponentEventDetail extends\n    MDCMenuItemEventDetail {\n  item: Element;\n}\n\n// Note: CustomEvent<T> is not supported by Closure Compiler.\n\nexport interface MDCMenuItemEvent extends Event {\n  readonly detail: MDCMenuItemEventDetail;\n}\n\nexport interface MDCMenuItemComponentEvent extends Event {\n  readonly detail: MDCMenuItemComponentEventDetail;\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\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCNotchedOutlineAdapter {\n  /**\n   * Adds a class to the root element.\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes a class from the root element.\n   */\n  removeClass(className: string): void;\n\n  /**\n   * Sets the width style property of the notch element.\n   */\n  setNotchWidthProperty(width: number): void;\n\n  /**\n   * Removes the width style property from the notch element.\n   */\n  removeNotchWidthProperty(): void;\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 {MDCComponent} from '@material/base/component';\nimport {MDCFloatingLabelFoundation} from '@material/floating-label/foundation';\n\nimport {MDCNotchedOutlineAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCNotchedOutlineFoundation} from './foundation';\n\n/** MDC Notched Outline Factory */\nexport type MDCNotchedOutlineFactory =\n    (el: HTMLElement, foundation?: MDCNotchedOutlineFoundation) =>\n        MDCNotchedOutline;\n\n/** MDC Notched Outline */\nexport class MDCNotchedOutline extends\n    MDCComponent<MDCNotchedOutlineFoundation> {\n  static override attachTo(root: HTMLElement): MDCNotchedOutline {\n    return new MDCNotchedOutline(root);\n  }\n\n  private notchElement!: HTMLElement;  // assigned in initialSyncWithDOM()\n\n  override initialSyncWithDOM() {\n    this.notchElement =\n        this.root.querySelector<HTMLElement>(strings.NOTCH_ELEMENT_SELECTOR)!;\n\n    const label = this.root.querySelector<HTMLElement>(\n        '.' + 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  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      setNotchWidthProperty: (width) => {\n        this.notchElement.style.setProperty('width', width + 'px');\n      },\n      removeNotchWidthProperty: () => {\n        this.notchElement.style.removeProperty('width');\n      },\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';\n\nimport {MDCNotchedOutlineAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\n/** MDC Notched Outline Foundation */\nexport class MDCNotchedOutlineFoundation extends\n    MDCFoundation<MDCNotchedOutlineAdapter> {\n  static override get strings() {\n    return strings;\n  }\n\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get numbers() {\n    return numbers;\n  }\n\n  /**\n   * See {@link MDCNotchedOutlineAdapter} for typing information on parameters\n   * and return types.\n   */\n  static override 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\n   * based off of notchWidth.\n   */\n  notch(notchWidth: number) {\n    const {OUTLINE_NOTCHED} = MDCNotchedOutlineFoundation.cssClasses;\n\n    if (notchWidth > 0) {\n      notchWidth +=\n          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\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCRadioAdapter {\n  addClass(className: string): void;\n  removeClass(className: string): void;\n  setNativeControlDisabled(disabled: boolean): void;\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 {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';\n\nimport {MDCRadioAdapter} from './adapter';\nimport {MDCRadioFoundation} from './foundation';\n\n/** MDC Radio */\nexport class MDCRadio extends MDCComponent<MDCRadioFoundation> implements\n    MDCRippleCapableSurface {\n  static override attachTo(root: HTMLElement) {\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.rippleSurface;\n  }\n\n  private readonly rippleSurface: MDCRipple = this.createRipple();\n\n  override destroy() {\n    this.rippleSurface.destroy();\n    super.destroy();\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCRadioAdapter = {\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      setNativeControlDisabled: (disabled) => this.nativeControl.disabled =\n          disabled,\n    };\n    return new MDCRadioFoundation(adapter);\n  }\n\n  private createRipple(): MDCRipple {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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: (eventType, handler) => {\n        this.nativeControl.addEventListener(eventType, handler, applyPassive());\n      },\n      deregisterInteractionHandler: (eventType, handler) => {\n        this.nativeControl.removeEventListener(\n            eventType, handler, applyPassive());\n      },\n      // Radio buttons technically go \"active\" whenever there is *any* keyboard\n      // interaction. 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 =\n        this.root.querySelector<HTMLInputElement>(NATIVE_CONTROL_SELECTOR);\n    if (!el) {\n      throw new Error(\n          `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';\n\nimport {MDCRadioAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\n/** MDC Radio Foundation */\nexport class MDCRadioFoundation extends MDCFoundation<MDCRadioAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override 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 {EventType, SpecificEventListener} from '@material/base/types';\n\nimport {MDCRipplePoint} from './types';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCRippleAdapter {\n  browserSupportsCssVars(): boolean;\n\n  isUnbounded(): boolean;\n\n  isSurfaceActive(): boolean;\n\n  isSurfaceDisabled(): boolean;\n\n  addClass(className: string): void;\n\n  removeClass(className: string): void;\n\n  containsEventTarget(target: EventTarget|null): boolean;\n\n  registerInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  deregisterInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  registerDocumentInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  deregisterDocumentInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  registerResizeHandler(handler: SpecificEventListener<'resize'>): void;\n\n  deregisterResizeHandler(handler: SpecificEventListener<'resize'>): void;\n\n  updateCssVariable(varName: string, value: string|null): void;\n\n  computeBoundingRect(): DOMRect;\n\n  getWindowPageOffset(): MDCRipplePoint;\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 {applyPassive} from '@material/dom/events';\nimport {matches} from '@material/dom/ponyfill';\n\nimport {MDCRippleAdapter} from './adapter';\nimport {MDCRippleFoundation} from './foundation';\nimport {MDCRippleAttachOpts, MDCRippleCapableSurface} from './types';\nimport * as util from './util';\n\n/** MDC Ripple Factory */\nexport type MDCRippleFactory =\n    (el: HTMLElement, foundation?: MDCRippleFoundation) => MDCRipple;\n\n/** MDC Ripple */\nexport class MDCRipple extends MDCComponent<MDCRippleFoundation> implements\n    MDCRippleCapableSurface {\n  static override attachTo(root: HTMLElement, opts: MDCRippleAttachOpts = {\n    isUnbounded: undefined\n  }): 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) => {\n        instance.root.classList.add(className);\n      },\n      browserSupportsCssVars: () => util.supportsCssVariables(window),\n      computeBoundingRect: () => instance.root.getBoundingClientRect(),\n      containsEventTarget: (target) => instance.root.contains(target as Node),\n      deregisterDocumentInteractionHandler: (eventType, handler) => {\n        document.documentElement.removeEventListener(\n            eventType, handler, applyPassive());\n      },\n      deregisterInteractionHandler: (eventType, handler) => {\n        instance.root.removeEventListener(eventType, handler, applyPassive());\n      },\n      deregisterResizeHandler: (handler) => {\n        window.removeEventListener('resize', handler);\n      },\n      getWindowPageOffset: () =>\n          ({x: window.pageXOffset, y: window.pageYOffset}),\n      isSurfaceActive: () => matches(instance.root, ':active'),\n      isSurfaceDisabled: () => Boolean(instance.disabled),\n      isUnbounded: () => Boolean(instance.unbounded),\n      registerDocumentInteractionHandler: (eventType, handler) => {\n        document.documentElement.addEventListener(\n            eventType, handler, applyPassive());\n      },\n      registerInteractionHandler: (eventType, handler) => {\n        instance.root.addEventListener(eventType, handler, applyPassive());\n      },\n      registerResizeHandler: (handler) => {\n        window.addEventListener('resize', handler);\n      },\n      removeClass: (className) => {\n        instance.root.classList.remove(className);\n      },\n      updateCssVariable: (varName, value) => {\n        instance.root.style.setProperty(varName, value);\n      },\n    };\n  }\n\n  disabled = false;\n\n  private isUnbounded?: boolean;\n\n  get unbounded(): boolean {\n    return Boolean(this.isUnbounded);\n  }\n\n  set unbounded(unbounded: boolean) {\n    this.isUnbounded = 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  override getDefaultFoundation() {\n    return new MDCRippleFoundation(MDCRipple.createAdapter(this));\n  }\n\n  override initialSyncWithDOM() {\n    const root = this.root;\n    this.isUnbounded = '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.isUnbounded));\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\n  // sorts,\n  // given that it's an 'upgrade' to an existing component. That being said it\n  // 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:\n      225,  // Corresponds to $mdc-ripple-translate-duration (i.e. activation\n            // animation duration)\n  FG_DEACTIVATION_MS: 150,  // Corresponds to $mdc-ripple-fade-out-duration\n                            // (i.e. deactivation animation duration)\n  INITIAL_ORIGIN_SCALE: 0.6,\n  PADDING: 10,\n  TAP_DELAY_MS:\n      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';\n\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\ninterface EventHandlerNonNull {\n  (event: Event): any;\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\n// activation\nconst ACTIVATION_EVENT_TYPES: ActivationEventType[] = [\n  'touchstart',\n  'pointerdown',\n  'mousedown',\n  'keydown',\n];\n\n// Deactivation events registered on documentElement when a pointer-related down\n// event occurs\nconst POINTER_DEACTIVATION_EVENT_TYPES: DeactivationEventType[] = [\n  'touchend',\n  'pointerup',\n  'mouseup',\n  'contextmenu',\n];\n\n// simultaneous nested activations\nlet activatedTargets: Array<EventTarget|null> = [];\n\n/** MDC Ripple Foundation */\nexport class MDCRippleFoundation extends MDCFoundation<MDCRippleAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override get numbers() {\n    return numbers;\n  }\n\n  static override get defaultAdapter(): MDCRippleAdapter {\n    return {\n      addClass: () => undefined,\n      browserSupportsCssVars: () => true,\n      computeBoundingRect: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\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) => {\n      this.activateImpl(e);\n    };\n    this.deactivateHandler = () => {\n      this.deactivateImpl();\n    };\n    this.focusHandler = () => {\n      this.handleFocus();\n    };\n    this.blurHandler = () => {\n      this.handleBlur();\n    };\n    this.resizeHandler = () => {\n      this.layout();\n    };\n  }\n\n  override 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\n          // coordinates for both shade and ripple\n          this.layoutInternal();\n        }\n      });\n    }\n  }\n\n  override 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(\n            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 event Optional event containing position information.\n   */\n  activate(event?: Event): void {\n    this.activateImpl(event);\n  }\n\n  deactivate(): void {\n    this.deactivateImpl();\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\n  handleBlur(): void {\n    requestAnimationFrame(() => {\n      this.adapter.removeClass(MDCRippleFoundation.cssClasses.BG_FOCUSED);\n    });\n  }\n\n  /**\n   * We compute this property so that we are not querying information about the\n   * client until the point in time where the foundation requests it. This\n   * prevents scenarios where client-side feature-detection may happen too\n   * early, such as when components are rendered on the server and then\n   * 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      for (const eventType of ACTIVATION_EVENT_TYPES) {\n        this.adapter.registerInteractionHandler(eventType, 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(event: Event) {\n    if (event.type === 'keydown') {\n      this.adapter.registerInteractionHandler('keyup', this.deactivateHandler);\n    } else {\n      for (const eventType of POINTER_DEACTIVATION_EVENT_TYPES) {\n        this.adapter.registerDocumentInteractionHandler(\n            eventType, this.deactivateHandler);\n      }\n    }\n  }\n\n  private deregisterRootHandlers() {\n    for (const eventType of ACTIVATION_EVENT_TYPES) {\n      this.adapter.deregisterInteractionHandler(eventType, 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    for (const eventType of POINTER_DEACTIVATION_EVENT_TYPES) {\n      this.adapter.deregisterDocumentInteractionHandler(\n          eventType, this.deactivateHandler);\n    }\n  }\n\n  private removeCssVars() {\n    const rippleStrings = MDCRippleFoundation.strings;\n    const keys =\n        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 activateImpl(event?: 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\n    // already-processed user interaction\n    const previousActivationEvent = this.previousActivationEvent;\n    const isSameInteraction = previousActivationEvent && event !== undefined &&\n        previousActivationEvent.type !== event.type;\n    if (isSameInteraction) {\n      return;\n    }\n\n    activationState.isActivated = true;\n    activationState.isProgrammatic = event === undefined;\n    activationState.activationEvent = event;\n    activationState.wasActivatedByPointer = activationState.isProgrammatic ?\n        false :\n        event !== undefined &&\n            (event.type === 'mousedown' || event.type === 'touchstart' ||\n             event.type === 'pointerdown');\n\n    const hasActivatedChild = event !== undefined &&\n        activatedTargets.length > 0 &&\n        activatedTargets.some(\n            (target) => this.adapter.containsEventTarget(target));\n    if (hasActivatedChild) {\n      // Immediately reset activation state, while preserving logic that\n      // prevents touch follow-on events\n      this.resetActivationState();\n      return;\n    }\n\n    if (event !== undefined) {\n      activatedTargets.push(event.target);\n      this.registerDeactivationHandlers(event);\n    }\n\n    activationState.wasElementMadeActive = this.checkElementMadeActive(event);\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\n      // bubble to prevent ancestor ripples\n      activatedTargets = [];\n\n      if (!activationState.wasElementMadeActive && event !== undefined &&\n          ((event as KeyboardEvent).key === ' ' ||\n           (event as KeyboardEvent).keyCode === 32)) {\n        // If space was pressed, try again within an rAF call to detect :active,\n        // because different UAs report active states inconsistently when\n        // 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\n        // problem, but will crash if a CSS variable is set within a rAF\n        // callback for a submit button interaction (#2241).\n        activationState.wasElementMadeActive = this.checkElementMadeActive(event);\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(event?: Event) {\n    return (event !== undefined && event.type === 'keydown') ?\n        this.adapter.isSurfaceActive() :\n        true;\n  }\n\n  private animateActivation() {\n    const {VAR_FG_TRANSLATE_START, VAR_FG_TRANSLATE_END} =\n        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(() => {\n      this.activationTimerCallback();\n    }, 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\n    // the activation animation ends. The deactivation animation should only run\n    // 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\n    // a short time. Store the previous event until it's safe to assume that\n    // subsequent events are for new interactions.\n    setTimeout(\n        () => this.previousActivationEvent = undefined,\n        MDCRippleFoundation.numbers.TAP_DELAY_MS);\n  }\n\n  private deactivateImpl(): void {\n    const activationState = this.activationState;\n    // This can happen in scenarios such as when you have a keyup event that\n    // blurs the element.\n    if (!activationState.isActivated) {\n      return;\n    }\n\n    const state: ActivationStateType = {...activationState};\n\n    if (activationState.isProgrammatic) {\n      requestAnimationFrame(() => {\n        this.animateDeactivation(state);\n      });\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}:\n                                  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\n    // ripples. Unbounded ripple diameter is calculated smaller since the\n    // surface is expected to already be padded appropriately to extend the\n    // hitbox, and the ripple is expected to meet the edges of the padded hitbox\n    // (which is typically square). Bounded ripples, on the other hand, are\n    // fully expected to expand beyond the surface's longest diameter\n    // (calculated based on the diagonal plus a constant padding), and are\n    // clipped at the surface's border via `overflow: hidden`.\n    const getBoundedRadius = () => {\n      const hypotenuse = Math.sqrt(\n          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,\n    // then scales up using a CSS scale transform\n    const initialSize =\n        Math.floor(maxDim * MDCRippleFoundation.numbers.INITIAL_ORIGIN_SCALE);\n    // Unbounded ripple size should always be even number to equally center\n    // align.\n    if (this.adapter.isUnbounded() && initialSize % 2 !== 0) {\n      this.initialSize = initialSize - 1;\n    } else {\n      this.initialSize = initialSize;\n    }\n    this.fgScale = `${this.maxRadius / this.initialSize}`;\n\n    this.updateLayoutCssVars();\n  }\n\n  private updateLayoutCssVars() {\n    const {\n      VAR_FG_SIZE,\n      VAR_LEFT,\n      VAR_TOP,\n      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(\n          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 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 interface MDCRipplePoint {\n  x: number;\n  y: number;\n}\n\n/**\n * Options passed in when attaching a ripple to an object.\n */\nexport interface MDCRippleAttachOpts {\n  isUnbounded?: boolean;\n}\n\n/**\n * See Material Design spec for more details on when to use ripples.\n * https://material.io/guidelines/motion/choreography.html#choreography-creation\n * unbounded Whether or not the ripple bleeds out of the bounds of the element.\n * disabled Whether or not the ripple is attached to a disabled component.\n */\nexport interface MDCRippleCapableSurface {\n  root: HTMLElement;\n  unbounded?: boolean;\n  disabled?: boolean;\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 {MDCRipplePoint} from './types';\n\n/**\n * Stores result from supportsCssVariables to avoid redundant processing to\n * detect CSS custom variable support.\n */\nlet supportsCssVariablesCache: boolean|undefined;\n\n/** Checks if the window supports CSS Variables */\nexport function supportsCssVariables(\n    windowObj: typeof globalThis, forceRefresh = false): boolean {\n  const {CSS} = windowObj;\n  let supportsCssVars = supportsCssVariablesCache;\n  if (typeof supportsCssVariablesCache === 'boolean' && !forceRefresh) {\n    return supportsCssVariablesCache;\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)') && CSS.supports('color', '#00000000'));\n\n  supportsCssVars =\n      explicitlySupportsCssVars || weAreFeatureDetectingSafari10plus;\n\n  if (!forceRefresh) {\n    supportsCssVariablesCache = supportsCssVars;\n  }\n  return supportsCssVars;\n}\n\n/** Gets the normalized events coordinates */\nexport function getNormalizedEventCoords(\n    event: Event|undefined, pageOffset: MDCRipplePoint,\n    clientRect: DOMRect): MDCRipplePoint {\n  if (!event) {\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 (event.type === 'touchstart') {\n    const touchEvent = event as TouchEvent;\n    normalizedX = touchEvent.changedTouches[0].pageX - documentX;\n    normalizedY = touchEvent.changedTouches[0].pageY - documentY;\n  } else {\n    const mouseEvent = event 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 2020 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 './segmented-button/index';\nexport * from './segment/index';\nexport * from './types';\n","/**\n * @license\n * Copyright 2020 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 interface MDCSegmentedButtonSegmentAdapter {\n  /**\n   * @return Returns true if wrapping segmented button is single select\n   */\n  isSingleSelect(): boolean;\n\n  /**\n   * @param attrName Attribute of interest\n   * @return Returns segment's attribute value if it is set, otherwise returns\n   * null\n   */\n  getAttr(attrName: string): string|null;\n\n  /**\n   * Sets segment's attribute value to new value\n   *\n   * @param attrName Attribute of interest\n   * @param value New value of attribute\n   */\n  setAttr(attrName: string, value: string): void;\n\n  /**\n   * Adds css class to segment\n   *\n   * @param className Class to add\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes css class from segment\n   *\n   * @param className Class to remove\n   */\n  removeClass(className: string): void;\n\n  /**\n   * @param className Class of interest\n   * @return Returns true if segment has css class, otherwise returns false\n   */\n  hasClass(className: string): boolean;\n\n  /**\n   * Emits event about segment to wrapping segmented button\n   *\n   * @param selected Represents whether segment is currently selected\n   * @event selected With detail - SegmentDetail\n   */\n  notifySelectedChange(selected: boolean): void;\n\n  /**\n   * @return Returns bounding rectangle for ripple effect\n   */\n  getRootBoundingClientRect(): DOMRect;\n}\n","/**\n * @license\n * Copyright 2020 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';\n\nimport {SegmentDetail} from '../types';\n\nimport {MDCSegmentedButtonSegmentAdapter} from './adapter';\nimport {events} from './constants';\nimport {MDCSegmentedButtonSegmentFoundation} from './foundation';\n\n/**\n * MDCSegmentedButtonSegment factory type.\n */\nexport type MDCSegmentedButtonSegmentFactory =\n    (el: HTMLElement, foundation?: MDCSegmentedButtonSegmentFoundation) =>\n        MDCSegmentedButtonSegment;\n\n/**\n * Implementation of MDCSegmentedButtonSegmentFoundation\n */\nexport class MDCSegmentedButtonSegment extends\n    MDCComponent<MDCSegmentedButtonSegmentFoundation> implements\n        MDCRippleCapableSurface {\n  get ripple(): MDCRipple {\n    return this.rippleComponent;\n  }\n\n  static override attachTo(root: HTMLElement) {\n    return new MDCSegmentedButtonSegment(root);\n  }\n\n  private index!: number;            // assigned in setIndex by parent\n  private isSingleSelect!: boolean;  // assigned in setIsSingleSelect by parent\n  private rippleComponent!: MDCRipple;  // assigned in initialize\n  private handleClick!:\n      SpecificEventListener<'click'>;  // assigned in initialSyncWithDOM\n\n  override initialize(\n      rippleFactory: MDCRippleFactory = (el, foundation) =>\n          new MDCRipple(el, foundation)) {\n    const rippleAdapter: MDCRippleAdapter = {\n      ...MDCRipple.createAdapter(this),\n      computeBoundingRect: () => this.foundation.getDimensions()\n    };\n    this.rippleComponent =\n        rippleFactory(this.root, new MDCRippleFoundation(rippleAdapter));\n  }\n\n  override initialSyncWithDOM() {\n    this.handleClick = () => {\n      this.foundation.handleClick();\n    };\n\n    this.listen(events.CLICK, this.handleClick);\n  }\n\n  override destroy() {\n    this.ripple.destroy();\n\n    this.unlisten(events.CLICK, this.handleClick);\n\n    super.destroy();\n  }\n\n  override getDefaultFoundation(): MDCSegmentedButtonSegmentFoundation {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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: MDCSegmentedButtonSegmentAdapter = {\n      isSingleSelect: () => {\n        return this.isSingleSelect;\n      },\n      getAttr: (attrName) => {\n        return this.root.getAttribute(attrName);\n      },\n      setAttr: (attrName, value) => {\n        this.safeSetAttribute(this.root, attrName, value);\n      },\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      hasClass: (className) => {\n        return this.root.classList.contains(className);\n      },\n      notifySelectedChange: (selected) => {\n        this.emit<SegmentDetail>(\n            events.SELECTED,\n            {index: this.index, selected, segmentId: this.getSegmentId()},\n            true /* shouldBubble */\n        );\n      },\n      getRootBoundingClientRect: () => {\n        return this.root.getBoundingClientRect();\n      }\n    };\n    return new MDCSegmentedButtonSegmentFoundation(adapter);\n  }\n\n  /**\n   * Sets segment's index value\n   *\n   * @param index Segment's index within wrapping segmented button\n   */\n  setIndex(index: number) {\n    this.index = index;\n  }\n\n  /**\n   * Sets segment's isSingleSelect value\n   *\n   * @param isSingleSelect True if wrapping segmented button is single select\n   */\n  setIsSingleSelect(isSingleSelect: boolean) {\n    this.isSingleSelect = isSingleSelect;\n  }\n\n  /**\n   * @return Returns true if segment is currently selected, otherwise returns\n   * false\n   */\n  isSelected(): boolean {\n    return this.foundation.isSelected();\n  }\n\n  /**\n   * Sets segment to be selected\n   */\n  setSelected() {\n    this.foundation.setSelected();\n  }\n\n  /**\n   * Sets segment to be not selected\n   */\n  setUnselected() {\n    this.foundation.setUnselected();\n  }\n\n  /**\n   * @return Returns segment's segmentId if it was set by client\n   */\n  getSegmentId(): string|undefined {\n    return this.foundation.getSegmentId();\n  }\n}\n","/**\n * @license\n * Copyright 2020 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 * Boolean strings for segment\n */\nexport const booleans = {\n  TRUE: 'true',\n  FALSE: 'false'\n};\n\n/**\n * Attributes referenced by segment\n */\nexport const attributes = {\n  ARIA_CHECKED: 'aria-checked',\n  ARIA_PRESSED: 'aria-pressed',\n  DATA_SEGMENT_ID: 'data-segment-id'\n};\n\n/**\n * Events received or emitted by segment\n */\nexport const events = {\n  CLICK: 'click',\n  SELECTED: 'selected'\n};\n\n/**\n * Style classes for segment\n */\nexport const cssClasses = {\n  SELECTED: 'mdc-segmented-button__segment--selected'\n};\n","/**\n * @license\n * Copyright 2020 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';\n\nimport {MDCSegmentedButtonSegmentAdapter} from './adapter';\nimport {attributes, booleans, cssClasses} from './constants';\n\nconst emptyClientRect = {\n  bottom: 0,\n  height: 0,\n  left: 0,\n  right: 0,\n  top: 0,\n  width: 0,\n} as any;\n\n/** MDC Segmented Button Segment Foundation */\nexport class MDCSegmentedButtonSegmentFoundation extends\n    MDCFoundation<MDCSegmentedButtonSegmentAdapter> {\n  static override get defaultAdapter(): MDCSegmentedButtonSegmentAdapter {\n    return {\n      isSingleSelect: () => false, getAttr: () => '', setAttr: () => undefined,\n                      addClass: () => undefined, removeClass: () => undefined,\n                      hasClass: () => false,\n                      notifySelectedChange: () => undefined,\n                      getRootBoundingClientRect: () => emptyClientRect,\n    }\n  }\n\n  constructor(adapter?: Partial<MDCSegmentedButtonSegmentAdapter>) {\n    super({...MDCSegmentedButtonSegmentFoundation.defaultAdapter, ...adapter});\n  }\n\n  /**\n   * @return Returns true if segment is currently selected, otherwise returns\n   * false\n   */\n  isSelected(): boolean {\n    return this.adapter.hasClass(cssClasses.SELECTED);\n  }\n\n  /**\n   * Sets segment to be selected\n   */\n  setSelected() {\n    this.adapter.addClass(cssClasses.SELECTED);\n    this.setAriaAttr(booleans.TRUE);\n  }\n\n  /**\n   * Sets segment to be not selected\n   */\n  setUnselected() {\n    this.adapter.removeClass(cssClasses.SELECTED);\n    this.setAriaAttr(booleans.FALSE);\n  }\n\n  /**\n   * @return Returns segment's segmentId if it was set by client\n   */\n  getSegmentId(): string|undefined {\n    return this.adapter.getAttr(attributes.DATA_SEGMENT_ID) ?? undefined;\n  }\n\n  /**\n   * Called when segment is clicked. If the wrapping segmented button is single\n   * select, doesn't allow segment to be set to not selected. Otherwise, toggles\n   * segment's selected status. Finally, emits event to wrapping segmented\n   * button.\n   *\n   * @event selected With detail - SegmentDetail\n   */\n  handleClick(): void {\n    if (this.adapter.isSingleSelect()) {\n      this.setSelected();\n    } else {\n      this.toggleSelection();\n    }\n    this.adapter.notifySelectedChange(this.isSelected());\n  }\n\n  /**\n   * @return Returns bounding rectangle for ripple effect\n   */\n  getDimensions(): DOMRect {\n    return this.adapter.getRootBoundingClientRect();\n  }\n\n  /**\n   * Sets segment from not selected to selected, or selected to not selected\n   */\n  private toggleSelection() {\n    if (this.isSelected()) {\n      this.setUnselected();\n    } else {\n      this.setSelected();\n    }\n  }\n\n  /**\n   * Sets appropriate aria attribute, based on wrapping segmented button's\n   * single selected value, to new value\n   *\n   * @param value Value that represents selected status\n   */\n  private setAriaAttr(value: string) {\n    if (this.adapter.isSingleSelect()) {\n      this.adapter.setAttr(attributes.ARIA_CHECKED, value);\n    } else {\n      this.adapter.setAttr(attributes.ARIA_PRESSED, value);\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2020 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 './foundation';\nexport * from './component';\n","/**\n * @license\n * Copyright 2020 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 {SegmentDetail} from '../types';\n\nexport interface MDCSegmentedButtonAdapter {\n  /**\n   * @param className Class of interest\n   * @return Returns true if segmented button has css class, otherwise returns\n   * false\n   */\n  hasClass(className: string): boolean;\n\n  /**\n   * @return Returns child segments represented as readonly list of\n   * SegmentDetails\n   */\n  getSegments(): readonly SegmentDetail[];\n\n  /**\n   * Sets identified child segment to be selected\n   *\n   * @param indexOrSegmentId Number index or string segmentId that identifies\n   * child segment\n   */\n  selectSegment(indexOrSegmentId: number|string): void;\n\n  /**\n   * Sets identified child segment to be not selected\n   *\n   * @param indexOrSegmentId Number index or string segmentId that identifies\n   * child segment\n   */\n  unselectSegment(indexOrSegmentId: number|string): void;\n\n  /**\n   * Emits event about changed child segment to client\n   *\n   * @param detail Changed child segment represented as a SegmentDetail\n   * @event change With detail - SegmentDetail\n   */\n  notifySelectedChange(detail: SegmentDetail): void;\n}\n","/**\n * @license\n * Copyright 2020 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} from '@material/base/types';\n\nimport {MDCSegmentedButtonSegment, MDCSegmentedButtonSegmentFactory} from '../segment/component';\nimport {MDCSegmentedButtonEvent, SegmentDetail} from '../types';\n\nimport {MDCSegmentedButtonAdapter} from './adapter';\nimport {events, selectors} from './constants';\nimport {MDCSegmentedButtonFoundation} from './foundation';\n\n/** MDC Segmented Button */\nexport class MDCSegmentedButton extends\n    MDCComponent<MDCSegmentedButtonFoundation> {\n  static override attachTo(root: HTMLElement): MDCSegmentedButton {\n    return new MDCSegmentedButton(root);\n  }\n\n  get segments(): readonly MDCSegmentedButtonSegment[] {\n    return this.segmentsList.slice();\n  }\n\n  private segmentsList!: MDCSegmentedButtonSegment[];  // assigned in initialize\n  private segmentFactory!:\n      (el: HTMLElement) => MDCSegmentedButtonSegment;  // assigned in initialize\n  private handleSelected!:\n      CustomEventListener<MDCSegmentedButtonEvent>;  // assigned in\n                                                     // initialSyncWithDOM\n\n  override initialize(\n      segmentFactory: MDCSegmentedButtonSegmentFactory = (el) =>\n          new MDCSegmentedButtonSegment(el)) {\n    this.segmentFactory = segmentFactory;\n    this.segmentsList = this.instantiateSegments(this.segmentFactory);\n  }\n\n  /**\n   * @param segmentFactory Factory to create new child segments\n   * @return Returns list of child segments found in DOM\n   */\n  private instantiateSegments(segmentFactory: MDCSegmentedButtonSegmentFactory):\n      MDCSegmentedButtonSegment[] {\n    const segmentElements =\n        Array.from(this.root.querySelectorAll<HTMLElement>(selectors.SEGMENT));\n    return segmentElements.map((el) => segmentFactory(el));\n  }\n\n  override initialSyncWithDOM() {\n    this.handleSelected = (event) => {\n      this.foundation.handleSelected(event.detail);\n    };\n    this.listen(events.SELECTED, this.handleSelected);\n\n    const isSingleSelect = this.foundation.isSingleSelect();\n    for (let i = 0; i < this.segmentsList.length; i++) {\n      const segment = this.segmentsList[i];\n      segment.setIndex(i);\n      segment.setIsSingleSelect(isSingleSelect);\n    }\n\n    const selectedSegments =\n        this.segmentsList.filter((segment) => segment.isSelected());\n    if (isSingleSelect && selectedSegments.length === 0 &&\n        this.segmentsList.length > 0) {\n      throw new Error(\n          'No segment selected in singleSelect mdc-segmented-button');\n    } else if (isSingleSelect && selectedSegments.length > 1) {\n      throw new Error(\n          'Multiple segments selected in singleSelect mdc-segmented-button');\n    }\n  }\n\n  override destroy() {\n    for (const segment of this.segmentsList) {\n      segment.destroy();\n    }\n\n    this.unlisten(events.SELECTED, this.handleSelected);\n\n    super.destroy();\n  }\n\n  override getDefaultFoundation(): MDCSegmentedButtonFoundation {\n    const adapter: MDCSegmentedButtonAdapter = {\n      hasClass: (className) => {\n        return this.root.classList.contains(className);\n      },\n      getSegments: () => {\n        return this.mappedSegments();\n      },\n      selectSegment: (indexOrSegmentId) => {\n        const segmentDetail = this.mappedSegments().find(\n            (detail) => detail.index === indexOrSegmentId ||\n                detail.segmentId === indexOrSegmentId);\n        if (segmentDetail) {\n          this.segmentsList[segmentDetail.index].setSelected();\n        }\n      },\n      unselectSegment: (indexOrSegmentId) => {\n        const segmentDetail = this.mappedSegments().find(\n            (detail) => detail.index === indexOrSegmentId ||\n                detail.segmentId === indexOrSegmentId);\n        if (segmentDetail) {\n          this.segmentsList[segmentDetail.index].setUnselected();\n        }\n      },\n      notifySelectedChange: (detail) => {\n        this.emit<SegmentDetail>(\n            events.CHANGE, detail, true /* shouldBubble */\n        );\n      }\n    };\n    return new MDCSegmentedButtonFoundation(adapter);\n  }\n\n  /**\n   * @return Returns readonly list of selected child segments as SegmentDetails\n   */\n  getSelectedSegments(): readonly SegmentDetail[] {\n    return this.foundation.getSelectedSegments();\n  }\n\n  /**\n   * Sets identified segment to be selected\n   *\n   * @param indexOrSegmentId Number index or string segmentId that identifies\n   * child segment\n   */\n  selectSegment(indexOrSegmentId: number|string) {\n    this.foundation.selectSegment(indexOrSegmentId);\n  }\n\n  /**\n   * Sets identified segment to be not selected\n   *\n   * @param indexOrSegmentId Number index or string segmentId that identifies\n   * child segment\n   */\n  unselectSegment(indexOrSegmentId: number|string) {\n    this.foundation.unselectSegment(indexOrSegmentId);\n  }\n\n  /**\n   * @param indexOrSegmentId Number index or string segmentId that identifies\n   * child segment\n   * @return Returns true if identified child segment is currently selected,\n   * otherwise returns false\n   */\n  isSegmentSelected(indexOrSegmentId: number|string): boolean {\n    return this.foundation.isSegmentSelected(indexOrSegmentId);\n  }\n\n  /**\n   * @return Returns child segments mapped to readonly SegmentDetail list\n   */\n  private mappedSegments(): readonly SegmentDetail[] {\n    return this.segmentsList.map(\n        (segment: MDCSegmentedButtonSegment, index: number) => {\n          return {\n            index,\n            selected: segment.isSelected(),\n            segmentId: segment.getSegmentId()\n          };\n        });\n  }\n}\n","/**\n * @license\n * Copyright 2020 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 * Selectors used by segmented-button\n */\nexport const selectors = {\n  SEGMENT: '.mdc-segmented-button__segment'\n};\n\n/**\n * Events received or emitted by segmented-button\n */\nexport const events = {\n  SELECTED: 'selected',\n  CHANGE: 'change'\n};\n\n/**\n * Style classes for segmented-button\n */\nexport const cssClasses = {\n  SINGLE_SELECT: 'mdc-segmented-button--single-select'\n};\n","/**\n * @license\n * Copyright 2020 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';\n\nimport {SegmentDetail} from '../types';\n\nimport {MDCSegmentedButtonAdapter} from './adapter';\nimport {cssClasses} from './constants';\n\n/** MDC Segmented Button Foundation */\nexport class MDCSegmentedButtonFoundation extends\n    MDCFoundation<MDCSegmentedButtonAdapter> {\n  static override get defaultAdapter(): MDCSegmentedButtonAdapter {\n    return {\n      hasClass: () => false,\n      getSegments: () => [],\n      selectSegment: () => undefined,\n      unselectSegment: () => undefined,\n      notifySelectedChange: () => undefined\n    };\n  }\n\n  constructor(adapter?: Partial<MDCSegmentedButtonAdapter>) {\n    super({...MDCSegmentedButtonFoundation.defaultAdapter, ...adapter});\n  }\n\n  /**\n   * Sets identified child segment to be selected\n   *\n   * @param indexOrSegmentId Number index or string segmentId that identifies\n   * child segment\n   */\n  selectSegment(indexOrSegmentId: number|string) {\n    this.adapter.selectSegment(indexOrSegmentId);\n  }\n\n  /**\n   * Sets identified child segment to be not selected\n   *\n   * @param indexOrSegmentId Number index or string segmentId that identifies\n   * child segment\n   */\n  unselectSegment(indexOrSegmentId: number|string) {\n    this.adapter.unselectSegment(indexOrSegmentId);\n  }\n\n  /**\n   * @return Returns currently selected child segments as readonly list of\n   * SegmentDetails\n   */\n  getSelectedSegments(): readonly SegmentDetail[] {\n    return this.adapter.getSegments().filter(\n        segmentDetail => segmentDetail.selected);\n  }\n\n  /**\n   * @param indexOrSegmentId Number index or string segmentId that identifies\n   * child segment\n   * @return Returns true if identified child segment is currently selected,\n   * otherwise returns false\n   */\n  isSegmentSelected(indexOrSegmentId: number|string|undefined): boolean {\n    return this.adapter.getSegments().some(\n        segmentDetail => (segmentDetail.index === indexOrSegmentId ||\n                          segmentDetail.segmentId === indexOrSegmentId) &&\n            segmentDetail.selected);\n  }\n\n  /**\n   * @return Returns true if segmented button is single select, otherwise\n   * returns false\n   */\n  isSingleSelect(): boolean {\n    return this.adapter.hasClass(cssClasses.SINGLE_SELECT);\n  }\n\n  /**\n   * Called when child segment's selected status may have changed. If segmented\n   * button is single select, unselects all child segments other than identified\n   * child segment. Finally, emits event to client.\n   *\n   * @param detail Child segment affected represented as SegmentDetail\n   * @event change With detail - SegmentDetail\n   */\n  handleSelected(detail: SegmentDetail) {\n    if (this.isSingleSelect()) {\n      this.unselectPrevSelected(detail.index);\n    }\n    this.adapter.notifySelectedChange(detail);\n  }\n\n  /**\n   * Sets all child segments to be not selected except for child segment\n   * identified by index\n   *\n   * @param index Index of child segment to not unselect\n   */\n  private unselectPrevSelected(index: number) {\n    for (const selectedSegment of this.getSelectedSegments()) {\n      if (selectedSegment.index !== index) {\n        this.unselectSegment(selectedSegment.index);\n      }\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2020 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 './foundation';\nexport * from './component';\n","/**\n * @license\n * Copyright 2020 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 * Event detail triggered by a click on a segment. This event detail is used\n * to alert the segment-button to the change and trigger a DOM event.\n */\nexport interface SegmentDetail {\n  index: number;\n  selected: boolean;\n  segmentId?: string;\n}\n\n/**\n * Event emitted by segment to alert the segment-button of a change in its\n * selected status.\n */\nexport interface MDCSegmentedButtonEvent extends Event {\n  readonly detail: SegmentDetail;\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 {Corner} from '@material/menu-surface/constants';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCSelectAdapter {\n  /**\n   * Adds class to select anchor element.\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes a class from the select anchor element.\n   */\n  removeClass(className: string): void;\n\n  /**\n   * Returns true if the select anchor element contains the given class name.\n   */\n  hasClass(className: string): boolean;\n\n  /**\n   * Activates the bottom line, showing a focused state.\n   */\n  activateBottomLine(): void;\n\n  /**\n   * Deactivates the bottom line.\n   */\n  deactivateBottomLine(): void;\n\n  /**\n   * Returns true if label exists, false if it doesn't.\n   */\n  hasLabel(): boolean;\n\n  /**\n   * Floats label determined based off of the shouldFloat argument.\n   */\n  floatLabel(shouldFloat: boolean): void;\n\n  /**\n   * Returns width of label in pixels, if the label exists.\n   */\n  getLabelWidth(): number;\n\n  /**\n   * Styles the label as required, if the label exists.\n   */\n  setLabelRequired(isRequired: boolean): void;\n\n  /**\n   * Returns true if outline element exists, false if it doesn't.\n   */\n  hasOutline(): boolean;\n\n  /**\n   * Only implement if outline element exists.\n   */\n  notchOutline(labelWidth: number): void;\n\n  /**\n   * Closes notch in outline element, if the outline exists.\n   */\n  closeOutline(): void;\n\n  /**\n   * Sets the line ripple transform origin center.\n   */\n  setRippleCenter(normalizedX: number): void;\n\n  /**\n   * Emits a change event when an element is selected.\n   */\n  notifyChange(value: string): void;\n\n  /**\n   * Sets the text content of the selectedText element to the given string.\n   */\n  setSelectedText(text: string): void;\n\n  /**\n   * Returns whether the select anchor is focused.\n   */\n  isSelectAnchorFocused(): boolean;\n\n  /**\n   * Gets the given attribute on the select anchor element.\n   */\n  getSelectAnchorAttr(attr: string): string|null;\n\n  /**\n   * Sets the given attribute on the select anchor element.\n   */\n  setSelectAnchorAttr(attr: string, value: string): void;\n\n  /**\n   * Removes the given attribute on the select anchor element.\n   */\n  removeSelectAnchorAttr(attr: string): void;\n\n  // Menu-related methods ======================================================\n  /**\n   * Adds class to the menu element.\n   */\n  addMenuClass(className: string): void;\n\n  /**\n   * Removes a class from the menu element.\n   */\n  removeMenuClass(className: string): void;\n\n  /**\n   * Opens the menu.\n   */\n  openMenu(): void;\n\n  /**\n   * Closes the menu.\n   */\n  closeMenu(): void;\n\n  /**\n   * Returns the select anchor element.\n   */\n  getAnchorElement(): Element|null;\n\n  /**\n   * Sets the menu anchor element.\n   */\n  setMenuAnchorElement(anchorEl: Element): void;\n\n  /**\n   * Sets the menu anchor corner.\n   */\n  setMenuAnchorCorner(anchorCorner: Corner): void;\n\n  /**\n   * Sets whether the menu should wrap focus.\n   */\n  setMenuWrapFocus(wrapFocus: boolean): void;\n\n  /**\n   * Focuses the menu item element at the given index.\n   */\n  focusMenuItemAtIndex(index: number): void;\n\n  /**\n   * Returns the number of menu items.\n   */\n  getMenuItemCount(): number;\n\n  /**\n   * Returns an array representing the VALUE_ATTR attributes of each menu item.\n   */\n  getMenuItemValues(): string[];\n\n  /**\n   * Gets the text content of the menu item element at the given index.\n   */\n  getMenuItemTextAtIndex(index: number): string;\n\n  /**\n   * Returns the selected index.\n   */\n  getSelectedIndex(): number;\n\n  /**\n   * Sets the selected index in the menu.\n   */\n  setSelectedIndex(index: number): void;\n\n  /**\n   * Returns whether typeahead is in progress in the menu.\n   */\n  isTypeaheadInProgress(): boolean;\n\n  /**\n   * Adds a character to the list typeahead buffer and returns index of the\n   * next item in the list matching the buffer.\n   */\n  typeaheadMatchItem(nextChar: string, startingIndex: number): number;\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';\n\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\n/** MDC Select */\nexport class MDCSelect extends MDCComponent<MDCSelectFoundation> {\n  static override attachTo(root: HTMLElement): MDCSelect {\n    return new MDCSelect(root);\n  }\n\n  private ripple!: MDCRipple|null;\n\n  private menu!: MDCMenu;  // assigned in menuSetup()\n\n  private selectAnchor!: HTMLElement;           // assigned in initialize()\n  private selectedText!: HTMLElement;           // assigned in initialize()\n  private hiddenInput!: HTMLInputElement|null;  // assigned in initialize()\n\n  private menuElement!: HTMLElement;              // assigned in menuSetup()\n  private menuItemValues!: string[];              // assigned in menuSetup()\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\n  // Event handlers\n  private handleFocus!: SpecificEventListener<'focus'>;\n  private handleBlur!: SpecificEventListener<'blur'>;\n  private handleClick!: SpecificEventListener<'click'>;\n  private handleKeydown!: SpecificEventListener<'keydown'>;\n  private handleMenuOpened!: EventListener;\n  private handleMenuClosed!: EventListener;\n  private handleMenuClosing!: EventListener;\n  private handleMenuItemAction!: CustomEventListener<MDCMenuItemEvent>;\n\n  override initialize(\n      labelFactory: MDCFloatingLabelFactory = (el) => new MDCFloatingLabel(el),\n      lineRippleFactory: MDCLineRippleFactory = (el) => new MDCLineRipple(el),\n      outlineFactory:\n          MDCNotchedOutlineFactory = (el) => new MDCNotchedOutline(el),\n      menuFactory: MDCMenuFactory = (el) => new MDCMenu(el),\n      iconFactory: MDCSelectIconFactory = (el) => new MDCSelectIcon(el),\n      helperTextFactory:\n          MDCSelectHelperTextFactory = (el) => new MDCSelectHelperText(el),\n  ) {\n    this.selectAnchor =\n        this.root.querySelector<HTMLElement>(strings.SELECT_ANCHOR_SELECTOR)!;\n    this.selectedText =\n        this.root.querySelector<HTMLElement>(strings.SELECTED_TEXT_SELECTOR)!;\n    this.hiddenInput = this.root.querySelector<HTMLInputElement>(\n        strings.HIDDEN_INPUT_SELECTOR)!;\n\n    if (!this.selectedText) {\n      throw new Error(\n          'MDCSelect: Missing required element: The following selector must be present: ' +\n              `'${strings.SELECTED_TEXT_SELECTOR}'`,\n      );\n    }\n\n    if (this.selectAnchor.hasAttribute(strings.ARIA_CONTROLS)) {\n      const helperTextElement = document.getElementById(\n          this.selectAnchor.getAttribute(strings.ARIA_CONTROLS)!);\n      if (helperTextElement) {\n        this.helperText = helperTextFactory(helperTextElement);\n      }\n    }\n\n    this.menuSetup(menuFactory);\n\n    const labelElement =\n        this.root.querySelector<HTMLElement>(strings.LABEL_SELECTOR);\n    this.label = labelElement ? labelFactory(labelElement) : null;\n\n    const lineRippleElement =\n        this.root.querySelector<HTMLElement>(strings.LINE_RIPPLE_SELECTOR);\n    this.lineRipple =\n        lineRippleElement ? lineRippleFactory(lineRippleElement) : null;\n\n    const outlineElement =\n        this.root.querySelector<HTMLElement>(strings.OUTLINE_SELECTOR);\n    this.outline = outlineElement ? outlineFactory(outlineElement) : null;\n\n    const leadingIcon =\n        this.root.querySelector<HTMLElement>(strings.LEADING_ICON_SELECTOR);\n    if (leadingIcon) {\n      this.leadingIcon = iconFactory(leadingIcon);\n    }\n\n    if (!this.root.classList.contains(cssClasses.OUTLINED)) {\n      this.ripple = this.createRipple();\n    }\n  }\n\n  /**\n   * Initializes the select's event listeners and internal state based\n   * on the environment's state.\n   */\n  override initialSyncWithDOM() {\n    this.handleFocus = () => {\n      this.foundation.handleFocus();\n    };\n    this.handleBlur = () => {\n      this.foundation.handleBlur();\n    };\n    this.handleClick = (event) => {\n      this.selectAnchor.focus();\n      this.foundation.handleClick(this.getNormalizedXCoordinate(event));\n    };\n    this.handleKeydown = (event) => {\n      this.foundation.handleKeydown(event);\n    };\n    this.handleMenuItemAction = (event) => {\n      this.foundation.handleMenuItemAction(event.detail.index);\n    };\n    this.handleMenuOpened = () => {\n      this.foundation.handleMenuOpened();\n    };\n    this.handleMenuClosed = () => {\n      this.foundation.handleMenuClosed();\n    };\n    this.handleMenuClosing = () => {\n      this.foundation.handleMenuClosing();\n    };\n\n    this.selectAnchor.addEventListener('focus', this.handleFocus);\n    this.selectAnchor.addEventListener('blur', this.handleBlur);\n\n    this.selectAnchor.addEventListener(\n        'click', this.handleClick as EventListener);\n\n    this.selectAnchor.addEventListener('keydown', this.handleKeydown);\n    this.menu.listen(\n        menuSurfaceConstants.strings.CLOSED_EVENT, this.handleMenuClosed);\n    this.menu.listen(\n        menuSurfaceConstants.strings.CLOSING_EVENT, this.handleMenuClosing);\n    this.menu.listen(\n        menuSurfaceConstants.strings.OPENED_EVENT, this.handleMenuOpened);\n    this.menu.listen(\n        menuConstants.strings.SELECTED_EVENT, this.handleMenuItemAction);\n\n    if (this.hiddenInput) {\n      if (this.hiddenInput.value) {\n        // If the hidden input already has a value, use it to restore the\n        // select's value. This can happen e.g. if the user goes back or (in\n        // some browsers) refreshes the page.\n        this.foundation.setValue(\n            this.hiddenInput.value, /** skipNotify */ true);\n        this.foundation.layout();\n        return;\n      }\n\n      this.hiddenInput.value = this.value;\n    }\n  }\n\n  override destroy() {\n    this.selectAnchor.removeEventListener('focus', this.handleFocus);\n    this.selectAnchor.removeEventListener('blur', this.handleBlur);\n    this.selectAnchor.removeEventListener('keydown', this.handleKeydown);\n    this.selectAnchor.removeEventListener(\n        'click', this.handleClick as EventListener);\n\n    this.menu.unlisten(\n        menuSurfaceConstants.strings.CLOSED_EVENT, this.handleMenuClosed);\n    this.menu.unlisten(\n        menuSurfaceConstants.strings.OPENED_EVENT, this.handleMenuOpened);\n    this.menu.unlisten(\n        menuConstants.strings.SELECTED_EVENT, this.handleMenuItemAction);\n    this.menu.destroy();\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\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  setValue(value: string, skipNotify = false) {\n    this.foundation.setValue(value, skipNotify);\n  }\n\n  get selectedIndex(): number {\n    return this.foundation.getSelectedIndex();\n  }\n\n  set selectedIndex(selectedIndex: number) {\n    this.foundation.setSelectedIndex(selectedIndex, /* closeMenu */ true);\n  }\n\n  setSelectedIndex(selectedIndex: number, skipNotify = false) {\n    this.foundation.setSelectedIndex(\n        selectedIndex, /* closeMenu */ true, skipNotify);\n  }\n\n  get disabled(): boolean {\n    return this.foundation.getDisabled();\n  }\n\n  set disabled(disabled: boolean) {\n    this.foundation.setDisabled(disabled);\n    if (this.hiddenInput) {\n      this.hiddenInput.disabled = disabled;\n    }\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   * Enables or disables the default validation scheme where a required select\n   * must be non-empty. Set to false for custom validation.\n   * @param useDefaultValidation Set this to false to ignore default\n   *     validation scheme.\n   */\n  set useDefaultValidation(useDefaultValidation: boolean) {\n    this.foundation.setUseDefaultValidation(useDefaultValidation);\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    this.foundation.setRequired(isRequired);\n  }\n\n  /**\n   * Returns whether the select is required.\n   */\n  get required(): boolean {\n    return this.foundation.getRequired();\n  }\n\n  /**\n   * Re-calculates if the notched outline should be notched and if the label\n   * should float.\n   */\n  layout() {\n    this.foundation.layout();\n  }\n\n  /**\n   * Synchronizes the list of options with the state of the foundation. Call\n   * this whenever menu options are dynamically updated.\n   */\n  layoutOptions() {\n    this.foundation.layoutOptions();\n    this.menu.layout();\n    // Update cached menuItemValues for adapter.\n    this.menuItemValues =\n        this.menu.items.map((el) => el.getAttribute(strings.VALUE_ATTR) || '');\n\n    if (this.hiddenInput) {\n      this.hiddenInput.value = this.value;\n    }\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCSelectAdapter = {\n      ...this.getSelectAdapterMethods(),\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 menu.\n   */\n  private menuSetup(menuFactory: MDCMenuFactory) {\n    this.menuElement =\n        this.root.querySelector<HTMLElement>(strings.MENU_SELECTOR)!;\n    this.menu = menuFactory(this.menuElement);\n    this.menu.hasTypeahead = true;\n    this.menu.singleSelection = true;\n    this.menuItemValues =\n        this.menu.items.map((el) => el.getAttribute(strings.VALUE_ATTR) || '');\n  }\n\n  private createRipple(): MDCRipple {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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({root: this.selectAnchor}),\n      registerInteractionHandler: (eventType, handler) => {\n        this.selectAnchor.addEventListener(eventType, handler);\n      },\n      deregisterInteractionHandler: (eventType, handler) => {\n        this.selectAnchor.removeEventListener(eventType, handler);\n      },\n    };\n    // tslint:enable:object-literal-sort-keys\n    return new MDCRipple(this.selectAnchor, new MDCRippleFoundation(adapter));\n  }\n\n  private getSelectAdapterMethods() {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      getMenuItemAttr: (menuItem: Element, attr: string) =>\n          menuItem.getAttribute(attr),\n      setSelectedText: (text: string) => {\n        this.selectedText.textContent = text;\n\n        let index = this.menu.selectedIndex;\n        if (index === -1) return;\n        index = index instanceof Array ? index[0] : index;\n        const selectedItem = this.menu.items[index];\n        if (!selectedItem) return;\n        this.selectedText.setAttribute(\n            'aria-label', selectedItem.getAttribute('aria-label') || '');\n      },\n      isSelectAnchorFocused: () => document.activeElement === this.selectAnchor,\n      getSelectAnchorAttr: (attr: string) =>\n          this.selectAnchor.getAttribute(attr),\n      setSelectAnchorAttr: (attr: string, value: string) => {\n        this.safeSetAttribute(this.selectAnchor, attr, value);\n      },\n      removeSelectAnchorAttr: (attr: string) => {\n        this.selectAnchor.removeAttribute(attr);\n      },\n      addMenuClass: (className: string) => {\n        this.menuElement.classList.add(className);\n      },\n      removeMenuClass: (className: string) => {\n        this.menuElement.classList.remove(className);\n      },\n      openMenu: () => {\n        this.menu.open = true;\n      },\n      closeMenu: () => {\n        this.menu.open = false;\n      },\n      getAnchorElement: () =>\n          this.root.querySelector<HTMLElement>(strings.SELECT_ANCHOR_SELECTOR)!,\n      setMenuAnchorElement: (anchorEl: HTMLElement) => {\n        this.menu.setAnchorElement(anchorEl);\n      },\n      setMenuAnchorCorner: (anchorCorner: menuSurfaceConstants.Corner) => {\n        this.menu.setAnchorCorner(anchorCorner);\n      },\n      setMenuWrapFocus: (wrapFocus: boolean) => {\n        this.menu.wrapFocus = wrapFocus;\n      },\n      getSelectedIndex: () => {\n        const index = this.menu.selectedIndex;\n        return index instanceof Array ? index[0] : index;\n      },\n      setSelectedIndex: (index: number) => {\n        this.menu.selectedIndex = index;\n      },\n      focusMenuItemAtIndex: (index: number) => {\n        this.menu.items[index]?.focus();\n      },\n      getMenuItemCount: () => this.menu.items.length,\n      // Cache menu item values. layoutOptions() updates this cache.\n      getMenuItemValues: () => this.menuItemValues,\n      getMenuItemTextAtIndex: (index: number) =>\n          this.menu.getPrimaryTextAtIndex(index),\n      isTypeaheadInProgress: () => this.menu.typeaheadInProgress,\n      typeaheadMatchItem: (nextChar: string, startingIndex: number) =>\n          this.menu.typeaheadMatchItem(nextChar, startingIndex),\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) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className: string) => {\n        this.root.classList.remove(className);\n      },\n      hasClass: (className: string) => this.root.classList.contains(className),\n      setRippleCenter: (normalizedX: number) => {\n        this.lineRipple && this.lineRipple.setRippleCenter(normalizedX);\n      },\n      activateBottomLine: () => {\n        this.lineRipple && this.lineRipple.activate();\n      },\n      deactivateBottomLine: () => {\n        this.lineRipple && this.lineRipple.deactivate();\n      },\n      notifyChange: (value: string) => {\n        if (this.hiddenInput) {\n          this.hiddenInput.value = value;\n        }\n\n        const index = this.selectedIndex;\n        this.emit<MDCSelectEventDetail>(\n            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) => {\n        this.outline && this.outline.notch(labelWidth);\n      },\n      closeOutline: () => {\n        this.outline && this.outline.closeNotch();\n      },\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private getLabelAdapterMethods() {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n    return {\n      hasLabel: () => !!this.label,\n      floatLabel: (shouldFloat: boolean) => {\n        this.label && this.label.float(shouldFloat);\n      },\n      getLabelWidth: () => this.label ? this.label.getWidth() : 0,\n      setLabelRequired: (isRequired: boolean) => {\n        this.label && this.label.setRequired(isRequired);\n      },\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  /**\n   * Calculates where the line ripple should start based on the x coordinate\n   * within the component.\n   */\n  private getNormalizedXCoordinate(event: MouseEvent|TouchEvent): number {\n    const targetClientRect = (event.target as Element).getBoundingClientRect();\n    const xCoordinate =\n        this.isTouchEvent(event) ? event.touches[0].clientX : event.clientX;\n    return xCoordinate - targetClientRect.left;\n  }\n\n  private isTouchEvent(event: MouseEvent|TouchEvent): event is TouchEvent {\n    return Boolean((event 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.foundationForSelect :\n                                    undefined,\n      leadingIcon: this.leadingIcon ? this.leadingIcon.foundationForSelect :\n                                      undefined,\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  ACTIVATED: 'mdc-select--activated',\n  DISABLED: 'mdc-select--disabled',\n  FOCUSED: 'mdc-select--focused',\n  INVALID: 'mdc-select--invalid',\n  MENU_INVALID: 'mdc-select__menu--invalid',\n  OUTLINED: 'mdc-select--outlined',\n  REQUIRED: 'mdc-select--required',\n  ROOT: 'mdc-select',\n  WITH_LEADING_ICON: 'mdc-select--with-leading-icon',\n};\n\nconst strings = {\n  ARIA_CONTROLS: 'aria-controls',\n  ARIA_DESCRIBEDBY: 'aria-describedby',\n  ARIA_SELECTED_ATTR: 'aria-selected',\n  CHANGE_EVENT: 'MDCSelect:change',\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  OUTLINE_SELECTOR: '.mdc-notched-outline',\n  SELECTED_TEXT_SELECTOR: '.mdc-select__selected-text',\n  SELECT_ANCHOR_SELECTOR: '.mdc-select__anchor',\n  VALUE_ATTR: 'data-value',\n};\n\nconst numbers = {\n  LABEL_SCALE: 0.75,\n  UNSET_INDEX: -1,\n  CLICK_DEBOUNCE_TIMEOUT_MS: 330,\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 {KEY, normalizeKey} from '@material/dom/keyboard';\nimport {Corner} from '@material/menu-surface/constants';\n\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\n/** MDC Select Foundation */\nexport class MDCSelectFoundation extends MDCFoundation<MDCSelectAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get numbers() {\n    return numbers;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  /**\n   * See {@link MDCSelectAdapter} for typing information on parameters and\n   * return types.\n   */\n  static override 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      getSelectedIndex: () => -1,\n      setSelectedIndex: () => undefined,\n      hasLabel: () => false,\n      floatLabel: () => undefined,\n      getLabelWidth: () => 0,\n      setLabelRequired: () => undefined,\n      hasOutline: () => false,\n      notchOutline: () => undefined,\n      closeOutline: () => undefined,\n      setRippleCenter: () => undefined,\n      notifyChange: () => undefined,\n      setSelectedText: () => undefined,\n      isSelectAnchorFocused: () => false,\n      getSelectAnchorAttr: () => '',\n      setSelectAnchorAttr: () => undefined,\n      removeSelectAnchorAttr: () => undefined,\n      addMenuClass: () => undefined,\n      removeMenuClass: () => undefined,\n      openMenu: () => undefined,\n      closeMenu: () => undefined,\n      getAnchorElement: () => null,\n      setMenuAnchorElement: () => undefined,\n      setMenuAnchorCorner: () => undefined,\n      setMenuWrapFocus: () => undefined,\n      focusMenuItemAtIndex: () => undefined,\n      getMenuItemCount: () => 0,\n      getMenuItemValues: () => [],\n      getMenuItemTextAtIndex: () => '',\n      isTypeaheadInProgress: () => false,\n      typeaheadMatchItem: () => -1,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private readonly leadingIcon: MDCSelectIconFoundation|undefined;\n  private readonly helperText: MDCSelectHelperTextFoundation|undefined;\n  // Client provided `aria-describedby` ids. Does not include helpTextId.\n  private readonly ariaDescribedbyIds: string[];\n\n  // Disabled state\n  private disabled = false;\n  // isMenuOpen is used to track the state of the menu by listening to the\n  // MDCMenuSurface:closed event For reference, menu.open will return false if\n  // the menu is still closing, but isMenuOpen returns false only after the menu\n  // has closed\n  private isMenuOpen = false;\n  // By default, select is invalid if it is required but no value is selected.\n  private useDefaultValidation = true;\n  private customValidity = true;\n  private lastSelectedIndex = numbers.UNSET_INDEX;\n\n  private clickDebounceTimeout = 0;\n  private recentlyClicked = false;\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(\n      adapter?: Partial<MDCSelectAdapter>,\n      foundationMap: Partial<MDCSelectFoundationMap> = {}) {\n    super({...MDCSelectFoundation.defaultAdapter, ...adapter});\n\n    this.leadingIcon = foundationMap.leadingIcon;\n    this.helperText = foundationMap.helperText;\n    this.ariaDescribedbyIds =\n        this.adapter.getSelectAnchorAttr(strings.ARIA_DESCRIBEDBY)\n            ?.split(' ')\n            ?.filter(id => id !== this.helperText?.getId() && id !== '') ||\n        [];\n  }\n\n  /** Returns the index of the currently selected menu item, or -1 if none. */\n  getSelectedIndex(): number {\n    return this.adapter.getSelectedIndex();\n  }\n\n  setSelectedIndex(index: number, closeMenu = false, skipNotify = false) {\n    if (index >= this.adapter.getMenuItemCount()) {\n      return;\n    }\n\n    this.adapter.setSelectedIndex(index);\n\n    if (index === numbers.UNSET_INDEX) {\n      this.adapter.setSelectedText('');\n    } else {\n      this.adapter.setSelectedText(\n          this.adapter.getMenuItemTextAtIndex(index).trim());\n    }\n\n    if (closeMenu) {\n      this.adapter.closeMenu();\n    }\n\n    if (!skipNotify && this.lastSelectedIndex !== index) {\n      this.handleChange();\n    }\n    this.lastSelectedIndex = index;\n  }\n\n  setValue(value: string, skipNotify = false) {\n    const index = this.adapter.getMenuItemValues().indexOf(value);\n    this.setSelectedIndex(index, /** closeMenu */ false, skipNotify);\n  }\n\n  getValue() {\n    const index = this.adapter.getSelectedIndex();\n    const menuItemValues = this.adapter.getMenuItemValues();\n    return index !== numbers.UNSET_INDEX ? menuItemValues[index] : '';\n  }\n\n  getDisabled() {\n    return this.disabled;\n  }\n\n  setDisabled(isDisabled: boolean) {\n    this.disabled = isDisabled;\n    if (this.disabled) {\n      this.adapter.addClass(cssClasses.DISABLED);\n      this.adapter.closeMenu();\n    } else {\n      this.adapter.removeClass(cssClasses.DISABLED);\n    }\n\n    if (this.leadingIcon) {\n      this.leadingIcon.setDisabled(this.disabled);\n    }\n\n    if (this.disabled) {\n      // Prevent click events from focusing select. Simply pointer-events: none\n      // is not enough since screenreader clicks may bypass this.\n      this.adapter.removeSelectAnchorAttr('tabindex');\n    } else {\n      this.adapter.setSelectAnchorAttr('tabindex', '0');\n    }\n\n    this.adapter.setSelectAnchorAttr('aria-disabled', this.disabled.toString());\n  }\n\n  /** Opens the menu. */\n  openMenu() {\n    this.adapter.addClass(cssClasses.ACTIVATED);\n    this.adapter.openMenu();\n    this.isMenuOpen = true;\n    this.adapter.setSelectAnchorAttr('aria-expanded', 'true');\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  /**\n   * Re-calculates if the notched outline should be notched and if the label\n   * should float.\n   */\n  layout() {\n    if (this.adapter.hasLabel()) {\n      const optionHasValue = this.getValue().length > 0;\n      const isFocused = this.adapter.hasClass(cssClasses.FOCUSED);\n      const shouldFloatAndNotch = optionHasValue || isFocused;\n      const isRequired = this.adapter.hasClass(cssClasses.REQUIRED);\n\n      this.notchOutline(shouldFloatAndNotch);\n      this.adapter.floatLabel(shouldFloatAndNotch);\n      this.adapter.setLabelRequired(isRequired);\n    }\n  }\n\n  /**\n   * Synchronizes the list of options with the state of the foundation. Call\n   * this whenever menu options are dynamically updated.\n   */\n  layoutOptions() {\n    const menuItemValues = this.adapter.getMenuItemValues();\n    const selectedIndex = menuItemValues.indexOf(this.getValue());\n    this.setSelectedIndex(\n        selectedIndex, /** closeMenu */ false, /** skipNotify */ true);\n  }\n\n  handleMenuOpened() {\n    if (this.adapter.getMenuItemValues().length === 0) {\n      return;\n    }\n\n    // Menu should open to the last selected element, should open to first menu\n    // item otherwise.\n    const selectedIndex = this.getSelectedIndex();\n    const focusItemIndex = selectedIndex >= 0 ? selectedIndex : 0;\n    this.adapter.focusMenuItemAtIndex(focusItemIndex);\n  }\n\n  handleMenuClosing() {\n    this.adapter.setSelectAnchorAttr('aria-expanded', 'false');\n  }\n\n  handleMenuClosed() {\n    this.adapter.removeClass(cssClasses.ACTIVATED);\n    this.isMenuOpen = false;\n\n    // Unfocus the select if menu is closed without a selection\n    if (!this.adapter.isSelectAnchorFocused()) {\n      this.blur();\n    }\n  }\n\n  /**\n   * Handles value changes, via change event or programmatic updates.\n   */\n  handleChange() {\n    this.layout();\n    this.adapter.notifyChange(this.getValue());\n\n    const isRequired = this.adapter.hasClass(cssClasses.REQUIRED);\n    if (isRequired && this.useDefaultValidation) {\n      this.setValid(this.isValid());\n    }\n  }\n\n  handleMenuItemAction(index: number) {\n    this.setSelectedIndex(index, /** closeMenu */ true);\n  }\n\n  /**\n   * Handles focus events from select element.\n   */\n  handleFocus() {\n    this.adapter.addClass(cssClasses.FOCUSED);\n    this.layout();\n\n    this.adapter.activateBottomLine();\n  }\n\n  /**\n   * Handles blur events from select element.\n   */\n  handleBlur() {\n    if (this.isMenuOpen) {\n      return;\n    }\n    this.blur();\n  }\n\n  handleClick(normalizedX: number) {\n    if (this.disabled || this.recentlyClicked) {\n      return;\n    }\n\n    this.setClickDebounceTimeout();\n\n    if (this.isMenuOpen) {\n      this.adapter.closeMenu();\n      return;\n    }\n\n    this.adapter.setRippleCenter(normalizedX);\n\n    this.openMenu();\n  }\n\n  /**\n   * Handles keydown events on select element. Depending on the type of\n   * character typed, does typeahead matching or opens menu.\n   */\n  handleKeydown(event: KeyboardEvent) {\n    if (this.isMenuOpen || !this.adapter.hasClass(cssClasses.FOCUSED)) {\n      return;\n    }\n\n    const isEnter = normalizeKey(event) === KEY.ENTER;\n    const isSpace = normalizeKey(event) === KEY.SPACEBAR;\n    const arrowUp = normalizeKey(event) === KEY.ARROW_UP;\n    const arrowDown = normalizeKey(event) === KEY.ARROW_DOWN;\n    const isModifier = event.ctrlKey || event.metaKey;\n    // Typeahead\n    if (!isModifier &&\n        (!isSpace && event.key && event.key.length === 1 ||\n         isSpace && this.adapter.isTypeaheadInProgress())) {\n      const key = isSpace ? ' ' : event.key;\n      const typeaheadNextIndex =\n          this.adapter.typeaheadMatchItem(key, this.getSelectedIndex());\n      if (typeaheadNextIndex >= 0) {\n        this.setSelectedIndex(typeaheadNextIndex);\n      }\n      event.preventDefault();\n      return;\n    }\n\n    if (!isEnter && !isSpace && !arrowUp && !arrowDown) {\n      return;\n    }\n\n    this.openMenu();\n    event.preventDefault();\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  getUseDefaultValidation(): boolean {\n    return this.useDefaultValidation;\n  }\n\n  setUseDefaultValidation(useDefaultValidation: boolean) {\n    this.useDefaultValidation = useDefaultValidation;\n  }\n\n  setValid(isValid: boolean) {\n    if (!this.useDefaultValidation) {\n      this.customValidity = isValid;\n    }\n\n    this.adapter.setSelectAnchorAttr('aria-invalid', (!isValid).toString());\n    if (isValid) {\n      this.adapter.removeClass(cssClasses.INVALID);\n      this.adapter.removeMenuClass(cssClasses.MENU_INVALID);\n    } else {\n      this.adapter.addClass(cssClasses.INVALID);\n      this.adapter.addMenuClass(cssClasses.MENU_INVALID);\n    }\n\n    this.syncHelperTextValidity(isValid);\n  }\n\n  isValid() {\n    if (this.useDefaultValidation &&\n        this.adapter.hasClass(cssClasses.REQUIRED) &&\n        !this.adapter.hasClass(cssClasses.DISABLED)) {\n      // See notes for required attribute under\n      // https://www.w3.org/TR/html52/sec-forms.html#the-select-element TL;DR:\n      // Invalid if no index is selected, or if the first index is selected and\n      // has an empty value.\n      return this.getSelectedIndex() !== numbers.UNSET_INDEX &&\n          (this.getSelectedIndex() !== 0 || Boolean(this.getValue()));\n    }\n    return this.customValidity;\n  }\n\n  setRequired(isRequired: boolean) {\n    if (isRequired) {\n      this.adapter.addClass(cssClasses.REQUIRED);\n    } else {\n      this.adapter.removeClass(cssClasses.REQUIRED);\n    }\n    this.adapter.setSelectAnchorAttr('aria-required', isRequired.toString());\n    this.adapter.setLabelRequired(isRequired);\n  }\n\n  getRequired() {\n    return this.adapter.getSelectAnchorAttr('aria-required') === 'true';\n  }\n\n  override init() {\n    const anchorEl = this.adapter.getAnchorElement();\n    if (anchorEl) {\n      this.adapter.setMenuAnchorElement(anchorEl);\n      this.adapter.setMenuAnchorCorner(Corner.BOTTOM_START);\n    }\n    this.adapter.setMenuWrapFocus(false);\n\n    this.setDisabled(this.adapter.hasClass(cssClasses.DISABLED));\n    this.syncHelperTextValidity(!this.adapter.hasClass(cssClasses.INVALID));\n    this.layout();\n    this.layoutOptions();\n  }\n\n  /**\n   * Unfocuses the select component.\n   */\n  private blur() {\n    this.adapter.removeClass(cssClasses.FOCUSED);\n    this.layout();\n    this.adapter.deactivateBottomLine();\n\n    const isRequired = this.adapter.hasClass(cssClasses.REQUIRED);\n    if (isRequired && this.useDefaultValidation) {\n      this.setValid(this.isValid());\n    }\n  }\n\n  private syncHelperTextValidity(isValid: boolean) {\n    if (!this.helperText) {\n      return;\n    }\n\n    this.helperText.setValidity(isValid);\n\n    const helperTextVisible = this.helperText.isVisible();\n    const helperTextId = this.helperText.getId();\n\n    if (helperTextVisible && helperTextId) {\n      this.adapter.setSelectAnchorAttr(\n          strings.ARIA_DESCRIBEDBY,\n          [...this.ariaDescribedbyIds, helperTextId].join(' '));\n    } else {\n      // Remove helptext from list of describedby ids. Needed because\n      // screenreaders will read labels pointed to by `aria-describedby` even if\n      // they are `aria-hidden`.\n      if (this.ariaDescribedbyIds.length > 0) {\n        this.adapter.setSelectAnchorAttr(\n            strings.ARIA_DESCRIBEDBY, this.ariaDescribedbyIds.join(' '));\n      } else {  // helper text is the only describedby element\n        this.adapter.removeSelectAnchorAttr(strings.ARIA_DESCRIBEDBY);\n      }\n    }\n  }\n\n  private setClickDebounceTimeout() {\n    clearTimeout(this.clickDebounceTimeout);\n    this.clickDebounceTimeout = setTimeout(() => {\n      this.recentlyClicked = false;\n    }, numbers.CLICK_DEBOUNCE_TIMEOUT_MS);\n    this.recentlyClicked = 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 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\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCSelectHelperTextAdapter {\n  /**\n   * Adds a class to the helper text element.\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes a class from the helper text element.\n   */\n  removeClass(className: string): void;\n\n  /**\n   * Returns whether or not the helper text element contains the given class.\n   */\n  hasClass(className: string): boolean;\n\n  /**\n   * Sets an attribute with a given value on the helper text element.\n   */\n  setAttr(attr: string, value: string): void;\n\n  /**\n   * Removes an attribute from the helper text element.\n   */\n  removeAttr(attr: string): void;\n\n  /**\n   * Gets an attribute from the helper text element.\n   */\n  getAttr(attr: string): string|null;\n\n  /**\n   * Sets the text content for the helper text element.\n   */\n  setContent(content: string): void;\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';\n\nimport {MDCSelectHelperTextAdapter} from './adapter';\nimport {MDCSelectHelperTextFoundation} from './foundation';\n\n/** MDC Select Helper Text Factory */\nexport type MDCSelectHelperTextFactory =\n    (el: HTMLElement, foundation?: MDCSelectHelperTextFoundation) =>\n        MDCSelectHelperText;\n\n/** MDC Select Helper Text */\nexport class MDCSelectHelperText extends\n    MDCComponent<MDCSelectHelperTextFoundation> {\n  static override attachTo(root: HTMLElement): MDCSelectHelperText {\n    return new MDCSelectHelperText(root);\n  }\n\n  // Provided for access by MDCSelect component\n  get foundationForSelect(): MDCSelectHelperTextFoundation {\n    return this.foundation;\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      hasClass: (className) => this.root.classList.contains(className),\n      getAttr: (attr) => this.root.getAttribute(attr),\n      setAttr: (attr, value) => {\n        this.safeSetAttribute(this.root, attr, value);\n      },\n      removeAttr: (attr) => {\n        this.root.removeAttribute(attr);\n      },\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_VALIDATION_MSG: 'mdc-select-helper-text--validation-msg',\n  HELPER_TEXT_VALIDATION_MSG_PERSISTENT:\n      'mdc-select-helper-text--validation-msg-persistent',\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';\n\nimport {MDCSelectHelperTextAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\n/** MDC Select Helper Text Foundation */\nexport class MDCSelectHelperTextFoundation extends\n    MDCFoundation<MDCSelectHelperTextAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  /**\n   * See {@link MDCSelectHelperTextAdapter} for typing information on parameters\n   * and return types.\n   */\n  static override 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      getAttr: () => null,\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   * @return The ID of the helper text, or null if none is set.\n   */\n  getId(): string|null {\n    return this.adapter.getAttr('id');\n  }\n\n  /**\n   * @return Whether the helper text is currently visible.\n   */\n  isVisible(): boolean {\n    return this.adapter.getAttr(strings.ARIA_HIDDEN) !== 'true';\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 helper text to act as a validation message.\n   * By default, validation messages are hidden when the select is valid and\n   * visible when the select is invalid.\n   *\n   * @param isValidation True to make the helper text act as an error validation\n   *     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   * Sets the persistency of the validation helper text.\n   * This keeps the validation message visible even if the select is valid,\n   * though it will be displayed in the normal (grey) color.\n   */\n  setValidationMsgPersistent(isPersistent: boolean) {\n    if (isPersistent) {\n      this.adapter.addClass(cssClasses.HELPER_TEXT_VALIDATION_MSG_PERSISTENT);\n    } else {\n      this.adapter.removeClass(\n          cssClasses.HELPER_TEXT_VALIDATION_MSG_PERSISTENT);\n    }\n  }\n\n  /**\n   * @return Whether the helper text acts as a validation message.\n   * By default, validation messages are hidden when the select is valid and\n   * visible when the select is invalid.\n   */\n  getIsValidation() {\n    return this.adapter.hasClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n  }\n\n  /**\n   * @return Whether the validation helper text persists even if the input is\n   * valid. If it is, it will be displayed in the normal (grey) color.\n   */\n  getIsValidationMsgPersistent() {\n    return this.adapter.hasClass(\n        cssClasses.HELPER_TEXT_VALIDATION_MSG_PERSISTENT);\n  }\n\n  /**\n   * When acting as a validation message, shows/hides the helper text and\n   * triggers alerts as necessary based on the select's validity.\n   */\n  setValidity(selectIsValid: boolean) {\n    const isValidationMsg =\n        this.adapter.hasClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n\n    if (!isValidationMsg) {\n      // Non-validating helper-text is always displayed and does not participate\n      // in validation logic.\n      return;\n    }\n\n    const isPersistentValidationMsg =\n        this.adapter.hasClass(cssClasses.HELPER_TEXT_VALIDATION_MSG_PERSISTENT);\n\n    // Validating helper text is displayed if select is invalid, unless it is\n    // set as persistent, in which case it always displays.\n    const msgShouldDisplay = !selectIsValid || isPersistentValidationMsg;\n    if (msgShouldDisplay) {\n      this.showToScreenReader();\n\n      // In addition to displaying, also trigger an alert if the select\n      // has become invalid.\n      if (!selectIsValid) {\n        this.adapter.setAttr(strings.ROLE, 'alert');\n      } else {\n        this.adapter.removeAttr(strings.ROLE);\n      }\n      return;\n    }\n\n    // Hide everything.\n    this.adapter.removeAttr(strings.ROLE);\n    this.hide();\n  }\n\n  /**\n   * Makes the helper text visible to screen readers.\n   */\n  private showToScreenReader() {\n    this.adapter.removeAttr(strings.ARIA_HIDDEN);\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 {EventType, SpecificEventListener} from '@material/base/types';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCSelectIconAdapter {\n  /**\n   * Gets the value of an attribute on the icon element.\n   */\n  getAttr(attr: string): string|null;\n\n  /**\n   * Sets an attribute on the icon element.\n   */\n  setAttr(attr: string, value: string): void;\n\n  /**\n   * Removes an attribute from the icon element.\n   */\n  removeAttr(attr: string): void;\n\n  /**\n   * Sets the text content of the icon element.\n   */\n  setContent(content: string): void;\n\n  /**\n   * Registers an event listener on the icon element for a given event.\n   */\n  registerInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener on the icon element for a given event.\n   */\n  deregisterInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Emits a custom event \"MDCSelect:icon\" denoting a user has clicked the icon.\n   */\n  notifyIconAction(): void;\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';\n\nimport {MDCSelectIconAdapter} from './adapter';\nimport {MDCSelectIconFoundation} from './foundation';\n\n/** MDC Select Icon Factory */\nexport type MDCSelectIconFactory =\n    (el: HTMLElement, foundation?: MDCSelectIconFoundation) => MDCSelectIcon;\n\n/** MDC Select Icon */\nexport class MDCSelectIcon extends MDCComponent<MDCSelectIconFoundation> {\n  static override attachTo(root: HTMLElement): MDCSelectIcon {\n    return new MDCSelectIcon(root);\n  }\n\n  // Provided for access by MDCSelect component\n  get foundationForSelect(): MDCSelectIconFoundation {\n    return this.foundation;\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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) => {\n        this.safeSetAttribute(this.root, attr, value);\n      },\n      removeAttr: (attr) => {\n        this.root.removeAttribute(attr);\n      },\n      setContent: (content) => {\n        this.root.textContent = content;\n      },\n      registerInteractionHandler: (eventType, handler) => {\n        this.listen(eventType, handler);\n      },\n      deregisterInteractionHandler: (eventType, handler) => {\n        this.unlisten(eventType, handler);\n      },\n      notifyIconAction: () => {\n        this.emit(\n            MDCSelectIconFoundation.strings.ICON_EVENT, {} /* eventData */,\n            true /* shouldBubble */);\n      },\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';\n\nimport {MDCSelectIconAdapter} from './adapter';\nimport {strings} from './constants';\n\ntype InteractionEventType = 'click'|'keydown';\n\nconst INTERACTION_EVENTS: InteractionEventType[] = ['click', 'keydown'];\n\n/** MDC Select Icon Foundation */\nexport class MDCSelectIconFoundation extends\n    MDCFoundation<MDCSelectIconAdapter> {\n  static override get strings() {\n    return strings;\n  }\n\n  /**\n   * See {@link MDCSelectIconAdapter} for typing information on parameters and\n   * return types.\n   */\n  static override 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!:\n      SpecificEventListener<InteractionEventType>;\n\n  constructor(adapter?: Partial<MDCSelectIconAdapter>) {\n    super({...MDCSelectIconFoundation.defaultAdapter, ...adapter});\n\n    this.interactionHandler = (event) => {\n      this.handleInteraction(event);\n    };\n  }\n\n  override init() {\n    this.savedTabIndex = this.adapter.getAttr('tabindex');\n\n    for (const eventType of INTERACTION_EVENTS) {\n      this.adapter.registerInteractionHandler(eventType, this.interactionHandler);\n    }\n  }\n\n  override destroy() {\n    for (const eventType of INTERACTION_EVENTS) {\n      this.adapter.deregisterInteractionHandler(\n          eventType, 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(event: MouseEvent|KeyboardEvent) {\n    const isEnterKey = (event as KeyboardEvent).key === 'Enter' ||\n        (event as KeyboardEvent).keyCode === 13;\n    if (event.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 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 {MDCSelectHelperTextFoundation} from './helper-text/foundation';\nimport {MDCSelectIconFoundation} from './icon/foundation';\n\nexport interface MDCSelectFoundationMap {\n  leadingIcon: MDCSelectIconFoundation;\n  helperText: MDCSelectHelperTextFoundation;\n}\n\nexport interface MDCSelectEventDetail {\n  value: string;\n  index: number;\n}\n\n// Note: CustomEvent<T> is not supported by Closure Compiler.\n\nexport interface MDCSelectEvent extends Event {\n  readonly detail: MDCSelectEventDetail;\n}\n","/**\n * @license\n * Copyright 2020 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 {EventType, SpecificEventListener} from '@material/base/types';\n\nimport {Thumb, TickMark} from './types';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCSliderAdapter {\n  /**\n   * @return Returns true if the slider root element has the given class.\n   */\n  hasClass(className: string): boolean;\n\n  /**\n   * Adds the given class to the slider root element.\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes the given class from the slider root element.\n   */\n  removeClass(className: string): void;\n\n  /**\n   * @return Returns the given attribute value on the slider root element.\n   */\n  getAttribute(attribute: string): string|null;\n\n  /**\n   * Adds the class to the given thumb element.\n   */\n  addThumbClass(className: string, thumb: Thumb): void;\n\n  /**\n   * Removes the class from the given thumb element.\n   */\n  removeThumbClass(className: string, thumb: Thumb): void;\n\n  /**\n   * - If thumb is `Thumb.START`, returns the value property on the start input\n   *   (for range slider variant).\n   * - If thumb is `Thumb.END`, returns the value property on the end input (or\n   *   only input for single point slider).\n   */\n  getInputValue(thumb: Thumb): string;\n\n  /**\n   * - If thumb is `Thumb.START`, sets the value property on the start input\n   *   (for range slider variant).\n   * - If thumb is `Thumb.END`, sets the value property on the end input (or\n   *   only input for single point slider).\n   */\n  setInputValue(value: string, thumb: Thumb): void;\n\n  /**\n   * - If thumb is `Thumb.START`, returns the attribute value on the start input\n   *   (for range slider variant).\n   * - If thumb is `Thumb.END`, returns the attribute value on the end input (or\n   *   only input for single point slider).\n   */\n  getInputAttribute(attribute: string, thumb: Thumb): string|null;\n\n  /**\n   * - If thumb is `Thumb.START`, sets the attribute on the start input\n   *   (for range slider variant).\n   * - If thumb is `Thumb.END`, sets the attribute on the end input (or\n   *   only input for single point slider).\n   */\n  setInputAttribute(attribute: string, value: string, thumb: Thumb): void;\n\n  /**\n   * - If thumb is `Thumb.START`, removes the attribute on the start input\n   *   (for range slider variant).\n   * - If thumb is `Thumb.END`, removes the attribute on the end input (or\n   *   only input for single point slider).\n   */\n  removeInputAttribute(attribute: string, thumb: Thumb): void;\n\n  /**\n   * - If thumb is `Thumb.START`, focuses start input (range slider variant).\n   * - If thumb is `Thumb.END`, focuses end input (or only input for single\n   *   point slider).\n   */\n  focusInput(thumb: Thumb): void;\n\n  /**\n   * @return Returns true if the given input is focused.\n   */\n  isInputFocused(thumb: Thumb): boolean;\n\n  /**\n   * @return Returns true if focus styles should be hidden for pointer events.\n   */\n  shouldHideFocusStylesForPointerEvents?(): boolean;\n\n  /**\n   * @return Returns the width of the given thumb knob.\n   */\n  getThumbKnobWidth(thumb: Thumb): number;\n\n  /**\n   * @return Returns the bounding client rect of the given thumb.\n   */\n  getThumbBoundingClientRect(thumb: Thumb): DOMRect;\n\n  /**\n   * @return Returns the bounding client rect for the slider root element.\n   */\n  getBoundingClientRect(): DOMRect;\n\n  /**\n   * @return Returns the width of the given value indicator container.\n   */\n  getValueIndicatorContainerWidth(thumb: Thumb): number;\n\n  /**\n   * @return Returns true if the root element is RTL, otherwise false\n   */\n  isRTL(): boolean;\n\n  /**\n   * Sets a style property of the thumb element to the passed value.\n   * - If thumb is `Thumb.START`, sets style on the start thumb (for\n   *   range slider variant).\n   * - If thumb is `Thumb.END`, sets style on the end thumb (or only thumb\n   *   for single point slider).\n   */\n  setThumbStyleProperty(propertyName: string, value: string, thumb: Thumb):\n      void;\n\n  /**\n   * Removes the given style property from the thumb element.\n   * - If thumb is `Thumb.START`, removes style from the start thumb (for\n   *   range slider variant).\n   * - If thumb is `Thumb.END`, removes style from the end thumb (or only thumb\n   *   for single point slider).\n   */\n  removeThumbStyleProperty(propertyName: string, thumb: Thumb): void;\n\n  /**\n   * Sets a style property of the active track element to the passed value.\n   */\n  setTrackActiveStyleProperty(propertyName: string, value: string): void;\n\n  /**\n   * Removes the given style property from the active track element.\n   */\n  removeTrackActiveStyleProperty(propertyName: string): void;\n\n  /**\n   * Sets value indicator text based on the given value.\n   * - If thumb is `Thumb.START`, updates value indicator on start thumb\n   *   (for range slider variant).\n   * - If thumb is `Thumb.END`, updates value indicator on end thumb (or\n   *   only thumb for single point slider).\n   */\n  setValueIndicatorText(value: number, thumb: Thumb): void;\n\n  /**\n   * Returns a function that maps the slider value to the value of the\n   * `aria-valuetext` attribute on the thumb element. If null, the\n   * `aria-valuetext` attribute is unchanged when the value changes.\n   */\n  getValueToAriaValueTextFn(): ((value: number, thumb: Thumb) => string)|null;\n\n  /**\n   * Updates tick marks container element with tick mark elements and their\n   * active/inactive classes, based on the given mappings:\n   * - TickMark.ACTIVE => `cssClasses.TICK_MARK_ACTIVE`\n   * - TickMark.INACTIVE => `cssClasses.TICK_MARK_INACTIVE`\n   */\n  updateTickMarks(tickMarks: TickMark[]): void;\n\n  /**\n   * Sets pointer capture on the slider root.\n   * https://developer.mozilla.org/en-US/docs/Web/API/Element/setPointerCapture\n   */\n  setPointerCapture(pointerId: number): void;\n\n  /**\n   * Emits a `change` event from the slider root, indicating that the value\n   * has been changed and committed on the given thumb, from a user event.\n   * Mirrors the native `change` event:\n   * https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/change_event\n   */\n  emitChangeEvent(value: number, thumb: Thumb): void;\n\n  /**\n   * Emits an `input` event from the slider root, indicating that the value\n   * has been changed on the given thumb, from a user event.\n   * Mirrors the native `input` event:\n   * https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/input_event\n   */\n  emitInputEvent(value: number, thumb: Thumb): void;\n\n  /**\n   * Emits an event on drag start, containing the current value on the\n   * thumb being dragged.\n   */\n  emitDragStartEvent(value: number, thumb: Thumb): void;\n\n  /**\n   * Emits an event on drag end, containing the final value on the\n   * thumb that was dragged.\n   */\n  emitDragEndEvent(value: number, thumb: Thumb): void;\n\n  /**\n   * Registers an event listener on the root element.\n   */\n  registerEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener on the root element.\n   */\n  deregisterEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Registers an event listener on the given thumb element.\n   */\n  registerThumbEventHandler<K extends EventType>(\n      thumb: Thumb, eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener on the given thumb element.\n   */\n  deregisterThumbEventHandler<K extends EventType>(\n      thumb: Thumb, eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Registers an event listener on the given input element.\n   */\n  registerInputEventHandler<K extends EventType>(\n      thumb: Thumb, eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener on the given input element.\n   */\n  deregisterInputEventHandler<K extends EventType>(\n      thumb: Thumb, eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Registers an event listener on the body element.\n   */\n  registerBodyEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener on the body element.\n   */\n  deregisterBodyEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Registers an event listener on the window.\n   */\n  registerWindowEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener on the window.\n   */\n  deregisterWindowEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n}\n","/**\n * @license\n * Copyright 2020 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, SpecificEventListener} 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';\n\nimport {MDCSliderAdapter} from './adapter';\nimport {cssClasses, events} from './constants';\nimport {MDCSliderFoundation} from './foundation';\nimport {MDCSliderChangeEventDetail, Thumb, TickMark} from './types';\n\n/** Vanilla implementation of slider component. */\nexport class MDCSlider extends MDCComponent<MDCSliderFoundation> {\n  static override attachTo(root: HTMLElement, options: {\n    skipInitialUIUpdate?: boolean\n  } = {}) {\n    return new MDCSlider(root, undefined, options);\n  }\n\n  private inputs!: HTMLInputElement[];  // Assigned in #initialize.\n  private thumbs!: HTMLElement[];       // Assigned in #initialize.\n  private trackActive!: HTMLElement;    // Assigned in #initialize.\n  private ripples!: MDCRipple[];        // Assigned in #initialize.\n\n  private skipInitialUIUpdate = false;\n  // Function that maps a slider value to the value of the `aria-valuetext`\n  // attribute on the thumb element.\n  private valueToAriaValueTextFn: ((value: number) => string)|null = null;\n\n  override getDefaultFoundation() {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same\n    // order as the adapter interface.\n    const adapter: MDCSliderAdapter = {\n      hasClass: (className) => this.root.classList.contains(className),\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      addThumbClass: (className, thumb: Thumb) => {\n        this.getThumbEl(thumb).classList.add(className);\n      },\n      removeThumbClass: (className, thumb: Thumb) => {\n        this.getThumbEl(thumb).classList.remove(className);\n      },\n      getAttribute: (attribute) => this.root.getAttribute(attribute),\n      getInputValue: (thumb: Thumb) => this.getInput(thumb).value,\n      setInputValue: (value: string, thumb: Thumb) => {\n        this.getInput(thumb).value = value;\n      },\n      getInputAttribute: (attribute, thumb: Thumb) =>\n          this.getInput(thumb).getAttribute(attribute),\n      setInputAttribute: (attribute, value, thumb: Thumb) => {\n        this.getInput(thumb).setAttribute(attribute, value);\n      },\n      removeInputAttribute: (attribute, thumb: Thumb) => {\n        this.getInput(thumb).removeAttribute(attribute);\n      },\n      focusInput: (thumb: Thumb) => {\n        this.getInput(thumb).focus();\n      },\n      isInputFocused: (thumb: Thumb) =>\n          this.getInput(thumb) === document.activeElement,\n      shouldHideFocusStylesForPointerEvents: () => false,\n      getThumbKnobWidth: (thumb: Thumb) => {\n        return this.getThumbEl(thumb)\n            .querySelector<HTMLElement>(`.${cssClasses.THUMB_KNOB}`)!\n            .getBoundingClientRect()\n            .width;\n      },\n      getThumbBoundingClientRect: (thumb: Thumb) =>\n          this.getThumbEl(thumb).getBoundingClientRect(),\n      getBoundingClientRect: () => this.root.getBoundingClientRect(),\n      getValueIndicatorContainerWidth: (thumb: Thumb) => {\n        return this.getThumbEl(thumb)\n            .querySelector<HTMLElement>(\n                `.${cssClasses.VALUE_INDICATOR_CONTAINER}`)!\n            .getBoundingClientRect()\n            .width;\n      },\n      isRTL: () => getComputedStyle(this.root).direction === 'rtl',\n      setThumbStyleProperty: (propertyName, value, thumb: Thumb) => {\n        this.getThumbEl(thumb).style.setProperty(propertyName, value);\n      },\n      removeThumbStyleProperty: (propertyName, thumb: Thumb) => {\n        this.getThumbEl(thumb).style.removeProperty(propertyName);\n      },\n      setTrackActiveStyleProperty: (propertyName, value) => {\n        this.trackActive.style.setProperty(propertyName, value);\n      },\n      removeTrackActiveStyleProperty: (propertyName) => {\n        this.trackActive.style.removeProperty(propertyName);\n      },\n      setValueIndicatorText: (value: number, thumb: Thumb) => {\n        const valueIndicatorEl =\n            this.getThumbEl(thumb).querySelector<HTMLElement>(\n                `.${cssClasses.VALUE_INDICATOR_TEXT}`);\n        valueIndicatorEl!.textContent = String(value);\n      },\n      getValueToAriaValueTextFn: () => this.valueToAriaValueTextFn,\n      updateTickMarks: (tickMarks: TickMark[]) => {\n        let tickMarksContainer = this.root.querySelector<HTMLElement>(\n            `.${cssClasses.TICK_MARKS_CONTAINER}`);\n        if (!tickMarksContainer) {\n          tickMarksContainer = document.createElement('div');\n          tickMarksContainer.classList.add(cssClasses.TICK_MARKS_CONTAINER);\n          const track =\n              this.root.querySelector<HTMLElement>(`.${cssClasses.TRACK}`);\n          track!.appendChild(tickMarksContainer);\n        }\n\n        if (tickMarks.length !== tickMarksContainer.children.length) {\n          while (tickMarksContainer.firstChild) {\n            tickMarksContainer.removeChild(tickMarksContainer.firstChild);\n          }\n          this.addTickMarks(tickMarksContainer, tickMarks);\n        } else {\n          this.updateTickMarks(tickMarksContainer, tickMarks);\n        }\n      },\n      setPointerCapture: (pointerId) => {\n        this.root.setPointerCapture(pointerId);\n      },\n      emitChangeEvent: (value, thumb: Thumb) => {\n        this.emit<MDCSliderChangeEventDetail>(events.CHANGE, {value, thumb});\n      },\n      emitInputEvent: (value, thumb: Thumb) => {\n        this.emit<MDCSliderChangeEventDetail>(events.INPUT, {value, thumb});\n      },\n      // tslint:disable-next-line:enforce-name-casing\n      emitDragStartEvent: (_, thumb: Thumb) => {\n        // Emitting event is not yet implemented. See issue:\n        // https://github.com/material-components/material-components-web/issues/6448\n\n        this.getRipple(thumb).activate();\n      },\n      // tslint:disable-next-line:enforce-name-casing\n      emitDragEndEvent: (_, thumb: Thumb) => {\n        // Emitting event is not yet implemented. See issue:\n        // https://github.com/material-components/material-components-web/issues/6448\n\n        this.getRipple(thumb).deactivate();\n      },\n      registerEventHandler: (eventType, handler) => {\n        this.listen(eventType, handler);\n      },\n      deregisterEventHandler: (eventType, handler) => {\n        this.unlisten(eventType, handler);\n      },\n      registerThumbEventHandler: (thumb, eventType, handler) => {\n        this.getThumbEl(thumb).addEventListener(eventType, handler);\n      },\n      deregisterThumbEventHandler: (thumb, eventType, handler) => {\n        this.getThumbEl(thumb).removeEventListener(eventType, handler);\n      },\n      registerInputEventHandler: (thumb, eventType, handler) => {\n        this.getInput(thumb).addEventListener(eventType, handler);\n      },\n      deregisterInputEventHandler: (thumb, eventType, handler) => {\n        this.getInput(thumb).removeEventListener(eventType, handler);\n      },\n      registerBodyEventHandler: (eventType, handler) => {\n        document.body.addEventListener(eventType, handler);\n      },\n      deregisterBodyEventHandler: (eventType, handler) => {\n        document.body.removeEventListener(eventType, handler);\n      },\n      registerWindowEventHandler: (eventType, handler) => {\n        window.addEventListener(eventType, handler);\n      },\n      deregisterWindowEventHandler: (eventType, handler) => {\n        window.removeEventListener(eventType, handler);\n      },\n      // tslint:enable:object-literal-sort-keys\n    };\n    return new MDCSliderFoundation(adapter);\n  }\n\n  /**\n   * Initializes component, with the following options:\n   * - `skipInitialUIUpdate`: Whether to skip updating the UI when initially\n   *   syncing with the DOM. This should be enabled when the slider position\n   *   is set before component initialization.\n   */\n  override initialize({skipInitialUIUpdate}: {skipInitialUIUpdate?:\n                                                  boolean} = {}) {\n    this.inputs = Array.from(\n        this.root.querySelectorAll<HTMLInputElement>(`.${cssClasses.INPUT}`));\n    this.thumbs = Array.from(\n        this.root.querySelectorAll<HTMLElement>(`.${cssClasses.THUMB}`));\n    this.trackActive =\n        this.root.querySelector<HTMLElement>(`.${cssClasses.TRACK_ACTIVE}`)!;\n    this.ripples = this.createRipples();\n\n    if (skipInitialUIUpdate) {\n      this.skipInitialUIUpdate = true;\n    }\n  }\n\n  override initialSyncWithDOM() {\n    this.foundation.layout({skipUpdateUI: this.skipInitialUIUpdate});\n  }\n\n  /** Redraws UI based on DOM (e.g. element dimensions, RTL). */\n  layout() {\n    this.foundation.layout();\n  }\n\n  getValueStart(): number {\n    return this.foundation.getValueStart();\n  }\n\n  setValueStart(valueStart: number) {\n    this.foundation.setValueStart(valueStart);\n  }\n\n  getValue(): number {\n    return this.foundation.getValue();\n  }\n\n  setValue(value: number) {\n    this.foundation.setValue(value);\n  }\n\n  /** @return Slider disabled state. */\n  getDisabled(): boolean {\n    return this.foundation.getDisabled();\n  }\n\n  /** Sets slider disabled state. */\n  setDisabled(disabled: boolean) {\n    this.foundation.setDisabled(disabled);\n  }\n\n  /**\n   * Sets a function that maps the slider value to the value of the\n   * `aria-valuetext` attribute on the thumb element.\n   */\n  setValueToAriaValueTextFn(mapFn: ((value: number) => string)|null) {\n    this.valueToAriaValueTextFn = mapFn;\n  }\n\n  private getThumbEl(thumb: Thumb) {\n    return thumb === Thumb.END ? this.thumbs[this.thumbs.length - 1] :\n                                 this.thumbs[0];\n  }\n\n  private getInput(thumb: Thumb) {\n    return thumb === Thumb.END ? this.inputs[this.inputs.length - 1] :\n                                 this.inputs[0];\n  }\n\n  private getRipple(thumb: Thumb) {\n    return thumb === Thumb.END ? this.ripples[this.ripples.length - 1] :\n                                 this.ripples[0];\n  }\n\n  /** Adds tick mark elements to the given container. */\n  private addTickMarks(tickMarkContainer: HTMLElement, tickMarks: TickMark[]) {\n    const fragment = document.createDocumentFragment();\n    for (let i = 0; i < tickMarks.length; i++) {\n      const div = document.createElement('div');\n      const tickMarkClass = tickMarks[i] === TickMark.ACTIVE ?\n          cssClasses.TICK_MARK_ACTIVE :\n          cssClasses.TICK_MARK_INACTIVE;\n      div.classList.add(tickMarkClass);\n      fragment.appendChild(div);\n    }\n    tickMarkContainer.appendChild(fragment);\n  }\n\n  /** Updates tick mark elements' classes in the given container. */\n  private updateTickMarks(\n      tickMarkContainer: HTMLElement, tickMarks: TickMark[]) {\n    const tickMarkEls = Array.from(tickMarkContainer.children);\n    for (let i = 0; i < tickMarkEls.length; i++) {\n      if (tickMarks[i] === TickMark.ACTIVE) {\n        tickMarkEls[i].classList.add(cssClasses.TICK_MARK_ACTIVE);\n        tickMarkEls[i].classList.remove(cssClasses.TICK_MARK_INACTIVE);\n      } else {\n        tickMarkEls[i].classList.add(cssClasses.TICK_MARK_INACTIVE);\n        tickMarkEls[i].classList.remove(cssClasses.TICK_MARK_ACTIVE);\n      }\n    }\n  }\n\n  /** Initializes thumb ripples. */\n  private createRipples(): MDCRipple[] {\n    const ripples = [];\n    const rippleSurfaces = Array.from(\n        this.root.querySelectorAll<HTMLElement>(`.${cssClasses.THUMB}`));\n    for (let i = 0; i < rippleSurfaces.length; i++) {\n      const rippleSurface = rippleSurfaces[i];\n      // Use the corresponding input as the focus source for the ripple (i.e.\n      // when the input is focused, the ripple is in the focused state).\n      const input = this.inputs[i];\n\n      const adapter: MDCRippleAdapter = {\n        ...MDCRipple.createAdapter(this),\n        addClass: (className: string) => {\n          rippleSurface.classList.add(className);\n        },\n        computeBoundingRect: () => rippleSurface.getBoundingClientRect(),\n        deregisterInteractionHandler: <K extends EventType>(\n            eventType: K, handler: SpecificEventListener<K>) => {\n          input.removeEventListener(eventType, handler);\n        },\n        isSurfaceActive: () => matches(input, ':active'),\n        isUnbounded: () => true,\n        registerInteractionHandler: <K extends EventType>(\n            eventType: K, handler: SpecificEventListener<K>) => {\n          input.addEventListener(eventType, handler, applyPassive());\n        },\n        removeClass: (className: string) => {\n          rippleSurface.classList.remove(className);\n        },\n        updateCssVariable: (varName: string, value: string) => {\n          rippleSurface.style.setProperty(varName, value);\n        },\n      };\n\n      const ripple =\n          new MDCRipple(rippleSurface, new MDCRippleFoundation(adapter));\n      ripple.unbounded = true;\n      ripples.push(ripple);\n    }\n\n    return ripples;\n  }\n}\n","/**\n * @license\n * Copyright 2020 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/** Slider element classes. */\nexport const cssClasses = {\n  DISABLED: 'mdc-slider--disabled',\n  DISCRETE: 'mdc-slider--discrete',\n  INPUT: 'mdc-slider__input',\n  RANGE: 'mdc-slider--range',\n  THUMB: 'mdc-slider__thumb',\n  // Applied when thumb is in the focused state.\n  THUMB_FOCUSED: 'mdc-slider__thumb--focused',\n  THUMB_KNOB: 'mdc-slider__thumb-knob',\n  // Class added to the top thumb (for overlapping thumbs in range slider).\n  THUMB_TOP: 'mdc-slider__thumb--top',\n  THUMB_WITH_INDICATOR: 'mdc-slider__thumb--with-indicator',\n  TICK_MARKS: 'mdc-slider--tick-marks',\n  TICK_MARKS_CONTAINER: 'mdc-slider__tick-marks',\n  TICK_MARK_ACTIVE: 'mdc-slider__tick-mark--active',\n  TICK_MARK_INACTIVE: 'mdc-slider__tick-mark--inactive',\n  TRACK: 'mdc-slider__track',\n  // The active track fill element that will be scaled as the value changes.\n  TRACK_ACTIVE: 'mdc-slider__track--active_fill',\n  VALUE_INDICATOR_CONTAINER: 'mdc-slider__value-indicator-container',\n  VALUE_INDICATOR_TEXT: 'mdc-slider__value-indicator-text',\n};\n\n/** Slider numbers. */\nexport const numbers = {\n  // Default step size.\n  STEP_SIZE: 1,\n  // Default minimum difference between the start and end values.\n  MIN_RANGE: 0,\n  // Minimum absolute difference between clientX of move event / down event\n  // for which to update thumb, in the case of overlapping thumbs.\n  // This is needed to reduce chances of choosing the thumb based on\n  // pointer jitter.\n  THUMB_UPDATE_MIN_PX: 5,\n};\n\n/** Slider attributes. */\nexport const attributes = {\n  ARIA_VALUETEXT: 'aria-valuetext',\n  INPUT_DISABLED: 'disabled',\n  INPUT_MIN: 'min',\n  INPUT_MAX: 'max',\n  INPUT_VALUE: 'value',\n  INPUT_STEP: 'step',\n  DATA_MIN_RANGE: 'data-min-range',\n};\n\n/** Slider events. */\nexport const events = {\n  CHANGE: 'MDCSlider:change',\n  INPUT: 'MDCSlider:input',\n};\n\n/** Slider strings. */\nexport const strings = {\n  VAR_VALUE_INDICATOR_CARET_LEFT: '--slider-value-indicator-caret-left',\n  VAR_VALUE_INDICATOR_CARET_RIGHT: '--slider-value-indicator-caret-right',\n  VAR_VALUE_INDICATOR_CARET_TRANSFORM:\n      '--slider-value-indicator-caret-transform',\n  VAR_VALUE_INDICATOR_CONTAINER_LEFT: '--slider-value-indicator-container-left',\n  VAR_VALUE_INDICATOR_CONTAINER_RIGHT:\n      '--slider-value-indicator-container-right',\n  VAR_VALUE_INDICATOR_CONTAINER_TRANSFORM:\n      '--slider-value-indicator-container-transform',\n};\n","/**\n * @license\n * Copyright 2020 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 {AnimationFrame} from '@material/animation/animationframe';\nimport {getCorrectPropertyName} from '@material/animation/util';\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener} from '@material/base/types';\n\nimport {MDCSliderAdapter} from './adapter';\nimport {attributes, cssClasses, numbers, strings} from './constants';\nimport {Thumb, TickMark} from './types';\n\nenum AnimationKeys {\n  SLIDER_UPDATE = 'slider_update'\n}\n\n// Accessing `window` without a `typeof` check will throw on Node environments.\nconst HAS_WINDOW = typeof window !== 'undefined';\n\n/**\n * Foundation class for slider. Responsibilities include:\n * - Updating slider values (internal state and DOM updates) based on client\n *   'x' position.\n * - Updating DOM after slider property updates (e.g. min, max).\n */\nexport class MDCSliderFoundation extends MDCFoundation<MDCSliderAdapter> {\n  static SUPPORTS_POINTER_EVENTS = HAS_WINDOW && Boolean(window.PointerEvent) &&\n      // #setPointerCapture is buggy on iOS, so we can't use pointer events\n      // until the following bug is fixed:\n      // https://bugs.webkit.org/show_bug.cgi?id=220196\n      !isIOS();\n\n  // Whether the initial styles (to position the thumb, before component\n  // initialization) have been removed.\n  private initialStylesRemoved = false;\n\n  private min!: number;  // Assigned in init()\n  private max!: number;  // Assigned in init()\n  // If `isRange`, this is the value of Thumb.START. Otherwise, defaults to min.\n  private valueStart!: number;  // Assigned in init()\n  // If `isRange`, this it the value of Thumb.END. Otherwise, it is the\n  // value of the single thumb.\n  private value!: number;  // Assigned in init()\n\n  private isDisabled = false;\n\n  private isDiscrete = false;\n  private step = numbers.STEP_SIZE;\n  private minRange = numbers.MIN_RANGE;\n  // Number of digits after the decimal point to round to, when computing\n  // values. This is based on the step size by default and is used to\n  // avoid floating point precision errors in JS.\n  private numDecimalPlaces!: number;  // Assigned in init()\n  private hasTickMarks = false;\n\n  // The following properties are only set for range sliders.\n  private isRange = false;\n  // Tracks the thumb being moved across a slider pointer interaction (down,\n  // move event).\n  private thumb: Thumb|null = null;\n  // `clientX` from the most recent down event. Used in subsequent move\n  // events to determine which thumb to move (in the case of\n  // overlapping thumbs).\n  private downEventClientX: number|null = null;\n  // `valueStart` before the most recent down event. Used in subsequent up\n  // events to determine whether to fire the `change` event.\n  private valueStartBeforeDownEvent!: number;  // Assigned in init()\n  // `value` before the most recent down event. Used in subsequent up\n  // events to determine whether to fire the `change` event.\n  private valueBeforeDownEvent!: number;  // Assigned in init()\n  // Width of the start thumb knob.\n  private startThumbKnobWidth = 0;\n  // Width of the end thumb knob.\n  private endThumbKnobWidth = 0;\n\n  private readonly animFrame: AnimationFrame;\n\n  // Assigned in #initialize.\n  private mousedownOrTouchstartListener!:\n      SpecificEventListener<'mousedown'|'touchstart'>;\n  // Assigned in #initialize.\n  private moveListener!:\n      SpecificEventListener<'pointermove'|'mousemove'|'touchmove'>;\n  private pointerdownListener!:\n      SpecificEventListener<'pointerdown'>;  // Assigned in #initialize.\n  private pointerupListener!:\n      SpecificEventListener<'pointerup'>;  // Assigned in #initialize.\n  private thumbMouseenterListener!:\n      SpecificEventListener<'mouseenter'>;  // Assigned in #initialize.\n  private thumbMouseleaveListener!:\n      SpecificEventListener<'mouseleave'>;  // Assigned in #initialize.\n  private inputStartChangeListener!:\n      SpecificEventListener<'change'>;  // Assigned in #initialize.\n  private inputEndChangeListener!:\n      SpecificEventListener<'change'>;  // Assigned in #initialize.\n  private inputStartFocusListener!:\n      SpecificEventListener<'focus'>;  // Assigned in #initialize.\n  private inputEndFocusListener!:\n      SpecificEventListener<'focus'>;  // Assigned in #initialize.\n  private inputStartBlurListener!:\n      SpecificEventListener<'blur'>;  // Assigned in #initialize.\n  private inputEndBlurListener!:\n      SpecificEventListener<'blur'>;  // Assigned in #initialize.\n  private resizeListener!:\n      SpecificEventListener<'resize'>;  // Assigned in #initialize.\n\n  constructor(adapter?: Partial<MDCSliderAdapter>) {\n    super({...MDCSliderFoundation.defaultAdapter, ...adapter});\n\n    this.animFrame = new AnimationFrame();\n  }\n\n  static override get defaultAdapter(): MDCSliderAdapter {\n    // tslint:disable:object-literal-sort-keys Methods should be in the same\n    // order as the adapter interface.\n    return {\n      hasClass: () => false,\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      addThumbClass: () => undefined,\n      removeThumbClass: () => undefined,\n      getAttribute: () => null,\n      getInputValue: () => '',\n      setInputValue: () => undefined,\n      getInputAttribute: () => null,\n      setInputAttribute: () => null,\n      removeInputAttribute: () => null,\n      focusInput: () => undefined,\n      isInputFocused: () => false,\n      shouldHideFocusStylesForPointerEvents: () => false,\n      getThumbKnobWidth: () => 0,\n      getValueIndicatorContainerWidth: () => 0,\n      getThumbBoundingClientRect: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\n      getBoundingClientRect: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\n      isRTL: () => false,\n      setThumbStyleProperty: () => undefined,\n      removeThumbStyleProperty: () => undefined,\n      setTrackActiveStyleProperty: () => undefined,\n      removeTrackActiveStyleProperty: () => undefined,\n      setValueIndicatorText: () => undefined,\n      getValueToAriaValueTextFn: () => null,\n      updateTickMarks: () => undefined,\n      setPointerCapture: () => undefined,\n      emitChangeEvent: () => undefined,\n      emitInputEvent: () => undefined,\n      emitDragStartEvent: () => undefined,\n      emitDragEndEvent: () => undefined,\n      registerEventHandler: () => undefined,\n      deregisterEventHandler: () => undefined,\n      registerThumbEventHandler: () => undefined,\n      deregisterThumbEventHandler: () => undefined,\n      registerInputEventHandler: () => undefined,\n      deregisterInputEventHandler: () => undefined,\n      registerBodyEventHandler: () => undefined,\n      deregisterBodyEventHandler: () => undefined,\n      registerWindowEventHandler: () => undefined,\n      deregisterWindowEventHandler: () => undefined,\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  override init() {\n    this.isDisabled = this.adapter.hasClass(cssClasses.DISABLED);\n    this.isDiscrete = this.adapter.hasClass(cssClasses.DISCRETE);\n    this.hasTickMarks = this.adapter.hasClass(cssClasses.TICK_MARKS);\n    this.isRange = this.adapter.hasClass(cssClasses.RANGE);\n\n    const min = this.convertAttributeValueToNumber(\n        this.adapter.getInputAttribute(\n            attributes.INPUT_MIN, this.isRange ? Thumb.START : Thumb.END),\n        attributes.INPUT_MIN);\n    const max = this.convertAttributeValueToNumber(\n        this.adapter.getInputAttribute(attributes.INPUT_MAX, Thumb.END),\n        attributes.INPUT_MAX);\n    const value = this.convertAttributeValueToNumber(\n        this.adapter.getInputAttribute(attributes.INPUT_VALUE, Thumb.END),\n        attributes.INPUT_VALUE);\n    const valueStart = this.isRange ?\n        this.convertAttributeValueToNumber(\n            this.adapter.getInputAttribute(attributes.INPUT_VALUE, Thumb.START),\n            attributes.INPUT_VALUE) :\n        min;\n    const stepAttr =\n        this.adapter.getInputAttribute(attributes.INPUT_STEP, Thumb.END);\n    const step = stepAttr ?\n        this.convertAttributeValueToNumber(stepAttr, attributes.INPUT_STEP) :\n        this.step;\n    const minRangeAttr = this.adapter.getAttribute(attributes.DATA_MIN_RANGE);\n    const minRange = minRangeAttr ?\n        this.convertAttributeValueToNumber(\n            minRangeAttr, attributes.DATA_MIN_RANGE) :\n        this.minRange;\n\n    this.validateProperties({min, max, value, valueStart, step, minRange});\n\n    this.min = min;\n    this.max = max;\n    this.value = value;\n    this.valueStart = valueStart;\n    this.step = step;\n    this.minRange = minRange;\n    this.numDecimalPlaces = getNumDecimalPlaces(this.step);\n\n    this.valueBeforeDownEvent = value;\n    this.valueStartBeforeDownEvent = valueStart;\n\n    this.mousedownOrTouchstartListener =\n        this.handleMousedownOrTouchstart.bind(this);\n    this.moveListener = this.handleMove.bind(this);\n    this.pointerdownListener = this.handlePointerdown.bind(this);\n    this.pointerupListener = this.handlePointerup.bind(this);\n    this.thumbMouseenterListener = this.handleThumbMouseenter.bind(this);\n    this.thumbMouseleaveListener = this.handleThumbMouseleave.bind(this);\n    this.inputStartChangeListener = () => {\n      this.handleInputChange(Thumb.START);\n    };\n    this.inputEndChangeListener = () => {\n      this.handleInputChange(Thumb.END);\n    };\n    this.inputStartFocusListener = () => {\n      this.handleInputFocus(Thumb.START);\n    };\n    this.inputEndFocusListener = () => {\n      this.handleInputFocus(Thumb.END);\n    };\n    this.inputStartBlurListener = () => {\n      this.handleInputBlur(Thumb.START);\n    };\n    this.inputEndBlurListener = () => {\n      this.handleInputBlur(Thumb.END);\n    };\n    this.resizeListener = this.handleResize.bind(this);\n    this.registerEventHandlers();\n  }\n\n  override destroy() {\n    this.deregisterEventHandlers();\n  }\n\n  setMin(value: number) {\n    this.min = value;\n    if (!this.isRange) {\n      this.valueStart = value;\n    }\n    this.updateUI();\n  }\n\n  setMax(value: number) {\n    this.max = value;\n    this.updateUI();\n  }\n\n  getMin() {\n    return this.min;\n  }\n\n  getMax() {\n    return this.max;\n  }\n\n  /**\n   * - For single point sliders, returns the thumb value.\n   * - For range (two-thumb) sliders, returns the end thumb's value.\n   */\n  getValue() {\n    return this.value;\n  }\n\n  /**\n   * - For single point sliders, sets the thumb value.\n   * - For range (two-thumb) sliders, sets the end thumb's value.\n   */\n  setValue(value: number) {\n    if (this.isRange && value < this.valueStart + this.minRange) {\n      throw new Error(\n          `end thumb value (${value}) must be >= start thumb ` +\n          `value (${this.valueStart}) + min range (${this.minRange})`);\n    }\n\n    this.updateValue(value, Thumb.END);\n  }\n\n  /**\n   * Only applicable for range sliders.\n   * @return The start thumb's value.\n   */\n  getValueStart() {\n    if (!this.isRange) {\n      throw new Error('`valueStart` is only applicable for range sliders.');\n    }\n\n    return this.valueStart;\n  }\n\n  /**\n   * Only applicable for range sliders. Sets the start thumb's value.\n   */\n  setValueStart(valueStart: number) {\n    if (!this.isRange) {\n      throw new Error('`valueStart` is only applicable for range sliders.');\n    }\n    if (this.isRange && valueStart > this.value - this.minRange) {\n      throw new Error(\n          `start thumb value (${valueStart}) must be <= end thumb ` +\n          `value (${this.value}) - min range (${this.minRange})`);\n    }\n\n    this.updateValue(valueStart, Thumb.START);\n  }\n\n  setStep(value: number) {\n    this.step = value;\n    this.numDecimalPlaces = getNumDecimalPlaces(value);\n\n    this.updateUI();\n  }\n\n  /**\n   * Only applicable for range sliders. Sets the minimum difference between the\n   * start and end values.\n   */\n  setMinRange(value: number) {\n    if (!this.isRange) {\n      throw new Error('`minRange` is only applicable for range sliders.');\n    }\n    if (value < 0) {\n      throw new Error(\n          '`minRange` must be non-negative. ' +\n          `Current value: ${value}`);\n    }\n    if (this.value - this.valueStart < value) {\n      throw new Error(\n          `start thumb value (${this.valueStart}) and end thumb value ` +\n          `(${this.value}) must differ by at least ${value}.`);\n    }\n    this.minRange = value;\n  }\n\n  setIsDiscrete(value: boolean) {\n    this.isDiscrete = value;\n    this.updateValueIndicatorUI();\n    this.updateTickMarksUI();\n  }\n\n  getStep() {\n    return this.step;\n  }\n\n  getMinRange() {\n    if (!this.isRange) {\n      throw new Error('`minRange` is only applicable for range sliders.');\n    }\n\n    return this.minRange;\n  }\n\n  setHasTickMarks(value: boolean) {\n    this.hasTickMarks = value;\n    this.updateTickMarksUI();\n  }\n\n  getDisabled() {\n    return this.isDisabled;\n  }\n\n  /**\n   * Sets disabled state, including updating styles and thumb tabindex.\n   */\n  setDisabled(disabled: boolean) {\n    this.isDisabled = disabled;\n\n    if (disabled) {\n      this.adapter.addClass(cssClasses.DISABLED);\n\n      if (this.isRange) {\n        this.adapter.setInputAttribute(\n            attributes.INPUT_DISABLED, '', Thumb.START);\n      }\n      this.adapter.setInputAttribute(attributes.INPUT_DISABLED, '', Thumb.END);\n    } else {\n      this.adapter.removeClass(cssClasses.DISABLED);\n\n      if (this.isRange) {\n        this.adapter.removeInputAttribute(\n            attributes.INPUT_DISABLED, Thumb.START);\n      }\n      this.adapter.removeInputAttribute(attributes.INPUT_DISABLED, Thumb.END);\n    }\n  }\n\n  /** @return Whether the slider is a range slider. */\n  getIsRange() {\n    return this.isRange;\n  }\n\n  /**\n   * - Updates UI based on internal state.\n   */\n  layout({skipUpdateUI}: {skipUpdateUI?: boolean} = {}) {\n    if (this.isRange) {\n      this.startThumbKnobWidth = this.adapter.getThumbKnobWidth(Thumb.START);\n      this.endThumbKnobWidth = this.adapter.getThumbKnobWidth(Thumb.END);\n    }\n\n    if (!skipUpdateUI) {\n      this.updateUI();\n    }\n  }\n\n  /** Handles resize events on the window. */\n  handleResize() {\n    this.layout();\n  }\n\n  /**\n   * Handles pointer down events on the slider root element.\n   */\n  handleDown(event: PointerEvent|MouseEvent|TouchEvent) {\n    if (this.isDisabled) return;\n\n    this.valueStartBeforeDownEvent = this.valueStart;\n    this.valueBeforeDownEvent = this.value;\n\n    const clientX = (event as MouseEvent).clientX != null ?\n        (event as MouseEvent).clientX :\n        (event as TouchEvent).targetTouches[0].clientX;\n    this.downEventClientX = clientX;\n    const value = this.mapClientXOnSliderScale(clientX);\n    this.thumb = this.getThumbFromDownEvent(clientX, value);\n    if (this.thumb === null) return;\n\n    this.handleDragStart(event, value, this.thumb);\n    this.updateValue(value, this.thumb, {emitInputEvent: true});\n  }\n\n  /**\n   * Handles pointer move events on the slider root element.\n   */\n  handleMove(event: PointerEvent|MouseEvent|TouchEvent) {\n    if (this.isDisabled) return;\n\n    // Prevent scrolling.\n    event.preventDefault();\n\n    const clientX = (event as MouseEvent).clientX != null ?\n        (event as MouseEvent).clientX :\n        (event as TouchEvent).targetTouches[0].clientX;\n    const dragAlreadyStarted = this.thumb != null;\n    this.thumb = this.getThumbFromMoveEvent(clientX);\n    if (this.thumb === null) return;\n\n    const value = this.mapClientXOnSliderScale(clientX);\n    if (!dragAlreadyStarted) {\n      this.handleDragStart(event, value, this.thumb);\n      this.adapter.emitDragStartEvent(value, this.thumb);\n    }\n    this.updateValue(value, this.thumb, {emitInputEvent: true});\n  }\n\n  /**\n   * Handles pointer up events on the slider root element.\n   */\n  handleUp() {\n    if (this.isDisabled || this.thumb === null) return;\n\n    // Remove the focused state and hide the value indicator(s) (if present)\n    // if focus state is meant to be hidden.\n    if (this.adapter.shouldHideFocusStylesForPointerEvents?.()) {\n      this.handleInputBlur(this.thumb);\n    }\n\n    const oldValue = this.thumb === Thumb.START ?\n        this.valueStartBeforeDownEvent :\n        this.valueBeforeDownEvent;\n    const newValue = this.thumb === Thumb.START ? this.valueStart : this.value;\n    if (oldValue !== newValue) {\n      this.adapter.emitChangeEvent(newValue, this.thumb);\n    }\n\n    this.adapter.emitDragEndEvent(newValue, this.thumb);\n    this.thumb = null;\n  }\n\n  /**\n   * For range, discrete slider, shows the value indicator on both thumbs.\n   */\n  handleThumbMouseenter() {\n    if (!this.isDiscrete || !this.isRange) return;\n\n    this.adapter.addThumbClass(cssClasses.THUMB_WITH_INDICATOR, Thumb.START);\n    this.adapter.addThumbClass(cssClasses.THUMB_WITH_INDICATOR, Thumb.END);\n  }\n\n  /**\n   * For range, discrete slider, hides the value indicator on both thumbs.\n   */\n  handleThumbMouseleave() {\n    if (!this.isDiscrete || !this.isRange) return;\n    if ((!this.adapter.shouldHideFocusStylesForPointerEvents?.() &&\n         (this.adapter.isInputFocused(Thumb.START) ||\n          this.adapter.isInputFocused(Thumb.END))) ||\n        this.thumb) {\n      // Leave value indicator shown if either input is focused or the thumb is\n      // being dragged.\n      return;\n    }\n\n    this.adapter.removeThumbClass(cssClasses.THUMB_WITH_INDICATOR, Thumb.START);\n    this.adapter.removeThumbClass(cssClasses.THUMB_WITH_INDICATOR, Thumb.END);\n  }\n\n  handleMousedownOrTouchstart(event: MouseEvent|TouchEvent) {\n    const moveEventType =\n        event.type === 'mousedown' ? 'mousemove' : 'touchmove';\n    // After a down event on the slider root, listen for move events on\n    // body (so the slider value is updated for events outside of the\n    // slider root).\n    this.adapter.registerBodyEventHandler(moveEventType, this.moveListener);\n\n    const upHandler = () => {\n      this.handleUp();\n\n      // Once the drag is finished (up event on body), remove the move\n      // handler.\n      this.adapter.deregisterBodyEventHandler(moveEventType, this.moveListener);\n\n      // Also stop listening for subsequent up events.\n      this.adapter.deregisterEventHandler('mouseup', upHandler);\n      this.adapter.deregisterEventHandler('touchend', upHandler);\n    };\n\n    this.adapter.registerBodyEventHandler('mouseup', upHandler);\n    this.adapter.registerBodyEventHandler('touchend', upHandler);\n\n    this.handleDown(event);\n  }\n\n  handlePointerdown(event: PointerEvent) {\n    const isPrimaryButton = event.button === 0;\n    if (!isPrimaryButton) return;\n\n    if (event.pointerId != null) {\n      this.adapter.setPointerCapture(event.pointerId);\n    }\n    this.adapter.registerEventHandler('pointermove', this.moveListener);\n\n    this.handleDown(event);\n  }\n\n  /**\n   * Handles input `change` event by setting internal slider value to match\n   * input's new value.\n   */\n  handleInputChange(thumb: Thumb) {\n    const value = Number(this.adapter.getInputValue(thumb));\n    if (thumb === Thumb.START) {\n      this.setValueStart(value);\n    } else {\n      this.setValue(value);\n    }\n\n    this.adapter.emitChangeEvent(\n        thumb === Thumb.START ? this.valueStart : this.value, thumb);\n    this.adapter.emitInputEvent(\n        thumb === Thumb.START ? this.valueStart : this.value, thumb);\n  }\n\n  /** Shows activated state and value indicator on thumb(s). */\n  handleInputFocus(thumb: Thumb) {\n    this.adapter.addThumbClass(cssClasses.THUMB_FOCUSED, thumb);\n    if (!this.isDiscrete) return;\n\n    this.adapter.addThumbClass(cssClasses.THUMB_WITH_INDICATOR, thumb);\n    if (this.isRange) {\n      const otherThumb = thumb === Thumb.START ? Thumb.END : Thumb.START;\n      this.adapter.addThumbClass(cssClasses.THUMB_WITH_INDICATOR, otherThumb);\n    }\n  }\n\n  /** Removes activated state and value indicator from thumb(s). */\n  handleInputBlur(thumb: Thumb) {\n    this.adapter.removeThumbClass(cssClasses.THUMB_FOCUSED, thumb);\n    if (!this.isDiscrete) return;\n\n    this.adapter.removeThumbClass(cssClasses.THUMB_WITH_INDICATOR, thumb);\n    if (this.isRange) {\n      const otherThumb = thumb === Thumb.START ? Thumb.END : Thumb.START;\n      this.adapter.removeThumbClass(\n          cssClasses.THUMB_WITH_INDICATOR, otherThumb);\n    }\n  }\n\n  /**\n   * Emits custom dragStart event, along with focusing the underlying input.\n   */\n  private handleDragStart(\n      event: PointerEvent|MouseEvent|TouchEvent, value: number, thumb: Thumb) {\n    this.adapter.emitDragStartEvent(value, thumb);\n\n    this.adapter.focusInput(thumb);\n\n    // Restore focused state and show the value indicator(s) (if present)\n    // in case they were previously hidden on dragEnd.\n    // This is needed if the input is already focused, in which case\n    // #focusInput above wouldn't actually trigger #handleInputFocus,\n    // which is why we need to invoke it manually here.\n    if (this.adapter.shouldHideFocusStylesForPointerEvents?.()) {\n      this.handleInputFocus(thumb);\n    }\n\n    // Prevent the input (that we just focused) from losing focus.\n    event.preventDefault();\n  }\n\n  /**\n   * @return The thumb to be moved based on initial down event.\n   */\n  private getThumbFromDownEvent(clientX: number, value: number): Thumb|null {\n    // For single point slider, thumb to be moved is always the END (only)\n    // thumb.\n    if (!this.isRange) return Thumb.END;\n\n    // Check if event press point is in the bounds of any thumb.\n    const thumbStartRect = this.adapter.getThumbBoundingClientRect(Thumb.START);\n    const thumbEndRect = this.adapter.getThumbBoundingClientRect(Thumb.END);\n    const inThumbStartBounds =\n        clientX >= thumbStartRect.left && clientX <= thumbStartRect.right;\n    const inThumbEndBounds =\n        clientX >= thumbEndRect.left && clientX <= thumbEndRect.right;\n\n    if (inThumbStartBounds && inThumbEndBounds) {\n      // Thumbs overlapping. Thumb to be moved cannot be determined yet.\n      return null;\n    }\n\n    // If press is in bounds for either thumb on down event, that's the thumb\n    // to be moved.\n    if (inThumbStartBounds) {\n      return Thumb.START;\n    }\n    if (inThumbEndBounds) {\n      return Thumb.END;\n    }\n\n    // For presses outside the range, return whichever thumb is closer.\n    if (value < this.valueStart) {\n      return Thumb.START;\n    }\n    if (value > this.value) {\n      return Thumb.END;\n    }\n\n    // For presses inside the range, return whichever thumb is closer.\n    return (value - this.valueStart <= this.value - value) ? Thumb.START :\n                                                             Thumb.END;\n  }\n\n  /**\n   * @return The thumb to be moved based on move event (based on drag\n   *     direction from original down event). Only applicable if thumbs\n   *     were overlapping in the down event.\n   */\n  private getThumbFromMoveEvent(clientX: number): Thumb|null {\n    // Thumb has already been chosen.\n    if (this.thumb !== null) return this.thumb;\n\n    if (this.downEventClientX === null) {\n      throw new Error('`downEventClientX` is null after move event.');\n    }\n\n    const moveDistanceUnderThreshold =\n        Math.abs(this.downEventClientX - clientX) < numbers.THUMB_UPDATE_MIN_PX;\n    if (moveDistanceUnderThreshold) return this.thumb;\n\n    const draggedThumbToLeft = clientX < this.downEventClientX;\n    if (draggedThumbToLeft) {\n      return this.adapter.isRTL() ? Thumb.END : Thumb.START;\n    } else {\n      return this.adapter.isRTL() ? Thumb.START : Thumb.END;\n    }\n  }\n\n  /**\n   * Updates UI based on internal state.\n   * @param thumb Thumb whose value is being updated. If undefined, UI is\n   *     updated for both thumbs based on current internal state.\n   */\n  private updateUI(thumb?: Thumb) {\n    if (thumb) {\n      this.updateThumbAndInputAttributes(thumb);\n    } else {\n      this.updateThumbAndInputAttributes(Thumb.START);\n      this.updateThumbAndInputAttributes(Thumb.END);\n    }\n    this.updateThumbAndTrackUI(thumb);\n    this.updateValueIndicatorUI(thumb);\n    this.updateTickMarksUI();\n  }\n\n  /**\n   * Updates thumb and input attributes based on current value.\n   * @param thumb Thumb whose aria attributes to update.\n   */\n  private updateThumbAndInputAttributes(thumb?: Thumb) {\n    if (!thumb) return;\n\n    const value =\n        this.isRange && thumb === Thumb.START ? this.valueStart : this.value;\n    const valueStr = String(value);\n    this.adapter.setInputAttribute(attributes.INPUT_VALUE, valueStr, thumb);\n    if (this.isRange && thumb === Thumb.START) {\n      this.adapter.setInputAttribute(\n          attributes.INPUT_MIN, String(value + this.minRange), Thumb.END);\n    } else if (this.isRange && thumb === Thumb.END) {\n      this.adapter.setInputAttribute(\n          attributes.INPUT_MAX, String(value - this.minRange), Thumb.START);\n    }\n\n    // Sync attribute with property.\n    if (this.adapter.getInputValue(thumb) !== valueStr) {\n      this.adapter.setInputValue(valueStr, thumb);\n    }\n\n    const valueToAriaValueTextFn = this.adapter.getValueToAriaValueTextFn();\n    if (valueToAriaValueTextFn) {\n      this.adapter.setInputAttribute(\n          attributes.ARIA_VALUETEXT, valueToAriaValueTextFn(value, thumb),\n          thumb);\n    }\n  }\n\n  /**\n   * Updates value indicator UI based on current value.\n   * @param thumb Thumb whose value indicator to update. If undefined, all\n   *     thumbs' value indicators are updated.\n   */\n  private updateValueIndicatorUI(thumb?: Thumb) {\n    if (!this.isDiscrete) return;\n\n    const value =\n        this.isRange && thumb === Thumb.START ? this.valueStart : this.value;\n    this.adapter.setValueIndicatorText(\n        value, thumb === Thumb.START ? Thumb.START : Thumb.END);\n\n    if (!thumb && this.isRange) {\n      this.adapter.setValueIndicatorText(this.valueStart, Thumb.START);\n    }\n  }\n\n  /**\n   * Updates tick marks UI within slider, based on current min, max, and step.\n   */\n  private updateTickMarksUI() {\n    if (!this.isDiscrete || !this.hasTickMarks) return;\n\n    const numTickMarksInactiveStart = (this.valueStart - this.min) / this.step;\n    const numTickMarksActive = (this.value - this.valueStart) / this.step + 1;\n    const numTickMarksInactiveEnd = (this.max - this.value) / this.step;\n    const tickMarksInactiveStart =\n        Array.from<TickMark>({length: numTickMarksInactiveStart})\n            .fill(TickMark.INACTIVE);\n    const tickMarksActive = Array.from<TickMark>({length: numTickMarksActive})\n                                .fill(TickMark.ACTIVE);\n    const tickMarksInactiveEnd =\n        Array.from<TickMark>({length: numTickMarksInactiveEnd})\n            .fill(TickMark.INACTIVE);\n\n    this.adapter.updateTickMarks(tickMarksInactiveStart.concat(tickMarksActive)\n                                     .concat(tickMarksInactiveEnd));\n  }\n\n  /** Maps clientX to a value on the slider scale. */\n  private mapClientXOnSliderScale(clientX: number): number {\n    const rect = this.adapter.getBoundingClientRect();\n    const xPos = clientX - rect.left;\n    let pctComplete = xPos / rect.width;\n    if (this.adapter.isRTL()) {\n      pctComplete = 1 - pctComplete;\n    }\n\n    // Fit the percentage complete between the range [min,max]\n    // by remapping from [0, 1] to [min, min+(max-min)].\n    const value = this.min + pctComplete * (this.max - this.min);\n    if (value === this.max || value === this.min) {\n      return value;\n    }\n    return Number(this.quantize(value).toFixed(this.numDecimalPlaces));\n  }\n\n  /** Calculates the quantized value based on step value. */\n  private quantize(value: number): number {\n    const numSteps = Math.round((value - this.min) / this.step);\n    return this.min + numSteps * this.step;\n  }\n\n  /**\n   * Updates slider value (internal state and UI) based on the given value.\n   */\n  private updateValue(value: number, thumb: Thumb, {\n    emitInputEvent,\n  }: {emitInputEvent?: boolean} = {}) {\n    value = this.clampValue(value, thumb);\n\n    if (this.isRange && thumb === Thumb.START) {\n      // Exit early if current value is the same as the new value.\n      if (this.valueStart === value) return;\n\n      this.valueStart = value;\n    } else {\n      // Exit early if current value is the same as the new value.\n      if (this.value === value) return;\n\n      this.value = value;\n    }\n\n    this.updateUI(thumb);\n\n    if (emitInputEvent) {\n      this.adapter.emitInputEvent(\n          thumb === Thumb.START ? this.valueStart : this.value, thumb);\n    }\n  }\n\n  /**\n   * Clamps the given value for the given thumb based on slider properties:\n   * - Restricts value within [min, max].\n   * - If range slider, clamp start value <= end value - min range, and\n   *   end value >= start value + min range.\n   */\n  private clampValue(value: number, thumb: Thumb): number {\n    // Clamp value to [min, max] range.\n    value = Math.min(Math.max(value, this.min), this.max);\n\n    const thumbStartMovedPastThumbEnd = this.isRange && thumb === Thumb.START &&\n        value > this.value - this.minRange;\n    if (thumbStartMovedPastThumbEnd) {\n      return this.value - this.minRange;\n    }\n    const thumbEndMovedPastThumbStart = this.isRange && thumb === Thumb.END &&\n        value < this.valueStart + this.minRange;\n    if (thumbEndMovedPastThumbStart) {\n      return this.valueStart + this.minRange;\n    }\n\n    return value;\n  }\n\n  /**\n   * Updates the active track and thumb style properties to reflect current\n   * value.\n   */\n  private updateThumbAndTrackUI(thumb?: Thumb) {\n    const {max, min} = this;\n    const rect = this.adapter.getBoundingClientRect();\n    const pctComplete = (this.value - this.valueStart) / (max - min);\n    const rangePx = pctComplete * rect.width;\n    const isRtl = this.adapter.isRTL();\n\n    const transformProp =\n        HAS_WINDOW ? getCorrectPropertyName(window, 'transform') : 'transform';\n    if (this.isRange) {\n      const thumbLeftPos = this.adapter.isRTL() ?\n          (max - this.value) / (max - min) * rect.width :\n          (this.valueStart - min) / (max - min) * rect.width;\n      const thumbRightPos = thumbLeftPos + rangePx;\n\n      this.animFrame.request(AnimationKeys.SLIDER_UPDATE, () => {\n        // Set active track styles, accounting for animation direction by\n        // setting `transform-origin`.\n        const trackAnimatesFromRight = (!isRtl && thumb === Thumb.START) ||\n            (isRtl && thumb !== Thumb.START);\n        if (trackAnimatesFromRight) {\n          this.adapter.setTrackActiveStyleProperty('transform-origin', 'right');\n          this.adapter.setTrackActiveStyleProperty('left', 'auto');\n          this.adapter.setTrackActiveStyleProperty(\n              'right', `${rect.width - thumbRightPos}px`);\n        } else {\n          this.adapter.setTrackActiveStyleProperty('transform-origin', 'left');\n          this.adapter.setTrackActiveStyleProperty('right', 'auto');\n          this.adapter.setTrackActiveStyleProperty('left', `${thumbLeftPos}px`);\n        }\n        this.adapter.setTrackActiveStyleProperty(\n            transformProp, `scaleX(${pctComplete})`);\n\n        // Set thumb styles.\n        const thumbStartPos = isRtl ? thumbRightPos : thumbLeftPos;\n        const thumbEndPos = this.adapter.isRTL() ? thumbLeftPos : thumbRightPos;\n        if (thumb === Thumb.START || !thumb || !this.initialStylesRemoved) {\n          this.adapter.setThumbStyleProperty(\n              transformProp, `translateX(${thumbStartPos}px)`, Thumb.START);\n          this.alignValueIndicator(Thumb.START, thumbStartPos);\n        }\n        if (thumb === Thumb.END || !thumb || !this.initialStylesRemoved) {\n          this.adapter.setThumbStyleProperty(\n              transformProp, `translateX(${thumbEndPos}px)`, Thumb.END);\n          this.alignValueIndicator(Thumb.END, thumbEndPos);\n        }\n\n        this.removeInitialStyles(isRtl);\n        this.updateOverlappingThumbsUI(thumbStartPos, thumbEndPos, thumb);\n      });\n    } else {\n      this.animFrame.request(AnimationKeys.SLIDER_UPDATE, () => {\n        const thumbStartPos = isRtl ? rect.width - rangePx : rangePx;\n        this.adapter.setThumbStyleProperty(\n            transformProp, `translateX(${thumbStartPos}px)`, Thumb.END);\n        this.alignValueIndicator(Thumb.END, thumbStartPos);\n        this.adapter.setTrackActiveStyleProperty(\n            transformProp, `scaleX(${pctComplete})`);\n\n        this.removeInitialStyles(isRtl);\n      });\n    }\n  }\n\n  /**\n   * Shifts the value indicator to either side if it would otherwise stick\n   * beyond the slider's length while keeping the caret above the knob.\n   */\n  private alignValueIndicator(thumb: Thumb, thumbPos: number) {\n    if (!this.isDiscrete) return;\n    const thumbHalfWidth =\n        this.adapter.getThumbBoundingClientRect(thumb).width / 2;\n    const containerWidth = this.adapter.getValueIndicatorContainerWidth(thumb);\n    const sliderWidth = this.adapter.getBoundingClientRect().width;\n    if (containerWidth / 2 > thumbPos + thumbHalfWidth) {\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CARET_LEFT, `${thumbHalfWidth}px`, thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CARET_RIGHT, 'auto', thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CARET_TRANSFORM, 'translateX(-50%)',\n          thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CONTAINER_LEFT, '0', thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CONTAINER_RIGHT, 'auto', thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CONTAINER_TRANSFORM, 'none', thumb);\n    } else if (containerWidth / 2 > sliderWidth - thumbPos + thumbHalfWidth) {\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CARET_LEFT, 'auto', thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CARET_RIGHT, `${thumbHalfWidth}px`,\n          thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CARET_TRANSFORM, 'translateX(50%)',\n          thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CONTAINER_LEFT, 'auto', thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CONTAINER_RIGHT, '0', thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CONTAINER_TRANSFORM, 'none', thumb);\n    } else {\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CARET_LEFT, '50%', thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CARET_RIGHT, 'auto', thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CARET_TRANSFORM, 'translateX(-50%)',\n          thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CONTAINER_LEFT, '50%', thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CONTAINER_RIGHT, 'auto', thumb);\n      this.adapter.setThumbStyleProperty(\n          strings.VAR_VALUE_INDICATOR_CONTAINER_TRANSFORM, 'translateX(-50%)',\n          thumb);\n    }\n  }\n\n  /**\n   * Removes initial inline styles if not already removed. `left:<...>%`\n   * inline styles can be added to position the thumb correctly before JS\n   * initialization. However, they need to be removed before the JS starts\n   * positioning the thumb. This is because the JS uses\n   * `transform:translateX(<...>)px` (for performance reasons) to position\n   * the thumb (which is not possible for initial styles since we need the\n   * bounding rect measurements).\n   */\n  private removeInitialStyles(isRtl: boolean) {\n    if (this.initialStylesRemoved) return;\n\n    // Remove thumb position properties that were added for initial render.\n    const position = isRtl ? 'right' : 'left';\n    this.adapter.removeThumbStyleProperty(position, Thumb.END);\n    if (this.isRange) {\n      this.adapter.removeThumbStyleProperty(position, Thumb.START);\n    }\n\n    this.initialStylesRemoved = true;\n\n    this.resetTrackAndThumbAnimation();\n  }\n\n  /**\n   * Resets track/thumb animation to prevent animation when adding\n   * `transform` styles to thumb initially.\n   */\n  private resetTrackAndThumbAnimation() {\n    if (!this.isDiscrete) return;\n\n    // Set transition properties to default (no animation), so that the\n    // newly added `transform` styles do not animate thumb/track from\n    // their default positions.\n    const transitionProp = HAS_WINDOW ?\n        getCorrectPropertyName(window, 'transition') :\n        'transition';\n    const transitionDefault = 'none 0s ease 0s';\n    this.adapter.setThumbStyleProperty(\n        transitionProp, transitionDefault, Thumb.END);\n    if (this.isRange) {\n      this.adapter.setThumbStyleProperty(\n          transitionProp, transitionDefault, Thumb.START);\n    }\n    this.adapter.setTrackActiveStyleProperty(transitionProp, transitionDefault);\n\n    // In the next frame, remove the transition inline styles we just\n    // added, such that any animations added in the CSS can now take effect.\n    requestAnimationFrame(() => {\n      this.adapter.removeThumbStyleProperty(transitionProp, Thumb.END);\n      this.adapter.removeTrackActiveStyleProperty(transitionProp);\n      if (this.isRange) {\n        this.adapter.removeThumbStyleProperty(transitionProp, Thumb.START);\n      }\n    });\n  }\n\n  /**\n   * Adds THUMB_TOP class to active thumb if thumb knobs overlap; otherwise\n   * removes THUMB_TOP class from both thumbs.\n   * @param thumb Thumb that is active (being moved).\n   */\n  private updateOverlappingThumbsUI(\n      thumbStartPos: number, thumbEndPos: number, thumb?: Thumb) {\n    let thumbsOverlap = false;\n    if (this.adapter.isRTL()) {\n      const startThumbLeftEdge = thumbStartPos - this.startThumbKnobWidth / 2;\n      const endThumbRightEdge = thumbEndPos + this.endThumbKnobWidth / 2;\n      thumbsOverlap = endThumbRightEdge >= startThumbLeftEdge;\n    } else {\n      const startThumbRightEdge = thumbStartPos + this.startThumbKnobWidth / 2;\n      const endThumbLeftEdge = thumbEndPos - this.endThumbKnobWidth / 2;\n      thumbsOverlap = startThumbRightEdge >= endThumbLeftEdge;\n    }\n\n    if (thumbsOverlap) {\n      this.adapter.addThumbClass(\n          cssClasses.THUMB_TOP,\n          // If no thumb was dragged (in the case of initial layout), end\n          // thumb is on top by default.\n          thumb || Thumb.END);\n      this.adapter.removeThumbClass(\n          cssClasses.THUMB_TOP,\n          thumb === Thumb.START ? Thumb.END : Thumb.START);\n    } else {\n      this.adapter.removeThumbClass(cssClasses.THUMB_TOP, Thumb.START);\n      this.adapter.removeThumbClass(cssClasses.THUMB_TOP, Thumb.END);\n    }\n  }\n\n  /**\n   * Converts attribute value to a number, e.g. '100' => 100. Throws errors\n   * for invalid values.\n   * @param attributeValue Attribute value, e.g. 100.\n   * @param attributeName Attribute name, e.g. `aria-valuemax`.\n   */\n  private convertAttributeValueToNumber(\n      attributeValue: string|null, attributeName: string) {\n    if (attributeValue === null) {\n      throw new Error(\n          'MDCSliderFoundation: `' + attributeName + '` must be non-null.');\n    }\n\n    const value = Number(attributeValue);\n    if (isNaN(value)) {\n      throw new Error(\n          'MDCSliderFoundation: `' + attributeName + '` value is `' +\n          attributeValue + '`, but must be a number.');\n    }\n\n    return value;\n  }\n\n  /** Checks that the given properties are valid slider values. */\n  private validateProperties({min, max, value, valueStart, step, minRange}: {\n    min: number,\n    max: number,\n    value: number,\n    valueStart: number,\n    step: number,\n    minRange: number\n  }) {\n    if (min >= max) {\n      throw new Error(\n          `MDCSliderFoundation: min must be strictly less than max. ` +\n          `Current: [min: ${min}, max: ${max}]`);\n    }\n\n    if (step <= 0) {\n      throw new Error(\n          `MDCSliderFoundation: step must be a positive number. ` +\n          `Current step: ${step}`);\n    }\n\n    if (this.isRange) {\n      if (value < min || value > max || valueStart < min || valueStart > max) {\n        throw new Error(\n            `MDCSliderFoundation: values must be in [min, max] range. ` +\n            `Current values: [start value: ${valueStart}, end value: ` +\n            `${value}, min: ${min}, max: ${max}]`);\n      }\n\n      if (valueStart > value) {\n        throw new Error(\n            `MDCSliderFoundation: start value must be <= end value. ` +\n            `Current values: [start value: ${valueStart}, end value: ${\n                value}]`);\n      }\n\n      if (minRange < 0) {\n        throw new Error(\n            `MDCSliderFoundation: minimum range must be non-negative. ` +\n            `Current min range: ${minRange}`);\n      }\n\n      if (value - valueStart < minRange) {\n        throw new Error(\n            `MDCSliderFoundation: start value and end value must differ by at least ` +\n            `${minRange}. Current values: [start value: ${valueStart}, ` +\n            `end value: ${value}]`);\n      }\n\n      const numStepsValueStartFromMin = (valueStart - min) / step;\n      const numStepsValueFromMin = (value - min) / step;\n      if (!Number.isInteger(parseFloat(numStepsValueStartFromMin.toFixed(6))) ||\n          !Number.isInteger(parseFloat(numStepsValueFromMin.toFixed(6)))) {\n        throw new Error(\n            `MDCSliderFoundation: Slider values must be valid based on the ` +\n            `step value (${step}). Current values: [start value: ` +\n            `${valueStart}, end value: ${value}, min: ${min}]`);\n      }\n    } else {  // Single point slider.\n      if (value < min || value > max) {\n        throw new Error(\n            `MDCSliderFoundation: value must be in [min, max] range. ` +\n            `Current values: [value: ${value}, min: ${min}, max: ${max}]`);\n      }\n\n      const numStepsValueFromMin = (value - min) / step;\n      if (!Number.isInteger(parseFloat(numStepsValueFromMin.toFixed(6)))) {\n        throw new Error(\n            `MDCSliderFoundation: Slider value must be valid based on the ` +\n            `step value (${step}). Current value: ${value}`);\n      }\n    }\n  }\n\n  private registerEventHandlers() {\n    this.adapter.registerWindowEventHandler('resize', this.resizeListener);\n\n    if (MDCSliderFoundation.SUPPORTS_POINTER_EVENTS) {\n      // If supported, use pointer events API with #setPointerCapture.\n      this.adapter.registerEventHandler(\n          'pointerdown', this.pointerdownListener);\n      this.adapter.registerEventHandler('pointerup', this.pointerupListener);\n    } else {\n      // Otherwise, fall back to mousedown/touchstart events.\n      this.adapter.registerEventHandler(\n          'mousedown', this.mousedownOrTouchstartListener);\n      this.adapter.registerEventHandler(\n          'touchstart', this.mousedownOrTouchstartListener);\n    }\n\n    if (this.isRange) {\n      this.adapter.registerThumbEventHandler(\n          Thumb.START, 'mouseenter', this.thumbMouseenterListener);\n      this.adapter.registerThumbEventHandler(\n          Thumb.START, 'mouseleave', this.thumbMouseleaveListener);\n\n      this.adapter.registerInputEventHandler(\n          Thumb.START, 'change', this.inputStartChangeListener);\n      this.adapter.registerInputEventHandler(\n          Thumb.START, 'focus', this.inputStartFocusListener);\n      this.adapter.registerInputEventHandler(\n          Thumb.START, 'blur', this.inputStartBlurListener);\n    }\n\n    this.adapter.registerThumbEventHandler(\n        Thumb.END, 'mouseenter', this.thumbMouseenterListener);\n    this.adapter.registerThumbEventHandler(\n        Thumb.END, 'mouseleave', this.thumbMouseleaveListener);\n\n    this.adapter.registerInputEventHandler(\n        Thumb.END, 'change', this.inputEndChangeListener);\n    this.adapter.registerInputEventHandler(\n        Thumb.END, 'focus', this.inputEndFocusListener);\n    this.adapter.registerInputEventHandler(\n        Thumb.END, 'blur', this.inputEndBlurListener);\n  }\n\n  private deregisterEventHandlers() {\n    this.adapter.deregisterWindowEventHandler('resize', this.resizeListener);\n\n    if (MDCSliderFoundation.SUPPORTS_POINTER_EVENTS) {\n      this.adapter.deregisterEventHandler(\n          'pointerdown', this.pointerdownListener);\n      this.adapter.deregisterEventHandler('pointerup', this.pointerupListener);\n    } else {\n      this.adapter.deregisterEventHandler(\n          'mousedown', this.mousedownOrTouchstartListener);\n      this.adapter.deregisterEventHandler(\n          'touchstart', this.mousedownOrTouchstartListener);\n    }\n\n    if (this.isRange) {\n      this.adapter.deregisterThumbEventHandler(\n          Thumb.START, 'mouseenter', this.thumbMouseenterListener);\n      this.adapter.deregisterThumbEventHandler(\n          Thumb.START, 'mouseleave', this.thumbMouseleaveListener);\n\n      this.adapter.deregisterInputEventHandler(\n          Thumb.START, 'change', this.inputStartChangeListener);\n      this.adapter.deregisterInputEventHandler(\n          Thumb.START, 'focus', this.inputStartFocusListener);\n      this.adapter.deregisterInputEventHandler(\n          Thumb.START, 'blur', this.inputStartBlurListener);\n    }\n\n    this.adapter.deregisterThumbEventHandler(\n        Thumb.END, 'mouseenter', this.thumbMouseenterListener);\n    this.adapter.deregisterThumbEventHandler(\n        Thumb.END, 'mouseleave', this.thumbMouseleaveListener);\n\n    this.adapter.deregisterInputEventHandler(\n        Thumb.END, 'change', this.inputEndChangeListener);\n    this.adapter.deregisterInputEventHandler(\n        Thumb.END, 'focus', this.inputEndFocusListener);\n    this.adapter.deregisterInputEventHandler(\n        Thumb.END, 'blur', this.inputEndBlurListener);\n  }\n\n  private handlePointerup() {\n    this.handleUp();\n\n    this.adapter.deregisterEventHandler('pointermove', this.moveListener);\n  }\n}\n\nfunction isIOS() {\n  // Source:\n  // https://stackoverflow.com/questions/9038625/detect-if-device-is-ios\n  return [\n    'iPad Simulator', 'iPhone Simulator', 'iPod Simulator', 'iPad', 'iPhone',\n    'iPod'\n  ].includes(navigator.platform)\n      // iPad on iOS 13 detection\n      || (navigator.userAgent.includes('Mac') && 'ontouchend' in document);\n}\n\n/**\n * Given a number, returns the number of digits that appear after the\n * decimal point.\n * See\n * https://stackoverflow.com/questions/9539513/is-there-a-reliable-way-in-javascript-to-obtain-the-number-of-decimal-places-of\n */\nfunction getNumDecimalPlaces(n: number): number {\n  // Pull out the fraction and the exponent.\n  const match = /(?:\\.(\\d+))?(?:[eE]([+\\-]?\\d+))?$/.exec(String(n));\n  // NaN or Infinity or integer.\n  // We arbitrarily decide that Infinity is integral.\n  if (!match) return 0;\n\n  const fraction = match[1] || '';  // E.g. 1.234e-2 => 234\n  const exponent = match[2] || 0;   // E.g. 1.234e-2 => -2\n  // Count the number of digits in the fraction and subtract the\n  // exponent to simulate moving the decimal point left by exponent places.\n  // 1.234e+2 has 1 fraction digit and '234'.length -  2 == 1\n  // 1.234e-2 has 5 fraction digit and '234'.length - -2 == 5\n  return Math.max(\n      0,  // lower limit\n      (fraction === '0' ? 0 : fraction.length) - Number(exponent));\n}\n","/**\n * @license\n * Copyright 2020 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 2020 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/** Tick mark enum, for discrete sliders. */\nexport enum TickMark {\n  ACTIVE,\n  INACTIVE,\n}\n\n/**\n * Thumb types: range slider has two thumbs (START, END) whereas single point\n * slider only has one thumb (END).\n */\nexport enum Thumb {\n  // Thumb at start of slider (e.g. in LTR mode, left thumb on range slider).\n  START = 1,\n  // Thumb at end of slider (e.g. in LTR mode, right thumb on range slider,\n  // or only thumb on single point slider).\n  END,\n}\n\n/** Interface for `detail` of slider custom change and input events. */\nexport interface MDCSliderChangeEventDetail {\n  // The new value after change.\n  value: number;\n\n  // The thumb for which the value has changed:\n  // - For single point slider, this will always be Thumb.END.\n  // - For range slider, either Thumb.START or Thumb.END.\n  thumb: Thumb;\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/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCSnackbarAdapter {\n  addClass(className: string): void;\n  announce(): void;\n  notifyClosed(reason: string): void;\n  notifyClosing(reason: string): void;\n  notifyOpened(): void;\n  notifyOpening(): void;\n  removeClass(className: string): void;\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 {closest} from '@material/dom/ponyfill';\n\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,\n  LABEL_SELECTOR,\n  ACTION_SELECTOR,\n  DISMISS_SELECTOR,\n  OPENING_EVENT,\n  OPENED_EVENT,\n  CLOSING_EVENT,\n  CLOSED_EVENT,\n} = strings;\n\n/** MDC Snackbar */\nexport class MDCSnackbar extends MDCComponent<MDCSnackbarFoundation> {\n  static override attachTo(root: HTMLElement) {\n    return new MDCSnackbar(root);\n  }\n\n  private announce!: MDCSnackbarAnnouncer;  // assigned in initialize()\n\n  private actionEl!: HTMLElement;   // assigned in initialSyncWithDOM()\n  private labelEl!: HTMLElement;    // assigned in initialSyncWithDOM()\n  private surfaceEl!: HTMLElement;  // assigned in initialSyncWithDOM()\n\n  private handleKeyDown!:\n      SpecificEventListener<'keydown'>;  // assigned in initialSyncWithDOM()\n  private handleSurfaceClick!:\n      SpecificEventListener<'click'>;  // assigned in initialSyncWithDOM()\n\n  override initialize(\n      announcerFactory: MDCSnackbarAnnouncerFactory = () => util.announce) {\n    this.announce = announcerFactory();\n  }\n\n  override initialSyncWithDOM() {\n    this.surfaceEl = this.root.querySelector<HTMLElement>(SURFACE_SELECTOR)!;\n    this.labelEl = this.root.querySelector<HTMLElement>(LABEL_SELECTOR)!;\n    this.actionEl = this.root.querySelector<HTMLElement>(ACTION_SELECTOR)!;\n\n    this.handleKeyDown = (event) => {\n      this.foundation.handleKeyDown(event);\n    };\n    this.handleSurfaceClick = (event) => {\n      const target = event.target as Element;\n      if (this.isActionButton(target)) {\n        this.foundation.handleActionButtonClick(event);\n      } else if (this.isActionIcon(target)) {\n        this.foundation.handleActionIconClick(event);\n      }\n    };\n\n    this.registerKeyDownHandler(this.handleKeyDown);\n    this.registerSurfaceClickHandler(this.handleSurfaceClick);\n  }\n\n  override 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\n   *     CLOSING_EVENT and CLOSED_EVENT via the `event.detail.reason` property.\n   *     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  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCSnackbarAdapter = {\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      announce: () => {\n        this.announce(this.labelEl);\n      },\n      notifyClosed: (reason) => {\n        this.emit<MDCSnackbarCloseEventDetail>(\n            CLOSED_EVENT, reason ? {reason} : {});\n      },\n      notifyClosing: (reason) => {\n        this.emit<MDCSnackbarCloseEventDetail>(\n            CLOSING_EVENT, reason ? {reason} : {});\n      },\n      notifyOpened: () => {\n        this.emit(OPENED_EVENT, {});\n      },\n      notifyOpening: () => {\n        this.emit(OPENING_EVENT, {});\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\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,\n    // or notation. 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:\n                                            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  CLOSED_EVENT: 'MDCSnackbar:closed',\n  CLOSING_EVENT: 'MDCSnackbar:closing',\n  DATA_LIVE_LABEL_TEXT: 'mdcSnackbarLabelText',\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  REASON_SECONDARY_ACTION: 'secondary-action',\n  SURFACE_SELECTOR: '.mdc-snackbar__surface',\n};\n\nconst numbers = {\n  DEFAULT_AUTO_DISMISS_TIMEOUT_MS: 5000,\n  INDETERMINATE: -1,\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';\n\nimport {MDCSnackbarAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\nconst {OPENING, OPEN, CLOSING} = cssClasses;\nconst {REASON_ACTION, REASON_DISMISS, REASON_SECONDARY_ACTION} = strings;\n\n/** MDC Snackbar Foundation */\nexport class MDCSnackbarFoundation extends MDCFoundation<MDCSnackbarAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override get numbers() {\n    return numbers;\n  }\n\n  static override 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 opened = 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  override 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.opened = 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\n    // animation\n    this.runNextAnimationFrame(() => {\n      this.adapter.addClass(OPEN);\n\n      this.animationTimer = setTimeout(() => {\n        const timeoutMs = this.getTimeoutMs();\n        this.handleAnimationTimerEnd();\n        this.adapter.notifyOpened();\n        if (timeoutMs !== numbers.INDETERMINATE) {\n          this.autoDismissTimer = setTimeout(() => {\n            this.close(REASON_DISMISS);\n          }, timeoutMs);\n        }\n      }, numbers.SNACKBAR_ANIMATION_OPEN_TIME_MS);\n    });\n  }\n\n  /**\n   * @param reason Why the snackbar was closed. Value will be passed to\n   *     CLOSING_EVENT and CLOSED_EVENT via the `event.detail.reason` property.\n   *     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.opened) {\n      // Avoid redundant close calls (and events), e.g. repeated interactions as\n      // the snackbar is animating closed\n      return;\n    }\n\n    cancelAnimationFrame(this.animationFrame);\n    this.animationFrame = 0;\n    this.clearAutoDismissTimer();\n\n    this.opened = 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.opened;\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    const indeterminateValue = numbers.INDETERMINATE;\n\n    if (timeoutMs === numbers.INDETERMINATE ||\n        (timeoutMs <= maxValue && timeoutMs >= minValue)) {\n      this.autoDismissTimeoutMs = timeoutMs;\n    } else {\n      throw new Error(`\n        timeoutMs must be an integer in the range ${minValue}–${maxValue}\n        (or ${indeterminateValue} to disable), 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(event: KeyboardEvent) {\n    const isEscapeKey = event.key === 'Escape' || event.keyCode === 27;\n    if (isEscapeKey && this.getCloseOnEscape()) {\n      this.close(REASON_DISMISS);\n    }\n  }\n\n  handleActionButtonClick(_event: MouseEvent) {\n    this.close(REASON_ACTION);\n  }\n\n  handleActionIconClick(_event: MouseEvent) {\n    this.close(REASON_DISMISS);\n  }\n\n  handleSecondaryActionButtonClick(_event: MouseEvent) {\n    this.close(REASON_SECONDARY_ACTION);\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\n   * 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 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 type MDCSnackbarAnnouncer =\n    (ariaEl: HTMLElement, labelEl?: HTMLElement) => void;\nexport type MDCSnackbarAnnouncerFactory = () => MDCSnackbarAnnouncer;\n\nexport interface MDCSnackbarCloseEventDetail {\n  reason?: string;\n}\n\n// Note: CustomEvent<T> is not supported by Closure Compiler.\n\nexport interface MDCSnackbarCloseEvent extends Event {\n  readonly detail: MDCSnackbarCloseEventDetail;\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 {numbers, strings} from './constants';\n\nconst {ARIA_LIVE_DELAY_MS} = numbers;\nconst {DATA_LIVE_LABEL_TEXT} = strings;\n\n/** Accounce helper for snackbar */\nexport function announce(ariaEl: HTMLElement, labelEl: HTMLElement = 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\n  // message twice.\n  ariaEl.setAttribute('aria-live', 'off');\n\n  // Temporarily clear `textContent` to force a DOM mutation event that will be\n  // detected by screen readers. `aria-live` elements are only announced when\n  // the element's `textContent` *changes*, so snackbars sent to the browser in\n  // the initial HTML response won't be read unless we clear the element's\n  // `textContent` first. Similarly, displaying the same snackbar message twice\n  // in a row doesn't trigger a DOM mutation event, so screen readers won't\n  // 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\n  // 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\n  // cause jank when added/removed. N.B.: Setting `position: absolute`,\n  // `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  // For the second case, assigning a string directly to innerHTML results in a\n  // Trusted Types violation. Work around that by using document.createElement.\n  const span = document.createElement('span');\n  span.setAttribute('style', 'display: inline-block; width: 0; height: 1px;');\n  span.textContent = '\\u00a0';  // Equivalent to &nbsp;\n  labelEl.appendChild(span);\n\n  // Prevent visual jank by temporarily displaying the label text in the\n  // ::before pseudo-element. CSS generated content is normally announced by\n  // screen readers (except in IE 11; see\n  // https://tink.uk/accessibility-support-for-css-generated-content/); however,\n  // `aria-live` is turned off, so this DOM update will be ignored by screen\n  // readers.\n  labelEl.dataset[DATA_LIVE_LABEL_TEXT] = 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    delete labelEl.dataset[DATA_LIVE_LABEL_TEXT];\n\n    // Restore the original label text, which will be announced by screen\n    // readers.\n    labelEl.textContent = labelText;\n  }, ARIA_LIVE_DELAY_MS);\n}\n","/**\n * @license\n * Copyright 2021 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 * The state of the switch.\n */\nexport interface MDCSwitchState {\n  /**\n   * Indicates whether or not the switch is disabled.\n   */\n  disabled: boolean;\n  /**\n   * Indicates whether or not the switch is processing and showing a loading\n   * indicator. A disabled switch cannot be processing.\n   */\n  processing: boolean;\n  /**\n   * If true, the switch is on. If false, the switch is off.\n   */\n  selected: boolean;\n}\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n *\n * This adapter is used to delegate state-only updates from the foundation\n * to the component. It does not delegate DOM or rendering logic, such as adding\n * or removing classes.\n */\nexport interface MDCSwitchAdapter {\n  /**\n   * The state of the component.\n   */\n  state: MDCSwitchState;\n}\n\n/**\n * Defines the shape of the adapter expected by the rendering foundation.\n *\n * This adapter is used to delegate state and rendering logic updates from the\n * rendering foundation to the component.\n */\nexport interface MDCSwitchRenderAdapter extends MDCSwitchAdapter {\n  /**\n   * Adds a class to the root element.\n   * @param className The class to add.\n   */\n  addClass(className: CssClasses): void;\n  /**\n   * Returns whether or not the root element has a class.\n   * @param className The class to check.\n   * @return true if the root element has the class, or false if not.\n   */\n  hasClass(className: CssClasses): boolean;\n  /**\n   * Checks if the root element is disabled.\n   * @return true if the root element is disabled, or false if not.\n   */\n  isDisabled(): boolean;\n  /**\n   * Removes a class from the root element.\n   * @param className The class to remove.\n   */\n  removeClass(className: CssClasses): void;\n  /**\n   * Sets the `aria-checked` attribute of the root element.\n   * @param ariaChecked The value of the attribute to set.\n   */\n  setAriaChecked(ariaChecked: string): void;\n  /**\n   * Disables or enables the root element.\n   * @param disabled True to disable the root element, or false to enable.\n   */\n  setDisabled(disabled: boolean): void;\n}\n","/**\n * @license\n * Copyright 2021 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 {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\n\nimport {MDCSwitchRenderAdapter, MDCSwitchState} from './adapter';\nimport {Selectors} from './constants';\nimport {MDCSwitchRenderFoundation} from './foundation';\n\n/**\n * `MDCSwitch` provides a component implementation of a Material Design switch.\n */\nexport class MDCSwitch extends\n    MDCComponent<MDCSwitchRenderFoundation> implements MDCSwitchState,\n                                                       MDCRippleCapableSurface {\n  /**\n   * Creates a new `MDCSwitch` and attaches it to the given root element.\n   * @param root The root to attach to.\n   * @return the new component instance.\n   */\n  static override attachTo(root: HTMLButtonElement) {\n    return new MDCSwitch(root);\n  }\n\n  disabled!: boolean;\n  processing!: boolean;\n  selected!: boolean;\n\n  ripple!: MDCRipple;\n\n  private rippleElement!: Element;\n\n  constructor(\n      public override root: HTMLButtonElement,\n      foundation?: MDCSwitchRenderFoundation) {\n    super(root, foundation);\n  }\n\n  override initialize() {\n    this.ripple = new MDCRipple(this.root, this.createRippleFoundation());\n  }\n\n  override initialSyncWithDOM() {\n    const rippleElement =\n        this.root.querySelector<HTMLElement>(Selectors.RIPPLE);\n    if (!rippleElement) {\n      throw new Error(`Switch ${Selectors.RIPPLE} element is required.`);\n    }\n\n    this.rippleElement = rippleElement;\n    this.root.addEventListener('click', this.foundation.handleClick);\n    this.foundation.initFromDOM();\n  }\n\n  override destroy() {\n    super.destroy();\n    this.ripple.destroy();\n    this.root.removeEventListener('click', this.foundation.handleClick);\n  }\n\n  override getDefaultFoundation() {\n    return new MDCSwitchRenderFoundation(this.createAdapter());\n  }\n\n  protected createAdapter(): MDCSwitchRenderAdapter {\n    return {\n      addClass: className => {\n        this.root.classList.add(className);\n      },\n      hasClass: className => this.root.classList.contains(className),\n      isDisabled: () => this.root.disabled,\n      removeClass: className => {\n        this.root.classList.remove(className);\n      },\n      setAriaChecked: ariaChecked => {\n        this.root.setAttribute('aria-checked', ariaChecked);\n      },\n      setDisabled: disabled => {\n        this.root.disabled = disabled;\n      },\n      state: this,\n    };\n  }\n\n  protected createRippleFoundation() {\n    return new MDCRippleFoundation(this.createRippleAdapter());\n  }\n\n  protected createRippleAdapter(): MDCRippleAdapter {\n    return {\n      ...MDCRipple.createAdapter(this),\n      computeBoundingRect: () => this.rippleElement.getBoundingClientRect(),\n      isUnbounded: () => true,\n    };\n  }\n}\n","/**\n * @license\n * Copyright 2021 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 * CSS classes used for switch.\n */\nexport enum CssClasses {\n  PROCESSING = 'mdc-switch--processing',\n  SELECTED = 'mdc-switch--selected',\n  UNSELECTED = 'mdc-switch--unselected',\n}\n\n/**\n * Query selectors used for switch.\n */\nexport enum Selectors {\n  RIPPLE = '.mdc-switch__ripple',\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/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCSwitchAdapter {\n  /**\n   * Adds a CSS class to the root element.\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes a CSS class from the root element.\n   */\n  removeClass(className: string): void;\n\n  /**\n   * Sets checked state of the native HTML control underlying the switch.\n   */\n  setNativeControlChecked(checked: boolean): void;\n\n  /**\n   * Sets the disabled state of the native HTML control underlying the switch.\n   */\n  setNativeControlDisabled(disabled: boolean): void;\n\n  /**\n   * Sets an attribute value of the native HTML control underlying the switch.\n   */\n  setNativeControlAttr(attr: string, value: string): void;\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 {EventType, SpecificEventListener} 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 {safeAttrPrefix} from 'safevalues';\nimport {safeElement} from 'safevalues/dom';\n\nimport {MDCSwitchAdapter} from './adapter';\nimport {MDCSwitchFoundation} from './foundation';\n\n/** MDC Switch */\nexport class MDCSwitch extends MDCComponent<MDCSwitchFoundation> implements\n    MDCRippleCapableSurface {\n  static override attachTo(root: HTMLElement) {\n    return new MDCSwitch(root);\n  }\n\n  private readonly rippleSurface = this.createRipple();\n\n  // Initialized in `initialSyncWithDOM`.\n  private changeHandler!: EventListener;\n\n  override destroy() {\n    super.destroy();\n    this.rippleSurface.destroy();\n    this.nativeControl.removeEventListener('change', this.changeHandler);\n  }\n\n  override initialSyncWithDOM() {\n    this.changeHandler = (...args) => {\n      this.foundation.handleChange(...args);\n    };\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  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCSwitchAdapter = {\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      setNativeControlChecked: (checked) => this.nativeControl.checked =\n          checked,\n      setNativeControlDisabled: (disabled) => this.nativeControl.disabled =\n          disabled,\n      setNativeControlAttr: (attr, value) => {\n        safeElement.setPrefixedAttribute(\n            [safeAttrPrefix`aria-`], this.nativeControl, attr, value);\n      },\n    };\n    return new MDCSwitchFoundation(adapter);\n  }\n\n  get ripple() {\n    return this.rippleSurface;\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 =\n        this.root.querySelector<HTMLElement>(RIPPLE_SURFACE_SELECTOR)!;\n\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCRippleAdapter = {\n      ...MDCRipple.createAdapter(this),\n      addClass: (className: string) => {\n        rippleSurface.classList.add(className);\n      },\n      computeBoundingRect: () => rippleSurface.getBoundingClientRect(),\n      deregisterInteractionHandler: <K extends EventType>(\n          eventType: K, handler: SpecificEventListener<K>) => {\n        this.nativeControl.removeEventListener(\n            eventType, handler, applyPassive());\n      },\n      isSurfaceActive: () => matches(this.nativeControl, ':active'),\n      isUnbounded: () => true,\n      registerInteractionHandler: <K extends EventType>(\n          eventType: K, handler: SpecificEventListener<K>) => {\n        this.nativeControl.addEventListener(eventType, handler, applyPassive());\n      },\n      removeClass: (className: string) => {\n        rippleSurface.classList.remove(className);\n      },\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<HTMLInputElement>(NATIVE_CONTROL_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\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  /** Aria attribute for checked or unchecked state of switch */\n  ARIA_CHECKED_ATTR: 'aria-checked',\n  /** A CSS selector used to locate the native HTML control for the switch.  */\n  NATIVE_CONTROL_SELECTOR: '.mdc-switch__native-control',\n  /**\n   * A CSS selector used to locate the ripple surface element for the switch.\n   */\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';\n\nimport {MDCSwitchAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\n/** MDC Switch Foundation */\nexport class MDCSwitchFoundation extends MDCFoundation<MDCSwitchAdapter> {\n  /** The string constants used by the switch. */\n  static override get strings() {\n    return strings;\n  }\n\n  /** The CSS classes used by the switch. */\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  /** The default Adapter for the switch. */\n  static override get defaultAdapter(): MDCSwitchAdapter {\n    return {\n      addClass: () => undefined,\n      removeClass: () => undefined,\n      setNativeControlChecked: () => undefined,\n      setNativeControlDisabled: () => undefined,\n      setNativeControlAttr: () => 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.updateAriaChecked(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(event: Event) {\n    const nativeControl = event.target as HTMLInputElement;\n    this.updateAriaChecked(nativeControl.checked);\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  private updateAriaChecked(checked: boolean) {\n    this.adapter.setNativeControlAttr(\n        strings.ARIA_CHECKED_ATTR, `${!!checked}`);\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 2021 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 {MDCObserverFoundation} from '@material/base/observer-foundation';\n\nimport {MDCSwitchAdapter, MDCSwitchRenderAdapter} from './adapter';\nimport {CssClasses} from './constants';\n\n/**\n * `MDCSwitchFoundation` provides a state-only foundation for a switch\n * component.\n *\n * State observers and event handler entrypoints update a component's adapter's\n * state with the logic needed for switch to function.\n */\nexport class MDCSwitchFoundation extends\n    MDCObserverFoundation<MDCSwitchAdapter> {\n  constructor(adapter: MDCSwitchAdapter) {\n    super(adapter);\n    this.handleClick = this.handleClick.bind(this);\n  }\n\n  /**\n   * Initializes the foundation and starts observing state changes.\n   */\n  override init() {\n    this.observe(this.adapter.state, {\n      disabled: this.stopProcessingIfDisabled,\n      processing: this.stopProcessingIfDisabled,\n    });\n  }\n\n  /**\n   * Event handler for switch click events. Clicking on a switch will toggle its\n   * selected state.\n   */\n  handleClick() {\n    if (this.adapter.state.disabled) {\n      return;\n    }\n\n    this.adapter.state.selected = !this.adapter.state.selected;\n  }\n\n  protected stopProcessingIfDisabled() {\n    if (this.adapter.state.disabled) {\n      this.adapter.state.processing = false;\n    }\n  }\n}\n/**\n * `MDCSwitchRenderFoundation` provides a state and rendering foundation for a\n * switch component.\n *\n * State observers and event handler entrypoints update a component's\n * adapter's state with the logic needed for switch to function.\n *\n * In response to state changes, the rendering foundation uses the component's\n * render adapter to keep the component's DOM updated with the state.\n */\nexport class MDCSwitchRenderFoundation extends MDCSwitchFoundation {\n  protected override adapter!: MDCSwitchRenderAdapter;\n\n  /**\n   * Initializes the foundation and starts observing state changes.\n   */\n  override init() {\n    super.init();\n    this.observe(this.adapter.state, {\n      disabled: this.onDisabledChange,\n      processing: this.onProcessingChange,\n      selected: this.onSelectedChange,\n    })\n  }\n\n  /**\n   * Initializes the foundation from a server side rendered (SSR) component.\n   * This will sync the adapter's state with the current state of the DOM.\n   *\n   * This method should be called after `init()`.\n   */\n  initFromDOM() {\n    // Turn off observers while setting state\n    this.setObserversEnabled(this.adapter.state, false);\n\n    this.adapter.state.selected = this.adapter.hasClass(CssClasses.SELECTED);\n    // Ensure aria-checked is set if attribute is not present\n    this.onSelectedChange();\n    this.adapter.state.disabled = this.adapter.isDisabled();\n    this.adapter.state.processing =\n        this.adapter.hasClass(CssClasses.PROCESSING);\n\n    // Re-observe state\n    this.setObserversEnabled(this.adapter.state, true);\n    this.stopProcessingIfDisabled();\n  }\n\n  protected onDisabledChange() {\n    this.adapter.setDisabled(this.adapter.state.disabled);\n  }\n\n  protected onProcessingChange() {\n    this.toggleClass(this.adapter.state.processing, CssClasses.PROCESSING);\n  }\n\n  protected onSelectedChange() {\n    this.adapter.setAriaChecked(String(this.adapter.state.selected));\n    this.toggleClass(this.adapter.state.selected, CssClasses.SELECTED);\n    this.toggleClass(!this.adapter.state.selected, CssClasses.UNSELECTED);\n  }\n\n  private toggleClass(addClass: boolean, className: CssClasses) {\n    if (addClass) {\n      this.adapter.addClass(className);\n    } else {\n      this.adapter.removeClass(className);\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2021 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// TODO(b/185410690): remove deprecated export\nimport * as deprecated from './deprecated';\n\nexport {deprecated};\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 {MDCTabDimensions} from '@material/tab/types';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCTabBarAdapter {\n  /**\n   * Scrolls to the given position\n   * @param scrollX The position to scroll to\n   */\n  scrollTo(scrollX: number): void;\n\n  /**\n   * Increments the current scroll position by the given amount\n   * @param scrollXIncrement The amount to increment scroll\n   */\n  incrementScroll(scrollXIncrement: number): void;\n\n  /**\n   * Returns the current scroll position\n   */\n  getScrollPosition(): number;\n\n  /**\n   * Returns the width of the scroll content\n   */\n  getScrollContentWidth(): number;\n\n  /**\n   * Returns the root element's offsetWidth\n   */\n  getOffsetWidth(): number;\n\n  /**\n   * Returns if the Tab Bar language direction is RTL\n   */\n  isRTL(): boolean;\n\n  /**\n   * Sets the tab at the given index to be activated\n   * @param index The index of the tab to activate\n   */\n  setActiveTab(index: number): void;\n\n  /**\n   * Activates the tab at the given index with the given client rect\n   * @param index The index of the tab to activate\n   * @param clientRect The client rect of the previously active Tab Indicator\n   */\n  activateTabAtIndex(index: number, clientRect?: DOMRect): void;\n\n  /**\n   * Deactivates the tab at the given index\n   * @param index The index of the tab to deactivate\n   */\n  deactivateTabAtIndex(index: number): void;\n\n  /**\n   * Focuses the tab at the given index\n   * @param index The index of the tab to focus\n   */\n  focusTabAtIndex(index: number): void;\n\n  /**\n   * Returns the client rect of the tab's indicator\n   * @param index The index of the tab\n   */\n  getTabIndicatorClientRectAtIndex(index: number): DOMRect;\n\n  /**\n   * Returns the tab dimensions of the tab at the given index\n   * @param index The index of the tab\n   */\n  getTabDimensionsAtIndex(index: number): MDCTabDimensions;\n\n  /**\n   * Returns the length of the tab list\n   */\n  getTabListLength(): number;\n\n  /**\n   * Returns the index of the previously active tab\n   */\n  getPreviousActiveTabIndex(): number;\n\n  /**\n   * Returns the index of the focused tab\n   */\n  getFocusedTabIndex(): number;\n\n  /**\n   * Returns the index of the given tab\n   * @param id The ID of the tab whose index to determine\n   */\n  getIndexOfTabById(id: string): number;\n\n  /**\n   * Emits the MDCTabBar:activated event\n   * @param index The index of the activated tab\n   */\n  notifyTabActivated(index: number): void;\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 {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';\n\nimport {MDCTabBarAdapter} from './adapter';\nimport {MDCTabBarFoundation} from './foundation';\nimport {MDCTabBarActivatedEventDetail} from './types';\n\nconst {strings} = MDCTabBarFoundation;\n\nlet tabIdCounter = 0;\n\n/** MDC Tab Bar */\nexport class MDCTabBar extends MDCComponent<MDCTabBarFoundation> {\n  static override attachTo(root: HTMLElement): 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!:\n      CustomEventListener<MDCTabInteractionEvent>;  // assigned in\n                                                    // initialSyncWithDOM()\n  private handleKeyDown!:\n      SpecificEventListener<'keydown'>;  // assigned in initialSyncWithDOM()\n\n  set focusOnActivate(focusOnActivate: boolean) {\n    for (const tab of this.tabList) {\n      tab.focusOnActivate = focusOnActivate;\n    }\n  }\n\n  set useAutomaticActivation(useAutomaticActivation: boolean) {\n    this.foundation.setUseAutomaticActivation(useAutomaticActivation);\n  }\n\n  override initialize(\n      tabFactory: MDCTabFactory = (el) => new MDCTab(el),\n      tabScrollerFactory:\n          MDCTabScrollerFactory = (el) => new MDCTabScroller(el),\n  ) {\n    this.tabList = this.instantiateTabs(tabFactory);\n    this.tabScroller = this.instantiatetabScroller(tabScrollerFactory);\n  }\n\n  override initialSyncWithDOM() {\n    this.handleTabInteraction = (event) => {\n      this.foundation.handleTabInteraction(event);\n    };\n    this.handleKeyDown = (event) => {\n      this.foundation.handleKeyDown(event);\n    };\n\n    this.listen(\n        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  override destroy() {\n    super.destroy();\n    this.unlisten(\n        MDCTabFoundation.strings.INTERACTED_EVENT, this.handleTabInteraction);\n    this.unlisten('keydown', this.handleKeyDown);\n    for (const tab of this.tabList) {\n      tab.destroy();\n    }\n\n    if (this.tabScroller) {\n      this.tabScroller.destroy();\n    }\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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) => {\n        this.tabScroller!.scrollTo(scrollX);\n      },\n      incrementScroll: (scrollXIncrement) => {\n        this.tabScroller!.incrementScroll(scrollXIncrement);\n      },\n      getScrollPosition: () => this.tabScroller!.getScrollPosition(),\n      getScrollContentWidth: () => this.tabScroller!.getScrollContentWidth(),\n      getOffsetWidth: () => this.root.offsetWidth,\n      isRTL: () => window.getComputedStyle(this.root).getPropertyValue(\n                       'direction') === 'rtl',\n      setActiveTab: (index) => {\n        this.foundation.activateTab(index);\n      },\n      activateTabAtIndex: (index, clientRect) => {\n        this.tabList[index].activate(clientRect);\n      },\n      deactivateTabAtIndex: (index) => {\n        this.tabList[index].deactivate();\n      },\n      focusTabAtIndex: (index) => {\n        this.tabList[index].focus();\n      },\n      getTabIndicatorClientRectAtIndex: (index) =>\n          this.tabList[index].computeIndicatorClientRect(),\n      getTabDimensionsAtIndex: (index) =>\n          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 as HTMLElement);\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>(\n            strings.TAB_ACTIVATED_EVENT, {index}, true);\n      },\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() {\n    return Array.from(\n        this.root.querySelectorAll<HTMLElement>(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):\n      MDCTabScroller|null {\n    const tabScrollerElement =\n        this.root.querySelector<HTMLElement>(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';\n\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\n// 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\n// 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\n/** MDC Tab Bar Foundation */\nexport class MDCTabBarFoundation extends MDCFoundation<MDCTabBarAdapter> {\n  static override get strings() {\n    return strings;\n  }\n\n  static override get numbers() {\n    return numbers;\n  }\n\n  static override 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: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\n      getTabDimensionsAtIndex: () =>\n          ({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 =\n          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(event: KeyboardEvent) {\n    // Get the key from the event\n    const key = this.getKeyFromEvent(event);\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,\n    // since :active is used to apply ripple\n    if (!this.isActivationKey(key)) {\n      event.preventDefault();\n    }\n\n    if (this.useAutomaticActivation && this.isActivationKey(key)) {\n      return;\n    }\n    const focusedTabIndex = this.adapter.getFocusedTabIndex();\n    if (this.isActivationKey(key)) {\n      this.adapter.setActiveTab(focusedTabIndex);\n      return;\n    }\n    const index = this.determineTargetFromKey(focusedTabIndex, key);\n    this.adapter.focusTabAtIndex(index);\n    this.scrollIntoView(index);\n    if (this.useAutomaticActivation) {\n      this.adapter.setActiveTab(index);\n    }\n  }\n\n  /**\n   * Handles the MDCTab:interacted event\n   */\n  handleTabInteraction(event: MDCTabInteractionEvent) {\n    this.adapter.setActiveTab(this.adapter.getIndexOfTabById(event.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      this.adapter.scrollTo(0);\n      return;\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      this.adapter.scrollTo(this.adapter.getScrollContentWidth());\n      return;\n    }\n\n    if (this.isRTL()) {\n      this.scrollIntoViewImplRTL(index);\n      return;\n    }\n\n    this.scrollIntoViewImpl(index);\n  }\n\n  /**\n   * Private method for determining the index of the destination tab based on\n   * 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 ||\n        key === strings.ARROW_RIGHT_KEY && isRTL;\n    const shouldIncrement = key === strings.ARROW_RIGHT_KEY && !isRTL ||\n        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\n   * 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 =\n        nextTabDimensions.contentLeft - scrollPosition - barWidth;\n    const relativeContentRight =\n        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\n   * 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 =\n        scrollContentWidth - nextTabDimensions.contentLeft - scrollPosition;\n    const relativeContentRight = scrollContentWidth -\n        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\n   * 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 =\n        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\n   * 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 =\n        scrollContentWidth - tabDimensions.rootLeft - barWidth - scrollPosition;\n    const rootRight =\n        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 event The keydown event\n   */\n  private getKeyFromEvent(event: KeyboardEvent): string {\n    if (ACCEPTABLE_KEYS.has(event.key)) {\n      return event.key;\n    }\n    return KEYCODE_MAP.get(event.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 scrollIntoViewImpl(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(\n        index, tabDimensions, scrollPosition, barWidth);\n\n    if (!this.indexIsInRange(nextIndex)) {\n      return;\n    }\n\n    const scrollIncrement = this.calculateScrollIncrement(\n        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 scrollIntoViewImplRTL(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(\n        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 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 interface MDCTabBarActivatedEventDetail {\n  index: number;\n}\n\n// Note: CustomEvent<T> is not supported by Closure Compiler.\n\nexport interface MDCTabBarActivatedEvent extends Event {\n  readonly detail: MDCTabBarActivatedEventDetail;\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/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCTabIndicatorAdapter {\n  /**\n   * Adds the given className to the root element.\n   * @param className The className to add\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes the given className from the root element.\n   * @param className The className to remove\n   */\n  removeClass(className: string): void;\n\n  /**\n   * Returns the client rect of the content element.\n   */\n  computeContentClientRect(): DOMRect;\n\n  /**\n   * Sets a style property of the content element to the passed value\n   * @param propName The style property name to set\n   * @param value The style property value\n   */\n  setContentStyleProperty(propName: string, value: string): void;\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';\n\nimport {MDCTabIndicatorAdapter} from './adapter';\nimport {MDCFadingTabIndicatorFoundation} from './fading-foundation';\nimport {MDCTabIndicatorFoundation} from './foundation';\nimport {MDCSlidingTabIndicatorFoundation} from './sliding-foundation';\n\n/** MDC Tab Indicator Factory */\nexport type MDCTabIndicatorFactory =\n    (el: HTMLElement, foundation?: MDCTabIndicatorFoundation) =>\n        MDCTabIndicator;\n\n/** MDC Tab Indicator */\nexport class MDCTabIndicator extends MDCComponent<MDCTabIndicatorFoundation> {\n  static override attachTo(root: HTMLElement): MDCTabIndicator {\n    return new MDCTabIndicator(root);\n  }\n\n  private content!: HTMLElement;  // assigned in initialize()\n\n  override initialize() {\n    this.content = this.root.querySelector<HTMLElement>(\n        MDCTabIndicatorFoundation.strings.CONTENT_SELECTOR)!;\n  }\n\n  computeContentClientRect(): DOMRect {\n    return this.foundation.computeContentClientRect();\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      computeContentClientRect: () => this.content.getBoundingClientRect(),\n      setContentStyleProperty: (prop, value) => {\n        this.content.style.setProperty(prop, value);\n      },\n    };\n    // tslint:enable:object-literal-sort-keys\n\n    if (this.root.classList.contains(\n            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?: DOMRect) {\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';\n\nimport {MDCTabIndicatorAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\n/** MDC Tab Indicator Foundation */\nexport abstract class MDCTabIndicatorFoundation extends\n    MDCFoundation<MDCTabIndicatorAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override 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: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\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(): DOMRect {\n    return this.adapter.computeContentClientRect();\n  }\n\n  abstract activate(previousIndicatorClientRect?: DOMRect): 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\n    MDCTabIndicatorFoundation {\n  activate(previousIndicatorClientRect?: DOMRect) {\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\n    // link below: https://aerotwist.com/blog/flip-your-animations/\n\n    // Calculate the dimensions based on the dimensions of the previous\n    // indicator\n    const currentClientRect = this.computeContentClientRect();\n    const widthDelta =\n        previousIndicatorClientRect.width / currentClientRect.width;\n    const xPosition = previousIndicatorClientRect.left - currentClientRect.left;\n    this.adapter.addClass(MDCTabIndicatorFoundation.cssClasses.NO_TRANSITION);\n    this.adapter.setContentStyleProperty(\n        'transform', `translateX(${xPosition}px) scaleX(${widthDelta})`);\n\n    // Force repaint before updating classes and transform to ensure the\n    // transform properly takes effect\n    this.computeContentClientRect();\n\n    this.adapter.removeClass(\n        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\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCTabScrollerAdapter {\n  /**\n   * Adds the given className to the root element.\n   * @param className The className to add\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes the given className from the root element.\n   * @param className The className to remove\n   */\n  removeClass(className: string): void;\n\n  /**\n   * Adds the given className to the scroll area element.\n   * @param className The className to add\n   */\n  addScrollAreaClass(className: string): void;\n\n  /**\n   * Returns whether the event target matches given className.\n   * @param eventTarget The event target\n   * @param selector The selector to check\n   */\n  eventTargetMatchesSelector(eventTarget: EventTarget, selector: string): boolean;\n\n  /**\n   * Sets a style property of the area element to the passed value.\n   * @param propName The style property name to set\n   * @param value The style property value\n   */\n  setScrollAreaStyleProperty(propName: string, value: string): void;\n\n  /**\n   * Sets a style property of the content element to the passed value.\n   * @param propName The style property name to set\n   * @param value The style property value\n   */\n  setScrollContentStyleProperty(propName: string, value: string): void;\n\n  /**\n   * Returns the scroll content element's computed style value of the given css\n   * property `propertyName`. We achieve this via\n   * `getComputedStyle(...).getPropertyValue(propertyName)`.\n   */\n  getScrollContentStyleValue(propertyName: string): string;\n\n  /**\n   * Sets the scrollLeft value of the scroll area element to the passed value.\n   * @param scrollLeft The new scrollLeft value\n   */\n  setScrollAreaScrollLeft(scrollLeft: number): void;\n\n  /**\n   * Returns the scrollLeft value of the scroll area element.\n   */\n  getScrollAreaScrollLeft(): number;\n\n  /**\n   * Returns the offsetWidth of the scroll content element.\n   */\n  getScrollContentOffsetWidth(): number;\n\n  /**\n   * Returns the offsetWitdth of the scroll area element.\n   */\n  getScrollAreaOffsetWidth(): number;\n\n  /**\n   * Returns the bounding client rect of the scroll area element.\n   */\n  computeScrollAreaClientRect(): DOMRect;\n\n  /**\n   * Returns the bounding client rect of the scroll content element.\n   */\n  computeScrollContentClientRect(): DOMRect;\n\n  /**\n   * Returns the height of the browser's horizontal scrollbars (in px).\n   */\n  computeHorizontalScrollbarHeight(): number;\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 {applyPassive} from '@material/dom/events';\nimport {matches} from '@material/dom/ponyfill';\n\nimport {MDCTabScrollerAdapter} from './adapter';\nimport {MDCTabScrollerFoundation} from './foundation';\nimport * as util from './util';\n\ntype InteractionEventType =\n    'wheel'|'touchstart'|'pointerdown'|'mousedown'|'keydown';\n\n/** MDC Tab Scroller Factory */\nexport type MDCTabScrollerFactory =\n    (el: HTMLElement, foundation?: MDCTabScrollerFoundation) => MDCTabScroller;\n\n/** MDC Tab Scroller */\nexport class MDCTabScroller extends MDCComponent<MDCTabScrollerFoundation> {\n  static override attachTo(root: HTMLElement): 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!:\n      SpecificEventListener<InteractionEventType>;  // assigned in\n                                                    // initialSyncWithDOM()\n  private handleTransitionEnd!:\n      SpecificEventListener<'transitionend'>;  // assigned in\n                                               // initialSyncWithDOM()\n\n  override initialize() {\n    this.area = this.root.querySelector<HTMLElement>(\n        MDCTabScrollerFoundation.strings.AREA_SELECTOR)!;\n    this.content = this.root.querySelector<HTMLElement>(\n        MDCTabScrollerFoundation.strings.CONTENT_SELECTOR)!;\n  }\n\n  override initialSyncWithDOM() {\n    this.handleInteraction = () => {\n      this.foundation.handleInteraction();\n    };\n    this.handleTransitionEnd = (event) => {\n      this.foundation.handleTransitionEnd(event);\n    };\n\n    this.area.addEventListener('wheel', this.handleInteraction, applyPassive());\n    this.area.addEventListener(\n        'touchstart', this.handleInteraction, applyPassive());\n    this.area.addEventListener(\n        'pointerdown', this.handleInteraction, applyPassive());\n    this.area.addEventListener(\n        'mousedown', this.handleInteraction, applyPassive());\n    this.area.addEventListener(\n        'keydown', this.handleInteraction, applyPassive());\n    this.content.addEventListener('transitionend', this.handleTransitionEnd);\n  }\n\n  override destroy() {\n    super.destroy();\n\n    this.area.removeEventListener(\n        'wheel', this.handleInteraction, applyPassive());\n    this.area.removeEventListener(\n        'touchstart', this.handleInteraction, applyPassive());\n    this.area.removeEventListener(\n        'pointerdown', this.handleInteraction, applyPassive());\n    this.area.removeEventListener(\n        'mousedown', this.handleInteraction, applyPassive());\n    this.area.removeEventListener(\n        'keydown', this.handleInteraction, applyPassive());\n    this.content.removeEventListener('transitionend', this.handleTransitionEnd);\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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: (eventTarget, selector) =>\n          matches(eventTarget as Element, selector),\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      addScrollAreaClass: (className) => {\n        this.area.classList.add(className);\n      },\n      setScrollAreaStyleProperty: (prop, value) => {\n        this.area.style.setProperty(prop, value);\n      },\n      setScrollContentStyleProperty: (prop, value) => {\n        this.content.style.setProperty(prop, value);\n      },\n      getScrollContentStyleValue: (propName) =>\n          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: () =>\n          this.content.getBoundingClientRect(),\n      computeHorizontalScrollbarHeight: () =>\n          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\n   *     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';\n\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\n/** MDC Tab Scroller Foundation */\nexport class MDCTabScrollerFoundation extends\n    MDCFoundation<MDCTabScrollerAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override 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: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\n      computeScrollContentClientRect: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\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\n   * during the animation.\n   */\n  private isAnimating = false;\n\n  /**\n   * The MDCTabScrollerRTL instance varies per browser and allows us to\n   * encapsulate the peculiar browser behavior of RTL scrolling in its own\n   * class.\n   */\n  private rtlScrollerInstance?: MDCTabScrollerRTL;\n\n  constructor(adapter?: Partial<MDCTabScrollerAdapter>) {\n    super({...MDCTabScrollerFoundation.defaultAdapter, ...adapter});\n  }\n\n  override init() {\n    // Compute horizontal scrollbar height on scroller with overflow initially\n    // hidden, then update overflow to scroll and immediately adjust bottom\n    // margin to avoid the scrollbar initially appearing before JS runs.\n    const horizontalScrollbarHeight =\n        this.adapter.computeHorizontalScrollbarHeight();\n    this.adapter.setScrollAreaStyleProperty(\n        'margin-bottom', -horizontalScrollbarHeight + 'px');\n    this.adapter.addScrollAreaClass(\n        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(event: Event) {\n    // Early exit if we aren't animating or the event was triggered by a\n    // different element.\n    const eventTarget = event.target as Element;\n    if (!this.isAnimating ||\n        !this.adapter.eventTargetMatchesSelector(\n            eventTarget, 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 using animation.\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    this.animate(this.getIncrementScrollOperation(scrollXIncrement));\n  }\n\n  /**\n   * Increment the scroll value by the scrollXIncrement without animation.\n   * @param scrollXIncrement The value by which to increment the scroll position\n   */\n  incrementScrollImmediate(scrollXIncrement: number) {\n    // Early exit for non-operational increment values\n    if (scrollXIncrement === 0) {\n      return;\n    }\n\n    const operation = this.getIncrementScrollOperation(scrollXIncrement);\n    if (operation.scrollDelta === 0) {\n      return;\n    }\n\n    this.stopScrollAnimation();\n    this.adapter.setScrollAreaScrollLeft(operation.finalScrollPosition);\n  }\n\n  /**\n   * Scrolls to the given scrollX value\n   */\n  scrollTo(scrollX: number) {\n    if (this.isRTL()) {\n      this.scrollToImplRTL(scrollX);\n      return;\n    }\n\n    this.scrollToImpl(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-suppressions \"Unused vars\" should be a linter warning, not a compiler error.\n    // @ts-ignore These unused variables should retain their semantic names for\n    // 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 scrollToImpl(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 scrollToImplRTL(scrollX: number) {\n    const animation = this.getRTLScroller().scrollToRTL(scrollX);\n    this.animate(animation);\n  }\n\n  /**\n   * Internal method to compute the increment scroll operation values.\n   * @param scrollX The desired scroll position increment\n   * @return MDCTabScrollerAnimation with the sanitized values for performing\n   *     the scroll operation.\n   */\n  private getIncrementScrollOperation(scrollX: number):\n      MDCTabScrollerAnimation {\n    if (this.isRTL()) {\n      return this.getRTLScroller().incrementScrollRTL(scrollX);\n    }\n\n    const currentScrollX = this.getScrollPosition();\n    const targetScrollX = scrollX + currentScrollX;\n    const safeScrollX = this.clampScrollValue(targetScrollX);\n    const scrollDelta = safeScrollX - currentScrollX;\n    return {\n      finalScrollPosition: safeScrollX,\n      scrollDelta,\n    };\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\n    // 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(\n        '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(\n          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 =\n        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\n/** MDC Tab Scroller RTL Default */\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 =\n        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\n/** MDC Tab Scroller RTL Negative */\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 =\n        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\n/** MDC Tab Scroller RTL Reverse */\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 =\n        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\n/** MDC Tab Scroller RTL */\nexport abstract class MDCTabScrollerRTL {\n  constructor(protected readonly adapter: MDCTabScrollerAdapter) {}\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):\n      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\n/**\n * MDCTabScrollerAnimation contains the values required for animating from the\n * current scroll position to the new scroll position. The \"finalScrollPosition\"\n * value represents the new scroll position while the \"scrollDelta\" value is the\n * corresponding transformation that is applied to the scroll content. Together,\n * they create the animation by first updating the scroll value then applying\n * the transformation and animating the transition. Both pieces are necessary\n * for the scroll animation to work. The values are used as-is by the tab\n * scroller animation method, ensuring that all logic for determining scroll\n * position or transformation is abstracted away from the animation method.\n */\nexport interface MDCTabScrollerAnimation {\n  finalScrollPosition: number;\n  scrollDelta: number;\n}\n\n/**\n * MDCTabScrollerHorizontalEdges represents the left and right edges of the\n * scroll content. These values vary depending on how scrolling in RTL is\n * implemented by the browser. One value is always 0 and one value is always\n * the max scrollable value as either a positive or negative integer.\n */\nexport interface MDCTabScrollerHorizontalEdges {\n  left: number;\n  right: number;\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 {cssClasses} from './constants';\n\n/**\n * Stores result from computeHorizontalScrollbarHeight to avoid redundant\n * processing.\n */\nlet horizontalScrollbarHeight_: number|undefined;\n\n/**\n * Computes the height of browser-rendered horizontal scrollbars using a\n * self-created test element. May return 0 (e.g. on OS X browsers under default\n * configuration).\n */\nexport function computeHorizontalScrollbarHeight(\n    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\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCTabAdapter {\n  /**\n   * Adds the given className to the root element.\n   * @param className The className to add\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes the given className from the root element.\n   * @param className The className to remove\n   */\n  removeClass(className: string): void;\n\n  /**\n   * Returns whether the root element has the given className.\n   * @param className The className to remove\n   */\n  hasClass(className: string): boolean;\n\n  /**\n   * Sets the given attrName of the root element to the given value.\n   * @param attr The attribute name to set\n   * @param value The value so give the attribute\n   */\n  setAttr(attr: string, value: string): void;\n\n  /**\n   * Activates the indicator element.\n   * @param previousIndicatorClientRect The client rect of the previously\n   *     activated indicator\n   */\n  activateIndicator(previousIndicatorClientRect?: DOMRect): void;\n\n  /** Deactivates the indicator. */\n  deactivateIndicator(): void;\n\n  /**\n   * Emits the MDCTab:interacted event for use by parent components\n   */\n  notifyInteracted(): void;\n\n  /**\n   * Returns the offsetLeft value of the root element.\n   */\n  getOffsetLeft(): number;\n\n  /**\n   * Returns the offsetWidth value of the root element.\n   */\n  getOffsetWidth(): number;\n\n  /**\n   * Returns the offsetLeft of the content element.\n   */\n  getContentOffsetLeft(): number;\n\n  /**\n   * Returns the offsetWidth of the content element.\n   */\n  getContentOffsetWidth(): number;\n\n  /**\n   * Applies focus to the root element\n   */\n  focus(): void;\n\n  /**\n   * Returns whether the root element is focused.\n   */\n  isFocused(): boolean;\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';\n\nimport {MDCTabAdapter} from './adapter';\nimport {MDCTabFoundation} from './foundation';\nimport {MDCTabDimensions, MDCTabInteractionEventDetail} from './types';\n\n/** MDC Tab Factory */\nexport type MDCTabFactory = (el: HTMLElement, foundation?: MDCTabFoundation) =>\n    MDCTab;\n\n/** MDC Tab */\nexport class MDCTab extends MDCComponent<MDCTabFoundation> implements\n    MDCRippleCapableSurface {\n  static override attachTo(root: HTMLElement): MDCTab {\n    return new MDCTab(root);\n  }\n\n  id!: string;  // assigned in initialize();\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!:\n      SpecificEventListener<'click'>;  // assigned in initialize();\n\n  override initialize(\n      rippleFactory:\n          MDCRippleFactory = (el, foundation) => new MDCRipple(el, foundation),\n      tabIndicatorFactory:\n          MDCTabIndicatorFactory = (el) => new MDCTabIndicator(el),\n  ) {\n    this.id = this.root.id;\n    const rippleFoundation =\n        new MDCRippleFoundation(MDCRipple.createAdapter(this));\n    this.ripple = rippleFactory(this.root, rippleFoundation);\n\n    const tabIndicatorElement = this.root.querySelector<HTMLElement>(\n        MDCTabFoundation.strings.TAB_INDICATOR_SELECTOR)!;\n    this.tabIndicator = tabIndicatorFactory(tabIndicatorElement);\n    this.content = this.root.querySelector<HTMLElement>(\n        MDCTabFoundation.strings.CONTENT_SELECTOR)!;\n  }\n\n  override initialSyncWithDOM() {\n    this.handleClick = () => {\n      this.foundation.handleClick();\n    };\n    this.listen('click', this.handleClick);\n  }\n\n  override destroy() {\n    this.unlisten('click', this.handleClick);\n    this.ripple.destroy();\n    super.destroy();\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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) => {\n        this.safeSetAttribute(this.root, attr, value);\n      },\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      hasClass: (className) => this.root.classList.contains(className),\n      activateIndicator: (previousIndicatorClientRect) => {\n        this.tabIndicator.activate(previousIndicatorClientRect);\n      },\n      deactivateIndicator: () => {\n        this.tabIndicator.deactivate();\n      },\n      notifyInteracted: () => {\n        this.emit<MDCTabInteractionEventDetail>(\n            MDCTabFoundation.strings.INTERACTED_EVENT, {tabId: this.id},\n            true /* bubble */);\n      },\n      getOffsetLeft: () => this.root.offsetLeft,\n      getOffsetWidth: () => this.root.offsetWidth,\n      getContentOffsetLeft: () => this.content.offsetLeft,\n      getContentOffsetWidth: () => this.content.offsetWidth,\n      focus: () => {\n        this.root.focus();\n      },\n      isFocused: () => this.root === document.activeElement,\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?: DOMRect) {\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(): DOMRect {\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';\n\nimport {MDCTabAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCTabDimensions} from './types';\n\n/** MDC Tab Foundation */\nexport class MDCTabFoundation extends MDCFoundation<MDCTabAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override 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      isFocused: () => false,\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?: DOMRect) {\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 && !this.adapter.isFocused()) {\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\n/**\n * MDCTabDimensions provides details about the left and right edges of the Tab\n * root element and the Tab content element. These values are used to determine\n * the visual position of the Tab with respect it's parent container.\n */\nexport interface MDCTabDimensions {\n  rootLeft: number;\n  rootRight: number;\n  contentLeft: number;\n  contentRight: number;\n}\n\nexport interface MDCTabInteractionEventDetail {\n  tabId: string;\n}\n\n// Note: CustomEvent<T> is not supported by Closure Compiler.\n\nexport interface MDCTabInteractionEvent extends Event {\n  readonly detail: MDCTabInteractionEventDetail;\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 {EventType, SpecificEventListener} from '@material/base/types';\n\nimport {MDCTextFieldNativeInputElement} from './types';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCTextFieldAdapter extends MDCTextFieldRootAdapter,\n                                             MDCTextFieldInputAdapter,\n                                             MDCTextFieldLabelAdapter,\n                                             MDCTextFieldLineRippleAdapter,\n                                             MDCTextFieldOutlineAdapter {}\n\nexport interface MDCTextFieldRootAdapter {\n  /**\n   * Adds a class to the root Element.\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes a class from the root Element.\n   */\n  removeClass(className: string): void;\n\n  /**\n   * @return true if the root element contains the given class name.\n   */\n  hasClass(className: string): boolean;\n\n  /**\n   * Registers an event handler on the root element for a given event.\n   */\n  registerTextFieldInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event handler on the root element for a given event.\n   */\n  deregisterTextFieldInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Registers a validation attribute change listener on the input element.\n   * Handler accepts list of attribute names.\n   */\n  registerValidationAttributeChangeHandler(\n      handler: (attributeNames: string[]) => void): MutationObserver;\n\n  /**\n   * Disconnects a validation attribute observer on the input element.\n   */\n  deregisterValidationAttributeChangeHandler(observer: MutationObserver): void;\n}\n\nexport interface MDCTextFieldInputAdapter {\n  /**\n   * @return The native `<input>` element, or an object with the same shape.\n   * Note that this method can return null, which the foundation will handle\n   * gracefully.\n   */\n  getNativeInput(): MDCTextFieldNativeInputElement|null;\n\n  /**\n   * Sets the specified attribute to the specified value on the input element.\n   */\n  setInputAttr(attr: string, value: string): void;\n\n  /**\n   * Removes the specified attribute from the input element.\n   */\n  removeInputAttr(attr: string): void;\n\n  /**\n   * @return true if the textfield is focused. We achieve this via\n   *     `document.activeElement === this.root`.\n   */\n  isFocused(): boolean;\n\n  /**\n   * Registers an event listener on the native input element for a given event.\n   */\n  registerInputInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener on the native input element for a given\n   * event.\n   */\n  deregisterInputInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n}\n\nexport interface MDCTextFieldLabelAdapter {\n  /**\n   * Only implement if label exists.\n   * Shakes label if shouldShake is true.\n   */\n  shakeLabel(shouldShake: boolean): void;\n\n  /**\n   * Only implement if label exists.\n   * Floats the label above the input element if shouldFloat is true.\n   */\n  floatLabel(shouldFloat: boolean): void;\n\n  /**\n   * @return true if label element exists, false if it doesn't.\n   */\n  hasLabel(): boolean;\n\n  /**\n   * Only implement if label exists.\n   * @return width of label in pixels.\n   */\n  getLabelWidth(): number;\n\n  /**\n   * Only implement if label exists.\n   * Styles the label as required.\n   */\n  setLabelRequired(isRequired: boolean): void;\n}\n\nexport interface MDCTextFieldLineRippleAdapter {\n  /**\n   * Activates the line ripple.\n   */\n  activateLineRipple(): void;\n\n  /**\n   * Deactivates the line ripple.\n   */\n  deactivateLineRipple(): void;\n\n  /**\n   * Sets the transform origin of the line ripple.\n   */\n  setLineRippleTransformOrigin(normalizedX: number): void;\n}\n\nexport interface MDCTextFieldOutlineAdapter {\n  /**\n   * @return true if outline element exists, false if it doesn't.\n   */\n  hasOutline(): boolean;\n\n  /**\n   * Only implement if outline element exists.\n   */\n  notchOutline(labelWidth: number): void;\n\n  /**\n   * Only implement if outline element exists.\n   * Closes notch in outline element.\n   */\n  closeOutline(): void;\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 * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCTextFieldCharacterCounterAdapter {\n  /**\n   * Sets the text content of character counter element.\n   */\n  setContent(content: string): void;\n\n  /**\n   * Sets the max char length and char length of current value.\n   * Allows more flexible character counter text.\n   */\n  setCounterValue(currentLength: number, maxLength: number): void;\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 {MDCComponent} from '@material/base/component';\n\nimport {MDCTextFieldCharacterCounterAdapter} from './adapter';\nimport {MDCTextFieldCharacterCounterFoundation} from './foundation';\n\n/** MDC Text Field Character Counter Factory */\nexport type MDCTextFieldCharacterCounterFactory =\n    (el: HTMLElement, foundation?: MDCTextFieldCharacterCounterFoundation) =>\n        MDCTextFieldCharacterCounter;\n\n/** MDC Text Field Character Counter */\nexport class MDCTextFieldCharacterCounter extends\n    MDCComponent<MDCTextFieldCharacterCounterFoundation> {\n  static override attachTo(root: HTMLElement): MDCTextFieldCharacterCounter {\n    return new MDCTextFieldCharacterCounter(root);\n  }\n\n  // Provided for access by MDCTextField component\n  get foundationForTextField(): MDCTextFieldCharacterCounterFoundation {\n    return this.foundation;\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // methods, we need a separate, strongly typed adapter variable.\n    const adapter: MDCTextFieldCharacterCounterAdapter = {\n      setContent: (content) => {\n        this.root.textContent = content;\n      },\n      setCounterValue: () => undefined,\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';\n\nimport {MDCTextFieldCharacterCounterAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\n/** MDC Text Field Character Counter Foundation */\nexport class MDCTextFieldCharacterCounterFoundation extends\n    MDCFoundation<MDCTextFieldCharacterCounterAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  /**\n   * See {@link MDCTextFieldCharacterCounterAdapter} for typing information on\n   * parameters and return types.\n   */\n  static override get defaultAdapter(): MDCTextFieldCharacterCounterAdapter {\n    return {\n      setContent: () => undefined,\n      setCounterValue: () => undefined,\n    };\n  }\n\n  constructor(adapter?: Partial<MDCTextFieldCharacterCounterAdapter>) {\n    super(\n        {...MDCTextFieldCharacterCounterFoundation.defaultAdapter, ...adapter});\n  }\n\n  setCounterValue(currentLength: number, maxLength: number) {\n    currentLength = Math.min(currentLength, maxLength);\n    this.adapter.setContent(`${currentLength} / ${maxLength}`);\n    this.adapter.setCounterValue(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';\n\nimport {MDCTextFieldAdapter, MDCTextFieldInputAdapter, MDCTextFieldLabelAdapter, MDCTextFieldLineRippleAdapter, MDCTextFieldOutlineAdapter, MDCTextFieldRootAdapter} from './adapter';\nimport {MDCTextFieldCharacterCounter, MDCTextFieldCharacterCounterFactory} from './character-counter/component';\nimport {MDCTextFieldCharacterCounterFoundation} from './character-counter/foundation';\nimport {cssClasses, strings} from './constants';\nimport {MDCTextFieldFoundation} from './foundation';\nimport {MDCTextFieldHelperText, MDCTextFieldHelperTextFactory} from './helper-text/component';\nimport {MDCTextFieldHelperTextFoundation} from './helper-text/foundation';\nimport {MDCTextFieldIcon, MDCTextFieldIconFactory} from './icon/component';\nimport {MDCTextFieldFoundationMap} from './types';\n\n/** MDC Text Field */\nexport class MDCTextField extends\n    MDCComponent<MDCTextFieldFoundation> implements MDCRippleCapableSurface {\n  static override attachTo(root: HTMLElement): MDCTextField {\n    return new MDCTextField(root);\n  }\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|\n      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  private prefix!: Element|null;                     // assigned in initialize()\n  private suffix!: Element|null;                     // assigned in initialize()\n\n  override initialize(\n      rippleFactory:\n          MDCRippleFactory = (el, foundation) => new MDCRipple(el, foundation),\n      lineRippleFactory: MDCLineRippleFactory = (el) => new MDCLineRipple(el),\n      helperTextFactory: MDCTextFieldHelperTextFactory = (el) =>\n          new MDCTextFieldHelperText(el),\n      characterCounterFactory: MDCTextFieldCharacterCounterFactory = (el) =>\n          new MDCTextFieldCharacterCounter(el),\n      iconFactory: MDCTextFieldIconFactory = (el) => new MDCTextFieldIcon(el),\n      labelFactory: MDCFloatingLabelFactory = (el) => new MDCFloatingLabel(el),\n      outlineFactory:\n          MDCNotchedOutlineFactory = (el) => new MDCNotchedOutline(el),\n  ) {\n    this.input =\n        this.root.querySelector<HTMLInputElement>(strings.INPUT_SELECTOR)!;\n\n    const labelElement =\n        this.root.querySelector<HTMLElement>(strings.LABEL_SELECTOR);\n    this.label = labelElement ? labelFactory(labelElement) : null;\n\n    const lineRippleElement =\n        this.root.querySelector<HTMLElement>(strings.LINE_RIPPLE_SELECTOR);\n    this.lineRipple =\n        lineRippleElement ? lineRippleFactory(lineRippleElement) : null;\n\n    const outlineElement =\n        this.root.querySelector<HTMLElement>(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 =\n        (nextElementSibling &&\n         nextElementSibling.classList.contains(cssClasses.HELPER_LINE));\n    const helperTextEl = hasHelperLine && nextElementSibling &&\n        nextElementSibling.querySelector<HTMLElement>(\n            helperTextStrings.ROOT_SELECTOR);\n    this.helperText = helperTextEl ? helperTextFactory(helperTextEl) : null;\n\n    // Character counter\n    const characterCounterStrings =\n        MDCTextFieldCharacterCounterFoundation.strings;\n    let characterCounterEl = this.root.querySelector<HTMLElement>(\n        characterCounterStrings.ROOT_SELECTOR);\n    // If character counter is not found in root element search in sibling\n    // element.\n    if (!characterCounterEl && hasHelperLine && nextElementSibling) {\n      characterCounterEl = nextElementSibling.querySelector<HTMLElement>(\n          characterCounterStrings.ROOT_SELECTOR);\n    }\n    this.characterCounter =\n        characterCounterEl ? characterCounterFactory(characterCounterEl) : null;\n\n    // Leading icon\n    const leadingIconEl =\n        this.root.querySelector<HTMLElement>(strings.LEADING_ICON_SELECTOR);\n    this.leadingIcon = leadingIconEl ? iconFactory(leadingIconEl) : null;\n\n    // Trailing icon\n    const trailingIconEl =\n        this.root.querySelector<HTMLElement>(strings.TRAILING_ICON_SELECTOR);\n    this.trailingIcon = trailingIconEl ? iconFactory(trailingIconEl) : null;\n\n    // Prefix and Suffix\n    this.prefix = this.root.querySelector<HTMLElement>(strings.PREFIX_SELECTOR);\n    this.suffix = this.root.querySelector<HTMLElement>(strings.SUFFIX_SELECTOR);\n\n    this.ripple = this.createRipple(rippleFactory);\n  }\n\n  override 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  override 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\n   * validation.\n   * @param useNativeValidation Set this to false to ignore native input\n   *     validation.\n   */\n  set useNativeValidation(useNativeValidation: boolean) {\n    this.foundation.setUseNativeValidation(useNativeValidation);\n  }\n\n  /**\n   * Gets the text content of the prefix, or null if it does not exist.\n   */\n  get prefixText(): string|null {\n    return this.prefix ? this.prefix.textContent : null;\n  }\n\n  /**\n   * Sets the text content of the prefix, if it exists.\n   */\n  set prefixText(prefixText: string|null) {\n    if (this.prefix) {\n      this.prefix.textContent = prefixText;\n    }\n  }\n\n  /**\n   * Gets the text content of the suffix, or null if it does not exist.\n   */\n  get suffixText(): string|null {\n    return this.suffix ? this.suffix.textContent : null;\n  }\n\n  /**\n   * Sets the text content of the suffix, if it exists.\n   */\n  set suffixText(suffixText: string|null) {\n    if (this.suffix) {\n      this.suffix.textContent = suffixText;\n    }\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  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      hasClass: (className) => this.root.classList.contains(className),\n      registerTextFieldInteractionHandler: (eventType, handler) => {\n        this.listen(eventType, handler);\n      },\n      deregisterTextFieldInteractionHandler: (eventType, handler) => {\n        this.unlisten(eventType, handler);\n      },\n      registerValidationAttributeChangeHandler: (handler) => {\n        const getAttributesList =\n            (mutationsList: MutationRecord[]): string[] => {\n              return mutationsList.map((mutation) => mutation.attributeName)\n                         .filter((attributeName) => attributeName) as string[];\n            };\n        const observer = new MutationObserver((mutationsList) => {\n          handler(getAttributesList(mutationsList));\n        });\n        const config = {attributes: true};\n        observer.observe(this.input, config);\n        return observer;\n      },\n      deregisterValidationAttributeChangeHandler: (observer) => {\n        observer.disconnect();\n      },\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      setInputAttr: (attr, value) => {\n        this.safeSetAttribute(this.input, attr, value);\n      },\n      removeInputAttr: (attr) => {\n        this.input.removeAttribute(attr);\n      },\n      isFocused: () => document.activeElement === this.input,\n      registerInputInteractionHandler: (eventType, handler) => {\n        this.input.addEventListener(eventType, handler, applyPassive());\n      },\n      deregisterInputInteractionHandler: (eventType, handler) => {\n        this.input.removeEventListener(eventType, handler, applyPassive());\n      },\n    };\n    // tslint:enable:object-literal-sort-keys\n  }\n\n  private getLabelAdapterMethods(): MDCTextFieldLabelAdapter {\n    return {\n      floatLabel: (shouldFloat) => {\n        this.label && this.label.float(shouldFloat);\n      },\n      getLabelWidth: () => this.label ? this.label.getWidth() : 0,\n      hasLabel: () => Boolean(this.label),\n      shakeLabel: (shouldShake) => {\n        this.label && this.label.shake(shouldShake);\n      },\n      setLabelRequired: (isRequired) => {\n        this.label && this.label.setRequired(isRequired);\n      },\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: () => {\n        this.outline && this.outline.closeNotch();\n      },\n      hasOutline: () => Boolean(this.outline),\n      notchOutline: (labelWidth) => {\n        this.outline && this.outline.notch(labelWidth);\n      },\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 ?\n          this.characterCounter.foundationForTextField :\n          undefined,\n      helperText: this.helperText ? this.helperText.foundationForTextField :\n                                    undefined,\n      leadingIcon: this.leadingIcon ? this.leadingIcon.foundationForTextField :\n                                      undefined,\n      trailingIcon: this.trailingIcon ?\n          this.trailingIcon.foundationForTextField :\n          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\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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: (eventType, handler) => {\n        this.input.addEventListener(eventType, handler, applyPassive());\n      },\n      deregisterInteractionHandler: (eventType, handler) => {\n        this.input.removeEventListener(eventType, handler, applyPassive());\n      },\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  ARIA_DESCRIBEDBY: 'aria-describedby',\n  INPUT_SELECTOR: '.mdc-text-field__input',\n  LABEL_SELECTOR: '.mdc-floating-label',\n  LEADING_ICON_SELECTOR: '.mdc-text-field__icon--leading',\n  LINE_RIPPLE_SELECTOR: '.mdc-line-ripple',\n  OUTLINE_SELECTOR: '.mdc-notched-outline',\n  PREFIX_SELECTOR: '.mdc-text-field__affix--prefix',\n  SUFFIX_SELECTOR: '.mdc-text-field__affix--suffix',\n  TRAILING_ICON_SELECTOR: '.mdc-text-field__icon--trailing'\n};\n\nconst cssClasses = {\n  DISABLED: 'mdc-text-field--disabled',\n  FOCUSED: 'mdc-text-field--focused',\n  HELPER_LINE: 'mdc-text-field-helper-line',\n  INVALID: 'mdc-text-field--invalid',\n  LABEL_FLOATING: 'mdc-text-field--label-floating',\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  WITH_INTERNAL_COUNTER: 'mdc-text-field--with-internal-counter',\n};\n\nconst numbers = {\n  LABEL_SCALE: 0.75,\n};\n\n/**\n * Whitelist based off of\n * 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',\n  'min',\n  'max',\n  'required',\n  'step',\n  'minlength',\n  'maxlength',\n];\n\n/**\n * Label should always float for these types as they show some UI even if value\n * is empty.\n */\nconst ALWAYS_FLOAT_TYPES = [\n  'color',\n  'date',\n  'datetime-local',\n  'month',\n  'range',\n  'time',\n  'week',\n];\n\nexport {\n  cssClasses,\n  strings,\n  numbers,\n  VALIDATION_ATTR_WHITELIST,\n  ALWAYS_FLOAT_TYPES\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';\n\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\n/** MDC Text Field Foundation */\nexport class MDCTextFieldFoundation extends MDCFoundation<MDCTextFieldAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override 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 || !!this.getValue() ||\n        this.isBadInput();\n  }\n\n  get shouldShake(): boolean {\n    return !this.isFocused && !this.isValid() && !!this.getValue();\n  }\n\n  /**\n   * See {@link MDCTextFieldAdapter} for typing information on parameters and\n   * return types.\n   */\n  static override 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      setInputAttr: () => undefined,\n      removeInputAttr: () => undefined,\n      registerTextFieldInteractionHandler: () => undefined,\n      deregisterTextFieldInteractionHandler: () => undefined,\n      registerInputInteractionHandler: () => undefined,\n      deregisterInputInteractionHandler: () => undefined,\n      registerValidationAttributeChangeHandler: () =>\n          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      setLabelRequired: () => 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 useNativeValidation = true;\n  private validateOnValueChange = true;\n  private valid: boolean;\n\n  private readonly inputFocusHandler: () => void;\n  private readonly inputBlurHandler: SpecificEventListener<'blur'>;\n  private readonly inputInputHandler: SpecificEventListener<'input'>;\n  private readonly setPointerXOffset:\n      SpecificEventListener<PointerDownEventType>;\n  private readonly textFieldInteractionHandler:\n      SpecificEventListener<InteractionEventType>;\n  private readonly validationAttributeChangeHandler:\n      (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(\n      adapter?: Partial<MDCTextFieldAdapter>,\n      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    this.valid =\n        !this.adapter.hasClass(MDCTextFieldFoundation.cssClasses.INVALID);\n\n    this.inputFocusHandler = () => {\n      this.activateFocus();\n    };\n    this.inputBlurHandler = () => {\n      this.deactivateFocus();\n    };\n    this.inputInputHandler = () => {\n      this.handleInput();\n    };\n    this.setPointerXOffset = (event) => {\n      this.setTransformOrigin(event);\n    };\n    this.textFieldInteractionHandler = () => {\n      this.handleTextFieldInteraction();\n    };\n    this.validationAttributeChangeHandler = (attributesList) => {\n      this.handleValidationAttributeChange(attributesList);\n    };\n  }\n\n  override init() {\n    if (this.adapter.hasLabel() && this.getNativeInput().required) {\n      this.adapter.setLabelRequired(true);\n    }\n\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      this.styleFloating(true);\n    }\n\n    this.adapter.registerInputInteractionHandler(\n        'focus', this.inputFocusHandler);\n    this.adapter.registerInputInteractionHandler('blur', this.inputBlurHandler);\n    this.adapter.registerInputInteractionHandler(\n        'input', this.inputInputHandler);\n    for (const eventType of POINTERDOWN_EVENTS) {\n      this.adapter.registerInputInteractionHandler(\n          eventType, this.setPointerXOffset);\n    }\n    for (const eventType of INTERACTION_EVENTS) {\n      this.adapter.registerTextFieldInteractionHandler(\n          eventType, this.textFieldInteractionHandler);\n    }\n    this.validationObserver =\n        this.adapter.registerValidationAttributeChangeHandler(\n            this.validationAttributeChangeHandler);\n    this.setcharacterCounter(this.getValue().length);\n  }\n\n  override destroy() {\n    this.adapter.deregisterInputInteractionHandler(\n        'focus', this.inputFocusHandler);\n    this.adapter.deregisterInputInteractionHandler(\n        'blur', this.inputBlurHandler);\n    this.adapter.deregisterInputInteractionHandler(\n        'input', this.inputInputHandler);\n    for (const eventType of POINTERDOWN_EVENTS) {\n      this.adapter.deregisterInputInteractionHandler(\n          eventType, this.setPointerXOffset);\n    }\n    for (const eventType of INTERACTION_EVENTS) {\n      this.adapter.deregisterTextFieldInteractionHandler(\n          eventType, this.textFieldInteractionHandler);\n    }\n    this.adapter.deregisterValidationAttributeChangeHandler(\n        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        this.adapter.setLabelRequired(this.getNativeInput().required);\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() || !this.adapter.hasLabel()) {\n      return;\n    }\n\n    if (openNotch) {\n      const labelWidth = this.adapter.getLabelWidth() * numbers.LABEL_SCALE;\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.styleFloating(this.shouldFloat);\n      this.adapter.shakeLabel(this.shouldShake);\n    }\n    if (this.helperText &&\n        (this.helperText.isPersistent() || !this.helperText.isValidation() ||\n         !this.valid)) {\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(event: TouchEvent|MouseEvent): void {\n    if (this.isDisabled() || this.adapter.hasOutline()) {\n      return;\n    }\n\n    const touches = (event as TouchEvent).touches;\n    const targetEvent = touches ? touches[0] : event;\n    const targetClientRect =\n        (targetEvent.target as Element).getBoundingClientRect();\n    const normalizedX =\n        (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.styleFloating(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\n    // value has not changed.\n    if (this.getValue() !== value) {\n      this.getNativeInput().value = value;\n    }\n    this.setcharacterCounter(value.length);\n    if (this.validateOnValueChange) {\n      const isValid = this.isValid();\n      this.styleValidity(isValid);\n    }\n    if (this.adapter.hasLabel()) {\n      this.notchOutline(this.shouldFloat);\n      this.adapter.floatLabel(this.shouldFloat);\n      this.styleFloating(this.shouldFloat);\n      if (this.validateOnValueChange) {\n        this.adapter.shakeLabel(this.shouldShake);\n      }\n    }\n  }\n\n  /**\n   * @return The custom validity state, if set; otherwise, the result of a\n   *     native validity check.\n   */\n  isValid(): boolean {\n    return this.useNativeValidation ? this.isNativeInputValid() : this.valid;\n  }\n\n  /**\n   * @param isValid Sets the custom validity state of the Text Field.\n   */\n  setValid(isValid: boolean): void {\n    this.valid = isValid;\n    this.styleValidity(isValid);\n\n    const shouldShake = !isValid && !this.isFocused && !!this.getValue();\n    if (this.adapter.hasLabel()) {\n      this.adapter.shakeLabel(shouldShake);\n    }\n  }\n\n  /**\n   * @param shouldValidate Whether or not validity should be updated on\n   *     value change.\n   */\n  setValidateOnValueChange(shouldValidate: boolean): void {\n    this.validateOnValueChange = shouldValidate;\n  }\n\n  /**\n   * @return Whether or not validity should be updated on value change. `true`\n   *     by default.\n   */\n  getValidateOnValueChange(): boolean {\n    return this.validateOnValueChange;\n  }\n\n  /**\n   * Enables or disables the use of native validation. Use this for custom\n   * validation.\n   * @param useNativeValidation Set this to false to ignore native input\n   *     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\n   * 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(\n          '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\n   *     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      // We dynamically set or unset aria-describedby for validation helper text\n      // only, based on whether the field is valid\n      const helperTextValidation = this.helperText.isValidation();\n      if (!helperTextValidation) {\n        return;\n      }\n\n      const helperTextVisible = this.helperText.isVisible();\n      const helperTextId = this.helperText.getId();\n\n      if (helperTextVisible && helperTextId) {\n        this.adapter.setInputAttr(strings.ARIA_DESCRIBEDBY, helperTextId);\n      } else {\n        this.adapter.removeInputAttr(strings.ARIA_DESCRIBEDBY);\n      }\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   * Styles the component based on the label floating state.\n   */\n  private styleFloating(isFloating: boolean): void {\n    const {LABEL_FLOATING} = MDCTextFieldFoundation.cssClasses;\n    if (isFloating) {\n      this.adapter.addClass(LABEL_FLOATING);\n    } else {\n      this.adapter.removeClass(LABEL_FLOATING);\n    }\n  }\n\n  /**\n   * @return The native text input element from the host environment, or an\n   *     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\n    // testdouble is creating a mock object and invokes the\n    // shouldShake/shouldFloat getters (which in turn call getValue(), which\n    // calls this method) before init() has been called from the MDCTextField\n    // 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      required: false,\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\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCTextFieldHelperTextAdapter {\n  /**\n   * Adds a class to the helper text element.\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes a class from the helper text element.\n   */\n  removeClass(className: string): void;\n\n  /**\n   * Returns whether or not the helper text element contains the given class.\n   */\n  hasClass(className: string): boolean;\n\n  /**\n   * @return the specified attribute's value on the helper text element.\n   */\n  getAttr(attr: string): string|null;\n\n  /**\n   * Sets an attribute with a given value on the helper text element.\n   */\n  setAttr(attr: string, value: string): void;\n\n  /**\n   * Removes an attribute from the helper text element.\n   */\n  removeAttr(attr: string): void;\n\n  /**\n   * Sets the text content for the helper text element.\n   */\n  setContent(content: string): void;\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 {MDCComponent} from '@material/base/component';\n\nimport {MDCTextFieldHelperTextAdapter} from './adapter';\nimport {MDCTextFieldHelperTextFoundation} from './foundation';\n\n/** MDC Text Field Helper Text Factory */\nexport type MDCTextFieldHelperTextFactory =\n    (el: HTMLElement, foundation?: MDCTextFieldHelperTextFoundation) =>\n        MDCTextFieldHelperText;\n\n/** MDC Text Field Helper Text */\nexport class MDCTextFieldHelperText extends\n    MDCComponent<MDCTextFieldHelperTextFoundation> {\n  static override attachTo(root: HTMLElement): MDCTextFieldHelperText {\n    return new MDCTextFieldHelperText(root);\n  }\n\n  // Provided for access by MDCTextField component\n  get foundationForTextField(): MDCTextFieldHelperTextFoundation {\n    return this.foundation;\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      hasClass: (className) => this.root.classList.contains(className),\n      getAttr: (attr) => this.root.getAttribute(attr),\n      setAttr: (attr, value) => {\n        this.safeSetAttribute(this.root, attr, value);\n      },\n      removeAttr: (attr) => {\n        this.root.removeAttribute(attr);\n      },\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';\n\nimport {MDCTextFieldHelperTextAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\n/** MDC Text Field Helper Text Foundation */\nexport class MDCTextFieldHelperTextFoundation extends\n    MDCFoundation<MDCTextFieldHelperTextAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  /**\n   * See {@link MDCTextFieldHelperTextAdapter} for typing information on\n   * parameters and return types.\n   */\n  static override 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      getAttr: () => null,\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  getId(): string|null {\n    return this.adapter.getAttr('id');\n  }\n\n  isVisible(): boolean {\n    return this.adapter.getAttr(strings.ARIA_HIDDEN) !== 'true';\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  isPersistent(): boolean {\n    return this.adapter.hasClass(cssClasses.HELPER_TEXT_PERSISTENT);\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   * @return whether the helper text acts as an error validation message.\n   */\n  isValidation(): boolean {\n    return this.adapter.hasClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n  }\n\n  /**\n   * @param isValidation True to make the helper text act as an error validation\n   *     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 =\n        this.adapter.hasClass(cssClasses.HELPER_TEXT_PERSISTENT);\n    const helperTextIsValidationMsg =\n        this.adapter.hasClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n    const validationMsgNeedsDisplay =\n        helperTextIsValidationMsg && !inputIsValid;\n\n    if (validationMsgNeedsDisplay) {\n      this.showToScreenReader();\n      // If role is already alert, refresh it to trigger another announcement\n      // from screenreader.\n      if (this.adapter.getAttr(strings.ROLE) === 'alert') {\n        this.refreshAlertRole();\n      } else {\n        this.adapter.setAttr(strings.ROLE, 'alert');\n      }\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  private refreshAlertRole() {\n    this.adapter.removeAttr(strings.ROLE);\n    requestAnimationFrame(() => {\n      this.adapter.setAttr(strings.ROLE, 'alert');\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 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 {EventType, SpecificEventListener} from '@material/base/types';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCTextFieldIconAdapter {\n  /**\n   * Gets the value of an attribute on the icon element.\n   */\n  getAttr(attr: string): string|null;\n\n  /**\n   * Sets an attribute on the icon element.\n   */\n  setAttr(attr: string, value: string): void;\n\n  /**\n   * Removes an attribute from the icon element.\n   */\n  removeAttr(attr: string): void;\n\n  /**\n   * Sets the text content of the icon element.\n   */\n  setContent(content: string): void;\n\n  /**\n   * Registers an event listener on the icon element for a given event.\n   */\n  registerInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener on the icon element for a given event.\n   */\n  deregisterInteractionHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Emits a custom event \"MDCTextField:icon\" denoting a user has clicked the\n   * icon.\n   */\n  notifyIconAction(): void;\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 {MDCComponent} from '@material/base/component';\n\nimport {MDCTextFieldIconAdapter} from './adapter';\nimport {MDCTextFieldIconFoundation} from './foundation';\n\n/** MDC Text Field Icon Factory */\nexport type MDCTextFieldIconFactory =\n    (el: HTMLElement, foundation?: MDCTextFieldIconFoundation) =>\n        MDCTextFieldIcon;\n\n/** MDC Text Field Icon */\nexport class MDCTextFieldIcon extends MDCComponent<MDCTextFieldIconFoundation> {\n  static override attachTo(root: HTMLElement): MDCTextFieldIcon {\n    return new MDCTextFieldIcon(root);\n  }\n\n  // Provided for access by MDCTextField component\n  get foundationForTextField(): MDCTextFieldIconFoundation {\n    return this.foundation;\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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) => {\n        this.safeSetAttribute(this.root, attr, value);\n      },\n      removeAttr: (attr) => {\n        this.root.removeAttribute(attr);\n      },\n      setContent: (content) => {\n        this.root.textContent = content;\n      },\n      registerInteractionHandler: (eventType, handler) => {\n        this.listen(eventType, handler);\n      },\n      deregisterInteractionHandler: (eventType, handler) => {\n        this.unlisten(eventType, handler);\n      },\n      notifyIconAction: () => {\n        this.emit(\n            MDCTextFieldIconFoundation.strings.ICON_EVENT, {} /* eventData */,\n            true /* shouldBubble */);\n      },\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';\n\nimport {MDCTextFieldIconAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\ntype InteractionEventType = 'click'|'keydown';\n\nconst INTERACTION_EVENTS: InteractionEventType[] = ['click', 'keydown'];\n\n/** MDC Text Field Icon Foundation */\nexport class MDCTextFieldIconFoundation extends\n    MDCFoundation<MDCTextFieldIconAdapter> {\n  static override get strings() {\n    return strings;\n  }\n\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  /**\n   * See {@link MDCTextFieldIconAdapter} for typing information on parameters\n   * and return types.\n   */\n  static override 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:\n      SpecificEventListener<InteractionEventType>;\n\n  constructor(adapter?: Partial<MDCTextFieldIconAdapter>) {\n    super({...MDCTextFieldIconFoundation.defaultAdapter, ...adapter});\n\n    this.interactionHandler = (event) => {\n      this.handleInteraction(event);\n    };\n  }\n\n  override init() {\n    this.savedTabIndex = this.adapter.getAttr('tabindex');\n\n    for (const eventType of INTERACTION_EVENTS) {\n      this.adapter.registerInteractionHandler(eventType, this.interactionHandler);\n    }\n  }\n\n  override destroy() {\n    for (const eventType of INTERACTION_EVENTS) {\n      this.adapter.deregisterInteractionHandler(\n          eventType, 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(event: MouseEvent|KeyboardEvent) {\n    const isEnterKey = (event as KeyboardEvent).key === 'Enter' ||\n        (event as KeyboardEvent).keyCode === 13;\n    const isSpaceKey = (event as KeyboardEvent).key === ' ';\n    if (event.type === 'click' || isEnterKey || isSpaceKey) {\n      event.preventDefault();  // stop click from causing host label to focus\n                             // input\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 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 {MDCTextFieldCharacterCounterFoundation} from './character-counter/foundation';\nimport {MDCTextFieldHelperTextFoundation} from './helper-text/foundation';\nimport {MDCTextFieldIconFoundation} from './icon/foundation';\n\nexport type MDCTextFieldNativeInputElement =\n    Pick<HTMLInputElement, 'disabled'|'maxLength'|'type'|'value'|'required'>&{\n  validity: Pick<ValidityState, 'badInput'|'valid'>;\n};\n\nexport interface MDCTextFieldFoundationMap {\n  helperText: MDCTextFieldHelperTextFoundation;\n  characterCounter: MDCTextFieldCharacterCounterFoundation;\n  leadingIcon: MDCTextFieldIconFoundation;\n  trailingIcon: MDCTextFieldIconFoundation;\n}\n","/**\n * @license\n * Copyright 2020 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 {EventType, SpecificEventListener} from '@material/base/types';\n\nimport {CssClasses} from './constants';\n\n/**\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCTooltipAdapter {\n  /**\n   * @return the attribute string if present on the root element, null\n   * otherwise.\n   */\n  getAttribute(attr: string): string|null;\n\n  /**\n   * Sets an attribute on the root element.\n   */\n  setAttribute(attr: string, value: string): void;\n\n  /**\n   * Removes an attribute on the root element.\n   */\n  removeAttribute(attr: string): void;\n\n  /**\n   * Adds a class onto the root element.\n   */\n  addClass(className: CssClasses): void;\n\n  /**\n   * @return whether or not the root element has the provided className.\n   */\n  hasClass(className: CssClasses): boolean;\n\n  /**\n   * Removes a class from the root element.\n   */\n  removeClass(className: CssClasses): void;\n\n  /**\n   * @return the value of the given computed style property on the root element.\n   */\n  getComputedStyleProperty(propertyName: string): string;\n\n  /**\n   * Sets the property value of the given style property on the root element.\n   */\n  setStyleProperty(propertyName: string, value: string): void;\n\n  /**\n   * Sets the property value of the given style property on the tooltip's\n   * surface-animation element (indicated by the\n   * \"mdc-tooltip__surface-animation\" class).\n   */\n  setSurfaceAnimationStyleProperty(propertyName: string, value: string): void;\n\n  /**\n   * @return the width of the viewport.\n   */\n  getViewportWidth(): number;\n\n  /**\n   * @return the height of the viewport.\n   */\n  getViewportHeight(): number;\n\n  /**\n   * @return the width and height of the tooltip element.\n   */\n  getTooltipSize(): {width: number, height: number};\n\n  /**\n   * @return the DOMRect for the anchor element.\n   */\n  getAnchorBoundingRect(): DOMRect|null;\n\n  /**\n   * @return the DOMRect for the parent of the tooltip element.\n   */\n  getParentBoundingRect(): DOMRect|null;\n\n  /**\n   * @return the attribute string if present on the anchor element, null\n   * otherwise.\n   */\n  getAnchorAttribute(attr: string): string|null;\n\n  /**\n   * Sets an attribute on the anchor element.\n   */\n  setAnchorAttribute(attr: string, value: string): void;\n\n  /**\n   * @return true if the text direction is right-to-left.\n   */\n  isRTL(): boolean;\n\n  /**\n   * Checks if element is contained within the anchor element.\n   */\n  anchorContainsElement(element: Element): boolean;\n\n  /**\n   * Checks if element is contained within the tooltip element.\n   */\n  tooltipContainsElement(element: Element): boolean;\n\n  /**\n   * Sets focus on the anchor element.\n   */\n  focusAnchorElement(): void;\n\n  /**\n   * Registers an event listener to the root element.\n   */\n  registerEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener to the root element.\n   */\n  deregisterEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Registers an event listener to the anchor element.\n   */\n  registerAnchorEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener to the anchor element.\n   */\n  deregisterAnchorEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Registers an event listener to the document body.\n   */\n  registerDocumentEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener to the document body.\n   */\n  deregisterDocumentEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Registers an event listener to the window.\n   */\n  registerWindowEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Deregisters an event listener to the window.\n   */\n  deregisterWindowEventHandler<K extends EventType>(\n      eventType: K, handler: SpecificEventListener<K>): void;\n\n  /**\n   * Notification that the tooltip element has been fully hidden. Typically used\n   * to wait for the hide animation to complete.\n   */\n  notifyHidden(): void;\n\n  /**\n   * Notification that the tooltip element has been shown.\n   */\n  notifyShown(): void;\n\n  /**\n   * @return the DOMRect for the caret element.\n   */\n  getTooltipCaretBoundingRect(): DOMRect|null;\n\n  /**\n   * Sets the property value of the given style property on both the caret-top\n   * and caret-bottom elements.\n   */\n  setTooltipCaretStyle(propertyName: string, value: string): void;\n\n  /**\n   * Clears all inline styles set on the caret-top and caret-bottom elements.\n   */\n  clearTooltipCaretStyles(): void;\n\n  /**\n   * @return the active element of the document that owns the tooltip.\n   */\n  getActiveElement(): Element|null;\n\n  /**\n   * @return whether the provided object is an Element or not. This is\n   * required because Elements from iframes are typed differently.\n   */\n  isInstanceOfElement(eventTarget: EventTarget|null): boolean;\n}\n","/**\n * @license\n * Copyright 2020 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, SpecificEventListener} from '@material/base/types';\nimport {safeAttrPrefix} from 'safevalues';\nimport {safeElement} from 'safevalues/dom';\n\nimport {MDCTooltipAdapter} from './adapter';\nimport {AnchorBoundaryType, CssClasses, events, PositionWithCaret, XPosition, YPosition} from './constants';\nimport {MDCTooltipFoundation} from './foundation';\n\nconst ARIA_ATTR_PREFIX = [safeAttrPrefix`aria-`];\n\n/** MDC Tooltip */\nexport class MDCTooltip extends MDCComponent<MDCTooltipFoundation> {\n  static override attachTo(root: HTMLElement) {\n    return new MDCTooltip(root);\n  }\n\n  private anchorElem!: HTMLElement;       // assigned in initialize\n  private isTooltipRich!: boolean;        // assigned in initialSyncWithDOM\n  private isTooltipPersistent!: boolean;  // assigned in initialSyncWithDOM\n\n  private handleMouseEnter!: SpecificEventListener<'mouseenter'>;\n  private handleFocus!: SpecificEventListener<'focus'>;\n  private handleMouseLeave!: SpecificEventListener<'mouseleave'>;\n  private handleTransitionEnd!: SpecificEventListener<'transitionend'>;\n  private handleClick!: SpecificEventListener<'click'>;\n  private handleTouchstart!: SpecificEventListener<'touchstart'>;\n  private handleTouchend!: SpecificEventListener<'touchend'>;\n\n  override initialize() {\n    const tooltipId = this.root.getAttribute('id');\n    if (!tooltipId) {\n      throw new Error('MDCTooltip: Tooltip component must have an id.');\n    }\n\n    const anchorElem = document.querySelector<HTMLElement>(\n                           `[data-tooltip-id=\"${tooltipId}\"]`) ||\n        document.querySelector<HTMLElement>(\n            `[aria-describedby=\"${tooltipId}\"]`);\n    if (!anchorElem) {\n      throw new Error(\n          'MDCTooltip: Tooltip component requires an anchor element annotated with [aria-describedby] or [data-tooltip-id].');\n    }\n    this.anchorElem = anchorElem;\n  }\n\n  override initialSyncWithDOM() {\n    this.isTooltipRich = this.foundation.isRich();\n    this.isTooltipPersistent = this.foundation.isPersistent();\n\n    this.handleMouseEnter = () => {\n      this.foundation.handleAnchorMouseEnter();\n    };\n\n    this.handleFocus = (event) => {\n      this.foundation.handleAnchorFocus(event);\n    };\n\n    this.handleMouseLeave = () => {\n      this.foundation.handleAnchorMouseLeave();\n    };\n\n    this.handleTransitionEnd = () => {\n      this.foundation.handleTransitionEnd();\n    };\n\n    this.handleClick = () => {\n      this.foundation.handleAnchorClick();\n    };\n\n    this.handleTouchstart = () => {\n      this.foundation.handleAnchorTouchstart();\n    };\n\n    this.handleTouchend = () => {\n      this.foundation.handleAnchorTouchend();\n    };\n\n    if (this.isTooltipRich && this.isTooltipPersistent) {\n      this.anchorElem.addEventListener('click', this.handleClick);\n    } else {\n      this.anchorElem.addEventListener('mouseenter', this.handleMouseEnter);\n      // TODO(b/157075286): Listening for a 'focus' event is too broad.\n      this.anchorElem.addEventListener('focus', this.handleFocus);\n      this.anchorElem.addEventListener('mouseleave', this.handleMouseLeave);\n      this.anchorElem.addEventListener('touchstart', this.handleTouchstart);\n      this.anchorElem.addEventListener('touchend', this.handleTouchend);\n    }\n\n    this.listen('transitionend', this.handleTransitionEnd);\n  }\n\n  override destroy() {\n    if (this.anchorElem) {\n      if (this.isTooltipRich && this.isTooltipPersistent) {\n        this.anchorElem.removeEventListener('click', this.handleClick);\n      } else {\n        this.anchorElem.removeEventListener(\n            'mouseenter', this.handleMouseEnter);\n        this.anchorElem.removeEventListener('focus', this.handleFocus);\n        this.anchorElem.removeEventListener(\n            'mouseleave', this.handleMouseLeave);\n        this.anchorElem.removeEventListener(\n            'touchstart', this.handleTouchstart);\n        this.anchorElem.removeEventListener('touchend', this.handleTouchend);\n      }\n    }\n\n    this.unlisten('transitionend', this.handleTransitionEnd);\n    super.destroy();\n  }\n\n  setTooltipPosition(position: {\n    xPos?: XPosition,\n    yPos?: YPosition,\n    withCaretPos?: PositionWithCaret\n  }) {\n    this.foundation.setTooltipPosition(position);\n  }\n\n  setAnchorBoundaryType(type: AnchorBoundaryType) {\n    this.foundation.setAnchorBoundaryType(type);\n  }\n\n  setShowDelay(delayMs: number) {\n    this.foundation.setShowDelay(delayMs);\n  }\n\n  setHideDelay(delayMs: number) {\n    this.foundation.setHideDelay(delayMs);\n  }\n\n  hide() {\n    this.foundation.hide();\n  }\n\n  isShown() {\n    return this.foundation.isShown();\n  }\n\n  /**\n   * Method that allows user to specify additional elements that should have a\n   * scroll event listener attached to it. This should be used in instances\n   * where the anchor element is placed inside a scrollable container (that is\n   * not the body element), and will ensure that the tooltip will stay attached\n   * to the anchor on scroll.\n   */\n  attachScrollHandler(\n      addEventListenerFn: <K extends EventType>(\n          event: K, handler: SpecificEventListener<K>) => void) {\n    this.foundation.attachScrollHandler(addEventListenerFn);\n  }\n\n  /**\n   * Must be used in conjunction with #attachScrollHandler. Removes the scroll\n   * event handler from elements on the page.\n   */\n  removeScrollHandler(\n      removeEventHandlerFn: <K extends EventType>(\n          event: K, handler: SpecificEventListener<K>) => void) {\n    this.foundation.removeScrollHandler(removeEventHandlerFn);\n  }\n\n  override getDefaultFoundation() {\n    const adapter: MDCTooltipAdapter = {\n      getAttribute: (attr) => this.root.getAttribute(attr),\n      setAttribute: (attr, value) => {\n        safeElement.setPrefixedAttribute(\n            ARIA_ATTR_PREFIX, this.root, attr, value);\n      },\n      removeAttribute: (attr) => {\n        this.root.removeAttribute(attr);\n      },\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      hasClass: (className) => this.root.classList.contains(className),\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      getComputedStyleProperty: (propertyName) => {\n        return window.getComputedStyle(this.root).getPropertyValue(\n            propertyName);\n      },\n      setStyleProperty: (propertyName, value) => {\n        this.root.style.setProperty(propertyName, value);\n      },\n      setSurfaceAnimationStyleProperty: (propertyName, value) => {\n        const surface = this.root.querySelector<HTMLElement>(\n            `.${CssClasses.SURFACE_ANIMATION}`);\n        surface?.style.setProperty(propertyName, value);\n      },\n      getViewportWidth: () => window.innerWidth,\n      getViewportHeight: () => window.innerHeight,\n      getTooltipSize: () => {\n        return {width: this.root.offsetWidth, height: this.root.offsetHeight};\n      },\n      getAnchorBoundingRect: () => {\n        return this.anchorElem ? this.anchorElem.getBoundingClientRect() : null;\n      },\n      getParentBoundingRect: () => {\n        return this.root.parentElement?.getBoundingClientRect() ?? null;\n      },\n      getAnchorAttribute: (attr) => {\n        return this.anchorElem ? this.anchorElem.getAttribute(attr) : null;\n      },\n      setAnchorAttribute: (attr, value) => {\n        if (this.anchorElem) {\n          safeElement.setPrefixedAttribute(\n              ARIA_ATTR_PREFIX, this.anchorElem, attr, value);\n        }\n      },\n      isRTL: () => getComputedStyle(this.root).direction === 'rtl',\n      anchorContainsElement: (element) => {\n        return !!this.anchorElem?.contains(element);\n      },\n      tooltipContainsElement: (element) => {\n        return this.root.contains(element);\n      },\n      focusAnchorElement: () => {\n        this.anchorElem?.focus();\n      },\n      registerEventHandler: (event, handler) => {\n        if (this.root instanceof HTMLElement) {\n          this.root.addEventListener(event, handler);\n        }\n      },\n      deregisterEventHandler: (event, handler) => {\n        if (this.root instanceof HTMLElement) {\n          this.root.removeEventListener(event, handler);\n        }\n      },\n      registerAnchorEventHandler: (event, handler) => {\n        this.anchorElem?.addEventListener(event, handler);\n      },\n      deregisterAnchorEventHandler: (event, handler) => {\n        this.anchorElem?.removeEventListener(event, handler);\n      },\n      registerDocumentEventHandler: (event, handler) => {\n        document.body.addEventListener(event, handler);\n      },\n      deregisterDocumentEventHandler: (event, handler) => {\n        document.body.removeEventListener(event, handler);\n      },\n      registerWindowEventHandler: (event, handler) => {\n        window.addEventListener(event, handler);\n      },\n      deregisterWindowEventHandler: (event, handler) => {\n        window.removeEventListener(event, handler);\n      },\n      notifyHidden: () => {\n        this.emit(events.HIDDEN, {});\n      },\n      notifyShown: () => {\n        this.emit(events.SHOWN, {});\n      },\n      getTooltipCaretBoundingRect: () => {\n        const caret = this.root.querySelector<HTMLElement>(\n            `.${CssClasses.TOOLTIP_CARET_TOP}`);\n        if (!caret) {\n          return null;\n        }\n        return caret.getBoundingClientRect();\n      },\n      setTooltipCaretStyle: (propertyName, value) => {\n        const topCaret = this.root.querySelector<HTMLElement>(\n            `.${CssClasses.TOOLTIP_CARET_TOP}`);\n        const bottomCaret = this.root.querySelector<HTMLElement>(\n            `.${CssClasses.TOOLTIP_CARET_BOTTOM}`);\n\n        if (!topCaret || !bottomCaret) {\n          return;\n        }\n\n        topCaret.style.setProperty(propertyName, value);\n        bottomCaret.style.setProperty(propertyName, value);\n      },\n      clearTooltipCaretStyles: () => {\n        const topCaret = this.root.querySelector<HTMLElement>(\n            `.${CssClasses.TOOLTIP_CARET_TOP}`);\n        const bottomCaret = this.root.querySelector<HTMLElement>(\n            `.${CssClasses.TOOLTIP_CARET_BOTTOM}`);\n\n        if (!topCaret || !bottomCaret) {\n          return;\n        }\n        topCaret.removeAttribute('style');\n        bottomCaret.removeAttribute('style');\n      },\n      getActiveElement: () => {\n        return document.activeElement;\n      },\n      isInstanceOfElement: (eventTarget: EventTarget) => {\n        return eventTarget instanceof Element;\n      },\n    };\n\n    //tslint:enable:object-literal-sort-keys\n    return new MDCTooltipFoundation(adapter);\n  }\n}\n","/**\n * @license\n * Copyright 2020 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\nenum CssClasses {\n  RICH = 'mdc-tooltip--rich',\n  SHOWN = 'mdc-tooltip--shown',\n  SHOWING = 'mdc-tooltip--showing',\n  SHOWING_TRANSITION = 'mdc-tooltip--showing-transition',\n  HIDE = 'mdc-tooltip--hide',\n  HIDE_TRANSITION = 'mdc-tooltip--hide-transition',\n  MULTILINE_TOOLTIP = 'mdc-tooltip--multiline',\n  SURFACE = 'mdc-tooltip__surface',\n  SURFACE_ANIMATION = 'mdc-tooltip__surface-animation',\n  TOOLTIP_CARET_TOP = 'mdc-tooltip__caret-surface-top',\n  TOOLTIP_CARET_BOTTOM = 'mdc-tooltip__caret-surface-bottom',\n}\n\nconst numbers = {\n  BOUNDED_ANCHOR_GAP: 4,\n  UNBOUNDED_ANCHOR_GAP: 8,\n  MIN_VIEWPORT_TOOLTIP_THRESHOLD: 8,\n  HIDE_DELAY_MS: 600,\n  SHOW_DELAY_MS: 500,\n  // LINT.IfChange(tooltip-dimensions)\n  MIN_WIDTH: 40,\n  MIN_HEIGHT: 24,\n  MAX_WIDTH: 200,\n  // LINT.ThenChange(_tooltip.scss:tooltip-dimensions)\n  CARET_INDENTATION: 24,\n  // LINT.IfChange(tooltip-anim-scale)\n  ANIMATION_SCALE: 0.8,\n  // LINT.ThenChange(_tooltip.scss:tooltip-anim-scale)\n  // LINT.IfChange(rich-tooltip-dimensions)\n  RICH_MAX_WIDTH: 320,\n  // LINT.ThenChange(_tooltip.scss:rich-tooltip-dimensions)\n};\n\nconst attributes = {\n  ARIA_EXPANDED: 'aria-expanded',\n  ARIA_HASPOPUP: 'aria-haspopup',\n  PERSISTENT: 'data-mdc-tooltip-persistent',\n  SCROLLABLE_ANCESTOR: 'tooltip-scrollable-ancestor',\n  HAS_CARET: 'data-mdc-tooltip-has-caret',\n};\n\nconst events = {\n  HIDDEN: 'MDCTooltip:hidden',\n  SHOWN: 'MDCTooltip:shown',\n};\n\n/** Enum for possible tooltip positioning relative to its anchor element. */\nenum XPosition {\n  DETECTED = 0,\n  START = 1,\n  // Note: CENTER is not valid for rich tooltips.\n  CENTER = 2,\n  END = 3,\n  // SIDE_XXX positioning is only valid for plain tooltips.\n  SIDE_START = 4,\n  SIDE_END = 5,\n}\n\nenum YPosition {\n  DETECTED = 0,\n  ABOVE = 1,\n  BELOW = 2,\n  // SIDE positioning is only valid for plain tooltips with either SIDE_START or\n  // SIDE_END x positioning.\n  SIDE = 3,\n}\n\n/**\n * Enum for possible anchor boundary types. This determines the gap between the\n * bottom of the anchor and the tooltip element.\n * Bounded anchors have an identifiable boundary (e.g. buttons).\n * Unbounded anchors don't have a visually declared boundary (e.g. plain text).\n */\nenum AnchorBoundaryType {\n  BOUNDED = 0,\n  UNBOUNDED = 1,\n}\n\nconst strings = {\n  LEFT: 'left',\n  RIGHT: 'right',\n  CENTER: 'center',\n  TOP: 'top',\n  BOTTOM: 'bottom'\n};\n\n/**\n * Enum for possible positions of a tooltip with caret (this specifies the\n * positioning of the tooltip relative to the anchor -- the position of the\n * caret will follow that of the tooltip). This can NOT be combined with the\n * above X/YPosition options. Naming for the enums follows: (vertical\n * placement)_(horizontal placement).\n */\nenum PositionWithCaret {\n  DETECTED = 0,\n\n  ABOVE_START = 1,\n  ABOVE_CENTER = 2,\n  ABOVE_END = 3,\n\n  TOP_SIDE_START = 4,\n  CENTER_SIDE_START = 5,\n  BOTTOM_SIDE_START = 6,\n\n  TOP_SIDE_END = 7,\n  CENTER_SIDE_END = 8,\n  BOTTOM_SIDE_END = 9,\n\n  BELOW_START = 10,\n  BELOW_CENTER = 11,\n  BELOW_END = 12,\n}\n\nenum YPositionWithCaret {\n  ABOVE = 1,\n  BELOW = 2,\n  SIDE_TOP = 3,\n  SIDE_CENTER = 4,\n  SIDE_BOTTOM = 5,\n}\n\nenum XPositionWithCaret {\n  START = 1,\n  CENTER = 2,\n  END = 3,\n  SIDE_START = 4,\n  SIDE_END = 5,\n}\n\nexport {\n  CssClasses,\n  numbers,\n  attributes,\n  events,\n  XPosition,\n  AnchorBoundaryType,\n  YPosition,\n  strings,\n  PositionWithCaret,\n  YPositionWithCaret,\n  XPositionWithCaret\n};\n","/**\n * @license\n * Copyright 2020 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 {AnimationFrame} from '@material/animation/animationframe';\nimport {getCorrectPropertyName} from '@material/animation/util';\nimport {MDCFoundation} from '@material/base/foundation';\nimport {EventType, SpecificEventListener} from '@material/base/types';\nimport {KEY, normalizeKey} from '@material/dom/keyboard';\n\nimport {MDCTooltipAdapter} from './adapter';\nimport {AnchorBoundaryType, attributes, CssClasses, numbers, PositionWithCaret, strings, XPosition, XPositionWithCaret, YPosition, YPositionWithCaret} from './constants';\n\nconst {\n  RICH,\n  SHOWN,\n  SHOWING,\n  SHOWING_TRANSITION,\n  HIDE,\n  HIDE_TRANSITION,\n  MULTILINE_TOOLTIP\n} = CssClasses;\n\nenum AnimationKeys {\n  POLL_ANCHOR = 'poll_anchor'\n}\n\n// Accessing `window` without a `typeof` check will throw on Node environments.\nconst HAS_WINDOW = typeof window !== 'undefined';\n\n/** MDC Tooltip Foundation */\nexport class MDCTooltipFoundation extends MDCFoundation<MDCTooltipAdapter> {\n  static override get defaultAdapter(): MDCTooltipAdapter {\n    return {\n      getAttribute: () => null,\n      setAttribute: () => undefined,\n      removeAttribute: () => undefined,\n      addClass: () => undefined,\n      hasClass: () => false,\n      removeClass: () => undefined,\n      getComputedStyleProperty: () => '',\n      setStyleProperty: () => undefined,\n      setSurfaceAnimationStyleProperty: () => undefined,\n      getViewportWidth: () => 0,\n      getViewportHeight: () => 0,\n      getTooltipSize: () => ({width: 0, height: 0}),\n      getAnchorBoundingRect: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\n      getParentBoundingRect: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\n      getAnchorAttribute: () => null,\n      setAnchorAttribute: () => null,\n      isRTL: () => false,\n      anchorContainsElement: () => false,\n      tooltipContainsElement: () => false,\n      focusAnchorElement: () => undefined,\n      registerEventHandler: () => undefined,\n      deregisterEventHandler: () => undefined,\n      registerAnchorEventHandler: () => undefined,\n      deregisterAnchorEventHandler: () => undefined,\n      registerDocumentEventHandler: () => undefined,\n      deregisterDocumentEventHandler: () => undefined,\n      registerWindowEventHandler: () => undefined,\n      deregisterWindowEventHandler: () => undefined,\n      notifyHidden: () => undefined,\n      notifyShown: () => undefined,\n      getTooltipCaretBoundingRect: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\n      setTooltipCaretStyle: () => undefined,\n      clearTooltipCaretStyles: () => undefined,\n      getActiveElement: () => null,\n      isInstanceOfElement: () => false,\n    };\n  }\n\n  private interactiveTooltip!: boolean;  // assigned in init()\n  private richTooltip!: boolean;         // assigned in init()\n  private persistentTooltip!: boolean;   // assigned in init()\n  private hasCaret!: boolean;            // assigned in init()\n  private tooltipShown = false;\n  private anchorGap = numbers.BOUNDED_ANCHOR_GAP;\n  private xTooltipPos = XPosition.DETECTED;\n  private yTooltipPos = YPosition.DETECTED;\n  private tooltipPositionWithCaret = PositionWithCaret.DETECTED;\n  // Minimum threshold distance needed between the tooltip and the viewport.\n  private readonly minViewportTooltipThreshold =\n      numbers.MIN_VIEWPORT_TOOLTIP_THRESHOLD;\n  private hideDelayMs = numbers.HIDE_DELAY_MS;\n  private showDelayMs = numbers.SHOW_DELAY_MS;\n\n  private anchorRect: DOMRect|null = null;\n  private parentRect: DOMRect|null = null;\n  private frameId: number|null = null;\n  private hideTimeout: number|null = null;\n  private showTimeout: number|null = null;\n  private readonly animFrame: AnimationFrame;\n  private readonly anchorBlurHandler: SpecificEventListener<'blur'>;\n  private readonly documentClickHandler: SpecificEventListener<'click'>;\n  private readonly documentKeydownHandler: SpecificEventListener<'keydown'>;\n  private readonly tooltipMouseEnterHandler:\n      SpecificEventListener<'mouseenter'>;\n  private readonly tooltipMouseLeaveHandler:\n      SpecificEventListener<'mouseleave'>;\n  private readonly richTooltipFocusOutHandler:\n      SpecificEventListener<'focusout'>;\n  private readonly windowScrollHandler: SpecificEventListener<'scroll'>;\n  private readonly windowResizeHandler: SpecificEventListener<'resize'>;\n\n  private readonly addAncestorScrollEventListeners = new Array<() => void>();\n  private readonly removeAncestorScrollEventListeners = new Array<() => void>();\n\n  constructor(adapter?: Partial<MDCTooltipAdapter>) {\n    super({...MDCTooltipFoundation.defaultAdapter, ...adapter});\n    this.animFrame = new AnimationFrame();\n\n    this.anchorBlurHandler = (event) => {\n      this.handleAnchorBlur(event);\n    };\n\n    this.documentClickHandler = (event) => {\n      this.handleDocumentClick(event);\n    };\n\n    this.documentKeydownHandler = (event) => {\n      this.handleKeydown(event);\n    };\n\n    this.tooltipMouseEnterHandler = () => {\n      this.handleTooltipMouseEnter();\n    };\n\n    this.tooltipMouseLeaveHandler = () => {\n      this.handleTooltipMouseLeave();\n    };\n\n    this.richTooltipFocusOutHandler = (event) => {\n      this.handleRichTooltipFocusOut(event);\n    };\n\n    this.windowScrollHandler = () => {\n      this.handleWindowScrollEvent();\n    };\n\n    this.windowResizeHandler = () => {\n      this.handleWindowChangeEvent();\n    };\n  }\n\n  override init() {\n    this.richTooltip = this.adapter.hasClass(RICH);\n    this.persistentTooltip =\n        this.adapter.getAttribute(attributes.PERSISTENT) === 'true';\n    this.interactiveTooltip =\n        !!this.adapter.getAnchorAttribute(attributes.ARIA_EXPANDED) &&\n        this.adapter.getAnchorAttribute(attributes.ARIA_HASPOPUP) === 'dialog';\n    this.hasCaret = this.richTooltip &&\n        this.adapter.getAttribute(attributes.HAS_CARET) === 'true';\n  }\n\n  isShown() {\n    return this.tooltipShown;\n  }\n\n  isRich() {\n    return this.richTooltip;\n  }\n\n  isPersistent() {\n    return this.persistentTooltip;\n  }\n\n  handleAnchorMouseEnter() {\n    if (this.tooltipShown) {\n      // Covers the instance where a user hovers over the anchor to reveal the\n      // tooltip, and then quickly navigates away and then back to the anchor.\n      // The tooltip should stay visible without animating out and then back in\n      // again.\n      this.show();\n    } else {\n      // clearHideTimeout here since handleAnchorMouseLeave sets a hideTimeout\n      // and that can execute before the showTimeout executes, resulting in hide\n      // being called and the showTimeout set below to be cleared.\n      this.clearHideTimeout();\n      this.showTimeout = setTimeout(() => {\n        this.show();\n      }, this.showDelayMs);\n    }\n  }\n\n  handleAnchorTouchstart() {\n    this.showTimeout = setTimeout(() => {\n      this.show();\n    }, this.showDelayMs);\n    // Prevent a context menu from appearing if user is long-pressing on a\n    // tooltip anchor.\n    this.adapter.registerWindowEventHandler(\n        'contextmenu', this.preventContextMenuOnLongTouch);\n  }\n\n  private preventContextMenuOnLongTouch(event: MouseEvent) {\n    event.preventDefault();\n  }\n\n  /**\n   * Helper methods for determining if the event target or related target\n   * is contained inside the tooltip or the anchor. These methods are used to\n   * determing when a tooltip should be closed of left open on blur and click\n   * events.\n   */\n  private tooltipContainsRelatedTargetElement(target: EventTarget|\n                                              null): boolean {\n    return this.adapter.isInstanceOfElement(target) &&\n        this.adapter.tooltipContainsElement((target as Element));\n  }\n\n  private anchorOrTooltipContainsTargetElement(target: EventTarget|\n                                               null): boolean {\n    return this.adapter.isInstanceOfElement(target) &&\n        (this.adapter.tooltipContainsElement((target as Element)) ||\n         this.adapter.anchorContainsElement((target as Element)));\n  }\n\n  handleAnchorTouchend() {\n    this.clearShowTimeout();\n\n    // Only remove the 'contextmenu' listener if the tooltip is not shown. When\n    // the tooltip *is* shown, listener is removed in the close method.\n    if (!this.isShown()) {\n      this.adapter.deregisterWindowEventHandler(\n          'contextmenu', this.preventContextMenuOnLongTouch);\n    }\n  }\n\n  handleAnchorFocus(event: FocusEvent) {\n    // TODO(b/157075286): Need to add some way to distinguish keyboard\n    // navigation focus events from other focus events, and only show the\n    // tooltip on the former of these events.\n\n    // Do not show tooltip if the previous focus was on a tooltip element. This\n    // occurs when a rich tooltip is closed and focus is restored to the anchor\n    // or when user tab-navigates back into the anchor from the rich tooltip.\n    if (this.tooltipContainsRelatedTargetElement(event.relatedTarget)) {\n      return;\n    }\n    this.showTimeout = setTimeout(() => {\n      this.show();\n    }, this.showDelayMs);\n  }\n\n  handleAnchorMouseLeave() {\n    this.clearShowTimeout();\n    this.hideTimeout = setTimeout(() => {\n      this.hide();\n    }, this.hideDelayMs);\n  }\n\n  handleAnchorClick() {\n    if (this.tooltipShown) {\n      this.hide();\n    } else {\n      this.show();\n    }\n  }\n\n  handleDocumentClick(event: MouseEvent) {\n    // For persistent rich tooltips, we will not hide if:\n    // - The click target is within the anchor element. Otherwise, both\n    //   the anchor element's click handler and this handler will handle the\n    //   click (due to event propagation), resulting in a shown tooltip\n    //   being immediately hidden if the tooltip was initially hidden.\n    // - The click target is within the tooltip element, since clicks\n    //   on the tooltip do not close the tooltip.\n    if (this.richTooltip && this.persistentTooltip &&\n        this.anchorOrTooltipContainsTargetElement(event.target)) {\n      return;\n    }\n    // Hide the tooltip immediately on click.\n    this.hide();\n  }\n\n  handleKeydown(event: KeyboardEvent) {\n    // Hide the tooltip immediately on ESC key.\n    const key = normalizeKey(event);\n    if (key === KEY.ESCAPE) {\n      const activeElement = this.adapter.getActiveElement();\n      let tooltipContainsActiveElement = false;\n      if (this.adapter.isInstanceOfElement(activeElement)) {\n        tooltipContainsActiveElement =\n            this.adapter.tooltipContainsElement((activeElement as Element));\n      }\n\n      if (tooltipContainsActiveElement) {\n        this.adapter.focusAnchorElement();\n      }\n      this.hide();\n      // prevent event from bubbling\n      event.stopPropagation();\n      return false;\n    }\n    return true;\n  }\n\n  private handleAnchorBlur(event: FocusEvent) {\n    if (this.richTooltip) {\n      if (event.relatedTarget === null ||\n          this.tooltipContainsRelatedTargetElement(event.relatedTarget)) {\n        // There are two scenarios where a blur event on a rich tooltip anchor\n        // should leave the tooltip open.\n        // 1. When the `event.relatedTarget` contains the tooltip element. This\n        // indicates that focus has moved off the anchor and onto the tooltip.\n        // 2. When the `event.relatedTarget` is null. This occurs because focus is\n        // moving to an element that is not focusable. This should only occur in\n        // instances of a screen reader in browse mode/linear navigation mode.\n        // We allow linear navigation over the contents of all rich tooltips to\n        // enable clients to hear a line-by-line reading of the tooltip's\n        // content.\n        return;\n      }\n    }\n    // Hide tooltip immediately on focus change.\n    this.hide();\n  }\n\n  private handleTooltipMouseEnter() {\n    this.show();\n  }\n\n  private handleTooltipMouseLeave() {\n    this.clearShowTimeout();\n    this.hideTimeout = setTimeout(() => {\n      this.hide();\n    }, this.hideDelayMs);\n  }\n\n  private handleRichTooltipFocusOut(event: FocusEvent) {\n    // If the focus is still within the anchor or the tooltip, do not hide the\n    // tooltip.\n    if (this.anchorOrTooltipContainsTargetElement(event.relatedTarget)) {\n      return;\n    }\n    if (event.relatedTarget === null && this.interactiveTooltip) {\n      // If event.relatedTarget is null, it is because focus is moving to an\n      // element that is not focusable. This should only occur in instances\n      // of a screen reader in browse mode/linear navigation mode. If the\n      // tooltip is interactive (and so the entire content is not read by\n      // the screen reader upon the tooltip being opened), we want to allow\n      // users to read the content of the tooltip (and not just the focusable\n      // elements).\n      return;\n    }\n\n    this.hide();\n  }\n\n  private handleWindowScrollEvent() {\n    if (!this.persistentTooltip) {\n      this.hide();\n    }\n  }\n\n  /**\n   * On window resize or scroll, check the anchor position and size and\n   * repostion tooltip if necessary.\n   */\n  private handleWindowChangeEvent() {\n    // Since scroll and resize events can fire at a high rate, we throttle\n    // the potential re-positioning of tooltip component using\n    // requestAnimationFrame.\n    this.animFrame.request(AnimationKeys.POLL_ANCHOR, () => {\n      this.repositionTooltipOnAnchorMove();\n    });\n  }\n\n  show() {\n    this.clearHideTimeout();\n    this.clearShowTimeout();\n\n    if (this.tooltipShown) {\n      return;\n    }\n\n    this.tooltipShown = true;\n    this.adapter.removeAttribute('aria-hidden');\n\n    if (this.richTooltip) {\n      if (this.interactiveTooltip) {\n        this.adapter.setAnchorAttribute('aria-expanded', 'true');\n      }\n      this.adapter.registerEventHandler(\n          'focusout', this.richTooltipFocusOutHandler);\n    }\n\n    if (!this.persistentTooltip) {\n      this.adapter.registerEventHandler(\n          'mouseenter', this.tooltipMouseEnterHandler);\n      this.adapter.registerEventHandler(\n          'mouseleave', this.tooltipMouseLeaveHandler);\n    }\n\n    this.adapter.removeClass(HIDE);\n    this.adapter.addClass(SHOWING);\n    if (this.isTooltipMultiline() && !this.richTooltip) {\n      this.adapter.addClass(MULTILINE_TOOLTIP);\n    }\n    this.anchorRect = this.adapter.getAnchorBoundingRect();\n    this.parentRect = this.adapter.getParentBoundingRect();\n    this.richTooltip ? this.positionRichTooltip() : this.positionPlainTooltip();\n    this.adapter.registerAnchorEventHandler('blur', this.anchorBlurHandler);\n    this.adapter.registerDocumentEventHandler(\n        'click', this.documentClickHandler);\n    this.adapter.registerDocumentEventHandler(\n        'keydown', this.documentKeydownHandler);\n\n    this.adapter.registerWindowEventHandler('scroll', this.windowScrollHandler);\n    this.adapter.registerWindowEventHandler('resize', this.windowResizeHandler);\n    // Register any additional scroll handlers\n    for (const fn of this.addAncestorScrollEventListeners) {\n      fn();\n    }\n\n    this.frameId = requestAnimationFrame(() => {\n      this.clearAllAnimationClasses();\n      this.adapter.addClass(SHOWN);\n      this.adapter.addClass(SHOWING_TRANSITION);\n    });\n  }\n\n  hide() {\n    this.clearHideTimeout();\n    this.clearShowTimeout();\n\n    if (!this.tooltipShown) {\n      return;\n    }\n\n    if (this.frameId) {\n      cancelAnimationFrame(this.frameId);\n    }\n\n    this.tooltipShown = false;\n    this.adapter.setAttribute('aria-hidden', 'true');\n    this.adapter.deregisterEventHandler(\n        'focusout', this.richTooltipFocusOutHandler);\n    if (this.richTooltip) {\n      if (this.interactiveTooltip) {\n        this.adapter.setAnchorAttribute('aria-expanded', 'false');\n      }\n    }\n\n    if (!this.persistentTooltip) {\n      this.adapter.deregisterEventHandler(\n          'mouseenter', this.tooltipMouseEnterHandler);\n      this.adapter.deregisterEventHandler(\n          'mouseleave', this.tooltipMouseLeaveHandler);\n    }\n\n    this.clearAllAnimationClasses();\n    this.adapter.addClass(HIDE);\n    this.adapter.addClass(HIDE_TRANSITION);\n    this.adapter.removeClass(SHOWN);\n\n    this.adapter.deregisterAnchorEventHandler('blur', this.anchorBlurHandler);\n    this.adapter.deregisterDocumentEventHandler(\n        'click', this.documentClickHandler);\n    this.adapter.deregisterDocumentEventHandler(\n        'keydown', this.documentKeydownHandler);\n    this.adapter.deregisterWindowEventHandler(\n        'scroll', this.windowScrollHandler);\n    this.adapter.deregisterWindowEventHandler(\n        'resize', this.windowResizeHandler);\n    this.adapter.deregisterWindowEventHandler(\n        'contextmenu', this.preventContextMenuOnLongTouch);\n\n    // Deregister any additional scroll handlers\n    for (const fn of this.removeAncestorScrollEventListeners) {\n      fn();\n    }\n  }\n\n  handleTransitionEnd() {\n    const isHidingTooltip = this.adapter.hasClass(HIDE);\n\n    this.adapter.removeClass(SHOWING);\n    this.adapter.removeClass(SHOWING_TRANSITION);\n    this.adapter.removeClass(HIDE);\n    this.adapter.removeClass(HIDE_TRANSITION);\n\n    // If handleTransitionEnd is called after hiding the tooltip, the tooltip\n    // will have the HIDE class (before calling the adapter removeClass method).\n    // If tooltip is now hidden, send a notification that the animation has\n    // completed and the tooltip is no longer visible.\n    // We don't send a notification of the animation completing if a showTimeout\n    // value is set -- this happens when a user triggers a tooltip to be shown\n    // while that tooltip is fading. Once this hide transition is completed,\n    // that same tooltip will be re-shown.\n    if (isHidingTooltip && this.showTimeout === null) {\n      this.adapter.notifyHidden();\n    } else if (!isHidingTooltip) {\n      this.adapter.notifyShown();\n    }\n  }\n\n  private clearAllAnimationClasses() {\n    this.adapter.removeClass(SHOWING_TRANSITION);\n    this.adapter.removeClass(HIDE_TRANSITION);\n  }\n\n  setTooltipPosition(position: {\n    xPos?: XPosition,\n    yPos?: YPosition,\n    withCaretPos?: PositionWithCaret\n  }) {\n    const {xPos, yPos, withCaretPos} = position;\n    if (this.hasCaret && withCaretPos) {\n      this.tooltipPositionWithCaret = withCaretPos;\n      return;\n    }\n\n    if (xPos) {\n      this.xTooltipPos = xPos;\n    }\n\n    if (yPos) {\n      this.yTooltipPos = yPos;\n    }\n  }\n\n  setAnchorBoundaryType(type: AnchorBoundaryType) {\n    if (type === AnchorBoundaryType.UNBOUNDED) {\n      this.anchorGap = numbers.UNBOUNDED_ANCHOR_GAP;\n    } else {\n      this.anchorGap = numbers.BOUNDED_ANCHOR_GAP;\n    }\n  }\n\n  setShowDelay(delayMs: number) {\n    this.showDelayMs = delayMs;\n  }\n\n  setHideDelay(delayMs: number) {\n    this.hideDelayMs = delayMs;\n  }\n\n  private isTooltipMultiline() {\n    const tooltipSize = this.adapter.getTooltipSize();\n    return tooltipSize.height > numbers.MIN_HEIGHT &&\n        tooltipSize.width >= numbers.MAX_WIDTH;\n  }\n\n  private positionPlainTooltip() {\n    // A plain tooltip has `fixed` positioning and is placed as an immediate\n    // child of the document body. Its positioning is calculated with respect to\n    // the viewport.\n    const {top, yTransformOrigin, left, xTransformOrigin} =\n        this.calculateTooltipStyles(this.anchorRect);\n\n    const transformProperty =\n        HAS_WINDOW ? getCorrectPropertyName(window, 'transform') : 'transform';\n    this.adapter.setSurfaceAnimationStyleProperty(\n        `${transformProperty}-origin`,\n        `${xTransformOrigin} ${yTransformOrigin}`);\n    this.adapter.setStyleProperty('top', `${top}px`);\n    this.adapter.setStyleProperty('left', `${left}px`);\n  }\n\n  private positionRichTooltip() {\n    // TODO(b/177686782): Remove width setting when max-content is used to style\n    // the rich tooltip.\n\n    // Reset rich tooltip positioning/styling so we can get an accurate\n    // measurement of the rich tooltip width. Toolip has to be moved to the left\n    // to ensure that the parent component does not restrict the size of the\n    // tooltip. See b/245915536 for more info.\n    this.adapter.setStyleProperty('width', '');\n    this.adapter.setStyleProperty('left', `-${numbers.RICH_MAX_WIDTH}px`);\n    // getComputedStyleProperty is used instead of getTooltipSize since\n    // getTooltipSize returns the offSetWidth, which includes the border and\n    // padding. What we need is the width of the tooltip without border and\n    // padding.\n    const computedWidth =\n        Number(this.adapter.getComputedStyleProperty('width').slice(0, -2));\n    const widthNum =\n        isFinite(computedWidth) ? computedWidth : numbers.RICH_MAX_WIDTH;\n    const viewportWidth = Math.max(\n        this.adapter.getViewportWidth() -\n            (2 * numbers.MIN_VIEWPORT_TOOLTIP_THRESHOLD),\n        numbers.MIN_WIDTH);\n    // Tooltip width is the minimum of the tooltip's computed width (which is\n    // dictated by the content inside the tooltip) and the viewport width.\n    // See b/261878540 for more info.\n    const tooltipWidth = Math.min(viewportWidth, widthNum);\n    // When rich tooltips are positioned within their parent containers, the\n    // tooltip width might be shrunk if it collides with the edge of the parent\n    // container. We set the width of the tooltip to prevent this.\n    this.adapter.setStyleProperty('width', `${tooltipWidth}px`);\n\n    const {top, yTransformOrigin, left, xTransformOrigin} = this.hasCaret ?\n        this.calculateTooltipWithCaretStyles(this.anchorRect) :\n        this.calculateTooltipStyles(this.anchorRect);\n\n    const transformProperty =\n        HAS_WINDOW ? getCorrectPropertyName(window, 'transform') : 'transform';\n    this.adapter.setSurfaceAnimationStyleProperty(\n        `${transformProperty}-origin`,\n        `${xTransformOrigin} ${yTransformOrigin}`);\n    // A rich tooltip has `absolute` positioning and is placed as a sibling to\n    // the anchor element. Its positioning is calculated with respect to the\n    // parent element, and so the values need to be adjusted against the parent\n    // element.\n    const leftAdjustment = left - (this.parentRect?.left ?? 0);\n    const topAdjustment = top - (this.parentRect?.top ?? 0);\n    this.adapter.setStyleProperty('top', `${topAdjustment}px`);\n    this.adapter.setStyleProperty('left', `${leftAdjustment}px`);\n  }\n\n  /**\n   * Calculates the position of the tooltip. A tooltip will be placed\n   * beneath the anchor element and aligned either with the 'start'/'end'\n   * edge of the anchor element or the 'center'.\n   *\n   * Tooltip alignment is selected such that the tooltip maintains a\n   * threshold distance away from the viewport (defaulting to 'center'\n   * alignment). If the placement of the anchor prevents this threshold\n   * distance from being maintained, the tooltip is positioned so that it\n   * does not collide with the viewport.\n   *\n   * Users can specify an alignment, however, if this alignment results in\n   * the tooltip colliding with the viewport, this specification is\n   * overwritten.\n   */\n  private calculateTooltipStyles(anchorRect: DOMRect|null) {\n    if (!anchorRect) {\n      return {top: 0, left: 0};\n    }\n\n    const tooltipSize = this.adapter.getTooltipSize();\n    const top = this.calculateYTooltipDistance(anchorRect, tooltipSize.height);\n    const left = this.calculateXTooltipDistance(anchorRect, tooltipSize.width);\n\n    return {\n      top: top.distance,\n      yTransformOrigin: top.yTransformOrigin,\n      left: left.distance,\n      xTransformOrigin: left.xTransformOrigin\n    };\n  }\n\n  /**\n   * Calculates the `left` distance for the tooltip.\n   * Returns the distance value and a string indicating the x-axis transform-\n   * origin that should be used when animating the tooltip.\n   */\n  private calculateXTooltipDistance(anchorRect: DOMRect, tooltipWidth: number):\n      ({distance: number, xTransformOrigin: string}) {\n    const isLTR = !this.adapter.isRTL();\n    let startPos: number|undefined, endPos: number|undefined,\n        centerPos: number|undefined, sideStartPos: number|undefined,\n        sideEndPos: number|undefined;\n    let startTransformOrigin: string, endTransformOrigin: string;\n    if (this.richTooltip) {\n      startPos = isLTR ? anchorRect.left - tooltipWidth : anchorRect.right;\n      endPos = isLTR ? anchorRect.right : anchorRect.left - tooltipWidth;\n\n      startTransformOrigin = isLTR ? strings.RIGHT : strings.LEFT;\n      endTransformOrigin = isLTR ? strings.LEFT : strings.RIGHT;\n    } else {\n      startPos = isLTR ? anchorRect.left : anchorRect.right - tooltipWidth;\n      endPos = isLTR ? anchorRect.right - tooltipWidth : anchorRect.left;\n      centerPos = anchorRect.left + (anchorRect.width - tooltipWidth) / 2;\n\n      const sideLeftAligned = anchorRect.left - (tooltipWidth + this.anchorGap);\n      const sideRightAligned = anchorRect.right + this.anchorGap;\n      sideStartPos = isLTR ? sideLeftAligned : sideRightAligned;\n      sideEndPos = isLTR ? sideRightAligned : sideLeftAligned;\n\n      startTransformOrigin = isLTR ? strings.LEFT : strings.RIGHT;\n      endTransformOrigin = isLTR ? strings.RIGHT : strings.LEFT;\n    }\n    // For plain tooltips, centerPos is defined\n    const plainTooltipPosOptions = [startPos, centerPos!, endPos];\n\n    // Side positioning should only be considered if it is specified by the\n    // client.\n    if (this.xTooltipPos === XPosition.SIDE_START) {\n      plainTooltipPosOptions.push(sideStartPos!);\n    } else if (this.xTooltipPos === XPosition.SIDE_END) {\n      plainTooltipPosOptions.push(sideEndPos!);\n    }\n\n    const positionOptions = this.richTooltip ?\n        this.determineValidPositionOptions(startPos, endPos) :\n        this.determineValidPositionOptions(...plainTooltipPosOptions);\n\n    if (this.xTooltipPos === XPosition.START && positionOptions.has(startPos)) {\n      return {distance: startPos, xTransformOrigin: startTransformOrigin};\n    } else if (\n        this.xTooltipPos === XPosition.END && positionOptions.has(endPos)) {\n      return {distance: endPos, xTransformOrigin: endTransformOrigin};\n    } else if (\n        this.xTooltipPos === XPosition.CENTER &&\n        positionOptions.has(centerPos)) {\n      // This code path is only executed if calculating the distance for plain\n      // tooltips. In this instance, centerPos will always be defined, so we can\n      // safely assert that the returned value is non-null/undefined.\n      return {distance: centerPos!, xTransformOrigin: strings.CENTER};\n    } else if (\n        this.xTooltipPos === XPosition.SIDE_START &&\n        positionOptions.has(sideStartPos)) {\n      // This code path is only executed if calculating the distance for plain\n      // tooltips. In this instance, sideStartPos will always be defined, so we\n      // can safely assert that the returned value is non-null/undefined.\n      return {distance: sideStartPos!, xTransformOrigin: endTransformOrigin};\n    } else if (\n        this.xTooltipPos === XPosition.SIDE_END &&\n        positionOptions.has(sideEndPos)) {\n      // This code path is only executed if calculating the distance for plain\n      // tooltips. In this instance, sideEndPos will always be defined, so we\n      // can safely assert that the returned value is non-null/undefined.\n      return {distance: sideEndPos!, xTransformOrigin: startTransformOrigin};\n    }\n\n    // If no user position is supplied, rich tooltips default to end pos, then\n    // start position. Plain tooltips default to center, start, then end.\n    const possiblePositions = this.richTooltip ?\n        [\n          {distance: endPos, xTransformOrigin: endTransformOrigin},\n          {distance: startPos, xTransformOrigin: startTransformOrigin}\n        ] :\n        [\n          {distance: centerPos!, xTransformOrigin: strings.CENTER},\n          {distance: startPos, xTransformOrigin: startTransformOrigin},\n          {distance: endPos, xTransformOrigin: endTransformOrigin}\n        ];\n\n    const validPosition =\n        possiblePositions.find(({distance}) => positionOptions.has(distance));\n    if (validPosition) {\n      return validPosition;\n    }\n\n    // Indicates that all potential positions would result in the tooltip\n    // colliding with the viewport. This would only occur when the anchor\n    // element itself collides with the viewport, or the viewport is very\n    // narrow. In this case, we allow the tooltip to be mis-aligned from the\n    // anchor element.\n    if (anchorRect.left < 0) {\n      return {\n        distance: this.minViewportTooltipThreshold,\n        xTransformOrigin: strings.LEFT\n      };\n    } else {\n      const viewportWidth = this.adapter.getViewportWidth();\n      const distance =\n          viewportWidth - (tooltipWidth + this.minViewportTooltipThreshold);\n      return {distance, xTransformOrigin: strings.RIGHT};\n    }\n  }\n\n  /**\n   * Given the values for the horizontal alignments of the tooltip, calculates\n   * which of these options would result in the tooltip maintaining the required\n   * threshold distance vs which would result in the tooltip staying within the\n   * viewport.\n   *\n   * A Set of values is returned holding the distances that would honor the\n   * above requirements. Following the logic for determining the tooltip\n   * position, if all alignments violate the threshold, then the returned Set\n   * contains values that keep the tooltip within the viewport.\n   */\n  private determineValidPositionOptions(...positions: number[]) {\n    const posWithinThreshold = new Set();\n    const posWithinViewport = new Set();\n\n    for (const position of positions) {\n      if (this.positionHonorsViewportThreshold(position)) {\n        posWithinThreshold.add(position);\n      } else if (this.positionDoesntCollideWithViewport(position)) {\n        posWithinViewport.add(position);\n      }\n    }\n\n    return posWithinThreshold.size ? posWithinThreshold : posWithinViewport;\n  }\n\n  private positionHonorsViewportThreshold(leftPos: number) {\n    const viewportWidth = this.adapter.getViewportWidth();\n    const tooltipWidth = this.adapter.getTooltipSize().width;\n\n    return leftPos + tooltipWidth <=\n        viewportWidth - this.minViewportTooltipThreshold &&\n        leftPos >= this.minViewportTooltipThreshold;\n  }\n\n  private positionDoesntCollideWithViewport(leftPos: number) {\n    const viewportWidth = this.adapter.getViewportWidth();\n    const tooltipWidth = this.adapter.getTooltipSize().width;\n\n    return leftPos + tooltipWidth <= viewportWidth && leftPos >= 0;\n  }\n\n  /**\n   * Calculates the `top` distance for the tooltip.\n   * Returns the distance value and a string indicating the y-axis transform-\n   * origin that should be used when animating the tooltip.\n   */\n  private calculateYTooltipDistance(\n      anchorRect: DOMRect, tooltipHeight: number) {\n    const belowYPos = anchorRect.bottom + this.anchorGap;\n    const aboveYPos = anchorRect.top - (this.anchorGap + tooltipHeight);\n    const anchorMidpoint = anchorRect.top + anchorRect.height / 2;\n    const sideYPos = anchorMidpoint - (tooltipHeight / 2);\n    const posOptions = [aboveYPos, belowYPos];\n    if (this.yTooltipPos === YPosition.SIDE) {\n      // Side positioning should only be considered if it is specified by the\n      // client.\n      posOptions.push(sideYPos);\n    }\n    const yPositionOptions = this.determineValidYPositionOptions(...posOptions);\n\n    if (this.yTooltipPos === YPosition.ABOVE &&\n        yPositionOptions.has(aboveYPos)) {\n      return {distance: aboveYPos, yTransformOrigin: strings.BOTTOM};\n    } else if (\n        this.yTooltipPos === YPosition.BELOW &&\n        yPositionOptions.has(belowYPos)) {\n      return {distance: belowYPos, yTransformOrigin: strings.TOP};\n    } else if (\n        this.yTooltipPos === YPosition.SIDE && yPositionOptions.has(sideYPos)) {\n      return {distance: sideYPos, yTransformOrigin: strings.CENTER};\n    }\n\n    if (yPositionOptions.has(belowYPos)) {\n      return {distance: belowYPos, yTransformOrigin: strings.TOP};\n    }\n\n    if (yPositionOptions.has(aboveYPos)) {\n      return {distance: aboveYPos, yTransformOrigin: strings.BOTTOM};\n    }\n\n    // Indicates that all potential positions would result in the tooltip\n    // colliding with the viewport. This would only occur when the viewport is\n    // very short.\n    return {distance: belowYPos, yTransformOrigin: strings.TOP};\n  }\n\n  /**\n   * Given the values for above/below alignment of the tooltip, calculates\n   * which of these options would result in the tooltip maintaining the required\n   * threshold distance vs which would result in the tooltip staying within the\n   * viewport.\n   *\n   * A Set of values is returned holding the distances that would honor the\n   * above requirements. Following the logic for determining the tooltip\n   * position, if all possible alignments violate the threshold, then the\n   * returned Set contains values that keep the tooltip within the viewport.\n   */\n  private determineValidYPositionOptions(...positions: number[]) {\n    const posWithinThreshold = new Set();\n    const posWithinViewport = new Set();\n    for (const position of positions) {\n      if (this.yPositionHonorsViewportThreshold(position)) {\n        posWithinThreshold.add(position);\n      } else if (this.yPositionDoesntCollideWithViewport(position)) {\n        posWithinViewport.add(position);\n      }\n    }\n    return posWithinThreshold.size ? posWithinThreshold : posWithinViewport;\n  }\n\n  private yPositionHonorsViewportThreshold(yPos: number) {\n    const viewportHeight = this.adapter.getViewportHeight();\n    const tooltipHeight = this.adapter.getTooltipSize().height;\n\n    return yPos + tooltipHeight + this.minViewportTooltipThreshold <=\n        viewportHeight &&\n        yPos >= this.minViewportTooltipThreshold;\n  }\n\n  private yPositionDoesntCollideWithViewport(yPos: number) {\n    const viewportHeight = this.adapter.getViewportHeight();\n    const tooltipHeight = this.adapter.getTooltipSize().height;\n\n    return yPos + tooltipHeight <= viewportHeight && yPos >= 0;\n  }\n\n  private calculateTooltipWithCaretStyles(anchorRect: DOMRect|null) {\n    // Prior to grabbing the caret bounding rect, we clear all styles set on the\n    // caret. This will ensure the width/height is consistent (since we rotate\n    // the caret 90deg in some positions which would result in the height and\n    // width bounding rect measurements flipping).\n    this.adapter.clearTooltipCaretStyles();\n    const caretSize = this.adapter.getTooltipCaretBoundingRect();\n    if (!anchorRect || !caretSize) {\n      return {position: PositionWithCaret.DETECTED, top: 0, left: 0};\n    }\n\n    // The caret for the rich tooltip is created by rotating/skewing/scaling\n    // square div into a diamond shape and then hiding half of it so it looks\n    // like a triangle. We use the boundingClientRect to calculate the\n    // width/height of the element after the transforms (to the caret) have been\n    // applied. Since the full tooltip is scaled by 0.8 for the entrance\n    // animation, we divide by this value to retrieve the actual caret\n    // dimensions.\n    const caretWidth = caretSize.width / numbers.ANIMATION_SCALE;\n    // Since we hide half of caret, we divide the returned DOMRect height\n    // by 2.\n    const caretHeight = (caretSize.height / numbers.ANIMATION_SCALE) / 2;\n    const tooltipSize = this.adapter.getTooltipSize();\n\n    const yOptions = this.calculateYWithCaretDistanceOptions(\n        anchorRect, tooltipSize.height, {caretWidth, caretHeight});\n    const xOptions = this.calculateXWithCaretDistanceOptions(\n        anchorRect, tooltipSize.width, {caretWidth, caretHeight});\n\n    let positionOptions =\n        this.validateTooltipWithCaretDistances(yOptions, xOptions);\n    if (positionOptions.size < 1) {\n      positionOptions = this.generateBackupPositionOption(\n          anchorRect, tooltipSize, {caretWidth, caretHeight});\n    }\n\n    const {position, xDistance, yDistance} =\n        this.determineTooltipWithCaretDistance(positionOptions);\n\n    // After determining the position of the tooltip relative to the anchor,\n    // place the caret in the corresponding position and retrieve the necessary\n    // x/y transform origins needed to properly animate the tooltip entrance.\n    const {yTransformOrigin, xTransformOrigin} =\n        this.setCaretPositionStyles(position, {caretWidth, caretHeight});\n\n    return {\n      yTransformOrigin,\n      xTransformOrigin,\n      top: yDistance,\n      left: xDistance\n    };\n  }\n\n  private calculateXWithCaretDistanceOptions(\n      anchorRect: DOMRect, tooltipWidth: number,\n      caretSize: {caretHeight: number, caretWidth: number}):\n      Map<XPositionWithCaret, number> {\n    const {caretWidth, caretHeight} = caretSize;\n    const isLTR = !this.adapter.isRTL();\n    const anchorMidpoint = anchorRect.left + anchorRect.width / 2;\n\n    const sideLeftAligned =\n        anchorRect.left - (tooltipWidth + this.anchorGap + caretHeight);\n    const sideRightAligned = anchorRect.right + this.anchorGap + caretHeight;\n    const sideStartPos = isLTR ? sideLeftAligned : sideRightAligned;\n    const sideEndPos = isLTR ? sideRightAligned : sideLeftAligned;\n\n    const verticalLeftAligned =\n        anchorMidpoint - (numbers.CARET_INDENTATION + caretWidth / 2);\n    const verticalRightAligned = anchorMidpoint -\n        (tooltipWidth - numbers.CARET_INDENTATION - caretWidth / 2);\n    const verticalStartPos = isLTR ? verticalLeftAligned : verticalRightAligned;\n    const verticalEndPos = isLTR ? verticalRightAligned : verticalLeftAligned;\n    const verticalCenterPos = anchorMidpoint - tooltipWidth / 2;\n\n    const possiblePositionsMap = new Map([\n      [XPositionWithCaret.START, verticalStartPos],\n      [XPositionWithCaret.CENTER, verticalCenterPos],\n      [XPositionWithCaret.END, verticalEndPos],\n      [XPositionWithCaret.SIDE_END, sideEndPos],\n      [XPositionWithCaret.SIDE_START, sideStartPos],\n    ]);\n    return possiblePositionsMap;\n  }\n\n  private calculateYWithCaretDistanceOptions(\n      anchorRect: DOMRect, tooltipHeight: number,\n      caretSize: {caretHeight: number, caretWidth: number}):\n      Map<YPositionWithCaret, number> {\n    const {caretWidth, caretHeight} = caretSize;\n    const anchorMidpoint = anchorRect.top + anchorRect.height / 2;\n\n    const belowYPos = anchorRect.bottom + this.anchorGap + caretHeight;\n    const aboveYPos =\n        anchorRect.top - (this.anchorGap + tooltipHeight + caretHeight);\n    const sideTopYPos =\n        anchorMidpoint - (numbers.CARET_INDENTATION + caretWidth / 2);\n    const sideCenterYPos = anchorMidpoint - (tooltipHeight / 2);\n    const sideBottomYPos = anchorMidpoint -\n        (tooltipHeight - numbers.CARET_INDENTATION - caretWidth / 2);\n\n    const possiblePositionsMap = new Map([\n      [YPositionWithCaret.ABOVE, aboveYPos],\n      [YPositionWithCaret.BELOW, belowYPos],\n      [YPositionWithCaret.SIDE_TOP, sideTopYPos],\n      [YPositionWithCaret.SIDE_CENTER, sideCenterYPos],\n      [YPositionWithCaret.SIDE_BOTTOM, sideBottomYPos],\n    ]);\n\n    return possiblePositionsMap;\n  }\n\n  private repositionTooltipOnAnchorMove() {\n    const newAnchorRect = this.adapter.getAnchorBoundingRect();\n    if (!newAnchorRect || !this.anchorRect) return;\n    // Don't repositioning the tooltip if the anchor is moved/scrolled out of\n    // the viewport. See b/264343145 for more info.\n    const windowHeight = this.adapter.getViewportHeight();\n    if ((newAnchorRect.top + newAnchorRect.height) < 0 ||\n        (newAnchorRect.bottom - newAnchorRect.height) >= windowHeight) {\n      return;\n    }\n\n    if (newAnchorRect.top !== this.anchorRect.top ||\n        newAnchorRect.left !== this.anchorRect.left ||\n        newAnchorRect.height !== this.anchorRect.height ||\n        newAnchorRect.width !== this.anchorRect.width) {\n      this.anchorRect = newAnchorRect;\n      this.parentRect = this.adapter.getParentBoundingRect();\n      this.richTooltip ? this.positionRichTooltip() :\n                         this.positionPlainTooltip();\n    }\n  }\n\n  /**\n   * Given a list of x/y position options for a rich tooltip with caret, checks\n   * if valid x/y combinations of these position options are either within the\n   * viewport threshold, or simply within the viewport. Returns a map with the\n   * valid x/y position combinations that all either honor the viewport\n   * threshold or are simply inside within the viewport.\n   */\n  private validateTooltipWithCaretDistances(\n      yOptions: Map<YPositionWithCaret, number>,\n      xOptions: Map<XPositionWithCaret, number>) {\n    const posWithinThreshold =\n        new Map<PositionWithCaret, {xDistance: number, yDistance: number}>();\n    const posWithinViewport =\n        new Map<PositionWithCaret, {xDistance: number, yDistance: number}>();\n\n    // If a tooltip has a caret, not all combinations of YPositionWithCarets and\n    // XPositionWithCarets are possible. Because of this we only check the\n    // validity of a given XPositionWithCaret if a potential corresponding\n    // YPositionWithCaret is valid.\n    const validMappings = new Map([\n      [\n        YPositionWithCaret.ABOVE,\n        [\n          XPositionWithCaret.START, XPositionWithCaret.CENTER,\n          XPositionWithCaret.END\n        ]\n      ],\n      [\n        YPositionWithCaret.BELOW,\n        [\n          XPositionWithCaret.START, XPositionWithCaret.CENTER,\n          XPositionWithCaret.END\n        ]\n      ],\n      [\n        YPositionWithCaret.SIDE_TOP,\n        [XPositionWithCaret.SIDE_START, XPositionWithCaret.SIDE_END]\n      ],\n      [\n        YPositionWithCaret.SIDE_CENTER,\n        [XPositionWithCaret.SIDE_START, XPositionWithCaret.SIDE_END]\n      ],\n      [\n        YPositionWithCaret.SIDE_BOTTOM,\n        [XPositionWithCaret.SIDE_START, XPositionWithCaret.SIDE_END]\n      ],\n    ]);\n\n    // TODO(b/227383292): Handle instances where one direction can fit in\n    // in the viewport (whether honoring the threshold or not), and the\n    // other direction does not.\n    for (const y of validMappings.keys()) {\n      const yDistance = yOptions.get(y)!;\n      if (this.yPositionHonorsViewportThreshold(yDistance)) {\n        for (const x of validMappings.get(y)!) {\n          const xDistance = xOptions.get(x)!;\n          if (this.positionHonorsViewportThreshold(xDistance)) {\n            const caretPositionName = this.caretPositionOptionsMapping(x, y);\n            posWithinThreshold.set(caretPositionName, {xDistance, yDistance});\n          }\n        }\n      }\n\n      if (this.yPositionDoesntCollideWithViewport(yDistance)) {\n        for (const x of validMappings.get(y)!) {\n          const xDistance = xOptions.get(x)!;\n          if (this.positionDoesntCollideWithViewport(xDistance)) {\n            const caretPositionName = this.caretPositionOptionsMapping(x, y);\n            posWithinViewport.set(caretPositionName, {xDistance, yDistance});\n          }\n        }\n      }\n    }\n\n    return posWithinThreshold.size ? posWithinThreshold : posWithinViewport;\n  }\n\n  /**\n   * Method for generating a horizontal and vertical position for the tooltip if\n   * all other calculated values are considered invalid. This would only happen\n   * in situations of very small viewports/large tooltips.\n   */\n  private generateBackupPositionOption(\n      anchorRect: DOMRect, tooltipSize: {width: number, height: number},\n      caretSize: {caretHeight: number, caretWidth: number}) {\n    const isLTR = !this.adapter.isRTL();\n    let xDistance: number;\n    let xPos: XPositionWithCaret;\n    if (anchorRect.left < 0) {\n      xDistance = this.minViewportTooltipThreshold + caretSize.caretHeight;\n      xPos = isLTR ? XPositionWithCaret.END : XPositionWithCaret.START;\n    } else {\n      const viewportWidth = this.adapter.getViewportWidth();\n      xDistance = viewportWidth -\n          (tooltipSize.width + this.minViewportTooltipThreshold +\n           caretSize.caretHeight);\n      xPos = isLTR ? XPositionWithCaret.START : XPositionWithCaret.END;\n    }\n\n    let yDistance: number;\n    let yPos: YPositionWithCaret;\n    if (anchorRect.top < 0) {\n      yDistance = this.minViewportTooltipThreshold + caretSize.caretHeight;\n      yPos = YPositionWithCaret.BELOW;\n    } else {\n      const viewportHeight = this.adapter.getViewportHeight();\n      yDistance = viewportHeight -\n          (tooltipSize.height + this.minViewportTooltipThreshold +\n           caretSize.caretHeight);\n      yPos = YPositionWithCaret.ABOVE;\n    }\n\n    const caretPositionName = this.caretPositionOptionsMapping(xPos, yPos);\n    return new Map<PositionWithCaret, {xDistance: number, yDistance: number}>(\n        [[caretPositionName, {xDistance, yDistance}]]);\n  }\n\n  /**\n   * Given a list of valid position options for a rich tooltip with caret,\n   * returns the option that should be used.\n   */\n  private determineTooltipWithCaretDistance(\n      options: Map<PositionWithCaret, {xDistance: number, yDistance: number}>):\n      {position: PositionWithCaret, xDistance: number, yDistance: number} {\n    if (options.has(this.tooltipPositionWithCaret)) {\n      const tooltipPos = options.get(this.tooltipPositionWithCaret)!;\n      return {\n        position: this.tooltipPositionWithCaret,\n        xDistance: tooltipPos.xDistance,\n        yDistance: tooltipPos.yDistance,\n      };\n    }\n\n    const orderPref = [\n      PositionWithCaret.ABOVE_START, PositionWithCaret.ABOVE_CENTER,\n      PositionWithCaret.ABOVE_END, PositionWithCaret.TOP_SIDE_START,\n      PositionWithCaret.CENTER_SIDE_START, PositionWithCaret.BOTTOM_SIDE_START,\n      PositionWithCaret.TOP_SIDE_END, PositionWithCaret.CENTER_SIDE_END,\n      PositionWithCaret.BOTTOM_SIDE_END, PositionWithCaret.BELOW_START,\n      PositionWithCaret.BELOW_CENTER, PositionWithCaret.BELOW_END\n    ];\n\n    // Before calling this method we check whether or not the \"options\" param\n    // is empty and invoke a different method. We, therefore, can be certain\n    // that \"validPosition\" will always be defined.\n    const validPosition = orderPref.find((pos) => options.has(pos))!;\n    const pos = options.get(validPosition)!;\n    return {\n      position: validPosition,\n      xDistance: pos.xDistance,\n      yDistance: pos.yDistance,\n    };\n  }\n\n  /**\n   * Returns the corresponding PositionWithCaret enum for the provided\n   * XPositionWithCaret and YPositionWithCaret enums. This mapping exists so our\n   * public API accepts only PositionWithCaret enums (as all combinations of\n   * XPositionWithCaret and YPositionWithCaret are not valid), but internally we\n   * can calculate the X and Y positions of a rich tooltip with caret\n   * separately.\n   */\n  private caretPositionOptionsMapping(\n      xPos: XPositionWithCaret, yPos: YPositionWithCaret): PositionWithCaret {\n    switch (yPos) {\n      case YPositionWithCaret.ABOVE:\n        if (xPos === XPositionWithCaret.START) {\n          return PositionWithCaret.ABOVE_START;\n        } else if (xPos === XPositionWithCaret.CENTER) {\n          return PositionWithCaret.ABOVE_CENTER;\n        } else if (xPos === XPositionWithCaret.END) {\n          return PositionWithCaret.ABOVE_END;\n        }\n        break;\n      case YPositionWithCaret.BELOW:\n        if (xPos === XPositionWithCaret.START) {\n          return PositionWithCaret.BELOW_START;\n        } else if (xPos === XPositionWithCaret.CENTER) {\n          return PositionWithCaret.BELOW_CENTER;\n        } else if (xPos === XPositionWithCaret.END) {\n          return PositionWithCaret.BELOW_END;\n        }\n        break;\n      case YPositionWithCaret.SIDE_TOP:\n        if (xPos === XPositionWithCaret.SIDE_START) {\n          return PositionWithCaret.TOP_SIDE_START;\n        } else if (xPos === XPositionWithCaret.SIDE_END) {\n          return PositionWithCaret.TOP_SIDE_END;\n        }\n        break;\n      case YPositionWithCaret.SIDE_CENTER:\n        if (xPos === XPositionWithCaret.SIDE_START) {\n          return PositionWithCaret.CENTER_SIDE_START;\n        } else if (xPos === XPositionWithCaret.SIDE_END) {\n          return PositionWithCaret.CENTER_SIDE_END;\n        }\n        break;\n      case YPositionWithCaret.SIDE_BOTTOM:\n        if (xPos === XPositionWithCaret.SIDE_START) {\n          return PositionWithCaret.BOTTOM_SIDE_START;\n        } else if (xPos === XPositionWithCaret.SIDE_END) {\n          return PositionWithCaret.BOTTOM_SIDE_END;\n        }\n        break;\n      default:\n        break;\n    }\n    throw new Error(\n        `MDCTooltipFoundation: Invalid caret position of ${xPos}, ${yPos}`);\n  }\n\n  /**\n   * Given a PositionWithCaret, applies the correct styles to the caret element\n   * so that it is positioned properly on the rich tooltip.\n   * Returns the x and y positions of the caret, to be used as the\n   * transform-origin on the tooltip itself for entrance animations.\n   */\n  private setCaretPositionStyles(position: PositionWithCaret, caretSize: {\n    caretWidth: number,\n    caretHeight: number\n  }) {\n    const values = this.calculateCaretPositionOnTooltip(position, caretSize);\n    if (!values) {\n      return {yTransformOrigin: 0, xTransformOrigin: 0};\n    }\n    // Prior to setting the caret position styles, clear any previous styles\n    // set. This is necessary as all position options do not use the same\n    // properties (e.g. using 'left' or 'right') and so old style properties\n    // might not get overridden, causing misplaced carets.\n    this.adapter.clearTooltipCaretStyles();\n\n    this.adapter.setTooltipCaretStyle(values.yAlignment, values.yAxisPx);\n    this.adapter.setTooltipCaretStyle(values.xAlignment, values.xAxisPx);\n    // Value of scaleX is cos(skew), Math.cos() expects radians though, so we\n    // must first convert the skew value (which is in degrees) to radians.\n    const skewRadians = values.skew * (Math.PI / 180);\n    const scaleX = Math.cos(skewRadians);\n\n    this.adapter.setTooltipCaretStyle(\n        'transform',\n        `rotate(${values.rotation}deg) skewY(${values.skew}deg) scaleX(${\n            scaleX})`);\n    this.adapter.setTooltipCaretStyle(\n        'transform-origin', `${values.xAlignment} ${values.yAlignment}`);\n    for (const corner of values.caretCorners) {\n      this.adapter.setTooltipCaretStyle(corner, '0');\n    }\n    return {\n      yTransformOrigin: values.yTransformOrigin,\n      xTransformOrigin: values.xTransformOrigin\n    };\n  }\n\n  /**\n   * Given a PositionWithCaret, determines the correct styles to position the\n   * caret properly on the rich tooltip.\n   */\n  private calculateCaretPositionOnTooltip(\n      tooltipPos: PositionWithCaret,\n      caretSize: {caretWidth: number, caretHeight: number}): CaretPosOnTooltip\n      |undefined {\n    const isLTR = !this.adapter.isRTL();\n    const tooltipWidth = this.adapter.getComputedStyleProperty('width');\n    const tooltipHeight = this.adapter.getComputedStyleProperty('height');\n    if (!tooltipWidth || !tooltipHeight || !caretSize) {\n      return;\n    }\n\n    const midpointWidth =\n        `calc((${tooltipWidth} - ${caretSize.caretWidth}px) / 2)`;\n    const midpointHeight =\n        `calc((${tooltipHeight} - ${caretSize.caretWidth}px) / 2)`;\n    const flushWithEdge = '0';\n    const indentedFromEdge = `${numbers.CARET_INDENTATION}px`;\n    const indentedFromWidth = `calc(${tooltipWidth} - ${indentedFromEdge})`;\n    const indentedFromHeight = `calc(${tooltipHeight} - ${indentedFromEdge})`;\n    const verticalRotation = 35;\n    const horizontalRotation = Math.abs(90 - verticalRotation);\n    const bottomRightTopLeftBorderRadius =\n        ['border-bottom-right-radius', 'border-top-left-radius'];\n    const bottomLeftTopRightBorderRadius =\n        ['border-bottom-left-radius', 'border-top-right-radius'];\n    const skewDeg = 20;\n\n    switch (tooltipPos) {\n      case PositionWithCaret.BELOW_CENTER:\n        return {\n          yAlignment: strings.TOP,\n          xAlignment: strings.LEFT,\n          yAxisPx: flushWithEdge,\n          xAxisPx: midpointWidth,\n          rotation: -1 * verticalRotation,\n          skew: -1 * skewDeg,\n          xTransformOrigin: midpointWidth,\n          yTransformOrigin: flushWithEdge,\n          caretCorners: bottomRightTopLeftBorderRadius,\n        };\n      case PositionWithCaret.BELOW_END:\n        return {\n          yAlignment: strings.TOP,\n          xAlignment: isLTR ? strings.RIGHT : strings.LEFT,\n          yAxisPx: flushWithEdge,\n          xAxisPx: indentedFromEdge,\n          rotation: isLTR ? verticalRotation : -1 * verticalRotation,\n          skew: isLTR ? skewDeg : -1 * skewDeg,\n          xTransformOrigin: isLTR ? indentedFromWidth : indentedFromEdge,\n          yTransformOrigin: flushWithEdge,\n          caretCorners: isLTR ? bottomLeftTopRightBorderRadius :\n                                bottomRightTopLeftBorderRadius,\n        };\n      case PositionWithCaret.BELOW_START:\n        return {\n          yAlignment: strings.TOP,\n          xAlignment: isLTR ? strings.LEFT : strings.RIGHT,\n          yAxisPx: flushWithEdge,\n          xAxisPx: indentedFromEdge,\n          rotation: isLTR ? -1 * verticalRotation : verticalRotation,\n          skew: isLTR ? -1 * skewDeg : skewDeg,\n          xTransformOrigin: isLTR ? indentedFromEdge : indentedFromWidth,\n          yTransformOrigin: flushWithEdge,\n          caretCorners: isLTR ? bottomRightTopLeftBorderRadius :\n                                bottomLeftTopRightBorderRadius,\n        };\n\n      case PositionWithCaret.TOP_SIDE_END:\n        return {\n          yAlignment: strings.TOP,\n          xAlignment: isLTR ? strings.LEFT : strings.RIGHT,\n          yAxisPx: indentedFromEdge,\n          xAxisPx: flushWithEdge,\n          rotation: isLTR ? horizontalRotation : -1 * horizontalRotation,\n          skew: isLTR ? -1 * skewDeg : skewDeg,\n          xTransformOrigin: isLTR ? flushWithEdge : tooltipWidth,\n          yTransformOrigin: indentedFromEdge,\n          caretCorners: isLTR ? bottomRightTopLeftBorderRadius :\n                                bottomLeftTopRightBorderRadius,\n        };\n      case PositionWithCaret.CENTER_SIDE_END:\n        return {\n          yAlignment: strings.TOP,\n          xAlignment: isLTR ? strings.LEFT : strings.RIGHT,\n          yAxisPx: midpointHeight,\n          xAxisPx: flushWithEdge,\n          rotation: isLTR ? horizontalRotation : -1 * horizontalRotation,\n          skew: isLTR ? -1 * skewDeg : skewDeg,\n          xTransformOrigin: isLTR ? flushWithEdge : tooltipWidth,\n          yTransformOrigin: midpointHeight,\n          caretCorners: isLTR ? bottomRightTopLeftBorderRadius :\n                                bottomLeftTopRightBorderRadius,\n        };\n      case PositionWithCaret.BOTTOM_SIDE_END:\n        return {\n          yAlignment: strings.BOTTOM,\n          xAlignment: isLTR ? strings.LEFT : strings.RIGHT,\n          yAxisPx: indentedFromEdge,\n          xAxisPx: flushWithEdge,\n          rotation: isLTR ? -1 * horizontalRotation : horizontalRotation,\n          skew: isLTR ? skewDeg : -1 * skewDeg,\n          xTransformOrigin: isLTR ? flushWithEdge : tooltipWidth,\n          yTransformOrigin: indentedFromHeight,\n          caretCorners: isLTR ? bottomLeftTopRightBorderRadius :\n                                bottomRightTopLeftBorderRadius,\n        };\n\n      case PositionWithCaret.TOP_SIDE_START:\n        return {\n          yAlignment: strings.TOP,\n          xAlignment: isLTR ? strings.RIGHT : strings.LEFT,\n          yAxisPx: indentedFromEdge,\n          xAxisPx: flushWithEdge,\n          rotation: isLTR ? -1 * horizontalRotation : horizontalRotation,\n          skew: isLTR ? skewDeg : -1 * skewDeg,\n          xTransformOrigin: isLTR ? tooltipWidth : flushWithEdge,\n          yTransformOrigin: indentedFromEdge,\n          caretCorners: isLTR ? bottomLeftTopRightBorderRadius :\n                                bottomRightTopLeftBorderRadius,\n        };\n      case PositionWithCaret.CENTER_SIDE_START:\n        return {\n          yAlignment: strings.TOP,\n          xAlignment: isLTR ? strings.RIGHT : strings.LEFT,\n          yAxisPx: midpointHeight,\n          xAxisPx: flushWithEdge,\n          rotation: isLTR ? -1 * horizontalRotation : horizontalRotation,\n          skew: isLTR ? skewDeg : -1 * skewDeg,\n          xTransformOrigin: isLTR ? tooltipWidth : flushWithEdge,\n          yTransformOrigin: midpointHeight,\n          caretCorners: isLTR ? bottomLeftTopRightBorderRadius :\n                                bottomRightTopLeftBorderRadius,\n        };\n      case PositionWithCaret.BOTTOM_SIDE_START:\n        return {\n          yAlignment: strings.BOTTOM,\n          xAlignment: isLTR ? strings.RIGHT : strings.LEFT,\n          yAxisPx: indentedFromEdge,\n          xAxisPx: flushWithEdge,\n          rotation: isLTR ? horizontalRotation : -1 * horizontalRotation,\n          skew: isLTR ? -1 * skewDeg : skewDeg,\n          xTransformOrigin: isLTR ? tooltipWidth : flushWithEdge,\n          yTransformOrigin: indentedFromHeight,\n          caretCorners: isLTR ? bottomRightTopLeftBorderRadius :\n                                bottomLeftTopRightBorderRadius,\n        };\n\n      case PositionWithCaret.ABOVE_CENTER:\n        return {\n          yAlignment: strings.BOTTOM,\n          xAlignment: strings.LEFT,\n          yAxisPx: flushWithEdge,\n          xAxisPx: midpointWidth,\n          rotation: verticalRotation,\n          skew: skewDeg,\n          xTransformOrigin: midpointWidth,\n          yTransformOrigin: tooltipHeight,\n          caretCorners: bottomLeftTopRightBorderRadius,\n        };\n      case PositionWithCaret.ABOVE_END:\n        return {\n          yAlignment: strings.BOTTOM,\n          xAlignment: isLTR ? strings.RIGHT : strings.LEFT,\n          yAxisPx: flushWithEdge,\n          xAxisPx: indentedFromEdge,\n          rotation: isLTR ? -1 * verticalRotation : verticalRotation,\n          skew: isLTR ? -1 * skewDeg : skewDeg,\n          xTransformOrigin: isLTR ? indentedFromWidth : indentedFromEdge,\n          yTransformOrigin: tooltipHeight,\n          caretCorners: isLTR ? bottomRightTopLeftBorderRadius :\n                                bottomLeftTopRightBorderRadius,\n        };\n      default:\n      case PositionWithCaret.ABOVE_START:\n        return {\n          yAlignment: strings.BOTTOM,\n          xAlignment: isLTR ? strings.LEFT : strings.RIGHT,\n          yAxisPx: flushWithEdge,\n          xAxisPx: indentedFromEdge,\n          rotation: isLTR ? verticalRotation : -1 * verticalRotation,\n          skew: isLTR ? skewDeg : -1 * skewDeg,\n          xTransformOrigin: isLTR ? indentedFromEdge : indentedFromWidth,\n          yTransformOrigin: tooltipHeight,\n          caretCorners: isLTR ? bottomLeftTopRightBorderRadius :\n                                bottomRightTopLeftBorderRadius,\n        };\n    }\n  }\n\n  private clearShowTimeout() {\n    if (this.showTimeout) {\n      clearTimeout(this.showTimeout);\n      this.showTimeout = null;\n    }\n  }\n\n  private clearHideTimeout() {\n    if (this.hideTimeout) {\n      clearTimeout(this.hideTimeout);\n      this.hideTimeout = null;\n    }\n  }\n\n  /**\n   * Method that allows user to specify additional elements that should have a\n   * scroll event listener attached to it. This should be used in instances\n   * where the anchor element is placed inside a scrollable container, and will\n   * ensure that the tooltip will stay attached to the anchor on scroll.\n   */\n  attachScrollHandler(\n      addEventListenerFn: <K extends EventType>(\n          event: K, handler: SpecificEventListener<K>) => void) {\n    this.addAncestorScrollEventListeners.push(() => {\n      addEventListenerFn('scroll', this.windowScrollHandler);\n    });\n  }\n\n  /**\n   * Must be used in conjunction with #attachScrollHandler. Removes the scroll\n   * event handler from elements on the page.\n   */\n  removeScrollHandler(\n      removeEventHandlerFn: <K extends EventType>(\n          event: K, handler: SpecificEventListener<K>) => void) {\n    this.removeAncestorScrollEventListeners.push(() => {\n      removeEventHandlerFn('scroll', this.windowScrollHandler);\n    });\n  }\n\n\n  override destroy() {\n    if (this.frameId) {\n      cancelAnimationFrame(this.frameId);\n      this.frameId = null;\n    }\n\n    this.clearHideTimeout();\n    this.clearShowTimeout();\n\n    this.adapter.removeClass(SHOWN);\n    this.adapter.removeClass(SHOWING_TRANSITION);\n    this.adapter.removeClass(SHOWING);\n    this.adapter.removeClass(HIDE);\n    this.adapter.removeClass(HIDE_TRANSITION);\n\n    if (this.richTooltip) {\n      this.adapter.deregisterEventHandler(\n          'focusout', this.richTooltipFocusOutHandler);\n    }\n\n    if (!this.persistentTooltip) {\n      this.adapter.deregisterEventHandler(\n          'mouseenter', this.tooltipMouseEnterHandler);\n      this.adapter.deregisterEventHandler(\n          'mouseleave', this.tooltipMouseLeaveHandler);\n    }\n\n    this.adapter.deregisterAnchorEventHandler('blur', this.anchorBlurHandler);\n\n    this.adapter.deregisterDocumentEventHandler(\n        'click', this.documentClickHandler);\n    this.adapter.deregisterDocumentEventHandler(\n        'keydown', this.documentKeydownHandler);\n\n    this.adapter.deregisterWindowEventHandler(\n        'scroll', this.windowScrollHandler);\n    this.adapter.deregisterWindowEventHandler(\n        'resize', this.windowResizeHandler);\n    for (const fn of this.removeAncestorScrollEventListeners) {\n      fn();\n    }\n\n    this.animFrame.cancelAll();\n  }\n}\n\ninterface CaretPosOnTooltip {\n  // Either 'top' or 'bottom', indicating which should be used with the yAxisPx\n  // value to position the caret.\n  yAlignment: string;\n  // Either 'left' or 'right', indicating which should be used with the xAxisPx\n  // value to position the caret.\n  xAlignment: string;\n  // Indicates the vertical px alignment of the caret.\n  yAxisPx: string;\n  // Indicates the horizontal px alignment of the caret.\n  xAxisPx: string;\n  // Value (in degrees) by which the caret will be rotated.\n  rotation: number;\n  // Value (in degrees) by which the caret will be skewed.\n  skew: number;\n  // The x-axis of the transform-origin property for the whole tooltip. This\n  // ensures that, during the opening animation of the tooltip, it expands from\n  // the caret.\n  xTransformOrigin: string;\n  // The y-axis of the transform-origin property for the whole tooltip. This\n  // ensures that, during the opening animation of the tooltip, it expands from\n  // the caret.\n  yTransformOrigin: string;\n  // List of border-radius properties (e.g. border-radius-top-left, etc) that\n  // indicate which corners of the caret element should have a border-radius of\n  // 0. Certain corners use a 0 border radius to ensure a clean junction between\n  // the tooltip and the caret.\n  caretCorners: string[];\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTooltipFoundation;\n","/**\n * @license\n * Copyright 2020 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';\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 * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCTopAppBarAdapter {\n  /**\n   * Adds a class to the root Element.\n   */\n  addClass(className: string): void;\n\n  /**\n   * Removes a class from the root Element.\n   */\n  removeClass(className: string): void;\n\n  /**\n   * Returns true if the root Element contains the given class.\n   */\n  hasClass(className: string): boolean;\n\n  /**\n   * Sets the specified inline style property on the root Element to the given\n   * value.\n   */\n  setStyle(property: string, value: string): void;\n\n  /**\n   * Gets the height of the top app bar.\n   */\n  getTopAppBarHeight(): number;\n\n  getViewportScrollY(): number;\n\n  getTotalActionItems(): number;\n\n  /**\n   * Emits an event when the navigation icon is clicked.\n   */\n  notifyNavigationIconClicked(): void;\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';\n\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\n/** MDC Top App Bar */\nexport class MDCTopAppBar extends MDCComponent<MDCTopAppBarBaseFoundation> {\n  static override attachTo(root: HTMLElement): MDCTopAppBar {\n    return new MDCTopAppBar(root);\n  }\n\n  private handleNavigationClick!:\n      SpecificEventListener<'click'>;  // assigned in initialSyncWithDOM()\n  private handleWindowResize!:\n      SpecificEventListener<'resize'>;  // assigned in initialSyncWithDOM()\n  private handleTargetScroll!:\n      SpecificEventListener<'scroll'>;  // assigned in initialSyncWithDOM()\n  private navIcon!: HTMLElement|null;\n  private iconRipples!: MDCRipple[];\n  private scrollTarget!: EventTarget;\n\n  override initialize(\n      rippleFactory: MDCRippleFactory = (el) => MDCRipple.attachTo(el)) {\n    this.navIcon =\n        this.root.querySelector<HTMLElement>(strings.NAVIGATION_ICON_SELECTOR);\n\n    // Get all icons in the toolbar and instantiate the ripples\n    const icons = Array.from(\n        this.root.querySelectorAll<HTMLElement>(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  override initialSyncWithDOM() {\n    this.handleNavigationClick =\n        this.foundation.handleNavigationClick.bind(this.foundation);\n    this.handleWindowResize =\n        this.foundation.handleWindowResize.bind(this.foundation);\n    this.handleTargetScroll =\n        this.foundation.handleTargetScroll.bind(this.foundation);\n\n    this.scrollTarget.addEventListener(\n        'scroll', this.handleTargetScroll as EventListener);\n\n    if (this.navIcon) {\n      this.navIcon.addEventListener(\n          '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(\n          'resize', this.handleWindowResize as EventListener);\n    }\n  }\n\n  override destroy() {\n    for (const iconRipple of this.iconRipples) {\n      iconRipple.destroy();\n    }\n    this.scrollTarget.removeEventListener(\n        'scroll', this.handleTargetScroll as EventListener);\n    if (this.navIcon) {\n      this.navIcon.removeEventListener(\n          '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(\n          '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(\n        '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(\n        'scroll', this.handleTargetScroll as EventListener);\n  }\n\n  override getDefaultFoundation() {\n    // DO NOT INLINE this variable. For backward compatibility, foundations take\n    // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n    // 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) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      setStyle: (property, value) => {\n        this.root.style.setProperty(property, value);\n      },\n      getTopAppBarHeight: () => this.root.clientHeight,\n      notifyNavigationIconClicked: () => {\n        this.emit(strings.NAVIGATION_EVENT, {});\n      },\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: () =>\n          this.root.querySelectorAll<HTMLElement>(strings.ACTION_ITEM_SELECTOR)\n              .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\n/** MDC Fixed Top App Bar Foundation */\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\n   * app bar.\n   */\n  override 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';\n\nimport {MDCTopAppBarAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\n/** MDC Top App Bar Base Foundation */\nexport class MDCTopAppBarBaseFoundation extends\n    MDCFoundation<MDCTopAppBarAdapter> {\n  static override get strings() {\n    return strings;\n  }\n\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get numbers() {\n    return numbers;\n  }\n\n  /**\n   * See {@link MDCTopAppBarAdapter} for typing information on parameters and\n   * return types.\n   */\n  static override 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\n/** MDC Short Top App Bar Foundation */\nexport class MDCShortTopAppBarFoundation extends MDCTopAppBarBaseFoundation {\n  // Public visibility for backward compatibility.\n  get isCollapsed(): boolean {\n    return this.collapsed;\n  }\n\n  private collapsed = 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  override 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\n    // 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\n   *     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\n   * short top app bar.\n   */\n  override 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.collapsed) {\n        this.uncollapse();\n      }\n    } else {\n      if (!this.collapsed) {\n        this.collapse();\n      }\n    }\n  }\n\n  private uncollapse() {\n    this.adapter.removeClass(cssClasses.SHORT_COLLAPSED_CLASS);\n    this.collapsed = false;\n  }\n\n  private collapse() {\n    this.adapter.addClass(cssClasses.SHORT_COLLAPSED_CLASS);\n    this.collapsed = 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\n/** MDC Top App Bar Foundation */\nexport class MDCTopAppBarFoundation extends MDCTopAppBarBaseFoundation {\n  /**\n   * Indicates if the top app bar was docked in the previous scroll handler\n   * 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\n   * 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\n   * hidden\n   */\n  private topAppBarHeight: number;\n\n  /**\n   * The timeout that's used to debounce toggling the isCurrentlyBeingResized\n   * 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  override 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   */\n  override handleTargetScroll() {\n    const currentScrollPosition =\n        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\n    // but the current scroll of the top app bar should stay in the same\n    // 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\n   * updates.\n   */\n  override 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 =\n        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\n      // bar height as our offset so the top app bar doesn't show if the window\n      // 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\n      // width, this will ensure that the top app bar remains in the correct\n      // location if completely hidden and a resize makes the top app bar a\n      // 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":""}