UNPKG

376 kBSource Map (JSON)View Raw
1{"version":3,"sources":["webpack://mdc.[name]/webpack/universalModuleDefinition","webpack://mdc.[name]/webpack/bootstrap","webpack://mdc.[name]/./packages/mdc-animation/util.ts","webpack://mdc.[name]/./packages/mdc-base/component.ts","webpack://mdc.[name]/./packages/mdc-base/foundation.ts","webpack://mdc.[name]/./packages/mdc-dom/events.ts","webpack://mdc.[name]/./packages/mdc-dom/keyboard.ts","webpack://mdc.[name]/./packages/mdc-dom/ponyfill.ts","webpack://mdc.[name]/./packages/mdc-floating-label/component.ts","webpack://mdc.[name]/./packages/mdc-floating-label/constants.ts","webpack://mdc.[name]/./packages/mdc-floating-label/foundation.ts","webpack://mdc.[name]/./packages/mdc-line-ripple/component.ts","webpack://mdc.[name]/./packages/mdc-line-ripple/constants.ts","webpack://mdc.[name]/./packages/mdc-line-ripple/foundation.ts","webpack://mdc.[name]/./packages/mdc-list/component.ts","webpack://mdc.[name]/./packages/mdc-list/constants.ts","webpack://mdc.[name]/./packages/mdc-list/events.ts","webpack://mdc.[name]/./packages/mdc-list/foundation.ts","webpack://mdc.[name]/./packages/mdc-list/typeahead.ts","webpack://mdc.[name]/./packages/mdc-menu-surface/component.ts","webpack://mdc.[name]/./packages/mdc-menu-surface/constants.ts","webpack://mdc.[name]/./packages/mdc-menu-surface/foundation.ts","webpack://mdc.[name]/./packages/mdc-menu/component.ts","webpack://mdc.[name]/./packages/mdc-menu/constants.ts","webpack://mdc.[name]/./packages/mdc-menu/foundation.ts","webpack://mdc.[name]/./packages/mdc-notched-outline/component.ts","webpack://mdc.[name]/./packages/mdc-notched-outline/constants.ts","webpack://mdc.[name]/./packages/mdc-notched-outline/foundation.ts","webpack://mdc.[name]/./packages/mdc-ripple/component.ts","webpack://mdc.[name]/./packages/mdc-ripple/constants.ts","webpack://mdc.[name]/./packages/mdc-ripple/foundation.ts","webpack://mdc.[name]/./packages/mdc-ripple/util.ts","webpack://mdc.[name]/./packages/mdc-select/adapter.ts","webpack://mdc.[name]/./packages/mdc-select/component.ts","webpack://mdc.[name]/./packages/mdc-select/constants.ts","webpack://mdc.[name]/./packages/mdc-select/foundation.ts","webpack://mdc.[name]/./packages/mdc-select/helper-text/adapter.ts","webpack://mdc.[name]/./packages/mdc-select/helper-text/component.ts","webpack://mdc.[name]/./packages/mdc-select/helper-text/constants.ts","webpack://mdc.[name]/./packages/mdc-select/helper-text/foundation.ts","webpack://mdc.[name]/./packages/mdc-select/helper-text/index.ts","webpack://mdc.[name]/./packages/mdc-select/icon/adapter.ts","webpack://mdc.[name]/./packages/mdc-select/icon/component.ts","webpack://mdc.[name]/./packages/mdc-select/icon/constants.ts","webpack://mdc.[name]/./packages/mdc-select/icon/foundation.ts","webpack://mdc.[name]/./packages/mdc-select/icon/index.ts","webpack://mdc.[name]/./packages/mdc-select/index.ts","webpack://mdc.[name]/./packages/mdc-select/types.ts"],"names":[],"mappings":"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","file":"mdc.select.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/select\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"select\"] = factory();\n\telse\n\t\troot[\"mdc\"] = root[\"mdc\"] || {}, root[\"mdc\"][\"select\"] = 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/mdc-select/index.ts\");\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {\n CssVendorPropertyMap, JsVendorPropertyMap,\n PrefixedCssPropertyName, PrefixedJsEventType,\n StandardCssPropertyName, StandardJsEventType,\n} from './types';\n\nconst cssPropertyNameMap: CssVendorPropertyMap = {\n animation: {\n prefixed: '-webkit-animation',\n standard: 'animation',\n },\n transform: {\n prefixed: '-webkit-transform',\n standard: 'transform',\n },\n transition: {\n prefixed: '-webkit-transition',\n standard: 'transition',\n },\n};\n\nconst jsEventTypeMap: JsVendorPropertyMap = {\n animationend: {\n cssProperty: 'animation',\n prefixed: 'webkitAnimationEnd',\n standard: 'animationend',\n },\n animationiteration: {\n cssProperty: 'animation',\n prefixed: 'webkitAnimationIteration',\n standard: 'animationiteration',\n },\n animationstart: {\n cssProperty: 'animation',\n prefixed: 'webkitAnimationStart',\n standard: 'animationstart',\n },\n transitionend: {\n cssProperty: 'transition',\n prefixed: 'webkitTransitionEnd',\n standard: 'transitionend',\n },\n};\n\nfunction isWindow(windowObj: Window): boolean {\n return Boolean(windowObj.document) && typeof windowObj.document.createElement === 'function';\n}\n\nexport function getCorrectPropertyName(windowObj: Window, cssProperty: StandardCssPropertyName):\n StandardCssPropertyName | PrefixedCssPropertyName {\n if (isWindow(windowObj) && cssProperty in cssPropertyNameMap) {\n const el = windowObj.document.createElement('div');\n const {standard, prefixed} = cssPropertyNameMap[cssProperty];\n const isStandard = standard in el.style;\n return isStandard ? standard : prefixed;\n }\n return cssProperty;\n}\n\nexport function getCorrectEventName(windowObj: Window, eventType: StandardJsEventType):\n StandardJsEventType | PrefixedJsEventType {\n if (isWindow(windowObj) && eventType in jsEventTypeMap) {\n const el = windowObj.document.createElement('div');\n const {standard, prefixed, cssProperty} = jsEventTypeMap[eventType];\n const isStandard = cssProperty in el.style;\n return isStandard ? standard : prefixed;\n }\n return eventType;\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from './foundation';\nimport {CustomEventListener, EventType, SpecificEventListener} from './types';\n\nexport class MDCComponent<FoundationType extends MDCFoundation> {\n static attachTo(root: Element): MDCComponent<MDCFoundation<{}>> {\n // Subclasses which extend MDCBase should provide an attachTo() method that takes a root element and\n // returns an instantiated component with its root set to that element. Also note that in the cases of\n // subclasses, an explicit foundation class will not have to be passed in; it will simply be initialized\n // from getDefaultFoundation().\n return new MDCComponent(root, new MDCFoundation({}));\n }\n\n protected foundation: FoundationType;\n\n constructor(\n public root: Element, foundation?: FoundationType, ...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 not need to be unit tested */\n initialize(..._args: Array<unknown>) {\n // Subclasses can override this to do any additional setup work that would be considered part of a\n // \"constructor\". Essentially, it is a hook into the parent constructor before the foundation is\n // initialized. Any additional arguments besides root and foundation will be passed in here.\n }\n\n getDefaultFoundation(): FoundationType {\n // Subclasses must override this method to return a properly configured foundation class for the\n // component.\n throw new Error('Subclasses must override getDefaultFoundation to return a properly configured ' +\n 'foundation class');\n }\n\n initialSyncWithDOM() {\n // Subclasses should override this method if they need to perform work to synchronize with a host DOM\n // object. An example of this would be a form control wrapper that needs to synchronize its internal state\n // to some property or attribute of the host DOM. Please note: this is *not* the place to perform DOM\n // reads/writes that would cause layout / paint, as this is called synchronously from within the constructor.\n }\n\n destroy() {\n // Subclasses may implement this method to release any resources / deregister any listeners they have\n // attached. An example of this might be deregistering a resize event from the window object.\n this.foundation.destroy();\n }\n\n /**\n * Wrapper method to add an event listener to the component's root element. This is most useful when\n * listening for custom events.\n */\n listen<K extends EventType>(\n evtType: K, handler: SpecificEventListener<K>, options?: AddEventListenerOptions | boolean): void;\n listen<E extends Event>(\n evtType: string, handler: CustomEventListener<E>, options?: AddEventListenerOptions | boolean): void;\n listen(evtType: string, handler: EventListener, options?: AddEventListenerOptions | boolean) {\n this.root.addEventListener(evtType, handler, options);\n }\n\n /**\n * Wrapper method to remove an event listener to the component's root element. This is most useful when\n * unlistening for custom events.\n */\n unlisten<K extends EventType>(\n evtType: K, handler: SpecificEventListener<K>, options?: AddEventListenerOptions | boolean): void;\n unlisten<E extends Event>(\n evtType: string, handler: CustomEventListener<E>, options?: AddEventListenerOptions | boolean): void;\n unlisten(evtType: string, handler: EventListener, options?: AddEventListenerOptions | boolean) {\n this.root.removeEventListener(evtType, handler, options);\n }\n\n /**\n * Fires a cross-browser-compatible custom event from the component root of the given type, with the given data.\n */\n emit<T extends object>(evtType: string, evtData: T, shouldBubble = false) {\n let evt: CustomEvent<T>;\n if (typeof CustomEvent === 'function') {\n evt = new CustomEvent<T>(evtType, {\n bubbles: shouldBubble,\n detail: evtData,\n });\n } else {\n evt = document.createEvent('CustomEvent');\n evt.initCustomEvent(evtType, shouldBubble, false, evtData);\n }\n\n this.root.dispatchEvent(evt);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCComponent;\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport class MDCFoundation<AdapterType extends {} = {}> {\n static get cssClasses(): { [key: string]: string } {\n // Classes extending MDCFoundation should implement this method to return an object which exports every\n // CSS class the foundation class needs as a property. e.g. {ACTIVE: 'mdc-component--active'}\n return {};\n }\n\n static get strings(): { [key: string]: string } {\n // Classes extending MDCFoundation should implement this method to return an object which exports all\n // semantic strings as constants. e.g. {ARIA_ROLE: 'tablist'}\n return {};\n }\n\n static get numbers(): { [key: string]: number } {\n // Classes extending MDCFoundation should implement this method to return an object which exports all\n // of its semantic numbers as constants. e.g. {ANIMATION_DELAY_MS: 350}\n return {};\n }\n\n static get defaultAdapter(): {} {\n // Classes extending MDCFoundation may choose to implement this getter in order to provide a convenient\n // way of viewing the necessary methods of an adapter. In the future, this could also be used for adapter\n // validation.\n return {};\n }\n\n constructor(protected adapter: AdapterType = {} as AdapterType) {}\n\n init() {\n // Subclasses should override this method to perform initialization routines (registering events, etc.)\n }\n\n destroy() {\n // Subclasses should override this method to perform de-initialization routines (de-registering events, etc.)\n }\n}\n\n/**\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<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\n/**\n * Determine whether the current browser supports passive event listeners, and\n * if so, use them.\n */\nexport function applyPassive(globalObj: Window = window):\n boolean | 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\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(evt: KeyboardEvent): string {\n const {key} = evt;\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(evt.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(evt: KeyboardEvent): boolean {\n return navigationKeys.has(normalizeKey(evt));\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 prototype chain.\n * This makes ponyfills safer than traditional polyfills, especially for libraries like MDC.\n */\n\nexport function closest(element: Element, selector: string): Element | null {\n if (element.closest) {\n return element.closest(selector);\n }\n\n let el: Element | null = element;\n while (el) {\n if (matches(el, selector)) {\n return el;\n }\n el = el.parentElement;\n }\n return null;\n}\n\nexport function matches(element: Element, selector: string): boolean {\n const nativeMatches = element.matches\n || element.webkitMatchesSelector\n || (element 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 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';\nimport {MDCFloatingLabelAdapter} from './adapter';\nimport {MDCFloatingLabelFoundation} from './foundation';\n\nexport type MDCFloatingLabelFactory = (el: Element, foundation?: MDCFloatingLabelFoundation) => MDCFloatingLabel;\n\nexport class MDCFloatingLabel extends MDCComponent<MDCFloatingLabelFoundation> {\n static override attachTo(root: Element): MDCFloatingLabel {\n return new MDCFloatingLabel(root);\n }\n\n /**\n * Styles the label to produce the label shake for errors.\n * @param shouldShake If true, shakes the label by adding a CSS class; otherwise, stops shaking by removing the class.\n */\n shake(shouldShake: boolean) {\n this.foundation.shake(shouldShake);\n }\n\n /**\n * Styles the label to float/dock.\n * @param shouldFloat If true, floats the label by adding a CSS class; otherwise, docks it by removing the class.\n */\n float(shouldFloat: boolean) {\n this.foundation.float(shouldFloat);\n }\n\n /**\n * Styles the label as required.\n * @param isRequired If true, adds an asterisk to the label, indicating that 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 a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCFloatingLabelAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n getWidth: () => estimateScrollWidth(this.root),\n registerInteractionHandler: (evtType, handler) =>\n this.listen(evtType, handler),\n deregisterInteractionHandler: (evtType, handler) =>\n this.unlisten(evtType, handler),\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCFloatingLabelFoundation(adapter);\n }\n}\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport const cssClasses = {\n LABEL_FLOAT_ABOVE: 'mdc-floating-label--float-above',\n LABEL_REQUIRED: 'mdc-floating-label--required',\n LABEL_SHAKE: 'mdc-floating-label--shake',\n ROOT: 'mdc-floating-label',\n};\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCFloatingLabelAdapter} from './adapter';\nimport {cssClasses} from './constants';\n\nexport class MDCFloatingLabelFoundation extends MDCFoundation<MDCFloatingLabelAdapter> {\n static override get cssClasses() {\n return cssClasses;\n }\n\n /**\n * See {@link MDCFloatingLabelAdapter} for typing information on parameters 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 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 shake class.\n */\n shake(shouldShake: boolean) {\n const {LABEL_SHAKE} = MDCFloatingLabelFoundation.cssClasses;\n if (shouldShake) {\n this.adapter.addClass(LABEL_SHAKE);\n } else {\n this.adapter.removeClass(LABEL_SHAKE);\n }\n }\n\n /**\n * Styles the label to float or dock.\n * @param shouldFloat If true, adds the float CSS class; otherwise, removes float and shake classes to dock the label.\n */\n float(shouldFloat: boolean) {\n const {LABEL_FLOAT_ABOVE, LABEL_SHAKE} = MDCFloatingLabelFoundation.cssClasses;\n if (shouldFloat) {\n this.adapter.addClass(LABEL_FLOAT_ABOVE);\n } else {\n this.adapter.removeClass(LABEL_FLOAT_ABOVE);\n this.adapter.removeClass(LABEL_SHAKE);\n }\n }\n\n /**\n * Styles the label as required.\n * @param isRequired If true, adds an asterisk to the label, indicating that 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 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 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCLineRippleAdapter} from './adapter';\nimport {MDCLineRippleFoundation} from './foundation';\n\nexport type MDCLineRippleFactory = (el: Element, foundation?: MDCLineRippleFoundation) => MDCLineRipple;\n\nexport class MDCLineRipple extends MDCComponent<MDCLineRippleFoundation> {\n static override attachTo(root: Element): MDCLineRipple {\n return new MDCLineRipple(root);\n }\n\n /**\n * Activates the line ripple\n */\n activate() {\n this.foundation.activate();\n }\n\n /**\n * Deactivates the line ripple\n */\n deactivate() {\n this.foundation.deactivate();\n }\n\n /**\n * Sets the transform origin given a user's click location.\n * The `rippleCenter` is the x-coordinate of the middle of the ripple.\n */\n setRippleCenter(xCoordinate: number) {\n this.foundation.setRippleCenter(xCoordinate);\n }\n\n override getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCLineRippleAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n hasClass: (className) => this.root.classList.contains(className),\n setStyle: (propertyName, value) => (this.root as HTMLElement).style.setProperty(propertyName, value),\n registerEventHandler: (evtType, handler) => this.listen(evtType, handler),\n deregisterEventHandler: (evtType, handler) => this.unlisten(evtType, handler),\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCLineRippleFoundation(adapter);\n }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n LINE_RIPPLE_ACTIVE: 'mdc-line-ripple--active',\n LINE_RIPPLE_DEACTIVATING: 'mdc-line-ripple--deactivating',\n};\n\nexport {cssClasses};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCLineRippleAdapter} from './adapter';\nimport {cssClasses} from './constants';\n\nexport class MDCLineRippleFoundation extends MDCFoundation<MDCLineRippleAdapter> {\n static override get cssClasses() {\n return cssClasses;\n }\n\n /**\n * See {@link MDCLineRippleAdapter} for typing information on parameters and 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 = (evt) => {\n this.handleTransitionEnd(evt);\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(evt: 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 (evt.propertyName === 'opacity') {\n if (isDeactivating) {\n this.adapter.removeClass(cssClasses.LINE_RIPPLE_ACTIVE);\n this.adapter.removeClass(cssClasses.LINE_RIPPLE_DEACTIVATING);\n }\n }\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCLineRippleFoundation;\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {closest, matches} from '@material/dom/ponyfill';\nimport {MDCListAdapter} from './adapter';\nimport {cssClasses, deprecatedClassNameMap, evolutionAttribute, evolutionClassNameMap, numbers, strings} from './constants';\nimport {MDCListFoundation} from './foundation';\nimport {MDCListActionEventDetail, MDCListIndex, MDCListSelectionChangeDetail} from './types';\n\nexport type MDCListFactory = (el: Element, foundation?: MDCListFoundation) =>\n MDCList;\n\nexport class MDCList extends MDCComponent<MDCListFoundation> {\n set vertical(value: boolean) {\n this.foundation.setVerticalOrientation(value);\n }\n\n get listElements(): Element[] {\n return Array.from(this.root.querySelectorAll(\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: Element) {\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 =\n evolutionAttribute in (this.root as HTMLElement).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(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 = this.root.querySelectorAll(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(\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(\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(strings.SELECTED_ITEM_SELECTOR),\n (listItem: Element) => 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 =\n this.root.querySelectorAll(strings.ARIA_ROLE_CHECKBOX_SELECTOR);\n const radioSelectedListItem =\n this.root.querySelector(strings.ARIA_CHECKED_RADIO_SELECTOR);\n\n if (checkboxListItems.length) {\n const preselectedItems =\n this.root.querySelectorAll(strings.ARIA_CHECKED_CHECKBOX_SELECTOR);\n this.selectedIndex = Array.from(\n preselectedItems,\n (listItem: Element) => 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 const element = this.listElements[index] as HTMLElement | undefined;\n if (element) {\n element.focus();\n }\n },\n getAttributeForElementIndex: (index, attr) =>\n this.listElements[index].getAttribute(attr),\n getFocusedElementIndex: () =>\n this.listElements.indexOf(document.activeElement!),\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(strings.CHECKBOX_SELECTOR);\n },\n hasRadioAtIndex: (index) => {\n const listItem = this.listElements[index];\n return !!listItem.querySelector(strings.RADIO_SELECTOR);\n },\n isCheckboxCheckedAtIndex: (index) => {\n const listItem = this.listElements[index];\n const toggleEl =\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>(strings.SELECTION_CHANGE_EVENT,\n {changedIndices}, /** 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 element.setAttribute(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(selector), (el: Element) => {\n el.setAttribute('tabindex', 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] as HTMLElement).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(\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 targetting. 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);\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(evt: FocusEvent) {\n const index = this.getListItemIndex(evt.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(evt: FocusEvent) {\n const index = this.getListItemIndex(evt.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(evt: KeyboardEvent) {\n const index = this.getListItemIndex(evt.target as Element);\n const target = evt.target as Element;\n this.foundation.handleKeydown(\n evt,\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(evt: MouseEvent) {\n const index = this.getListItemIndex(evt.target as Element);\n const target = evt.target as Element;\n // Toggle the checkbox only if it's not the target of the event, or the\n // checkbox will have 2 change events.\n const toggleCheckbox = !matches(target, strings.CHECKBOX_RADIO_SELECTOR);\n this.foundation.handleClick(index, toggleCheckbox, evt);\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 evt keyboard event to be prevented.\n */\nexport const preventDefaultEvent = (evt: KeyboardEvent) => {\n const target = evt.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 evt.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\ntype 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\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\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 = true;\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 } 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 ((isEnter || isSpace) && eventHasModifiers([])) {\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 && 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 && 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 this.focusItemAtIndex(initialIndex);\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 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 index: 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 const previousIsChecked = currentlySelected?.has(i);\n const newIsChecked = index.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 = 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 && changedIndices.length) {\n this.adapter.notifySelectionChange(changedIndices);\n }\n }\n\n /**\n * Toggles the state of all checkboxes in the given range (inclusive) based on\n * the state of the checkbox at the `toggleIndex`. To determine whether to set\n * the given range to checked or unchecked, read the value of the checkbox at\n * the `toggleIndex` and negate it. Then apply that new checked state to all\n * 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 change\n // 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 // 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 no\n // 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 0.\n if (!(this.selectedIndex instanceof Array) &&\n this.selectedIndex !== 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 // Action lists retain focus on the most recently focused item.\n if (!this.isSelectableList()) {\n return Math.max(this.focusedItemIndex, 0);\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.selectedIndex;\n }\n\n // Multiple-selection lists focus the first selected item.\n if (isNumberArray(this.selectedIndex) && this.selectedIndex.length > 0) {\n return this.selectedIndex.reduce(\n (minIndex, currentIndex) => Math.min(minIndex, currentIndex));\n }\n\n // Selection lists without a selection focus the first item.\n return 0;\n }\n\n private isIndexValid(index: MDCListIndex, validateListType: boolean = 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 checkboxListToggleAll(\n currentlySelectedIndexes: number[], isUserInteraction: boolean) {\n const count = this.adapter.getListItemCount();\n\n // If all items are selected, deselect everything.\n if (currentlySelectedIndexes.length === count) {\n this.setCheckboxAtIndex([], {isUserInteraction});\n } else {\n // Otherwise select all enabled options.\n const allIndexes: number[] = [];\n for (let i = 0; i < count; i++) {\n if (!this.isIndexDisabled(i) ||\n currentlySelectedIndexes.indexOf(i) > -1) {\n allIndexes.push(i);\n }\n }\n this.setCheckboxAtIndex(allIndexes, {isUserInteraction});\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 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(\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 current\n * list items by primary text.\n *\n * @return The primary texts of all the list items sorted by first 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 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 it's 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 mimicing the typeahead functionality of\n * 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 * @returns 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 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCMenuSurfaceAdapter} from './adapter';\nimport {Corner, cssClasses, strings} from './constants';\nimport {MDCMenuSurfaceFoundation} from './foundation';\nimport {MDCMenuDistance} from './types';\nimport {getCorrectPropertyName} from '@material/animation/util';\n\ntype RegisterFunction = () => void;\n\nexport type MDCMenuSurfaceFactory = (el: Element, foundation?: MDCMenuSurfaceFoundation) => MDCMenuSurface;\n\nexport class MDCMenuSurface extends MDCComponent<MDCMenuSurfaceFoundation> {\n static override attachTo(root: Element): 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 = parentEl && parentEl.classList.contains(cssClasses.ANCHOR) ? parentEl : null;\n\n if (this.root.classList.contains(cssClasses.FIXED)) {\n this.setFixedPosition(true);\n }\n\n this.handleKeydown = (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 /** Sets the foundation to use page offsets for an positioning when the menu is hoisted to the body. */\n setIsHoisted(isHoisted: boolean) {\n this.foundation.setIsHoisted(isHoisted);\n }\n\n /** Sets the element that the menu-surface is anchored to. */\n setMenuSurfaceAnchorElement(element: Element) {\n this.anchorElement = element;\n }\n\n /** Sets the menu-surface to position: fixed. */\n setFixedPosition(isFixed: boolean) {\n if (isFixed) {\n this.root.classList.add(cssClasses.FIXED);\n } else {\n this.root.classList.remove(cssClasses.FIXED);\n }\n\n this.foundation.setFixedPosition(isFixed);\n }\n\n /** Sets the absolute x/y position to position based on. Requires the menu to be hoisted. */\n setAbsolutePosition(x: number, y: number) {\n this.foundation.setAbsolutePosition(x, y);\n this.setIsHoisted(true);\n }\n\n /**\n * @param corner Default anchor corner alignment of top-left surface corner.\n */\n setAnchorCorner(corner: Corner) {\n this.foundation.setAnchorCorner(corner);\n }\n\n setAnchorMargin(margin: Partial<MDCMenuDistance>) {\n this.foundation.setAnchorMargin(margin);\n }\n\n override getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCMenuSurfaceAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n hasClass: (className) => this.root.classList.contains(className),\n hasAnchor: () => !!this.anchorElement,\n notifyClose: () =>\n this.emit(MDCMenuSurfaceFoundation.strings.CLOSED_EVENT, {}),\n notifyClosing: () => {\n this.emit(MDCMenuSurfaceFoundation.strings.CLOSING_EVENT, {});\n },\n notifyOpen: () =>\n this.emit(MDCMenuSurfaceFoundation.strings.OPENED_EVENT, {}),\n notifyOpening: () =>\n this.emit(MDCMenuSurfaceFoundation.strings.OPENING_EVENT, {}),\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 as HTMLElement).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 {\n width: (this.root as HTMLElement).offsetWidth,\n height: (this.root as HTMLElement).offsetHeight\n };\n },\n getAnchorDimensions: () => this.anchorElement ?\n this.anchorElement.getBoundingClientRect() :\n null,\n getWindowDimensions: () => {\n return {width: window.innerWidth, height: window.innerHeight};\n },\n getBodyDimensions: () => {\n return {width: document.body.clientWidth, height: document.body.clientHeight};\n },\n getWindowScroll: () => {\n return {x: window.pageXOffset, y: window.pageYOffset};\n },\n setPosition: (position) => {\n const rootHTML = this.root as HTMLElement;\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 as HTMLElement).style.maxHeight = height;\n },\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCMenuSurfaceFoundation(adapter);\n }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n ANCHOR: 'mdc-menu-surface--anchor',\n ANIMATING_CLOSED: 'mdc-menu-surface--animating-closed',\n ANIMATING_OPEN: 'mdc-menu-surface--animating-open',\n FIXED: 'mdc-menu-surface--fixed',\n 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 = CornerBit.BOTTOM | CornerBit.RIGHT, // tslint:disable-line:no-bitwise\n TOP_START = CornerBit.FLIP_RTL,\n TOP_END = CornerBit.FLIP_RTL | CornerBit.RIGHT, // tslint:disable-line:no-bitwise\n BOTTOM_START = CornerBit.BOTTOM | CornerBit.FLIP_RTL, // tslint:disable-line:no-bitwise\n BOTTOM_END = CornerBit.BOTTOM | CornerBit.RIGHT | CornerBit.FLIP_RTL, // tslint:disable-line:no-bitwise\n}\n\nexport {cssClasses, strings, numbers, CornerBit, Corner};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\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\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 getWindowDimensions: () => ({height: 0, width: 0}),\n getBodyDimensions: () => ({height: 0, width: 0}),\n getWindowScroll: () => ({x: 0, y: 0}),\n setPosition: () => undefined,\n setMaxHeight: () => undefined,\n setTransformOrigin: () => undefined,\n\n saveFocus: () => undefined,\n restoreFocus: () => undefined,\n\n notifyClose: () => undefined,\n notifyClosing: () => undefined,\n notifyOpen: () => undefined,\n notifyOpening: () => 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 /**\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\n override destroy() {\n clearTimeout(this.openAnimationEndTimerId);\n clearTimeout(this.closeAnimationEndTimerId);\n // Cancel any currently running animations.\n cancelAnimationFrame(this.animationRequestId);\n }\n\n /**\n * @param corner Default anchor corner alignment of top-left menu surface\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\n /**\n * Closes the menu surface.\n */\n close(skipRestoreFocus = false) {\n if (!this.isSurfaceOpen) {\n return;\n }\n\n this.adapter.notifyClosing();\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(evt: MouseEvent) {\n const el = evt.target as Element;\n if (this.adapter.isElementInContainer(el)) {\n return;\n }\n this.close();\n }\n\n /** Handle keys that close the surface. */\n handleKeydown(evt: KeyboardEvent) {\n const {keyCode, key} = evt;\n\n const isEscape = key === 'Escape' || keyCode === 27;\n if (isEscape) {\n this.close();\n }\n }\n\n private autoposition() {\n // Compute measurements for autoposition methods reuse.\n this.measurements = this.getAutoLayoutmeasurements();\n\n const corner = this.getoriginCorner();\n const maxMenuSurfaceHeight = this.getMenuSurfaceMaxHeight(corner);\n const verticalAlignment =\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.getWindowDimensions();\n const windowScroll = this.adapter.getWindowScroll();\n\n if (!anchorRect) {\n // tslint:disable:object-literal-sort-keys Positional properties are more readable when they're grouped together\n anchorRect = {\n top: this.position.y,\n right: this.position.x,\n bottom: this.position.y,\n left: this.position.x,\n width: 0,\n height: 0,\n } 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.right;\n availableRight = viewportDistance.right - this.anchorMargin.right;\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 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';\nimport {MDCMenuAdapter} from './adapter';\nimport {cssClasses, DefaultFocusState, strings} from './constants';\nimport {MDCMenuFoundation} from './foundation';\nimport {MDCMenuItemComponentEventDetail} from './types';\n\nexport type MDCMenuFactory = (el: Element, foundation?: MDCMenuFoundation) => MDCMenu;\n\nexport class MDCMenu extends MDCComponent<MDCMenuFoundation> {\n static override attachTo(root: Element) {\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(strings.LIST_SELECTOR);\n if (list) {\n this.list = this.listFactory(list);\n this.list.wrapFocus = true;\n } else {\n this.list = null;\n }\n\n this.handleKeydown = (evt) => {\n this.foundation.handleKeydown(evt);\n };\n this.handleItemAction = (evt) => {\n this.foundation.handleItemAction(this.items[evt.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 elements within\n * the items container that are proper list items, and not supplemental / presentational DOM\n * elements.\n */\n get items(): Element[] {\n return this.list ? this.list.listElements : [];\n }\n\n /**\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 a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCMenuAdapter = {\n addClassToElementAtIndex: (index, className) => {\n const list = this.items;\n list[index].classList.add(className);\n },\n removeClassFromElementAtIndex: (index, className) => {\n const list = this.items;\n list[index].classList.remove(className);\n },\n addAttributeToElementAtIndex: (index, attr, value) => {\n const list = this.items;\n list[index].setAttribute(attr, value);\n },\n removeAttributeFromElementAtIndex: (index, attr) => {\n const list = this.items;\n list[index].removeAttribute(attr);\n },\n 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: (evtData) => {\n this.emit<MDCMenuItemComponentEventDetail>(strings.SELECTED_EVENT, {\n index: evtData.index,\n item: this.items[evtData.index],\n });\n },\n getMenuItemCount: () => this.items.length,\n focusItemAtIndex: (index) => {\n (this.items[index] as HTMLElement).focus();\n },\n focusListRoot: () => {\n (this.root.querySelector(strings.LIST_SELECTOR) as HTMLElement).focus();\n },\n isSelectableItemAtIndex: (index) =>\n !!closest(this.items[index], `.${cssClasses.MENU_SELECTION_GROUP}`),\n getSelectedSiblingOfItemAtIndex: (index) => {\n const selectionGroupEl = closest(this.items[index], `.${cssClasses.MENU_SELECTION_GROUP}`) as HTMLElement;\n const selectedItemEl = selectionGroupEl.querySelector(`.${cssClasses.MENU_SELECTED_LIST_ITEM}`);\n return selectedItemEl ? this.items.indexOf(selectedItemEl) : -1;\n },\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCMenuFoundation(adapter);\n }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst cssClasses = {\n MENU_SELECTED_LIST_ITEM: 'mdc-menu-item--selected',\n MENU_SELECTION_GROUP: 'mdc-menu__selection-group',\n ROOT: 'mdc-menu',\n};\n\nconst strings = {\n ARIA_CHECKED_ATTR: 'aria-checked',\n ARIA_DISABLED_ATTR: 'aria-disabled',\n CHECKBOX_SELECTOR: 'input[type=\"checkbox\"]',\n LIST_SELECTOR: '.mdc-list,.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';\nimport {MDCMenuSurfaceFoundation} from '@material/menu-surface/foundation';\nimport {MDCMenuAdapter} from './adapter';\nimport {cssClasses, DefaultFocusState, numbers, strings} from './constants';\n\nexport class MDCMenuFoundation extends MDCFoundation<MDCMenuAdapter> {\n static 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 closeAnimationEndTimerId = 0;\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 if (this.closeAnimationEndTimerId) {\n clearTimeout(this.closeAnimationEndTimerId);\n }\n\n this.adapter.closeSurface();\n }\n\n handleKeydown(evt: KeyboardEvent) {\n const {key, keyCode} = evt;\n const isTab = key === 'Tab' || keyCode === 9;\n\n if (isTab) {\n this.adapter.closeSurface(/** skipRestoreFocus */ true);\n }\n }\n\n handleItemAction(listItem: Element) {\n const index = this.adapter.getElementIndex(listItem);\n if (index < 0) {\n return;\n }\n\n this.adapter.notifySelected({index});\n const skipRestoreFocus = this.adapter.getAttributeFromElementAtIndex(\n index, strings.SKIP_RESTORE_FOCUS) === 'true';\n this.adapter.closeSurface(skipRestoreFocus);\n\n // Wait for the menu to close before adding/removing classes that affect styles.\n this.closeAnimationEndTimerId = setTimeout(() => {\n // Recompute the index in case the menu contents have changed.\n const recomputedIndex = this.adapter.getElementIndex(listItem);\n if (recomputedIndex >= 0 &&\n this.adapter.isSelectableItemAtIndex(recomputedIndex)) {\n this.setSelectedIndex(recomputedIndex);\n }\n }, MDCMenuSurfaceFoundation.numbers.TRANSITION_CLOSE_DURATION);\n }\n\n handleMenuSurfaceOpened() {\n switch (this.defaultFocusState) {\n case DefaultFocusState.FIRST_ITEM:\n this.adapter.focusItemAtIndex(0);\n break;\n case DefaultFocusState.LAST_ITEM:\n this.adapter.focusItemAtIndex(this.adapter.getMenuItemCount() - 1);\n break;\n case DefaultFocusState.NONE:\n // Do nothing.\n break;\n default:\n this.adapter.focusListRoot();\n break;\n }\n }\n\n /**\n * Sets default focus state where the menu should focus every time when menu\n * is opened. Focuses the list root (`DefaultFocusState.LIST_ROOT`) element by\n * default.\n */\n setDefaultFocusState(focusState: DefaultFocusState) {\n this.defaultFocusState = focusState;\n }\n\n /** @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('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 2017 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCFloatingLabelFoundation} from '@material/floating-label/foundation';\nimport {MDCNotchedOutlineAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCNotchedOutlineFoundation} from './foundation';\n\nexport type MDCNotchedOutlineFactory = (el: Element, foundation?: MDCNotchedOutlineFoundation) => MDCNotchedOutline;\n\nexport class MDCNotchedOutline extends MDCComponent<MDCNotchedOutlineFoundation> {\n static override attachTo(root: Element): 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 a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCNotchedOutlineAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n setNotchWidthProperty: (width) => {\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';\nimport {MDCNotchedOutlineAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\nexport class MDCNotchedOutlineFoundation extends 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 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 based off of notchWidth.\n */\n notch(notchWidth: number) {\n const {OUTLINE_NOTCHED} = MDCNotchedOutlineFoundation.cssClasses;\n\n if (notchWidth > 0) {\n notchWidth += numbers.NOTCH_ELEMENT_PADDING; // Add padding from left/right.\n }\n\n this.adapter.setNotchWidthProperty(notchWidth);\n this.adapter.addClass(OUTLINE_NOTCHED);\n }\n\n /**\n * Removes notched outline selector to close the notch in the outline.\n */\n closeNotch() {\n const {OUTLINE_NOTCHED} = MDCNotchedOutlineFoundation.cssClasses;\n this.adapter.removeClass(OUTLINE_NOTCHED);\n this.adapter.removeNotchWidthProperty();\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCNotchedOutlineFoundation;\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCComponent} from '@material/base/component';\nimport {applyPassive} from '@material/dom/events';\nimport {matches} from '@material/dom/ponyfill';\nimport {MDCRippleAdapter} from './adapter';\nimport {MDCRippleFoundation} from './foundation';\nimport {MDCRippleAttachOpts, MDCRippleCapableSurface} from './types';\nimport * as util from './util';\n\nexport type MDCRippleFactory = (el: Element, foundation?: MDCRippleFoundation) => MDCRipple;\n\nexport class MDCRipple extends MDCComponent<MDCRippleFoundation> implements MDCRippleCapableSurface {\n static override attachTo(root: Element, 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) => instance.root.classList.add(className),\n browserSupportsCssVars: () => util.supportsCssVariables(window),\n computeBoundingRect: () => instance.root.getBoundingClientRect(),\n containsEventTarget: (target) => instance.root.contains(target as Node),\n deregisterDocumentInteractionHandler: (evtType, handler) =>\n document.documentElement.removeEventListener(\n evtType, handler, applyPassive()),\n deregisterInteractionHandler: (evtType, handler) =>\n (instance.root as HTMLElement)\n .removeEventListener(evtType, handler, applyPassive()),\n deregisterResizeHandler: (handler) =>\n window.removeEventListener('resize', handler),\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: (evtType, handler) =>\n document.documentElement.addEventListener(\n evtType, handler, applyPassive()),\n registerInteractionHandler: (evtType, handler) =>\n (instance.root as HTMLElement)\n .addEventListener(evtType, handler, applyPassive()),\n registerResizeHandler: (handler) =>\n window.addEventListener('resize', handler),\n removeClass: (className) => instance.root.classList.remove(className),\n updateCssVariable: (varName, value) =>\n (instance.root as HTMLElement).style.setProperty(varName, value),\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 as HTMLElement;\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 sorts,\n // given that it's an 'upgrade' to an existing component. That being said it is the root\n // CSS class that all other CSS classes derive from.\n BG_FOCUSED: 'mdc-ripple-upgraded--background-focused',\n FG_ACTIVATION: 'mdc-ripple-upgraded--foreground-activation',\n FG_DEACTIVATION: 'mdc-ripple-upgraded--foreground-deactivation',\n ROOT: 'mdc-ripple-upgraded',\n UNBOUNDED: 'mdc-ripple-upgraded--unbounded',\n};\n\nexport const strings = {\n VAR_FG_SCALE: '--mdc-ripple-fg-scale',\n VAR_FG_SIZE: '--mdc-ripple-fg-size',\n VAR_FG_TRANSLATE_END: '--mdc-ripple-fg-translate-end',\n VAR_FG_TRANSLATE_START: '--mdc-ripple-fg-translate-start',\n VAR_LEFT: '--mdc-ripple-left',\n VAR_TOP: '--mdc-ripple-top',\n};\n\nexport const numbers = {\n DEACTIVATION_TIMEOUT_MS: 225, // Corresponds to $mdc-ripple-translate-duration (i.e. activation animation duration)\n FG_DEACTIVATION_MS: 150, // Corresponds to $mdc-ripple-fade-out-duration (i.e. deactivation animation duration)\n INITIAL_ORIGIN_SCALE: 0.6,\n PADDING: 10,\n TAP_DELAY_MS: 300, // Delay between touch and simulated mouse events on touch devices\n};\n","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCRippleAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\nimport {MDCRipplePoint} from './types';\nimport {getNormalizedEventCoords} from './util';\n\ninterface ActivationStateType {\n isActivated?: boolean;\n hasDeactivationUXRun?: boolean;\n wasActivatedByPointer?: boolean;\n wasElementMadeActive?: boolean;\n activationEvent?: Event;\n isProgrammatic?: boolean;\n}\n\ninterface FgTranslationCoordinates {\n startPoint: MDCRipplePoint;\n endPoint: MDCRipplePoint;\n}\n\ninterface Coordinates {\n left: number;\n top: number;\n}\n\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 activation\nconst ACTIVATION_EVENT_TYPES: ActivationEventType[] = [\n 'touchstart', 'pointerdown', 'mousedown', 'keydown',\n];\n\n// Deactivation events registered on documentElement when a pointer-related down event occurs\nconst POINTER_DEACTIVATION_EVENT_TYPES: DeactivationEventType[] = [\n 'touchend', 'pointerup', 'mouseup', 'contextmenu',\n];\n\n// simultaneous nested activations\nlet activatedTargets: Array<EventTarget | null> = [];\n\nexport class MDCRippleFoundation extends MDCFoundation<MDCRippleAdapter> {\n static 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 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 evt Optional event containing position information.\n */\n activate(evt?: Event): void {\n this.activateImpl(evt);\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 handleBlur(): void {\n requestAnimationFrame(\n () => this.adapter.removeClass(\n MDCRippleFoundation.cssClasses.BG_FOCUSED));\n }\n\n /**\n * We compute this property so that we are not querying information about the client\n * until the point in time where the foundation requests it. This prevents scenarios where\n * client-side feature-detection may happen too early, such as when components are rendered on the server\n * and then initialized at mount time on the client.\n */\n private supportsPressRipple(): boolean {\n return this.adapter.browserSupportsCssVars();\n }\n\n private defaultActivationState(): ActivationStateType {\n return {\n activationEvent: undefined,\n hasDeactivationUXRun: false,\n isActivated: false,\n isProgrammatic: false,\n wasActivatedByPointer: false,\n wasElementMadeActive: false,\n };\n }\n\n /**\n * supportsPressRipple Passed from init to save a redundant function call\n */\n private registerRootHandlers(supportsPressRipple: boolean) {\n if (supportsPressRipple) {\n for (const evtType of ACTIVATION_EVENT_TYPES) {\n this.adapter.registerInteractionHandler(evtType, this.activateHandler);\n }\n if (this.adapter.isUnbounded()) {\n this.adapter.registerResizeHandler(this.resizeHandler);\n }\n }\n\n this.adapter.registerInteractionHandler('focus', this.focusHandler);\n this.adapter.registerInteractionHandler('blur', this.blurHandler);\n }\n\n private registerDeactivationHandlers(evt: Event) {\n if (evt.type === 'keydown') {\n this.adapter.registerInteractionHandler('keyup', this.deactivateHandler);\n } else {\n for (const evtType of POINTER_DEACTIVATION_EVENT_TYPES) {\n this.adapter.registerDocumentInteractionHandler(\n evtType, this.deactivateHandler);\n }\n }\n }\n\n private deregisterRootHandlers() {\n for (const evtType of ACTIVATION_EVENT_TYPES) {\n this.adapter.deregisterInteractionHandler(evtType, this.activateHandler);\n }\n this.adapter.deregisterInteractionHandler('focus', this.focusHandler);\n this.adapter.deregisterInteractionHandler('blur', this.blurHandler);\n\n if (this.adapter.isUnbounded()) {\n this.adapter.deregisterResizeHandler(this.resizeHandler);\n }\n }\n\n private deregisterDeactivationHandlers() {\n this.adapter.deregisterInteractionHandler('keyup', this.deactivateHandler);\n for (const evtType of POINTER_DEACTIVATION_EVENT_TYPES) {\n this.adapter.deregisterDocumentInteractionHandler(\n evtType, this.deactivateHandler);\n }\n }\n\n private removeCssVars() {\n const rippleStrings = MDCRippleFoundation.strings;\n const keys = Object.keys(rippleStrings) as Array<keyof typeof rippleStrings>;\n keys.forEach((key) => {\n if (key.indexOf('VAR_') === 0) {\n this.adapter.updateCssVariable(rippleStrings[key], null);\n }\n });\n }\n\n private activateImpl(evt?: Event) {\n if (this.adapter.isSurfaceDisabled()) {\n return;\n }\n\n const activationState = this.activationState;\n if (activationState.isActivated) {\n return;\n }\n\n // Avoid reacting to follow-on events fired by touch device after an already-processed user interaction\n const previousActivationEvent = this.previousActivationEvent;\n const isSameInteraction = previousActivationEvent && evt !== undefined && previousActivationEvent.type !== evt.type;\n if (isSameInteraction) {\n return;\n }\n\n activationState.isActivated = true;\n activationState.isProgrammatic = evt === undefined;\n activationState.activationEvent = evt;\n activationState.wasActivatedByPointer = activationState.isProgrammatic ? false : evt !== undefined && (\n evt.type === 'mousedown' || evt.type === 'touchstart' || evt.type === 'pointerdown'\n );\n\n const hasActivatedChild = evt !== undefined &&\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 prevents touch follow-on events\n this.resetActivationState();\n return;\n }\n\n if (evt !== undefined) {\n activatedTargets.push(evt.target);\n this.registerDeactivationHandlers(evt);\n }\n\n activationState.wasElementMadeActive = this.checkElementMadeActive(evt);\n if (activationState.wasElementMadeActive) {\n this.animateActivation();\n }\n\n requestAnimationFrame(() => {\n // Reset array on next frame after the current event has had a chance to bubble to prevent ancestor ripples\n activatedTargets = [];\n\n if (!activationState.wasElementMadeActive\n && evt !== undefined\n && ((evt as KeyboardEvent).key === ' ' || (evt as KeyboardEvent).keyCode === 32)) {\n // If space was pressed, try again within an rAF call to detect :active, because different UAs report\n // active states inconsistently when they're called within event handling code:\n // - https://bugs.chromium.org/p/chromium/issues/detail?id=635971\n // - https://bugzilla.mozilla.org/show_bug.cgi?id=1293741\n // We try first outside rAF to support Edge, which does not exhibit this problem, but will crash if a CSS\n // variable is set within a rAF callback for a submit button interaction (#2241).\n activationState.wasElementMadeActive = this.checkElementMadeActive(evt);\n if (activationState.wasElementMadeActive) {\n this.animateActivation();\n }\n }\n\n if (!activationState.wasElementMadeActive) {\n // Reset activation state immediately if element was not made active.\n this.activationState = this.defaultActivationState();\n }\n });\n }\n\n private checkElementMadeActive(evt?: Event) {\n return (evt !== undefined && evt.type === 'keydown') ?\n this.adapter.isSurfaceActive() :\n true;\n }\n\n private animateActivation() {\n const {VAR_FG_TRANSLATE_START, VAR_FG_TRANSLATE_END} = MDCRippleFoundation.strings;\n const {FG_DEACTIVATION, FG_ACTIVATION} = MDCRippleFoundation.cssClasses;\n const {DEACTIVATION_TIMEOUT_MS} = MDCRippleFoundation.numbers;\n\n this.layoutInternal();\n\n let translateStart = '';\n let translateEnd = '';\n\n if (!this.adapter.isUnbounded()) {\n const {startPoint, endPoint} = this.getFgTranslationCoordinates();\n translateStart = `${startPoint.x}px, ${startPoint.y}px`;\n translateEnd = `${endPoint.x}px, ${endPoint.y}px`;\n }\n\n this.adapter.updateCssVariable(VAR_FG_TRANSLATE_START, translateStart);\n this.adapter.updateCssVariable(VAR_FG_TRANSLATE_END, translateEnd);\n // Cancel any ongoing activation/deactivation animations\n clearTimeout(this.activationTimer);\n clearTimeout(this.fgDeactivationRemovalTimer);\n this.rmBoundedActivationClasses();\n this.adapter.removeClass(FG_DEACTIVATION);\n\n // Force layout in order to re-trigger the animation.\n this.adapter.computeBoundingRect();\n this.adapter.addClass(FG_ACTIVATION);\n this.activationTimer = setTimeout(() => {\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 the activation animation ends.\n // The deactivation animation should only run after both of those occur.\n const {FG_DEACTIVATION} = MDCRippleFoundation.cssClasses;\n const {hasDeactivationUXRun, isActivated} = this.activationState;\n const activationHasEnded = hasDeactivationUXRun || !isActivated;\n\n if (activationHasEnded && this.activationAnimationHasEnded) {\n this.rmBoundedActivationClasses();\n this.adapter.addClass(FG_DEACTIVATION);\n this.fgDeactivationRemovalTimer = setTimeout(() => {\n this.adapter.removeClass(FG_DEACTIVATION);\n }, numbers.FG_DEACTIVATION_MS);\n }\n }\n\n private rmBoundedActivationClasses() {\n const {FG_ACTIVATION} = MDCRippleFoundation.cssClasses;\n this.adapter.removeClass(FG_ACTIVATION);\n this.activationAnimationHasEnded = false;\n this.adapter.computeBoundingRect();\n }\n\n private resetActivationState() {\n this.previousActivationEvent = this.activationState.activationEvent;\n this.activationState = this.defaultActivationState();\n // Touch devices may fire additional events for the same interaction within a short time.\n // Store the previous event until it's safe to assume that subsequent events are for new interactions.\n setTimeout(\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 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 ripples.\n // Unbounded ripple diameter is calculated smaller since the surface is expected to already be padded appropriately\n // to extend the hitbox, and the ripple is expected to meet the edges of the padded hitbox (which is typically\n // square). Bounded ripples, on the other hand, are fully expected to expand beyond the surface's longest diameter\n // (calculated based on the diagonal plus a constant padding), and are clipped at the surface's border via\n // `overflow: hidden`.\n const getBoundedRadius = () => {\n const hypotenuse = Math.sqrt(\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, then scales up using a CSS scale transform\n const initialSize = Math.floor(maxDim * MDCRippleFoundation.numbers.INITIAL_ORIGIN_SCALE);\n // Unbounded ripple size should always be even number to equally center 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, VAR_LEFT, VAR_TOP, VAR_FG_SCALE,\n } = MDCRippleFoundation.strings;\n\n this.adapter.updateCssVariable(VAR_FG_SIZE, `${this.initialSize}px`);\n this.adapter.updateCssVariable(VAR_FG_SCALE, this.fgScale);\n\n if (this.adapter.isUnbounded()) {\n this.unboundedCoords = {\n left: Math.round((this.frame.width / 2) - (this.initialSize / 2)),\n top: Math.round((this.frame.height / 2) - (this.initialSize / 2)),\n };\n\n this.adapter.updateCssVariable(\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 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport {MDCRipplePoint} from './types';\n\n/**\n * Stores result from supportsCssVariables to avoid redundant processing to\n * detect CSS custom variable support.\n */\nlet supportsCssVariables_: boolean | undefined;\n\nexport function supportsCssVariables(windowObj: typeof globalThis, forceRefresh = false): boolean {\n const {CSS} = windowObj;\n let supportsCssVars = supportsCssVariables_;\n if (typeof supportsCssVariables_ === 'boolean' && !forceRefresh) {\n return supportsCssVariables_;\n }\n\n const supportsFunctionPresent = CSS && typeof CSS.supports === 'function';\n if (!supportsFunctionPresent) {\n return false;\n }\n\n const explicitlySupportsCssVars = CSS.supports('--css-vars', 'yes');\n // See: https://bugs.webkit.org/show_bug.cgi?id=154669\n // See: README section on Safari\n const weAreFeatureDetectingSafari10plus = (\n CSS.supports('(--css-vars: yes)') &&\n CSS.supports('color', '#00000000')\n );\n\n supportsCssVars =\n explicitlySupportsCssVars || weAreFeatureDetectingSafari10plus;\n\n if (!forceRefresh) {\n supportsCssVariables_ = supportsCssVars;\n }\n return supportsCssVars;\n}\n\nexport function getNormalizedEventCoords(evt: Event | undefined, pageOffset: MDCRipplePoint, clientRect: DOMRect):\n MDCRipplePoint {\n if (!evt) {\n return {x: 0, y: 0};\n }\n const {x, y} = pageOffset;\n const documentX = x + clientRect.left;\n const documentY = y + clientRect.top;\n\n let normalizedX;\n let normalizedY;\n // Determine touch point relative to the ripple container.\n if (evt.type === 'touchstart') {\n const touchEvent = evt as TouchEvent;\n normalizedX = touchEvent.changedTouches[0].pageX - documentX;\n normalizedY = touchEvent.changedTouches[0].pageY - documentY;\n } else {\n const mouseEvent = evt as MouseEvent;\n normalizedX = mouseEvent.pageX - documentX;\n normalizedY = mouseEvent.pageY - documentY;\n }\n\n return {x: normalizedX, y: normalizedY};\n}\n","/**\n * @license\n * Copyright 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';\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\nexport class MDCSelect extends MDCComponent<MDCSelectFoundation> {\n static override attachTo(root: Element): 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!: Element; // 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(strings.SELECT_ANCHOR_SELECTOR) as HTMLElement;\n this.selectedText =\n this.root.querySelector(strings.SELECTED_TEXT_SELECTOR) as HTMLElement;\n this.hiddenInput = this.root.querySelector(strings.HIDDEN_INPUT_SELECTOR) as\n HTMLInputElement;\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 = this.root.querySelector(strings.LABEL_SELECTOR);\n this.label = labelElement ? labelFactory(labelElement) : null;\n\n const lineRippleElement =\n this.root.querySelector(strings.LINE_RIPPLE_SELECTOR);\n this.lineRipple =\n lineRippleElement ? lineRippleFactory(lineRippleElement) : null;\n\n const outlineElement = this.root.querySelector(strings.OUTLINE_SELECTOR);\n this.outline = outlineElement ? outlineFactory(outlineElement) : null;\n\n const leadingIcon = this.root.querySelector(strings.LEADING_ICON_SELECTOR);\n if (leadingIcon) {\n this.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 = (evt) => {\n this.selectAnchor.focus();\n this.foundation.handleClick(this.getNormalizedXCoordinate(evt));\n };\n this.handleKeydown = (evt) => {\n this.foundation.handleKeydown(evt);\n };\n this.handleMenuItemAction = (evt) => {\n this.foundation.handleMenuItemAction(evt.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 a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCSelectAdapter = {\n ...this.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 = this.root.querySelector(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 a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCRippleAdapter = {\n ...MDCRipple.createAdapter({root: this.selectAnchor}),\n registerInteractionHandler: (evtType, handler) => {\n this.selectAnchor.addEventListener(evtType, handler);\n },\n deregisterInteractionHandler: (evtType, handler) => {\n this.selectAnchor.removeEventListener(evtType, 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 isSelectAnchorFocused: () => document.activeElement === this.selectAnchor,\n getSelectAnchorAttr: (attr: string) =>\n this.selectAnchor.getAttribute(attr),\n setSelectAnchorAttr: (attr: string, value: string) => {\n this.selectAnchor.setAttribute(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(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] as HTMLElement).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 within the component.\n */\n private getNormalizedXCoordinate(evt: MouseEvent|TouchEvent): number {\n const targetClientRect = (evt.target as Element).getBoundingClientRect();\n const xCoordinate =\n this.isTouchEvent(evt) ? evt.touches[0].clientX : evt.clientX;\n return xCoordinate - targetClientRect.left;\n }\n\n private isTouchEvent(evt: MouseEvent|TouchEvent): evt is TouchEvent {\n return Boolean((evt as TouchEvent).touches);\n }\n\n /**\n * Returns a map of all subcomponents to subfoundations.\n */\n private getFoundationMap(): Partial<MDCSelectFoundationMap> {\n return {\n helperText: this.helperText ? this.helperText.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\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 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\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(adapter?: Partial<MDCSelectAdapter>, foundationMap: Partial<MDCSelectFoundationMap> = {}) {\n super({...MDCSelectFoundation.defaultAdapter, ...adapter});\n\n this.leadingIcon = foundationMap.leadingIcon;\n this.helperText = foundationMap.helperText;\n }\n\n /** 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 if (index === numbers.UNSET_INDEX) {\n this.adapter.setSelectedText('');\n } else {\n this.adapter.setSelectedText(\n this.adapter.getMenuItemTextAtIndex(index).trim());\n }\n\n this.adapter.setSelectedIndex(index);\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 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 https://www.w3.org/TR/html52/sec-forms.html#the-select-element\n // TL;DR: Invalid if no index is selected, or if the first index is selected and has an empty value.\n return this.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(strings.ARIA_DESCRIBEDBY, helperTextId);\n } else {\n // Needed because screenreaders will read labels pointed to by\n // `aria-describedby` even if they are `aria-hidden`.\n this.adapter.removeSelectAnchorAttr(strings.ARIA_DESCRIBEDBY);\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';\nimport {MDCSelectHelperTextAdapter} from './adapter';\nimport {MDCSelectHelperTextFoundation} from './foundation';\n\nexport type MDCSelectHelperTextFactory =\n (el: Element, foundation?: MDCSelectHelperTextFoundation) => MDCSelectHelperText;\n\nexport class MDCSelectHelperText extends MDCComponent<MDCSelectHelperTextFoundation> {\n static override attachTo(root: Element): 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 a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCSelectHelperTextAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n hasClass: (className) => this.root.classList.contains(className),\n getAttr: (attr) => this.root.getAttribute(attr),\n setAttr: (attr, value) => this.root.setAttribute(attr, value),\n removeAttr: (attr) => this.root.removeAttribute(attr),\n setContent: (content) => {\n this.root.textContent = content;\n },\n };\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';\nimport {MDCSelectHelperTextAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCSelectHelperTextFoundation extends 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 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>(evtType: 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>(evtType: 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';\nimport {MDCSelectIconAdapter} from './adapter';\nimport {MDCSelectIconFoundation} from './foundation';\n\nexport type MDCSelectIconFactory = (el: Element, foundation?: MDCSelectIconFoundation) => MDCSelectIcon;\n\nexport class MDCSelectIcon extends MDCComponent<MDCSelectIconFoundation> {\n static override attachTo(root: Element): 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 a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCSelectIconAdapter = {\n getAttr: (attr) => this.root.getAttribute(attr),\n setAttr: (attr, value) => this.root.setAttribute(attr, value),\n removeAttr: (attr) => this.root.removeAttribute(attr),\n setContent: (content) => {\n this.root.textContent = content;\n },\n registerInteractionHandler: (evtType, handler) =>\n this.listen(evtType, handler),\n deregisterInteractionHandler: (evtType, handler) =>\n this.unlisten(evtType, handler),\n notifyIconAction: () => this.emit(\n MDCSelectIconFoundation.strings.ICON_EVENT, {} /* evtData */,\n true /* shouldBubble */),\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCSelectIconFoundation(adapter);\n }\n}\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst strings = {\n ICON_EVENT: 'MDCSelect:icon',\n ICON_ROLE: 'button',\n};\n\nexport {strings};\n","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCSelectIconAdapter} from './adapter';\nimport {strings} from './constants';\n\ntype InteractionEventType = 'click' | 'keydown';\n\nconst INTERACTION_EVENTS: InteractionEventType[] = ['click', 'keydown'];\n\nexport class MDCSelectIconFoundation extends MDCFoundation<MDCSelectIconAdapter> {\n static override get strings() {\n return strings;\n }\n\n /**\n * See {@link MDCSelectIconAdapter} for typing information on parameters and 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 = (evt) => {\n this.handleInteraction(evt);\n };\n }\n\n override init() {\n this.savedTabIndex = this.adapter.getAttr('tabindex');\n\n for (const evtType of INTERACTION_EVENTS) {\n this.adapter.registerInteractionHandler(evtType, this.interactionHandler);\n }\n }\n\n override destroy() {\n for (const evtType of INTERACTION_EVENTS) {\n this.adapter.deregisterInteractionHandler(\n evtType, this.interactionHandler);\n }\n }\n\n setDisabled(disabled: boolean) {\n if (!this.savedTabIndex) {\n return;\n }\n\n if (disabled) {\n this.adapter.setAttr('tabindex', '-1');\n this.adapter.removeAttr('role');\n } else {\n this.adapter.setAttr('tabindex', this.savedTabIndex);\n this.adapter.setAttr('role', strings.ICON_ROLE);\n }\n }\n\n setAriaLabel(label: string) {\n this.adapter.setAttr('aria-label', label);\n }\n\n setContent(content: string) {\n this.adapter.setContent(content);\n }\n\n handleInteraction(evt: MouseEvent | KeyboardEvent) {\n const isEnterKey = (evt as KeyboardEvent).key === 'Enter' || (evt as KeyboardEvent).keyCode === 13;\n if (evt.type === 'click' || isEnterKey) {\n this.adapter.notifyIconAction();\n }\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCSelectIconFoundation;\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport {strings as iconStrings} from './constants';\n","/**\n * @license\n * Copyright 2019 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\nexport * from './helper-text/index';\nexport * from './icon/index';\n","/**\n * @license\n * Copyright 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"],"sourceRoot":""}
\No newline at end of file