{"version":3,"sources":["webpack:///./node_modules/@vaadin/component-base/src/define.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/version.js","webpack:///./node_modules/@lit/reactive-element/css-tag.js","webpack:///./node_modules/@lit/reactive-element/reactive-element.js","webpack:///./node_modules/lit-html/lit-html.js","webpack:///./node_modules/lit-element/lit-element.js","webpack:///./node_modules/lit-html/is-server.js","webpack:///./node_modules/@vaadin/vaadin-themable-mixin/vaadin-theme-property-mixin.js","webpack:///./node_modules/@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/global.js","webpack:///./node_modules/@vaadin/vaadin-themable-mixin/register-styles.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/color.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/font-icons.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/spacing.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/style.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/typography.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/sizing.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/mixins/field-button.js","webpack:///./node_modules/@vaadin/multi-select-combo-box/theme/lumo/vaadin-multi-select-combo-box-chip-styles.js","webpack:///./node_modules/@vaadin/input-container/theme/lumo/vaadin-input-container-styles.js","webpack:///./node_modules/@vaadin/item/theme/lumo/vaadin-item-styles.js","webpack:///./node_modules/@vaadin/combo-box/theme/lumo/vaadin-combo-box-item-styles.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/mixins/loader.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/mixins/overlay.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/mixins/menu-overlay.js","webpack:///./node_modules/@vaadin/combo-box/theme/lumo/vaadin-combo-box-overlay-styles.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/mixins/helper.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/mixins/required-field.js","webpack:///./node_modules/@vaadin/vaadin-lumo-styles/mixins/input-field-shared.js","webpack:///./node_modules/@vaadin/multi-select-combo-box/theme/lumo/vaadin-multi-select-combo-box-styles.js","webpack:///./node_modules/@polymer/polymer/lib/utils/boot.js","webpack:///./node_modules/@polymer/polymer/lib/utils/resolve-url.js","webpack:///./node_modules/@polymer/polymer/lib/utils/settings.js","webpack:///./node_modules/@polymer/polymer/lib/utils/mixin.js","webpack:///./node_modules/@polymer/polymer/lib/elements/dom-module.js","webpack:///./node_modules/@polymer/polymer/lib/utils/style-gather.js","webpack:///./node_modules/@polymer/polymer/lib/utils/wrap.js","webpack:///./node_modules/@polymer/polymer/lib/utils/path.js","webpack:///./node_modules/@polymer/polymer/lib/utils/case-map.js","webpack:///./node_modules/@polymer/polymer/lib/utils/async.js","webpack:///./node_modules/@polymer/polymer/lib/mixins/properties-changed.js","webpack:///./node_modules/@polymer/polymer/lib/mixins/property-accessors.js","webpack:///./node_modules/@polymer/polymer/lib/mixins/template-stamp.js","webpack:///./node_modules/@polymer/polymer/lib/mixins/property-effects.js","webpack:///./node_modules/@polymer/polymer/lib/utils/telemetry.js","webpack:///./node_modules/@polymer/polymer/lib/mixins/properties-mixin.js","webpack:///./node_modules/@polymer/polymer/lib/mixins/element-mixin.js","webpack:///./node_modules/@polymer/polymer/lib/utils/html-tag.js","webpack:///./node_modules/@polymer/polymer/polymer-element.js","webpack:///./node_modules/@vaadin/multi-select-combo-box/src/vaadin-multi-select-combo-box-chip.js","webpack:///./node_modules/@vaadin/component-base/src/dir-mixin.js","webpack:///./node_modules/@vaadin/input-container/src/vaadin-input-container-mixin.js","webpack:///./node_modules/@vaadin/input-container/src/vaadin-input-container.js","webpack:///./node_modules/@vaadin/input-container/src/vaadin-input-container-styles.js","webpack:///./node_modules/@vaadin/multi-select-combo-box/src/vaadin-multi-select-combo-box-container.js","webpack:///./node_modules/@vaadin/combo-box/src/vaadin-combo-box-item-mixin.js","webpack:///./node_modules/@vaadin/multi-select-combo-box/src/vaadin-multi-select-combo-box-item.js","webpack:///./node_modules/@vaadin/a11y-base/src/focus-utils.js","webpack:///./node_modules/@vaadin/component-base/src/dom-utils.js","webpack:///./node_modules/@vaadin/overlay/src/vaadin-overlay-position-mixin.js","webpack:///./node_modules/@vaadin/overlay/src/vaadin-overlay-utils.js","webpack:///./node_modules/@vaadin/combo-box/src/vaadin-combo-box-overlay-mixin.js","webpack:///./node_modules/@polymer/polymer/lib/utils/render-status.js","webpack:///./node_modules/@vaadin/component-base/src/browser-utils.js","webpack:///./node_modules/@vaadin/a11y-base/src/aria-hidden.js","webpack:///./node_modules/@vaadin/a11y-base/src/aria-modal-controller.js","webpack:///./node_modules/@vaadin/a11y-base/src/focus-restoration-controller.js","webpack:///./node_modules/@vaadin/a11y-base/src/focus-trap-controller.js","webpack:///./node_modules/@vaadin/component-base/src/controller-mixin.js","webpack:///./node_modules/@vaadin/overlay/src/vaadin-overlay-focus-mixin.js","webpack:///./node_modules/@vaadin/overlay/src/vaadin-overlay-stack-mixin.js","webpack:///./node_modules/@vaadin/overlay/src/vaadin-overlay-mixin.js","webpack:///./node_modules/@vaadin/multi-select-combo-box/src/vaadin-multi-select-combo-box-overlay.js","webpack:///./node_modules/@vaadin/overlay/src/vaadin-overlay-styles.js","webpack:///./node_modules/@vaadin/combo-box/src/vaadin-combo-box-placeholder.js","webpack:///./node_modules/@vaadin/component-base/src/path-utils.js","webpack:///./node_modules/@vaadin/component-base/src/unique-id-utils.js","webpack:///./node_modules/@vaadin/component-base/src/async.js","webpack:///./node_modules/@vaadin/component-base/src/debounce.js","webpack:///./node_modules/@vaadin/component-base/src/iron-list-core.js","webpack:///./node_modules/@vaadin/component-base/src/virtualizer-iron-list-adapter.js","webpack:///./node_modules/@vaadin/component-base/src/virtualizer.js","webpack:///./node_modules/@vaadin/combo-box/src/vaadin-combo-box-scroller-mixin.js","webpack:///./node_modules/@vaadin/multi-select-combo-box/src/vaadin-multi-select-combo-box-scroller.js","webpack:///./node_modules/@vaadin/component-base/src/data-provider-controller/helpers.js","webpack:///./node_modules/@vaadin/component-base/src/data-provider-controller/cache.js","webpack:///./node_modules/@vaadin/component-base/src/data-provider-controller/data-provider-controller.js","webpack:///./node_modules/@vaadin/combo-box/src/vaadin-combo-box-data-provider-mixin.js","webpack:///./node_modules/@vaadin/a11y-base/src/disabled-mixin.js","webpack:///./node_modules/@vaadin/a11y-base/src/focus-mixin.js","webpack:///./node_modules/@vaadin/a11y-base/src/keyboard-mixin.js","webpack:///./node_modules/@vaadin/component-base/src/overlay-class-mixin.js","webpack:///./node_modules/@vaadin/component-base/src/templates.js","webpack:///./node_modules/@vaadin/field-base/src/input-mixin.js","webpack:///./node_modules/@vaadin/field-base/src/validate-mixin.js","webpack:///./node_modules/@vaadin/field-base/src/virtual-keyboard-controller.js","webpack:///./node_modules/@vaadin/combo-box/src/vaadin-combo-box-mixin.js","webpack:///./node_modules/@vaadin/multi-select-combo-box/src/vaadin-multi-select-combo-box-internal.js","webpack:///./node_modules/@vaadin/a11y-base/src/announce.js","webpack:///./node_modules/@vaadin/vaadin-development-mode-detector/vaadin-development-mode-detector.js","webpack:///./node_modules/@vaadin/vaadin-usage-statistics/vaadin-usage-statistics-collect.js","webpack:///./node_modules/@vaadin/component-base/src/element-mixin.js","webpack:///./node_modules/@vaadin/component-base/src/resize-mixin.js","webpack:///./node_modules/@vaadin/component-base/src/slot-observer.js","webpack:///./node_modules/@vaadin/component-base/src/slot-controller.js","webpack:///./node_modules/@vaadin/component-base/src/tooltip-controller.js","webpack:///./node_modules/@vaadin/a11y-base/src/tabindex-mixin.js","webpack:///./node_modules/@vaadin/a11y-base/src/delegate-focus-mixin.js","webpack:///./node_modules/@vaadin/component-base/src/slot-styles-mixin.js","webpack:///./node_modules/@vaadin/field-base/src/clear-button-mixin.js","webpack:///./node_modules/@vaadin/a11y-base/src/aria-id-reference.js","webpack:///./node_modules/@vaadin/a11y-base/src/field-aria-controller.js","webpack:///./node_modules/@vaadin/component-base/src/slot-child-observe-controller.js","webpack:///./node_modules/@vaadin/field-base/src/error-controller.js","webpack:///./node_modules/@vaadin/field-base/src/helper-controller.js","webpack:///./node_modules/@vaadin/field-base/src/label-controller.js","webpack:///./node_modules/@vaadin/field-base/src/label-mixin.js","webpack:///./node_modules/@vaadin/field-base/src/field-mixin.js","webpack:///./node_modules/@vaadin/component-base/src/delegate-state-mixin.js","webpack:///./node_modules/@vaadin/field-base/src/input-constraints-mixin.js","webpack:///./node_modules/@vaadin/field-base/src/input-control-mixin.js","webpack:///./node_modules/@vaadin/field-base/src/input-controller.js","webpack:///./node_modules/@vaadin/field-base/src/labelled-input-controller.js","webpack:///./node_modules/@vaadin/multi-select-combo-box/src/vaadin-multi-select-combo-box.js","webpack:///./node_modules/@vaadin/field-base/src/styles/input-field-shared-styles.js","webpack:///./node_modules/@vaadin/field-base/src/styles/field-shared-styles.js","webpack:///./node_modules/@vaadin/field-base/src/styles/input-field-container-styles.js","webpack:///./node_modules/@vaadin/field-base/src/styles/clear-button-styles.js"],"names":["defineCustomElement","CustomElement","version","arguments","length","undefined","Object","defineProperty","get","defined","customElements","is","definedVersion","console","warn","error","define","Lumo","HTMLElement","globalThis","ShadowRoot","ShadyCSS","nativeShadow","Document","prototype","CSSStyleSheet","Symbol","o","WeakMap","constructor","t","e","this","_$cssResult$","Error","cssText","styleSheet","s","replaceSync","set","toString","_len","Array","_key","reduce","S","adoptedStyleSheets","map","document","createElement","n","litNonce","setAttribute","textContent","appendChild","c","cssRules","_Symbol$metadata","_a$litPropertyMetadat","_a$reactiveElementVer","_slicedToArray","r","isArray","_arrayWithHoles","l","iterator","i","u","a","f","call","next","done","push","value","return","_iterableToArrayLimit","_arrayLikeToArray","slice","name","from","test","_unsupportedIterableToArray","TypeError","_nonIterableRest","getOwnPropertyDescriptor","h","getOwnPropertyNames","getOwnPropertySymbols","getPrototypeOf","trustedTypes","emptyScript","p","reactiveElementPolyfillSupport","d","toAttribute","Boolean","JSON","stringify","fromAttribute","Number","parse","y","attribute","type","String","converter","reflect","hasChanged","metadata","litPropertyMetadata","addInitializer","_this$l","_$Ei","observedAttributes","finalize","_$Eh","keys","createProperty","state","elementProperties","noAccessor","getPropertyDescriptor","_r","_ref","requestUpdate","configurable","enumerable","getPropertyOptions","_this$elementProperti","hasOwnProperty","Map","finalized","properties","_ref2","_ref3","_ref4","_ref5","_$Eu","elementStyles","finalizeStyles","styles","Set","flat","reverse","unshift","toLowerCase","super","_$Ep","isUpdatePending","hasUpdated","_$Em","_$Ev","_this$constructor$l","_$ES","Promise","enableUpdating","_$AL","_$E_","forEach","addController","_this$_$EO","_t$hostConnected","_$EO","add","renderRoot","isConnected","hostConnected","removeController","_this$_$EO2","delete","size","createRenderRoot","_this$shadowRoot","shadowRoot","attachShadow","shadowRootOptions","connectedCallback","_this$renderRoot","_this$_$EO3","_t$hostConnected2","disconnectedCallback","_this$_$EO4","_t$hostDisconnected","hostDisconnected","attributeChangedCallback","_$AK","_$EC","_i$converter","removeAttribute","_t$converter","_i","_i$hasChanged","P","_$ET","_this$_$Ej","has","_$Ej","reject","scheduleUpdate","performUpdate","_this$renderRoot2","_ref6","_ref7","_ref8","_ref9","wrapped","_this$_$EO5","shouldUpdate","willUpdate","_t$hostUpdate","hostUpdate","update","_$EU","_$AE","_this$_$EO6","_t$hostUpdated","hostUpdated","firstUpdated","updated","updateComplete","getUpdateComplete","_t$litHtmlVersions","mode","ReactiveElement","reactiveElementVersions","createPolicy","createHTML","Math","random","toFixed","createComment","v","_","m","RegExp","g","$","_$litType$","strings","values","T","for","E","A","C","createTreeWalker","V","lastIndex","exec","x","startsWith","N","parts","_V2","el","currentNode","content","firstChild","replaceWith","childNodes","nextNode","nodeType","hasAttributes","getAttributeNames","endsWith","getAttribute","split","index","ctor","H","I","L","k","tagName","append","data","indexOf","innerHTML","_s$_$Co","_h","_h2","_h2$_$AO","_s$_$Co2","_$Co","_$Cl","_$litDirective$","_$AO","_$AT","_$AS","M","_$AV","_$AN","_$AD","_$AM","parentNode","_$AU","_t$creationScope","_this$_$AD","creationScope","importNode","_l","R","nextSibling","z","_$AI","_this$_$AM$_$AU","_this$_$AM","_$Cv","_e$isConnected","_$AH","_$AA","_$AB","options","_t","startNode","endNode","_$AR","O","insertBefore","createTextNode","_this$_$AH","_$AC","_this$_$AP","_$AP","remove","setConnected","_this$_$AP2","element","fill","_r2","j","toggleAttribute","_S","capture","once","passive","removeEventListener","addEventListener","handleEvent","_this$options$host","_this$options","host","litHtmlPolyfillSupport","litHtmlVersions","_globalThis$litElemen","_globalThis$litElemen2","renderOptions","_$Do","_this$renderOptions","_this$renderOptions$r","renderBefore","render","_s$renderBefore","_$litPart$","_s$renderBefore2","_this$_$Do","_this$_$Do2","_$litElement$","litElementHydrateSupport","LitElement","litElementPolyfillSupport","litElementVersions","ThemePropertyMixin","superClass","_theme","readOnly","oldValue","newValue","_set_theme","ownKeys","filter","apply","_objectSpread","_defineProperty","getOwnPropertyDescriptors","defineProperties","toPrimitive","_toPrimitive","_toPropertyKey","writable","themeRegistry","themableInstances","themableTagNames","classHasThemes","elementClass","matchesThemeFor","themeFor","some","themeForToken","join","getCssText","style","STYLE_ID","updateInstanceStylesOfType","componentClass","ref","instance","deref","querySelectorAll","getElementById","template","_template","updateInstanceStyles","updateComponentStyles","getStylesForThis","inheritingTagName","inheritingClass","registerStyles","Infinity","flattenStyles","window","Vaadin","styleModules","include","moduleId","hasThemes","themes","__themes","theme","themeStyle","hasMatchingStyle","suppressPostFinalizeStylesWarning","getAllThemes","getIncludePriority","moduleName","includePriority","getIncludedStyles","includedStyles","concat","includeModuleId","includedTheme","find","getThemes","defaultModuleName","sort","themeA","themeB","ThemableMixin","WeakRef","styleEl","id","addStylesToTemplate","themeStyles","superClassThemes","parent","inheritedThemes","flatMap","lastIndexOf","addLumoGlobalStyles","styleTag","replace","head","insertAdjacentElement","addGlobalThemeStyles","font","fieldButton","comboBoxItem","loader","overlay","menuOverlayCore","comboBoxOverlay","comboBoxLoader","helper","requiredField","inputFieldShared","JSCompiler_renameProperty","prop","obj","workingURL","resolveDoc","CSS_URL_RX","ABS_URL","resolveUrl","url","baseURI","URL","pathname","href","location","implementation","createHTMLDocument","base","anchor","body","resolveCss","pre","post","pathFromUrl","substring","useShadow","ShadyDOM","inUse","supportsAdoptingStyleSheets","nativeCss","polyfillWrapFlushCallback","sheet","rootPath","Polymer","sanitizeDOMValue","setPassiveTouchGestures","strictTemplatePolicy","allowTemplateFromDomModule","legacyOptimizations","legacyWarnings","syncInitialRender","legacyUndefined","orderedComputed","cancelSyntheticClickEvents","removeNestedTemplates","fastDomIf","suppressTemplateNotifications","legacyNoObservedAttributes","useAdoptedStyleSheetsWithBuiltCSS","MixinFunction","__mixinApplications","__mixinSet","dedupingMixin","mixin","mixinApplications","mixinDedupeId","baseSet","extended","mixinSet","create","modules","lcModules","setModule","module","findModule","import","selector","querySelector","old","namespace","register","assetpath","__assetpath","owner","HTMLImports","importForElement","ownerDocument","inst","SHADY_UNSCOPED_ATTR","importModule","styleForImport","importDoc","importCss","stylesFromModules","moduleIds","trim","stylesFromModule","_styles","_stylesFromModuleImports","stylesFromTemplate","e$","item","self","p$","unscoped","hasAttribute","_unscopedStyle","_style","wrap","isPath","path","dotIndex","isAncestor","isDescendant","translate","newBase","normalize","args","root","info","last","caseMap","DASH_TO_CAMEL","CAMEL_TO_DASH","dashToCamelCase","dash","toUpperCase","camelToDashCase","camel","microtaskCurrHandle","microtaskLastHandle","microtaskCallbacks","microtaskNodeContent","microtaskScheduled","microtaskNode","MutationObserver","len","cb","setTimeout","splice","observe","characterData","microtask","run","callback","cancel","handle","idx","createProperties","props","proto","_createPropertyAccessor","attributeNameForProperty","property","typeForProperty","_addPropertyToAttributeMap","__dataHasAccessor","assign","_definePropertyAccessor","__dataAttributes","attr","__data","_setPendingProperty","_invalidateProperties","__dataEnabled","__dataReady","__dataInvalid","__dataPending","__dataOld","__dataInstanceProps","__dataCounter","__serializing","_initializeProperties","ready","_flushProperties","_initializeInstanceProperties","_setProperty","_getProperty","ext","changed","_shouldPropertyChange","_isPropertyPending","_enableProperties","changedProps","_shouldPropertiesChange","_propertiesChanged","currentProps","oldProps","_attributeToProperty","_deserializeValue","_propertyToAttribute","_valueToNodeAttribute","node","str","_serializeValue","nativeProperties","isTrustedType","val","isHTML","isScript","isScriptURL","createPropertiesForAttributes","a$","__dataProto","_initializeProtoProperties","_ensureAttribute","Date","outValue","isNaN","model","saveAccessorValue","_hasAccessor","templateExtensions","placeholderBugDetect","placeholderBug","fixPlaceholder","placeholder","hasPlaceholderBug","localName","copyAttributeWithTemplateEventPolicy","polymerTemplateEventAttributePolicy","createScript","dest","src","wrapTemplateExtension","replaceChild","attributes","findTemplateNode","nodeInfo","parentInfo","parentIndex","applyIdToMap","applyEventListener","events","_addMethodEventListenerToNode","applyTemplateInfo","parentTemplateInfo","templateInfo","_templateInfo","_parentTemplateInfo","TemplateStamp","_parseTemplate","outerTemplateInfo","nodeInfoList","nestedTemplate","stripWhiteSpace","_parseTemplateContent","_parseTemplateNode","noted","hasInsertionPoint","_parseTemplateNestedTemplate","_parseTemplateChildNodes","_parseTemplateNodeAttributes","Node","TEXT_NODE","removeChild","childInfo","infoIndex","createDocumentFragment","attrs","_parseTemplateNodeAttribute","_contentForTemplate","_stampTemplate","HTMLTemplateElement","decorate","dom","__noInsertionPoint","nodes","nodeList","eventName","methodName","context","handler","_methodHost","detail","createNodeEventHandler","_addEventListenerToNode","_removeEventListenerFromNode","NOOP","TYPES","COMPUTE","REFLECT","NOTIFY","PROPAGATE","OBSERVE","READ_ONLY","COMPUTE_INFO","capitalAttributeRegex","ensureOwnEffectMap","cloneArrays","effects","protoFx","instFx","runEffects","hasPaths","extraArgs","ran","fxs","fx","lastRun","pathMatchesTrigger","trigger","fn","runEffectsForProperty","dedupeId","triggerPath","structured","wildcard","runObserverEffect","method","changedProp","dynamicFn","notifyPath","rootProperty","dispatchNotifyEvent","queueProperty","dispatchEvent","CustomEvent","runNotifyEffect","runReflectEffect","attrName","runComputedEffects","computeEffects","order","ordered","__orderedComputedDeps","curr","_dependencyCounts","infoForComputed","counts","computedDeps","total","literal","dependencyCounts","shift","computedByCurr","computedProp","methodInfo","getComputedOrder","queue","enqueueEffectsFor","runComputedEffect","inputProps","insertEffect","start","end","mid","cmp","result","runMethodEffect","addBinding","kind","target","bindings","binding","isCompound","shouldAddListener","_binding$parts$","event","negate","listenerEvent","listenerNegate","part","compoundIndex","addEffectForBindingPart","dependencies","evaluator","parseArg","_addTemplatePropertyEffect","runBindingEffect","source","__isPropertyEffectsClient","_setPendingPropertyOrPath","_enqueueClient","_evaluateBinding","storage","__dataCompoundStorage","computeBindingValue","_setUnmanagedPropertyToNode","applyBindingValue","setupCompoundStorage","literals","addNotifyListener","fromProp","toPath","fromPath","currentTarget","handleNotification","createMethodEffect","sig","effectFn","static","arg","_addPropertyEffect","_marshalArgs","emptyArray","IDENT","ARGUMENT","bindingRegex","OPEN_BRACKET","literalFromParts","parseMethod","expression","match","argList","rawArg","parseArgs","fc","getArgValue","notifySplices","array","splices","splicesData","indexSplices","_overrideLegacyUndefined","notifySplice","addedCount","removed","object","propertyEffectsBase","__dataClientsReady","__dataPendingClients","__dataToNotify","__dataLinkedPaths","__dataHasPaths","__dataHost","__dataTemp","__dataClientsInitialized","__computeEffects","__computeInfo","__reflectEffects","__notifyEffects","__propagateEffects","__observeEffects","__readOnly","__templateInfo","PROPERTY_EFFECT_TYPES","_registerHost","hostStack","effect","_removePropertyEffect","_hasPropertyEffect","_hasReadOnlyEffect","_hasNotifyEffect","_hasReflectEffect","_hasComputedEffect","shouldNotify","isPathNotification","links","link","b","computeLinkedPaths","propIsPath","prevProps","client","_flushClients","__enableOrFlushClients","_readyClients","clients","setProperties","setReadOnly","notifyProps","_propagatePropertyChanges","notified","runNotifyEffects","_runEffectsForTemplate","baseRunEffects","propertyEffects","linkPaths","to","unlinkPaths","items","ret","pop","hadLength","deleteCount","_len2","_key2","floor","_len3","_key3","propPath","_createReadOnlyProperty","protectedSetter","_createPropertyObserver","_createMethodObserver","_createNotifyingProperty","_createReflectedProperty","_createComputedProperty","_args$i","matches","pathValue","addPropertyEffect","createPropertyObserver","createMethodObserver","createNotifyingProperty","createReadOnlyProperty","createReflectedProperty","createComputedProperty","bindTemplate","_bindTemplate","instanceBinding","wasPreBound","__preBoundTemplateInfo","previous","lastChild","previousSibling","hostProps","setupBindings","_removeBoundDom","_parseBindings","origName","nestedTemplateInfo","isDomIf","isDomRepeat","hostProp","text","customEvent","notifyEvent","colon","signature","dynamicFns","registrations","superPropertiesClass","superCtor","PropertiesMixin","ownProperties","output","normalizeProperties","__ownProperties","_properties","__observedAttributes","__finalized","_finalizeClass","__properties","builtCSS","ElementMixin","polymerElementBase","createPropertyFromConfig","allProps","computed","reflectToAttribute","notify","observer","processElementStyles","klass","templateStyles","stylesWithImports","linkedStyles","stylesFromModuleImports","firstTemplateChild","firstElementChild","_processStyleText","templateStyleIndex","templateStyle","cloneNode","prepareTemplate","css","_styleSheet","polymerElementVersion","observers","__ownObservers","createObservers","_prepareTemplate","protoTemplate","getTemplateFromDomModule","importPath","meta","importMeta","_importPath","_finalizeTemplate","__propertyDefaults","propertyDefaults","_canApplyPropertyDefault","__polymerFinalized","styleElement","_attachDom","shadyUpgradeFragment","flushInitial","updateStyles","styleSubtree","policy","LiteralString","assertValidTemplateStringParameters","string","acc","literalValue","html","htmlValue","raw","disabled","readonly","label","_onRemoveClick","stopPropagation","bubbles","composed","directionSubscribers","alignDirs","documentDir","elementDir","getDocumentDir","documentElement","attributeFilter","DirMixin","dir","__isRTL","__restoreSubscription","__subscribe","newValueEqlDocDir","newValueEmptied","newDiffValue","__unsubscribe","includes","InputContainerMixin","invalid","preventDefault","assignedNodes","flatten","focus","memoizedTemplate","slots","wrapper","autoExpandVertically","ComboBoxItemMixin","selected","focused","renderer","Function","_owner","hostDir","requestContentUpdate","__rendererOrItemChanged","_oldRenderer","__updateLabel","keyboardActive","getDeepActiveElement","activeElement","isKeyboardActive","isElementHiddenDirectly","visibility","display","computedStyle","getComputedStyle","hasLowerTabOrder","ati","max","tabIndex","bti","sortElementsByTabIndex","elements","pivot","ceil","left","right","mergeSortByTabIndex","isElementFocusable","isElementFocused","getRootNode","collectFocusableNodes","ELEMENT_NODE","normalizeTabIndex","needsSort","children","child","deserializeAttributeValue","serializeAttributeValue","addValueToAttribute","PROP_NAMES_VERTICAL","PROP_NAMES_HORIZONTAL","targetResizeObserver","ResizeObserver","entries","entry","__overlay","_updatePosition","positionTarget","sync","horizontalAlign","verticalAlign","noHorizontalOverlap","noVerticalOverlap","requiredVerticalSpace","__onScroll","bind","opened","__addUpdatePositionEventListeners","__removeUpdatePositionEventListeners","visualViewport","__positionTargetAncestorRootNodes","DOCUMENT_NODE","DOCUMENT_FRAGMENT_NODE","assignedSlot","getAncestorRootNodes","__observePositionTargetMove","io","cleanup","disconnect","refresh","skip","threshold","_element$getBoundingC","getBoundingClientRect","top","width","height","rootMargin","clientWidth","clientHeight","min","isFirstUpdate","IntersectionObserver","ratio","intersectionRatio","observeMove","__overlayOpenedChanged","unobserve","__margins","propName","parseInt","requestAnimationFrame","__positionSettingsChanged","contains","targetRect","shouldAlignStartVertically","__shouldAlignStartVertically","justifyContent","isRTL","shouldAlignStartHorizontally","__shouldAlignStartHorizontally","flexStart","alignItems","overlayRect","verticalProps","__calculatePositionInOneDimension","horizontalProps","rtl","contentWidth","__oldContentWidth","offsetWidth","viewportWidth","innerWidth","defaultAlignLeft","__shouldAlignStart","contentHeight","__oldContentHeight","offsetHeight","viewportHeight","innerHeight","defaultAlignTop","contentSize","viewportSize","margins","defaultAlignStart","noOverlap","propNames","spaceForStartAlignment","spaceForEndAlignment","spaceForDefaultAlignment","__adjustBottomProperty","cssPropNameToSet","currentValue","adjustedProp","__oldViewportHeight","__oldViewportWidth","shouldAlignStart","cssPropNameToClear","parseFloat","adjustedValue","diff","valueToSet","comboBox","_comboBox","_shouldCloseOnOutsideClick","eventPath","composedPath","_mouseDownListener","_updateOverlayWidth","propPrefix","setProperty","customWidth","getPropertyValue","removeProperty","_setOverlayWidth","scheduled","beforeRenderQueue","afterRenderQueue","schedule","flushQueue","callMethod","runQueue","testUserAgent","regexp","navigator","userAgent","testPlatform","platform","vendor","isIPad","maxTouchPoints","isIOS","isSafari","isTouch","createEvent","counterMap","uncontrolledNodes","markerMap","lockCount","isElement","logError","applyAttributeToOthers","originalTarget","markerName","controlAttribute","targets","correctTargets","markerCounter","hiddenNodes","elementsToKeep","elementsToStop","keep","slot","deep","alreadyHidden","counterValue","markerValue","clear","hideOthers","showModal","__showOthers","close","saveFocus","focusNode","restoreFocus","preventScroll","instances","__trapNode","__onKeyDown","__focusableElements","focusableElements","getFocusableElements","__focusedElementIndex","trapFocus","trapNode","releaseFocus","key","backward","shiftKey","__focusNextElement","step","currentIndex","select","ControllerMixin","__controllers","controller","focusTrap","restoreFocusOnClose","restoreFocusNode","__ariaModalController","__focusTrapController","__focusRestorationController","_resetFocus","_shouldRestoreFocus","_saveFocus","_trapFocus","_deepContains","doc","getAttachedInstances","_hasOverlayStackMixin","__zIndex","OverlayStackMixin","_last","isLastOverlay","bringToFront","zIndex","frontmost","_enterModalState","pointerEvents","_previousDocumentPointerEvents","_exitModalState","modeless","hidden","withBackdrop","_boundMouseDownListener","_boundMouseUpListener","_mouseUpListener","_boundOutsideClickListener","_outsideClickListener","_boundKeydownListener","_keydownListener","_boundIosResizeListener","_detectIosNavbar","backdrop","sourceEvent","evt","cancelable","defaultPrevented","landscape","_addGlobalListeners","_removeGlobalListeners","_rendererOrDataChanged","ownerOrModelChanged","_oldOwner","_oldModel","rendererChanged","hasOldRenderer","openedChanged","_oldOpened","_modelessChanged","_openedChanged","wasOpened","_animatedOpening","_animatedClosing","_hiddenChanged","_flushAnimation","_shouldAnimate","_enqueueAnimation","listener","_attachOverlay","_finishOpening","_placeholder","_finishClosing","_detachOverlay","_mouseDownInside","_mouseUpInside","_event","ComboBoxPlaceholder","uniqueId","generateUniqueId","after","delay","clearTimeout","cancelAnimationFrame","requestIdleCallback","cancelIdleCallback","queueMicrotask","debouncerQueue","Debouncer","debounce","debouncer","asyncModule","_cancelAsync","setConfig","_asyncModule","_callback","_timer","isActive","flush","enqueueDebouncer","flushDebouncers","didFlush","debouncers","IOS","IOS_TOUCH_SCROLLING","ironList","_ratio","_scrollerPaddingTop","_scrollPosition","_physicalSize","_physicalAverage","_physicalAverageCount","_physicalTop","_virtualCount","_estScrollHeight","_scrollHeight","_viewportHeight","_viewportWidth","_physicalItems","_physicalSizes","_firstVisibleIndexVal","_lastVisibleIndexVal","_maxPages","_templateCost","_physicalBottom","_scrollBottom","_virtualEnd","_virtualStart","_physicalCount","_hiddenContentSize","_maxScrollTop","_scrollOffset","_maxVirtualStart","virtualCount","_virtualStartVal","_clamp","_physicalStart","_physicalStartVal","_physicalEnd","_physicalCountVal","_optPhysicalSize","_isVisible","firstVisibleIndex","physicalOffset","_iterateItems","pidx","vidx","_getPhysicalSizeIncrement","lastVisibleIndex","scrollOffset","_scrollHandler","scrollTop","_scrollTop","delta","isScrollingDown","abs","idxAdjustment","round","_update","reusables","_getReusables","physicalTop","indexes","_debounce","_increasePoolIfNeeded","fromTop","ith","offsetContent","physicalItemHeight","idxs","protectedOffsetContent","virtualStart","virtualEnd","physicalCount","bottom","scrollBottom","itemSet","movingUp","_assignModels","_updateMetrics","_positionItems","_updateScrollerSize","_isClientFull","count","nextIncrease","ts","performance","now","_createPool","_isIndexRendered","_focusedVirtualIndex","_getPhysicalIndex","_render","isAttached","updateViewportBoundaries","_itemsChanged","change","_physicalIndexForKey","_resetScrollPosition","rtn","_computeVidx","_adjustScrollPosition","translate3d","deltaHeight","pos","scrollTarget","forceUpdate","estScrollHeight","scrollToIndex","currentTopItem","currentVirtualItem","targetOffsetTop","hiddenContentSize","_resetAverage","_resizeHandler","toggleScrollListener","_debouncers","OFFSET_ADJUST_MIN_THRESHOLD","createElements","updateElement","scrollContainer","elementsContainer","reorderElements","_vidxOffset","__placeholderHeight","__elementHeightQueue","timeouts","SCROLL_REORDER","IGNORE_WHEEL","FIX_INVALID_ITEM_POSITIONING","__resizeObserver","overflow","position","_scrollLineHeight","_getScrollLineHeight","__onWheel","__onElementFocused","__getFocusedElement","__mouseDown","__pendingReorder","__reorderElements","adjustedFirstVisibleIndex","adjustedLastVisibleIndex","_maxVirtualIndexOffset","__hasPlaceholders","__getVisibleElements","__virtualizerPlaceholder","__pendingScrollToIndex","visibleElementCount","targetVirtualIndex","__skipNextVirtualIndexAdjust","grid","__getIndexScrollOffset","__fixInvalidItemPositioningDebouncer","__scrollReorderDebouncer","__debouncerWheelAnimationFrame","startIndex","endIndex","updatedElements","__virtualIndex","__updateElement","__afterElementsUpdated","newPhysicalSize","oldPhysicalSize","prevAvgCount","prevPhysicalAvg","__getBorderBoxHeight","itemHeight","boxSizing","paddingBottom","paddingTop","borderBottomWidth","borderTopWidth","forceSameIndexUpdates","opacity","__preventElementUpdates","__lastUpdatedIndex","elementHeight","__placeholderClearDebouncer","filteredHeights","__size","fvi","fviOffsetBefore","fviOffsetAfter","_isRTL","direction","_scrollPageHeight","_updateGridMetrics","physicalItems","fragment","__clientFull","_x","_z","transform","__nextFocusableSiblingMissing","focusedElement","visibleElements","__previousFocusableSiblingMissing","reorderedVisibleElements","_adjustVirtualIndexOffset","__previousScrollTop","__fixInvalidItemPositioning","physicalTopBelowTop","physicalBottomAboveBottom","firstIndexVisible","lastIndexVisible","originalRatio","ctrlKey","_hasScrolledAncestor","deltaX","deltaY","deltaMode","WheelEvent","DOM_DELTA_LINE","DOM_DELTA_PAGE","_deltaYAcc","_wheelAnimationFrame","momentum","_canScroll","scrollLeft","_hasResidualMomentum","_ignoreNewWheel","_debouncerIgnoreNewWheel","_previousMomentum","parentElement","scrollHeight","scrollWidth","missingItemCount","optPhysicalSize","__getItemHeightBuffer","bufferZoneHeight","maxItemHeight","fontSize","adjustedVirtualStart","targetElement","targetPhysicalIndex","maxOffset","scale","oldOffset","maxShift","setPrototypeOf","config","__adapter","focusedIndex","loading","selectedItem","itemClassNameGenerator","itemIdPath","getItemLabel","__boundOnItemClick","__onItemClick","_viewportTotalPaddingBottom","_cachedViewportTotalPaddingBottom","itemsStyle","sum","__hostTagName","__patchWheelOverScrolling","__virtualizer","scrollIntoView","visibleItemsCount","_visibleItemsCount","targetIndex","lastPhysicalItem","lastPhysicalItemRect","scrollerRect","scrollTopAdjust","_isItemSelected","__initVirtualizer","__createElements","_updateElement","__itemsChanged","__loadingChanged","__openedChanged","__selectedItemChanged","__itemClassNameGeneratorChanged","generator","oldGenerator","__focusedIndexChanged","oldIndex","__rendererChanged","oldRenderer","className","__requestItemByIndex","scrolledToTop","scrolledToBottom","_selectedItem","_findIndex","selectedItems","_toArray","_iterableToArray","getFlatIndexContext","cache","flatIndex","level","levelIndex","subCache","subCaches","parentCacheIndex","flatSize","page","pageSize","getItemContext","targetItem","getItemId","levelFlatIndex","getSubCache","getFlatIndex","getFlatIndexByPath","subIndexes","flatIndexOnLevel","parentCache","__flatSize","parentItem","__subCacheByIndex","isLoading","pendingRequests","effectiveSize","_this$items","recalculateFlatSize","isExpanded","setPage","itemIndex","removeSubCache","removeSubCaches","createSubCache","clampedIndex","prev","getItemForIndex","getCacheAndIndex","_getFlatIndexContext2","scaledIndex","updateSize","ensureSubCacheForScaledIndex","__controller","__loadCachePage","itemCaches","EventTarget","isPlaceholder","dataProvider","dataProviderParams","rootCache","__createRootCache","__cacheContext","setPageSize","clearCache","setDataProvider","ensureFlatIndexLoaded","_this$getFlatIndexCon","__isItemLoaded","ensureFlatIndexHierarchy","_this$getFlatIndexCon2","loadFirstPage","params","ComboBoxDataProviderMixin","__dataProviderInitialized","__previousDataProviderFilter","__dataProviderController","__onDataProviderPageRequested","__onDataProviderPageLoaded","_scroller","_shouldFetchData","_dataProviderFilterChanged","__keepOverlayOpened","_ensureFirstPage","_forceNextRequest","_isInputFocused","_commitValue","_sizeChanged","_filteredItemsChanged","filteredItems","_pageSizeChanged","oldPageSize","_dataProviderChanged","oldDataProvider","_ensureItemsOrDataProvider","restoreOldValueCallback","_warnDataProviderValue","valueIndex","__getItemIndexByValue","_getItemLabel","DisabledMixin","superclass","_disabledChanged","_setAriaDisabled","click","FocusMixin","_keyboardActive","_shouldSetFocus","_setFocused","_shouldRemoveFocus","KeyboardMixin","_onKeyDown","_onKeyUp","_onEnter","_onEscape","OverlayClassMixin","overlayClass","_overlayElement","__updateOverlayClassNames","overlayElement","classList","__initialClasses","__previousClasses","classesToRemove","classesToAdd","processTemplates","component","templateRendererCallback","InputMixin","inputElement","_hasInputValue","_boundOnInput","__onInput","_boundOnChange","_onChange","_hasValue","_inputElementValueProperty","_inputElementValue","_addInputListeners","input","_removeInputListeners","_forwardInputValue","_inputElementChanged","oldInput","_hasInputValueChanged","hasValue","oldHasValue","_setHasInputValue","_onInput","__userInput","isTrusted","_toggleHasValue","_valueChanged","newVal","oldVal","ValidateMixin","required","validate","isValid","checkValidity","_setInvalid","valid","_shouldSetInvalid","_invalid","VirtualKeyboardController","__setVirtualKeyboardEnabled","inputMode","isValidValue","findItemIndex","findIndex","ComboBoxMixin","subclass","autoOpenDisabled","allowCustomValue","_lastCommittedValue","_focusedIndex","itemLabelPath","itemValuePath","_toggleElement","_dropdownItems","_closeOnBlurIsPrevented","_overlayOpened","_boundOverlaySelectedItemChanged","_overlaySelectedItemChanged","_boundOnClearButtonMouseDown","__onClearButtonMouseDown","_boundOnClick","_onClick","_boundOnOverlayTouchAction","_onOverlayTouchAction","_boundOnTouchend","_onTouchend","_tagNamePrefix","_nativeInput","autocomplete","autocapitalize","_revertInputValueToValue","clearElement","_initOverlay","_initScroller","bringToFrontListener","_getItemElements","open","_filterChanged","scroller","_updateScroller","maxHeight","_openedOrItemsChanged","keepOverlayOpened","_overlayOpenedChanged","_onOpened","_focusedIndexChanged","_updateActiveDescendant","_onClosed","blur","_isClearButton","_onClearButtonClick","_onClearAction","_onToggleButtonClick","_onHostClick","_onArrowDown","_onArrowUp","_getItemValue","_prefillFocusedItemLabel","focusedItem","_markAllSelectionRange","_setSelectionRange","setSelectionRange","_clearSelectionRange","_closeOrCommit","_hasValidInputValue","hasInvalidOption","clearButtonVisible","_revertInputValue","_toggleElementChanged","toggleElement","_detectAndDispatchChange","_clearFilter","itemMatchingInputValue","__getItemIndexByLabel","customValue","_lastCustomValue","_itemLabelPathChanged","_scrollIntoView","_filterItems","_selectedItemChanged","_selectItemForValue","hasFocus","oldItems","_setDropdownItems","arr","previouslySelectedItem","newItems","focusedItemIndex","relatedTarget","keepFilter","selectedItemsOnTop","lastFilter","topGroup","_target","_readonlyChanged","_topGroupChanged","_ignoreCommitValue","region","alertDebouncer","announce","timeout","clip","DEV_MODE_CODE_REGEXP","FlowClients","Flow","uncommentAndRun","log","runIfDevelopmentMode","developmentMode","maybeGatherAndSendStats","localStorage","getItem","hostname","productionMode","isDevelopmentMode","statsJob","developmentModeCallback","registered","doctype","resizables","resizable","_onResize","contentRect","ResizeMixin","_observeParent","__parent","_contentRect","SlotObserver","_storedNodes","_connected","_scheduled","_boundSchedule","_schedule","connect","_processNodes","currentNodes","addedNodes","removedNodes","movedNodes","generateId","slotName","initializer","multiple","useUniqueId","uniqueIdPrefix","slotInitializer","defaultId","initialized","initMultiple","initSingle","observeSlot","getSlotChild","initAddedNode","attachDefaultNode","initNode","getSlotChildren","defaultNode","Element","initCustomNode","_node","teardownNode","__slotObserver","current","newNodes","isEmptyTextNode","setTarget","tooltipNode","ariaTarget","manual","_position","shouldShow","__notifyChange","setAriaTarget","setContext","setManual","setOpened","setPosition","setShouldShow","TabindexMixin","tabindex","_lastTabIndex","oldDisabled","_tabindexChanged","DelegateFocusMixin","autofocus","focusElement","_boundOnBlur","_onBlur","_boundOnFocus","_onFocus","_focusElementChanged","oldElement","_addFocusListeners","__forwardTabIndex","_removeFocusListeners","Event","stylesMap","SlotStylesMixin","slotStyles","__applySlotStyles","rootStyles","getRootStyles","insertStyles","ClearButtonMixin","_onClearButtonMouseDown","attributeToTargets","getAttrMap","cleanAriaIDReference","storeAriaIDReference","attributeMap","setAriaIDReference","newId","oldId","fromUser","storedValues","removeValueFromAttribute","attributeValue","__required","__target","__setAriaRequiredAttribute","__setLabelIdToAriaAttribute","__labelId","__labelIdFromUser","__setErrorIdToAriaAttribute","__errorId","__setHelperIdToAriaAttribute","__helperId","setAriaLabel","__label","setRequired","__setAriaLabelToAttribute","setLabelId","labelId","oldLabelId","setErrorId","errorId","setHelperId","helperId","restoreGeneratedAriaIDReference","oldErrorId","oldHelperId","__updateNodeId","restoreDefaultNode","updateDefaultNode","observeNode","__nodeObserver","mutations","mutation","isCurrentNodeMutation","childList","subtree","__hasContent","hasContent","isFirstNode","setErrorMessage","errorMessage","setInvalid","errorNode","hasError","setHelperText","helperText","helperNode","setLabel","labelNode","LabelMixin","_labelController","_labelId","_labelNode","_labelChanged","FieldMixin","accessibleName","accessibleNameRef","_fieldAriaController","_helperController","_errorController","_event$detail","__labelChanged","_event$detail2","__helperChanged","_errorNode","_helperNode","hasHelper","_accessibleNameChanged","_accessibleNameRefChanged","hasLabel","_errorMessageChanged","_helperTextChanged","_ariaTargetChanged","_requiredChanged","_invalidChanged","DelegateStateMixin","stateTarget","delegateAttrs","delegateProps","_createDelegateAttrsObserver","_createDelegatePropsObserver","_stateTargetChanged","_ensureAttrsDelegated","_ensurePropsDelegated","_delegateAttribute","_delegateProperty","_delegateAttrsChanged","_delegatePropsChanged","InputConstraintsMixin","constraints","_createConstraintsObserver","_hasValidConstraints","__isValidConstraint","_constraintsChanged","hasConstraints","isLastConstraintRemoved","__previousHasConstraints","constraint","InputControlMixin","allowedCharPattern","autoselect","title","_boundOnPaste","_onPaste","_boundOnDrop","_onDrop","_boundOnBeforeInput","_onBeforeInput","__shouldAcceptKey","_markInputPrevented","_preventInputDebouncer","metaKey","__allowedCharRegExp","pastedText","clipboardData","getData","__allowedTextRegExp","draggedText","dataTransfer","_allowedCharPatternChanged","charPattern","LabelledInputController","labelController","__preventDuplicateLabelClick","__initLabel","inputClickHandler","stopImmediatePropagation","autoExpandHorizontally","i18n","cleared","deselected","_overflowItems","_focusedChipIndex","_lastFilter","_topGroup","tag","clearButton","_chips","_setInputElement","_setFocusElement","_tooltipController","_inputField","_overflowController","chip","_preventBlur","_overflow","__updateChips","__updateSelection","_autoExpandHorizontallyChanged","autoExpand","oldAutoExpand","_autoExpandVerticallyChanged","_clearButtonVisibleChanged","visible","oldVisible","_onFilteredItemsChanged","oldReadonly","_placeholderChanged","tmpPlaceholder","__tmpA11yPlaceholder","__savedPlaceholder","_selectedItemsChanged","_mergeItemLabels","__clearInternalValue","force","__announceItem","itemLabel","isSelected","itemCount","__removeItem","itemsCopy","__selectItem","__updateTopGroup","__createChip","_onItemRemoved","__getOverflowWidth","overflowStyle","overflowWidth","marginInlineStart","totalWidth","inputWidth","flexBasis","remainingWidth","chipMinWidth","chips","refNode","overflowItems","availableWidth","neededWidth","maxWidth","__updateOverflowChip","_onClearButtonTouchend","_onBackSpace","_onArrowLeft","_onArrowRight","selectionStart","newIdx","_focusedChipIndexChanged","oldFocusedIndex","_onComboBoxChange","_onComboBoxItemSelected","_onCustomValueSet"],"mappings":"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","file":"js/6-cfa2e0f5c3a9d68d6580.chunk.js","sourcesContent":["/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\nexport function defineCustomElement(CustomElement) {\n  let version = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '24.5.3';\n  Object.defineProperty(CustomElement, 'version', {\n    get() {\n      return version;\n    }\n  });\n  const defined = customElements.get(CustomElement.is);\n  if (!defined) {\n    customElements.define(CustomElement.is, CustomElement);\n  } else {\n    const definedVersion = defined.version;\n    if (definedVersion && CustomElement.version && definedVersion === CustomElement.version) {\n      // Just loading the same thing again\n      console.warn(`The component ${CustomElement.is} has been loaded twice`);\n    } else {\n      console.error(`Tried to define ${CustomElement.is} version ${CustomElement.version} when version ${defined.version} is already in use. Something will probably break.`);\n    }\n  }\n}","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { defineCustomElement } from '@vaadin/component-base/src/define.js';\n\n/**\n * Dummy custom element used for collecting\n * development time usage statistics.\n *\n * @private\n */\nclass Lumo extends HTMLElement {\n  static get is() {\n    return 'vaadin-lumo-styles';\n  }\n}\ndefineCustomElement(Lumo);\nexport { Lumo };","/**\n * @license\n * Copyright 2019 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nconst t = globalThis,\n  e = t.ShadowRoot && (void 0 === t.ShadyCSS || t.ShadyCSS.nativeShadow) && \"adoptedStyleSheets\" in Document.prototype && \"replace\" in CSSStyleSheet.prototype,\n  s = Symbol(),\n  o = new WeakMap();\nclass n {\n  constructor(t, e, o) {\n    if (this._$cssResult$ = !0, o !== s) throw Error(\"CSSResult is not constructable. Use `unsafeCSS` or `css` instead.\");\n    this.cssText = t, this.t = e;\n  }\n  get styleSheet() {\n    let t = this.o;\n    const s = this.t;\n    if (e && void 0 === t) {\n      const e = void 0 !== s && 1 === s.length;\n      e && (t = o.get(s)), void 0 === t && ((this.o = t = new CSSStyleSheet()).replaceSync(this.cssText), e && o.set(s, t));\n    }\n    return t;\n  }\n  toString() {\n    return this.cssText;\n  }\n}\nconst r = t => new n(\"string\" == typeof t ? t : t + \"\", void 0, s),\n  i = function (t) {\n    for (var _len = arguments.length, e = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      e[_key - 1] = arguments[_key];\n    }\n    const o = 1 === t.length ? t[0] : e.reduce((e, s, o) => e + (t => {\n      if (!0 === t._$cssResult$) return t.cssText;\n      if (\"number\" == typeof t) return t;\n      throw Error(\"Value passed to 'css' function must be a 'css' function result: \" + t + \". Use 'unsafeCSS' to pass non-literal values, but take care to ensure page security.\");\n    })(s) + t[o + 1], t[0]);\n    return new n(o, t, s);\n  },\n  S = (s, o) => {\n    if (e) s.adoptedStyleSheets = o.map(t => t instanceof CSSStyleSheet ? t : t.styleSheet);else for (const e of o) {\n      const o = document.createElement(\"style\"),\n        n = t.litNonce;\n      void 0 !== n && o.setAttribute(\"nonce\", n), o.textContent = e.cssText, s.appendChild(o);\n    }\n  },\n  c = e ? t => t : t => t instanceof CSSStyleSheet ? (t => {\n    let e = \"\";\n    for (const s of t.cssRules) e += s.cssText;\n    return r(e);\n  })(t) : t;\nexport { n as CSSResult, S as adoptStyles, i as css, c as getCompatibleStyle, e as supportsAdoptingStyleSheets, r as unsafeCSS };","var _Symbol$metadata, _a$litPropertyMetadat, _a$reactiveElementVer;\nfunction _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction _iterableToArrayLimit(r, l) { var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }\nfunction _arrayWithHoles(r) { if (Array.isArray(r)) return r; }\nimport { getCompatibleStyle as t, adoptStyles as s } from \"./css-tag.js\";\nexport { CSSResult, adoptStyles, css, getCompatibleStyle, supportsAdoptingStyleSheets, unsafeCSS } from \"./css-tag.js\";\n/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nconst i = Object.is,\n  e = Object.defineProperty,\n  r = Object.getOwnPropertyDescriptor,\n  h = Object.getOwnPropertyNames,\n  o = Object.getOwnPropertySymbols,\n  n = Object.getPrototypeOf,\n  a = globalThis,\n  c = a.trustedTypes,\n  l = c ? c.emptyScript : \"\",\n  p = a.reactiveElementPolyfillSupport,\n  d = (t, s) => t,\n  u = {\n    toAttribute(t, s) {\n      switch (s) {\n        case Boolean:\n          t = t ? l : null;\n          break;\n        case Object:\n        case Array:\n          t = null == t ? t : JSON.stringify(t);\n      }\n      return t;\n    },\n    fromAttribute(t, s) {\n      let i = t;\n      switch (s) {\n        case Boolean:\n          i = null !== t;\n          break;\n        case Number:\n          i = null === t ? null : Number(t);\n          break;\n        case Object:\n        case Array:\n          try {\n            i = JSON.parse(t);\n          } catch (t) {\n            i = null;\n          }\n      }\n      return i;\n    }\n  },\n  f = (t, s) => !i(t, s),\n  y = {\n    attribute: !0,\n    type: String,\n    converter: u,\n    reflect: !1,\n    hasChanged: f\n  };\n(_Symbol$metadata = Symbol.metadata) !== null && _Symbol$metadata !== void 0 ? _Symbol$metadata : Symbol.metadata = Symbol(\"metadata\"), (_a$litPropertyMetadat = a.litPropertyMetadata) !== null && _a$litPropertyMetadat !== void 0 ? _a$litPropertyMetadat : a.litPropertyMetadata = new WeakMap();\nclass b extends HTMLElement {\n  static addInitializer(t) {\n    var _this$l;\n    this._$Ei(), ((_this$l = this.l) !== null && _this$l !== void 0 ? _this$l : this.l = []).push(t);\n  }\n  static get observedAttributes() {\n    return this.finalize(), this._$Eh && [...this._$Eh.keys()];\n  }\n  static createProperty(t) {\n    let s = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : y;\n    if (s.state && (s.attribute = !1), this._$Ei(), this.elementProperties.set(t, s), !s.noAccessor) {\n      const i = Symbol(),\n        r = this.getPropertyDescriptor(t, i, s);\n      void 0 !== r && e(this.prototype, t, r);\n    }\n  }\n  static getPropertyDescriptor(t, s, i) {\n    var _r;\n    const _ref = (_r = r(this.prototype, t)) !== null && _r !== void 0 ? _r : {\n        get() {\n          return this[s];\n        },\n        set(t) {\n          this[s] = t;\n        }\n      },\n      e = _ref.get,\n      h = _ref.set;\n    return {\n      get() {\n        return e === null || e === void 0 ? void 0 : e.call(this);\n      },\n      set(s) {\n        const r = e === null || e === void 0 ? void 0 : e.call(this);\n        h.call(this, s), this.requestUpdate(t, r, i);\n      },\n      configurable: !0,\n      enumerable: !0\n    };\n  }\n  static getPropertyOptions(t) {\n    var _this$elementProperti;\n    return (_this$elementProperti = this.elementProperties.get(t)) !== null && _this$elementProperti !== void 0 ? _this$elementProperti : y;\n  }\n  static _$Ei() {\n    if (this.hasOwnProperty(d(\"elementProperties\"))) return;\n    const t = n(this);\n    t.finalize(), void 0 !== t.l && (this.l = [...t.l]), this.elementProperties = new Map(t.elementProperties);\n  }\n  static finalize() {\n    if (this.hasOwnProperty(d(\"finalized\"))) return;\n    if (this.finalized = !0, this._$Ei(), this.hasOwnProperty(d(\"properties\"))) {\n      const t = this.properties,\n        s = [...h(t), ...o(t)];\n      for (const i of s) this.createProperty(i, t[i]);\n    }\n    const t = this[Symbol.metadata];\n    if (null !== t) {\n      const s = litPropertyMetadata.get(t);\n      if (void 0 !== s) for (const _ref2 of s) {\n        var _ref3 = _slicedToArray(_ref2, 2);\n        const t = _ref3[0];\n        const i = _ref3[1];\n        this.elementProperties.set(t, i);\n      }\n    }\n    this._$Eh = new Map();\n    for (const _ref4 of this.elementProperties) {\n      var _ref5 = _slicedToArray(_ref4, 2);\n      const t = _ref5[0];\n      const s = _ref5[1];\n      {\n        const i = this._$Eu(t, s);\n        void 0 !== i && this._$Eh.set(i, t);\n      }\n    }\n    this.elementStyles = this.finalizeStyles(this.styles);\n  }\n  static finalizeStyles(s) {\n    const i = [];\n    if (Array.isArray(s)) {\n      const e = new Set(s.flat(1 / 0).reverse());\n      for (const s of e) i.unshift(t(s));\n    } else void 0 !== s && i.push(t(s));\n    return i;\n  }\n  static _$Eu(t, s) {\n    const i = s.attribute;\n    return !1 === i ? void 0 : \"string\" == typeof i ? i : \"string\" == typeof t ? t.toLowerCase() : void 0;\n  }\n  constructor() {\n    super(), this._$Ep = void 0, this.isUpdatePending = !1, this.hasUpdated = !1, this._$Em = null, this._$Ev();\n  }\n  _$Ev() {\n    var _this$constructor$l;\n    this._$ES = new Promise(t => this.enableUpdating = t), this._$AL = new Map(), this._$E_(), this.requestUpdate(), (_this$constructor$l = this.constructor.l) === null || _this$constructor$l === void 0 ? void 0 : _this$constructor$l.forEach(t => t(this));\n  }\n  addController(t) {\n    var _this$_$EO, _t$hostConnected;\n    ((_this$_$EO = this._$EO) !== null && _this$_$EO !== void 0 ? _this$_$EO : this._$EO = new Set()).add(t), void 0 !== this.renderRoot && this.isConnected && ((_t$hostConnected = t.hostConnected) === null || _t$hostConnected === void 0 ? void 0 : _t$hostConnected.call(t));\n  }\n  removeController(t) {\n    var _this$_$EO2;\n    (_this$_$EO2 = this._$EO) === null || _this$_$EO2 === void 0 ? void 0 : _this$_$EO2.delete(t);\n  }\n  _$E_() {\n    const t = new Map(),\n      s = this.constructor.elementProperties;\n    for (const i of s.keys()) this.hasOwnProperty(i) && (t.set(i, this[i]), delete this[i]);\n    t.size > 0 && (this._$Ep = t);\n  }\n  createRenderRoot() {\n    var _this$shadowRoot;\n    const t = (_this$shadowRoot = this.shadowRoot) !== null && _this$shadowRoot !== void 0 ? _this$shadowRoot : this.attachShadow(this.constructor.shadowRootOptions);\n    return s(t, this.constructor.elementStyles), t;\n  }\n  connectedCallback() {\n    var _this$renderRoot, _this$_$EO3;\n    (_this$renderRoot = this.renderRoot) !== null && _this$renderRoot !== void 0 ? _this$renderRoot : this.renderRoot = this.createRenderRoot(), this.enableUpdating(!0), (_this$_$EO3 = this._$EO) === null || _this$_$EO3 === void 0 ? void 0 : _this$_$EO3.forEach(t => {\n      var _t$hostConnected2;\n      return (_t$hostConnected2 = t.hostConnected) === null || _t$hostConnected2 === void 0 ? void 0 : _t$hostConnected2.call(t);\n    });\n  }\n  enableUpdating(t) {}\n  disconnectedCallback() {\n    var _this$_$EO4;\n    (_this$_$EO4 = this._$EO) === null || _this$_$EO4 === void 0 ? void 0 : _this$_$EO4.forEach(t => {\n      var _t$hostDisconnected;\n      return (_t$hostDisconnected = t.hostDisconnected) === null || _t$hostDisconnected === void 0 ? void 0 : _t$hostDisconnected.call(t);\n    });\n  }\n  attributeChangedCallback(t, s, i) {\n    this._$AK(t, i);\n  }\n  _$EC(t, s) {\n    const i = this.constructor.elementProperties.get(t),\n      e = this.constructor._$Eu(t, i);\n    if (void 0 !== e && !0 === i.reflect) {\n      var _i$converter;\n      const r = (void 0 !== ((_i$converter = i.converter) === null || _i$converter === void 0 ? void 0 : _i$converter.toAttribute) ? i.converter : u).toAttribute(s, i.type);\n      this._$Em = t, null == r ? this.removeAttribute(e) : this.setAttribute(e, r), this._$Em = null;\n    }\n  }\n  _$AK(t, s) {\n    const i = this.constructor,\n      e = i._$Eh.get(t);\n    if (void 0 !== e && this._$Em !== e) {\n      var _t$converter;\n      const t = i.getPropertyOptions(e),\n        r = \"function\" == typeof t.converter ? {\n          fromAttribute: t.converter\n        } : void 0 !== ((_t$converter = t.converter) === null || _t$converter === void 0 ? void 0 : _t$converter.fromAttribute) ? t.converter : u;\n      this._$Em = e, this[e] = r.fromAttribute(s, t.type), this._$Em = null;\n    }\n  }\n  requestUpdate(t, s, i) {\n    if (void 0 !== t) {\n      var _i, _i$hasChanged;\n      if ((_i = i) !== null && _i !== void 0 ? _i : i = this.constructor.getPropertyOptions(t), !((_i$hasChanged = i.hasChanged) !== null && _i$hasChanged !== void 0 ? _i$hasChanged : f)(this[t], s)) return;\n      this.P(t, s, i);\n    }\n    !1 === this.isUpdatePending && (this._$ES = this._$ET());\n  }\n  P(t, s, i) {\n    var _this$_$Ej;\n    this._$AL.has(t) || this._$AL.set(t, s), !0 === i.reflect && this._$Em !== t && ((_this$_$Ej = this._$Ej) !== null && _this$_$Ej !== void 0 ? _this$_$Ej : this._$Ej = new Set()).add(t);\n  }\n  async _$ET() {\n    this.isUpdatePending = !0;\n    try {\n      await this._$ES;\n    } catch (t) {\n      Promise.reject(t);\n    }\n    const t = this.scheduleUpdate();\n    return null != t && (await t), !this.isUpdatePending;\n  }\n  scheduleUpdate() {\n    return this.performUpdate();\n  }\n  performUpdate() {\n    if (!this.isUpdatePending) return;\n    if (!this.hasUpdated) {\n      var _this$renderRoot2;\n      if ((_this$renderRoot2 = this.renderRoot) !== null && _this$renderRoot2 !== void 0 ? _this$renderRoot2 : this.renderRoot = this.createRenderRoot(), this._$Ep) {\n        for (const _ref6 of this._$Ep) {\n          var _ref7 = _slicedToArray(_ref6, 2);\n          const t = _ref7[0];\n          const s = _ref7[1];\n          this[t] = s;\n        }\n        this._$Ep = void 0;\n      }\n      const t = this.constructor.elementProperties;\n      if (t.size > 0) for (const _ref8 of t) {\n        var _ref9 = _slicedToArray(_ref8, 2);\n        const s = _ref9[0];\n        const i = _ref9[1];\n        !0 !== i.wrapped || this._$AL.has(s) || void 0 === this[s] || this.P(s, this[s], i);\n      }\n    }\n    let t = !1;\n    const s = this._$AL;\n    try {\n      var _this$_$EO5;\n      t = this.shouldUpdate(s), t ? (this.willUpdate(s), (_this$_$EO5 = this._$EO) !== null && _this$_$EO5 !== void 0 && _this$_$EO5.forEach(t => {\n        var _t$hostUpdate;\n        return (_t$hostUpdate = t.hostUpdate) === null || _t$hostUpdate === void 0 ? void 0 : _t$hostUpdate.call(t);\n      }), this.update(s)) : this._$EU();\n    } catch (s) {\n      throw t = !1, this._$EU(), s;\n    }\n    t && this._$AE(s);\n  }\n  willUpdate(t) {}\n  _$AE(t) {\n    var _this$_$EO6;\n    (_this$_$EO6 = this._$EO) !== null && _this$_$EO6 !== void 0 && _this$_$EO6.forEach(t => {\n      var _t$hostUpdated;\n      return (_t$hostUpdated = t.hostUpdated) === null || _t$hostUpdated === void 0 ? void 0 : _t$hostUpdated.call(t);\n    }), this.hasUpdated || (this.hasUpdated = !0, this.firstUpdated(t)), this.updated(t);\n  }\n  _$EU() {\n    this._$AL = new Map(), this.isUpdatePending = !1;\n  }\n  get updateComplete() {\n    return this.getUpdateComplete();\n  }\n  getUpdateComplete() {\n    return this._$ES;\n  }\n  shouldUpdate(t) {\n    return !0;\n  }\n  update(t) {\n    this._$Ej && (this._$Ej = this._$Ej.forEach(t => this._$EC(t, this[t]))), this._$EU();\n  }\n  updated(t) {}\n  firstUpdated(t) {}\n}\nb.elementStyles = [], b.shadowRootOptions = {\n  mode: \"open\"\n}, b[d(\"elementProperties\")] = new Map(), b[d(\"finalized\")] = new Map(), p !== null && p !== void 0 && p({\n  ReactiveElement: b\n}), ((_a$reactiveElementVer = a.reactiveElementVersions) !== null && _a$reactiveElementVer !== void 0 ? _a$reactiveElementVer : a.reactiveElementVersions = []).push(\"2.0.4\");\nexport { b as ReactiveElement, u as defaultConverter, f as notEqual };","var _t$litHtmlVersions;\nfunction _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction _iterableToArrayLimit(r, l) { var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }\nfunction _arrayWithHoles(r) { if (Array.isArray(r)) return r; }\n/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nconst t = globalThis,\n  i = t.trustedTypes,\n  s = i ? i.createPolicy(\"lit-html\", {\n    createHTML: t => t\n  }) : void 0,\n  e = \"$lit$\",\n  h = `lit$${Math.random().toFixed(9).slice(2)}$`,\n  o = \"?\" + h,\n  n = `<${o}>`,\n  r = document,\n  l = () => r.createComment(\"\"),\n  c = t => null === t || \"object\" != typeof t && \"function\" != typeof t,\n  a = Array.isArray,\n  u = t => a(t) || \"function\" == typeof (t === null || t === void 0 ? void 0 : t[Symbol.iterator]),\n  d = \"[ \\t\\n\\f\\r]\",\n  f = /<(?:(!--|\\/[^a-zA-Z])|(\\/?[a-zA-Z][^>\\s]*)|(\\/?$))/g,\n  v = /-->/g,\n  _ = />/g,\n  m = RegExp(`>|${d}(?:([^\\\\s\"'>=/]+)(${d}*=${d}*(?:[^ \\t\\n\\f\\r\"'\\`<>=]|(\"|')|))|$)`, \"g\"),\n  p = /'/g,\n  g = /\"/g,\n  $ = /^(?:script|style|textarea|title)$/i,\n  y = t => function (i) {\n    for (var _len = arguments.length, s = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      s[_key - 1] = arguments[_key];\n    }\n    return {\n      _$litType$: t,\n      strings: i,\n      values: s\n    };\n  },\n  x = y(1),\n  b = y(2),\n  w = y(3),\n  T = Symbol.for(\"lit-noChange\"),\n  E = Symbol.for(\"lit-nothing\"),\n  A = new WeakMap(),\n  C = r.createTreeWalker(r, 129);\nfunction P(t, i) {\n  if (!a(t) || !t.hasOwnProperty(\"raw\")) throw Error(\"invalid template strings array\");\n  return void 0 !== s ? s.createHTML(i) : i;\n}\nconst V = (t, i) => {\n  const s = t.length - 1,\n    o = [];\n  let r,\n    l = 2 === i ? \"<svg>\" : 3 === i ? \"<math>\" : \"\",\n    c = f;\n  for (let i = 0; i < s; i++) {\n    const s = t[i];\n    let a,\n      u,\n      d = -1,\n      y = 0;\n    for (; y < s.length && (c.lastIndex = y, u = c.exec(s), null !== u);) {\n      var _r;\n      y = c.lastIndex, c === f ? \"!--\" === u[1] ? c = v : void 0 !== u[1] ? c = _ : void 0 !== u[2] ? ($.test(u[2]) && (r = RegExp(\"</\" + u[2], \"g\")), c = m) : void 0 !== u[3] && (c = m) : c === m ? \">\" === u[0] ? (c = (_r = r) !== null && _r !== void 0 ? _r : f, d = -1) : void 0 === u[1] ? d = -2 : (d = c.lastIndex - u[2].length, a = u[1], c = void 0 === u[3] ? m : '\"' === u[3] ? g : p) : c === g || c === p ? c = m : c === v || c === _ ? c = f : (c = m, r = void 0);\n    }\n    const x = c === m && t[i + 1].startsWith(\"/>\") ? \" \" : \"\";\n    l += c === f ? s + n : d >= 0 ? (o.push(a), s.slice(0, d) + e + s.slice(d) + h + x) : s + h + (-2 === d ? i : x);\n  }\n  return [P(t, l + (t[s] || \"<?>\") + (2 === i ? \"</svg>\" : 3 === i ? \"</math>\" : \"\")), o];\n};\nclass N {\n  constructor(_ref, n) {\n    let t = _ref.strings,\n      s = _ref._$litType$;\n    let r;\n    this.parts = [];\n    let c = 0,\n      a = 0;\n    const u = t.length - 1,\n      d = this.parts,\n      _V = V(t, s),\n      _V2 = _slicedToArray(_V, 2),\n      f = _V2[0],\n      v = _V2[1];\n    if (this.el = N.createElement(f, n), C.currentNode = this.el.content, 2 === s || 3 === s) {\n      const t = this.el.content.firstChild;\n      t.replaceWith(...t.childNodes);\n    }\n    for (; null !== (r = C.nextNode()) && d.length < u;) {\n      if (1 === r.nodeType) {\n        if (r.hasAttributes()) for (const t of r.getAttributeNames()) if (t.endsWith(e)) {\n          const i = v[a++],\n            s = r.getAttribute(t).split(h),\n            e = /([.?@])?(.*)/.exec(i);\n          d.push({\n            type: 1,\n            index: c,\n            name: e[2],\n            strings: s,\n            ctor: \".\" === e[1] ? H : \"?\" === e[1] ? I : \"@\" === e[1] ? L : k\n          }), r.removeAttribute(t);\n        } else t.startsWith(h) && (d.push({\n          type: 6,\n          index: c\n        }), r.removeAttribute(t));\n        if ($.test(r.tagName)) {\n          const t = r.textContent.split(h),\n            s = t.length - 1;\n          if (s > 0) {\n            r.textContent = i ? i.emptyScript : \"\";\n            for (let i = 0; i < s; i++) r.append(t[i], l()), C.nextNode(), d.push({\n              type: 2,\n              index: ++c\n            });\n            r.append(t[s], l());\n          }\n        }\n      } else if (8 === r.nodeType) if (r.data === o) d.push({\n        type: 2,\n        index: c\n      });else {\n        let t = -1;\n        for (; -1 !== (t = r.data.indexOf(h, t + 1));) d.push({\n          type: 7,\n          index: c\n        }), t += h.length - 1;\n      }\n      c++;\n    }\n  }\n  static createElement(t, i) {\n    const s = r.createElement(\"template\");\n    return s.innerHTML = t, s;\n  }\n}\nfunction S(t, i) {\n  var _s$_$Co, _h, _h2, _h2$_$AO, _s$_$Co2;\n  let s = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : t;\n  let e = arguments.length > 3 ? arguments[3] : undefined;\n  if (i === T) return i;\n  let h = void 0 !== e ? (_s$_$Co = s._$Co) === null || _s$_$Co === void 0 ? void 0 : _s$_$Co[e] : s._$Cl;\n  const o = c(i) ? void 0 : i._$litDirective$;\n  return ((_h = h) === null || _h === void 0 ? void 0 : _h.constructor) !== o && ((_h2 = h) !== null && _h2 !== void 0 && (_h2$_$AO = _h2._$AO) !== null && _h2$_$AO !== void 0 && _h2$_$AO.call(_h2, !1), void 0 === o ? h = void 0 : (h = new o(t), h._$AT(t, s, e)), void 0 !== e ? ((_s$_$Co2 = s._$Co) !== null && _s$_$Co2 !== void 0 ? _s$_$Co2 : s._$Co = [])[e] = h : s._$Cl = h), void 0 !== h && (i = S(t, h._$AS(t, i.values), h, e)), i;\n}\nclass M {\n  constructor(t, i) {\n    this._$AV = [], this._$AN = void 0, this._$AD = t, this._$AM = i;\n  }\n  get parentNode() {\n    return this._$AM.parentNode;\n  }\n  get _$AU() {\n    return this._$AM._$AU;\n  }\n  u(t) {\n    var _t$creationScope;\n    const _this$_$AD = this._$AD,\n      i = _this$_$AD.el.content,\n      s = _this$_$AD.parts,\n      e = ((_t$creationScope = t === null || t === void 0 ? void 0 : t.creationScope) !== null && _t$creationScope !== void 0 ? _t$creationScope : r).importNode(i, !0);\n    C.currentNode = e;\n    let h = C.nextNode(),\n      o = 0,\n      n = 0,\n      l = s[0];\n    for (; void 0 !== l;) {\n      var _l;\n      if (o === l.index) {\n        let i;\n        2 === l.type ? i = new R(h, h.nextSibling, this, t) : 1 === l.type ? i = new l.ctor(h, l.name, l.strings, this, t) : 6 === l.type && (i = new z(h, this, t)), this._$AV.push(i), l = s[++n];\n      }\n      o !== ((_l = l) === null || _l === void 0 ? void 0 : _l.index) && (h = C.nextNode(), o++);\n    }\n    return C.currentNode = r, e;\n  }\n  p(t) {\n    let i = 0;\n    for (const s of this._$AV) void 0 !== s && (void 0 !== s.strings ? (s._$AI(t, s, i), i += s.strings.length - 2) : s._$AI(t[i])), i++;\n  }\n}\nclass R {\n  get _$AU() {\n    var _this$_$AM$_$AU, _this$_$AM;\n    return (_this$_$AM$_$AU = (_this$_$AM = this._$AM) === null || _this$_$AM === void 0 ? void 0 : _this$_$AM._$AU) !== null && _this$_$AM$_$AU !== void 0 ? _this$_$AM$_$AU : this._$Cv;\n  }\n  constructor(t, i, s, e) {\n    var _e$isConnected;\n    this.type = 2, this._$AH = E, this._$AN = void 0, this._$AA = t, this._$AB = i, this._$AM = s, this.options = e, this._$Cv = (_e$isConnected = e === null || e === void 0 ? void 0 : e.isConnected) !== null && _e$isConnected !== void 0 ? _e$isConnected : !0;\n  }\n  get parentNode() {\n    var _t;\n    let t = this._$AA.parentNode;\n    const i = this._$AM;\n    return void 0 !== i && 11 === ((_t = t) === null || _t === void 0 ? void 0 : _t.nodeType) && (t = i.parentNode), t;\n  }\n  get startNode() {\n    return this._$AA;\n  }\n  get endNode() {\n    return this._$AB;\n  }\n  _$AI(t) {\n    let i = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this;\n    t = S(this, t, i), c(t) ? t === E || null == t || \"\" === t ? (this._$AH !== E && this._$AR(), this._$AH = E) : t !== this._$AH && t !== T && this._(t) : void 0 !== t._$litType$ ? this.$(t) : void 0 !== t.nodeType ? this.T(t) : u(t) ? this.k(t) : this._(t);\n  }\n  O(t) {\n    return this._$AA.parentNode.insertBefore(t, this._$AB);\n  }\n  T(t) {\n    this._$AH !== t && (this._$AR(), this._$AH = this.O(t));\n  }\n  _(t) {\n    this._$AH !== E && c(this._$AH) ? this._$AA.nextSibling.data = t : this.T(r.createTextNode(t)), this._$AH = t;\n  }\n  $(t) {\n    var _this$_$AH;\n    const i = t.values,\n      s = t._$litType$,\n      e = \"number\" == typeof s ? this._$AC(t) : (void 0 === s.el && (s.el = N.createElement(P(s.h, s.h[0]), this.options)), s);\n    if (((_this$_$AH = this._$AH) === null || _this$_$AH === void 0 ? void 0 : _this$_$AH._$AD) === e) this._$AH.p(i);else {\n      const t = new M(e, this),\n        s = t.u(this.options);\n      t.p(i), this.T(s), this._$AH = t;\n    }\n  }\n  _$AC(t) {\n    let i = A.get(t.strings);\n    return void 0 === i && A.set(t.strings, i = new N(t)), i;\n  }\n  k(t) {\n    a(this._$AH) || (this._$AH = [], this._$AR());\n    const i = this._$AH;\n    let s,\n      e = 0;\n    for (const h of t) e === i.length ? i.push(s = new R(this.O(l()), this.O(l()), this, this.options)) : s = i[e], s._$AI(h), e++;\n    e < i.length && (this._$AR(s && s._$AB.nextSibling, e), i.length = e);\n  }\n  _$AR() {\n    let t = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._$AA.nextSibling;\n    let i = arguments.length > 1 ? arguments[1] : undefined;\n    for ((_this$_$AP = this._$AP) === null || _this$_$AP === void 0 ? void 0 : _this$_$AP.call(this, !1, !0, i); t && t !== this._$AB;) {\n      var _this$_$AP;\n      const i = t.nextSibling;\n      t.remove(), t = i;\n    }\n  }\n  setConnected(t) {\n    var _this$_$AP2;\n    void 0 === this._$AM && (this._$Cv = t, (_this$_$AP2 = this._$AP) === null || _this$_$AP2 === void 0 ? void 0 : _this$_$AP2.call(this, t));\n  }\n}\nclass k {\n  get tagName() {\n    return this.element.tagName;\n  }\n  get _$AU() {\n    return this._$AM._$AU;\n  }\n  constructor(t, i, s, e, h) {\n    this.type = 1, this._$AH = E, this._$AN = void 0, this.element = t, this.name = i, this._$AM = e, this.options = h, s.length > 2 || \"\" !== s[0] || \"\" !== s[1] ? (this._$AH = Array(s.length - 1).fill(new String()), this.strings = s) : this._$AH = E;\n  }\n  _$AI(t) {\n    let i = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this;\n    let s = arguments.length > 2 ? arguments[2] : undefined;\n    let e = arguments.length > 3 ? arguments[3] : undefined;\n    const h = this.strings;\n    let o = !1;\n    if (void 0 === h) t = S(this, t, i, 0), o = !c(t) || t !== this._$AH && t !== T, o && (this._$AH = t);else {\n      const e = t;\n      let n, r;\n      for (t = h[0], n = 0; n < h.length - 1; n++) {\n        var _r2;\n        r = S(this, e[s + n], i, n), r === T && (r = this._$AH[n]), o || (o = !c(r) || r !== this._$AH[n]), r === E ? t = E : t !== E && (t += ((_r2 = r) !== null && _r2 !== void 0 ? _r2 : \"\") + h[n + 1]), this._$AH[n] = r;\n      }\n    }\n    o && !e && this.j(t);\n  }\n  j(t) {\n    t === E ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, t !== null && t !== void 0 ? t : \"\");\n  }\n}\nclass H extends k {\n  constructor() {\n    super(...arguments), this.type = 3;\n  }\n  j(t) {\n    this.element[this.name] = t === E ? void 0 : t;\n  }\n}\nclass I extends k {\n  constructor() {\n    super(...arguments), this.type = 4;\n  }\n  j(t) {\n    this.element.toggleAttribute(this.name, !!t && t !== E);\n  }\n}\nclass L extends k {\n  constructor(t, i, s, e, h) {\n    super(t, i, s, e, h), this.type = 5;\n  }\n  _$AI(t) {\n    var _S;\n    let i = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this;\n    if ((t = (_S = S(this, t, i, 0)) !== null && _S !== void 0 ? _S : E) === T) return;\n    const s = this._$AH,\n      e = t === E && s !== E || t.capture !== s.capture || t.once !== s.once || t.passive !== s.passive,\n      h = t !== E && (s === E || e);\n    e && this.element.removeEventListener(this.name, this, s), h && this.element.addEventListener(this.name, this, t), this._$AH = t;\n  }\n  handleEvent(t) {\n    var _this$options$host, _this$options;\n    \"function\" == typeof this._$AH ? this._$AH.call((_this$options$host = (_this$options = this.options) === null || _this$options === void 0 ? void 0 : _this$options.host) !== null && _this$options$host !== void 0 ? _this$options$host : this.element, t) : this._$AH.handleEvent(t);\n  }\n}\nclass z {\n  constructor(t, i, s) {\n    this.element = t, this.type = 6, this._$AN = void 0, this._$AM = i, this.options = s;\n  }\n  get _$AU() {\n    return this._$AM._$AU;\n  }\n  _$AI(t) {\n    S(this, t);\n  }\n}\nconst Z = {\n    M: e,\n    P: h,\n    A: o,\n    C: 1,\n    L: V,\n    R: M,\n    D: u,\n    V: S,\n    I: R,\n    H: k,\n    N: I,\n    U: L,\n    B: H,\n    F: z\n  },\n  j = t.litHtmlPolyfillSupport;\nj !== null && j !== void 0 && j(N, R), ((_t$litHtmlVersions = t.litHtmlVersions) !== null && _t$litHtmlVersions !== void 0 ? _t$litHtmlVersions : t.litHtmlVersions = []).push(\"3.2.1\");\nconst B = (t, i, s) => {\n  var _s$renderBefore;\n  const e = (_s$renderBefore = s === null || s === void 0 ? void 0 : s.renderBefore) !== null && _s$renderBefore !== void 0 ? _s$renderBefore : i;\n  let h = e._$litPart$;\n  if (void 0 === h) {\n    var _s$renderBefore2;\n    const t = (_s$renderBefore2 = s === null || s === void 0 ? void 0 : s.renderBefore) !== null && _s$renderBefore2 !== void 0 ? _s$renderBefore2 : null;\n    e._$litPart$ = h = new R(i.insertBefore(l(), t), t, void 0, s !== null && s !== void 0 ? s : {});\n  }\n  return h._$AI(t), h;\n};\nexport { Z as _$LH, x as html, w as mathml, T as noChange, E as nothing, B as render, b as svg };","var _globalThis$litElemen, _globalThis$litElemen2;\nimport { ReactiveElement as t } from \"@lit/reactive-element\";\nexport * from \"@lit/reactive-element\";\nimport { render as e, noChange as s } from \"lit-html\";\nexport * from \"lit-html\";\n/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nclass r extends t {\n  constructor() {\n    super(...arguments), this.renderOptions = {\n      host: this\n    }, this._$Do = void 0;\n  }\n  createRenderRoot() {\n    var _this$renderOptions, _this$renderOptions$r;\n    const t = super.createRenderRoot();\n    return (_this$renderOptions$r = (_this$renderOptions = this.renderOptions).renderBefore) !== null && _this$renderOptions$r !== void 0 ? _this$renderOptions$r : _this$renderOptions.renderBefore = t.firstChild, t;\n  }\n  update(t) {\n    const s = this.render();\n    this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), super.update(t), this._$Do = e(s, this.renderRoot, this.renderOptions);\n  }\n  connectedCallback() {\n    var _this$_$Do;\n    super.connectedCallback(), (_this$_$Do = this._$Do) === null || _this$_$Do === void 0 ? void 0 : _this$_$Do.setConnected(!0);\n  }\n  disconnectedCallback() {\n    var _this$_$Do2;\n    super.disconnectedCallback(), (_this$_$Do2 = this._$Do) === null || _this$_$Do2 === void 0 ? void 0 : _this$_$Do2.setConnected(!1);\n  }\n  render() {\n    return s;\n  }\n}\nr._$litElement$ = !0, r[\"finalized\"] = !0, (_globalThis$litElemen = globalThis.litElementHydrateSupport) === null || _globalThis$litElemen === void 0 ? void 0 : _globalThis$litElemen.call(globalThis, {\n  LitElement: r\n});\nconst i = globalThis.litElementPolyfillSupport;\ni === null || i === void 0 ? void 0 : i({\n  LitElement: r\n});\nconst o = {\n  _$AK: (t, e, s) => {\n    t._$AK(e, s);\n  },\n  _$AL: t => t._$AL\n};\n((_globalThis$litElemen2 = globalThis.litElementVersions) !== null && _globalThis$litElemen2 !== void 0 ? _globalThis$litElemen2 : globalThis.litElementVersions = []).push(\"4.1.1\");\nexport { r as LitElement, o as _$LE };","/**\n * @license\n * Copyright 2022 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nconst o = !1;\nexport { o as isServer };","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n/**\n * @polymerMixin\n */\nexport const ThemePropertyMixin = superClass => class VaadinThemePropertyMixin extends superClass {\n  static get properties() {\n    return {\n      /**\n       * Helper property with theme attribute value facilitating propagation\n       * in shadow DOM.\n       *\n       * Enables the component implementation to propagate the `theme`\n       * attribute value to the sub-components in Shadow DOM by binding\n       * the sub-component's \"theme\" attribute to the `theme` property of\n       * the host.\n       *\n       * **NOTE:** Extending the mixin only provides the property for binding,\n       * and does not make the propagation alone.\n       *\n       * See [Styling Components: Sub-components](https://vaadin.com/docs/latest/styling/styling-components/#sub-components).\n       * page for more information.\n       *\n       * @protected\n       */\n      _theme: {\n        type: String,\n        readOnly: true\n      }\n    };\n  }\n  static get observedAttributes() {\n    return [...super.observedAttributes, 'theme'];\n  }\n\n  /** @protected */\n  attributeChangedCallback(name, oldValue, newValue) {\n    super.attributeChangedCallback(name, oldValue, newValue);\n    if (name === 'theme') {\n      this._set_theme(newValue);\n    }\n  }\n};","function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }\nfunction _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\nfunction _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\n/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { adoptStyles, css, CSSResult, LitElement, unsafeCSS } from 'lit';\nimport { ThemePropertyMixin } from './vaadin-theme-property-mixin.js';\nexport { css, unsafeCSS };\n\n/**\n * @typedef {Object} Theme\n * @property {string} themeFor\n * @property {CSSResult[]} styles\n * @property {string | string[]} [include]\n * @property {string} [moduleId]\n *\n * @typedef {CSSResult[] | CSSResult} CSSResultGroup\n */\n\n/**\n * @type {Theme[]}\n */\nconst themeRegistry = [];\n\n/**\n * @type {WeakRef<HTMLElement>[]}\n */\nconst themableInstances = new Set();\n\n/**\n * @type {string[]}\n */\nconst themableTagNames = new Set();\n\n/**\n * Check if the custom element type has themes applied.\n * @param {Function} elementClass\n * @returns {boolean}\n */\nfunction classHasThemes(elementClass) {\n  return elementClass && Object.prototype.hasOwnProperty.call(elementClass, '__themes');\n}\n\n/**\n * Check if the custom element type has themes applied.\n * @param {string} tagName\n * @returns {boolean}\n */\nfunction hasThemes(tagName) {\n  return classHasThemes(customElements.get(tagName));\n}\n\n/**\n * Flattens the styles into a single array of styles.\n * @param {CSSResultGroup} styles\n * @param {CSSResult[]} result\n * @returns {CSSResult[]}\n */\nfunction flattenStyles() {\n  let styles = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n  return [styles].flat(Infinity).filter(style => {\n    if (style instanceof CSSResult) {\n      return true;\n    }\n    console.warn('An item in styles is not of type CSSResult. Use `unsafeCSS` or `css`.');\n    return false;\n  });\n}\n\n/**\n * Returns true if the themeFor string matches the tag name\n * @param {string} themeFor\n * @param {string} tagName\n * @returns {boolean}\n */\nfunction matchesThemeFor(themeFor, tagName) {\n  return (themeFor || '').split(' ').some(themeForToken => {\n    return new RegExp(`^${themeForToken.split('*').join('.*')}$`, 'u').test(tagName);\n  });\n}\n\n/**\n * Returns the CSS text content from an array of CSSResults\n * @param {CSSResult[]} styles\n * @returns {string}\n */\nfunction getCssText(styles) {\n  return styles.map(style => style.cssText).join('\\n');\n}\nconst STYLE_ID = 'vaadin-themable-mixin-style';\n\n/**\n * Includes the styles to the template.\n * @param {CSSResult[]} styles\n * @param {HTMLTemplateElement} template\n */\nfunction addStylesToTemplate(styles, template) {\n  const styleEl = document.createElement('style');\n  styleEl.id = STYLE_ID;\n  styleEl.textContent = getCssText(styles);\n  template.content.appendChild(styleEl);\n}\n\n/**\n * Dynamically updates the styles of the given component instance.\n * @param {HTMLElement} instance\n */\nfunction updateInstanceStyles(instance) {\n  if (!instance.shadowRoot) {\n    return;\n  }\n  const componentClass = instance.constructor;\n  if (instance instanceof LitElement) {\n    // LitElement\n\n    // The adoptStyles function may fall back to appending style elements to shadow root.\n    // Remove them first to avoid duplicates.\n    [...instance.shadowRoot.querySelectorAll('style')].forEach(style => style.remove());\n\n    // Adopt the updated styles\n    adoptStyles(instance.shadowRoot, componentClass.elementStyles);\n  } else {\n    // PolymerElement\n\n    // Update style element content in the shadow root\n    const style = instance.shadowRoot.getElementById(STYLE_ID);\n    const template = componentClass.prototype._template;\n    style.textContent = template.content.getElementById(STYLE_ID).textContent;\n  }\n}\n\n/**\n * Dynamically updates the styles of the instances matching the given component type.\n * @param {Function} componentClass\n */\nfunction updateInstanceStylesOfType(componentClass) {\n  // Iterate over component instances and update their styles if needed\n  themableInstances.forEach(ref => {\n    const instance = ref.deref();\n    if (instance instanceof componentClass) {\n      updateInstanceStyles(instance);\n    } else if (!instance) {\n      // Clean up the weak reference to a GC'd instance\n      themableInstances.delete(ref);\n    }\n  });\n}\n\n/**\n * Dynamically updates the styles of the given component type.\n * @param {Function} componentClass\n */\nfunction updateComponentStyles(componentClass) {\n  if (componentClass.prototype instanceof LitElement) {\n    // Update LitElement-based component's elementStyles\n    componentClass.elementStyles = componentClass.finalizeStyles(componentClass.styles);\n  } else {\n    // Update Polymer-based component's template\n    const template = componentClass.prototype._template;\n    template.content.getElementById(STYLE_ID).textContent = getCssText(componentClass.getStylesForThis());\n  }\n\n  // Update the styles of inheriting types\n  themableTagNames.forEach(inheritingTagName => {\n    const inheritingClass = customElements.get(inheritingTagName);\n    if (inheritingClass !== componentClass && inheritingClass.prototype instanceof componentClass) {\n      updateComponentStyles(inheritingClass);\n    }\n  });\n}\n\n/**\n * Check if the component type already has a style matching the given styles.\n *\n * @param {Function} componentClass\n * @param {CSSResultGroup} styles\n * @returns {boolean}\n */\nfunction hasMatchingStyle(componentClass, styles) {\n  const themes = componentClass.__themes;\n  if (!themes || !styles) {\n    return false;\n  }\n  return themes.some(theme => theme.styles.some(themeStyle => styles.some(style => style.cssText === themeStyle.cssText)));\n}\n\n/**\n * Registers CSS styles for a component type. Make sure to register the styles before\n * the first instance of a component of the type is attached to DOM.\n *\n * @param {string} themeFor The local/tag name of the component type to register the styles for\n * @param {CSSResultGroup} styles The CSS style rules to be registered for the component type\n * matching themeFor and included in the local scope of each component instance\n * @param {{moduleId?: string, include?: string | string[]}} options Additional options\n * @return {void}\n */\nexport function registerStyles(themeFor, styles) {\n  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  styles = flattenStyles(styles);\n  if (window.Vaadin && window.Vaadin.styleModules) {\n    window.Vaadin.styleModules.registerStyles(themeFor, styles, options);\n  } else {\n    themeRegistry.push({\n      themeFor,\n      styles,\n      include: options.include,\n      moduleId: options.moduleId\n    });\n  }\n  if (themeFor) {\n    // Update styles of the component types that match themeFor and have already been finalized\n    themableTagNames.forEach(tagName => {\n      if (matchesThemeFor(themeFor, tagName) && hasThemes(tagName)) {\n        const componentClass = customElements.get(tagName);\n        if (hasMatchingStyle(componentClass, styles)) {\n          // Show a warning if the component type already has some of the given styles\n          console.warn(`Registering styles that already exist for ${tagName}`);\n        } else if (!window.Vaadin || !window.Vaadin.suppressPostFinalizeStylesWarning) {\n          // Show a warning if the component type has already been finalized\n          console.warn(`The custom element definition for \"${tagName}\" ` + `was finalized before a style module was registered. ` + `Ideally, import component specific style modules before ` + `importing the corresponding custom element. ` + `This warning can be suppressed by setting \"window.Vaadin.suppressPostFinalizeStylesWarning = true\".`);\n        }\n\n        // Update the styles of the component type\n        updateComponentStyles(componentClass);\n        // Update the styles of the component instances matching the component type\n        updateInstanceStylesOfType(componentClass);\n      }\n    });\n  }\n}\n\n/**\n * Returns all registered themes. By default the themeRegistry is returned as is.\n * In case the style-modules adapter is imported, the themes are obtained from there instead\n * @returns {Theme[]}\n */\nfunction getAllThemes() {\n  if (window.Vaadin && window.Vaadin.styleModules) {\n    return window.Vaadin.styleModules.getAllThemes();\n  }\n  return themeRegistry;\n}\n\n/**\n * Maps the moduleName to an include priority number which is used for\n * determining the order in which styles are applied.\n * @param {string} moduleName\n * @returns {number}\n */\nfunction getIncludePriority() {\n  let moduleName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n  let includePriority = 0;\n  if (moduleName.startsWith('lumo-') || moduleName.startsWith('material-')) {\n    includePriority = 1;\n  } else if (moduleName.startsWith('vaadin-')) {\n    includePriority = 2;\n  }\n  return includePriority;\n}\n\n/**\n * Gets an array of CSSResults matching the include property of the theme.\n * @param {Theme} theme\n * @returns {CSSResult[]}\n */\nfunction getIncludedStyles(theme) {\n  const includedStyles = [];\n  if (theme.include) {\n    [].concat(theme.include).forEach(includeModuleId => {\n      const includedTheme = getAllThemes().find(s => s.moduleId === includeModuleId);\n      if (includedTheme) {\n        includedStyles.push(...getIncludedStyles(includedTheme), ...includedTheme.styles);\n      } else {\n        console.warn(`Included moduleId ${includeModuleId} not found in style registry`);\n      }\n    }, theme.styles);\n  }\n  return includedStyles;\n}\n\n/**\n * Returns an array of themes that should be used for styling a component matching\n * the tag name. The array is sorted by the include order.\n * @param {string} tagName\n * @returns {Theme[]}\n */\nfunction getThemes(tagName) {\n  const defaultModuleName = `${tagName}-default-theme`;\n  const themes = getAllThemes()\n  // Filter by matching themeFor properties\n  .filter(theme => theme.moduleId !== defaultModuleName && matchesThemeFor(theme.themeFor, tagName)).map(theme => _objectSpread(_objectSpread({}, theme), {}, {\n    // Prepend styles from included themes\n    styles: [...getIncludedStyles(theme), ...theme.styles],\n    // Map moduleId to includePriority\n    includePriority: getIncludePriority(theme.moduleId)\n  }))\n  // Sort by includePriority\n  .sort((themeA, themeB) => themeB.includePriority - themeA.includePriority);\n  if (themes.length > 0) {\n    return themes;\n  }\n  // No theme modules found, return the default module if it exists\n  return getAllThemes().filter(theme => theme.moduleId === defaultModuleName);\n}\n\n/**\n * @polymerMixin\n * @mixes ThemePropertyMixin\n */\nexport const ThemableMixin = superClass => class VaadinThemableMixin extends ThemePropertyMixin(superClass) {\n  constructor() {\n    super();\n    // Store a weak reference to the instance\n    themableInstances.add(new WeakRef(this));\n  }\n\n  /**\n   * Covers PolymerElement based component styling\n   * @protected\n   */\n  static finalize() {\n    super.finalize();\n    if (this.is) {\n      themableTagNames.add(this.is);\n    }\n\n    // Make sure not to run the logic intended for PolymerElement when LitElement is used.\n    if (this.elementStyles) {\n      return;\n    }\n    const template = this.prototype._template;\n    if (!template || classHasThemes(this)) {\n      return;\n    }\n    addStylesToTemplate(this.getStylesForThis(), template);\n  }\n\n  /**\n   * Covers LitElement based component styling\n   *\n   * @protected\n   */\n  static finalizeStyles(styles) {\n    // The \"styles\" object originates from the \"static get styles()\" function of\n    // a LitElement based component. The theme styles are added after it\n    // so that they can override the component styles.\n    const themeStyles = this.getStylesForThis();\n    return styles ? [...[styles].flat(Infinity), ...themeStyles] : themeStyles;\n  }\n\n  /**\n   * Get styles for the component type\n   *\n   * @private\n   */\n  static getStylesForThis() {\n    const superClassThemes = superClass.__themes || [];\n    const parent = Object.getPrototypeOf(this.prototype);\n    const inheritedThemes = (parent ? parent.constructor.__themes : []) || [];\n    this.__themes = [...superClassThemes, ...inheritedThemes, ...getThemes(this.is)];\n    const themeStyles = this.__themes.flatMap(theme => theme.styles);\n    // Remove duplicates\n    return themeStyles.filter((style, index) => index === themeStyles.lastIndexOf(style));\n  }\n};\nexport { themeRegistry as __themeRegistry };","import { addGlobalThemeStyles } from '@vaadin/vaadin-themable-mixin/register-styles.js';\nexport const addLumoGlobalStyles = function (id) {\n  for (var _len = arguments.length, styles = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    styles[_key - 1] = arguments[_key];\n  }\n  addGlobalThemeStyles(`lumo-${id}`, styles);\n};","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nexport { registerStyles, css, unsafeCSS } from './vaadin-themable-mixin.js';\n\n/**\n * This is for use internally by Lumo and Material styles.\n *\n * @param {string} id the id to set on the created element, only for informational purposes\n * @param  {CSSResultGroup[]} styles the styles to add\n */\nexport const addGlobalThemeStyles = function (id) {\n  const styleTag = document.createElement('style');\n  styleTag.id = id;\n  for (var _len = arguments.length, styles = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    styles[_key - 1] = arguments[_key];\n  }\n  styleTag.textContent = styles.map(style => style.toString()).join('\\n').replace(':host', 'html');\n  document.head.insertAdjacentElement('afterbegin', styleTag);\n};","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport './version.js';\nimport { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nimport { addLumoGlobalStyles } from './global.js';\nconst colorBase = css`\n  :host {\n    /* Base (background) */\n    --lumo-base-color: #fff;\n\n    /* Tint */\n    --lumo-tint-5pct: hsla(0, 0%, 100%, 0.3);\n    --lumo-tint-10pct: hsla(0, 0%, 100%, 0.37);\n    --lumo-tint-20pct: hsla(0, 0%, 100%, 0.44);\n    --lumo-tint-30pct: hsla(0, 0%, 100%, 0.5);\n    --lumo-tint-40pct: hsla(0, 0%, 100%, 0.57);\n    --lumo-tint-50pct: hsla(0, 0%, 100%, 0.64);\n    --lumo-tint-60pct: hsla(0, 0%, 100%, 0.7);\n    --lumo-tint-70pct: hsla(0, 0%, 100%, 0.77);\n    --lumo-tint-80pct: hsla(0, 0%, 100%, 0.84);\n    --lumo-tint-90pct: hsla(0, 0%, 100%, 0.9);\n    --lumo-tint: #fff;\n\n    /* Shade */\n    --lumo-shade-5pct: hsla(214, 61%, 25%, 0.05);\n    --lumo-shade-10pct: hsla(214, 57%, 24%, 0.1);\n    --lumo-shade-20pct: hsla(214, 53%, 23%, 0.16);\n    --lumo-shade-30pct: hsla(214, 50%, 22%, 0.26);\n    --lumo-shade-40pct: hsla(214, 47%, 21%, 0.38);\n    --lumo-shade-50pct: hsla(214, 45%, 20%, 0.52);\n    --lumo-shade-60pct: hsla(214, 43%, 19%, 0.6);\n    --lumo-shade-70pct: hsla(214, 42%, 18%, 0.69);\n    --lumo-shade-80pct: hsla(214, 41%, 17%, 0.83);\n    --lumo-shade-90pct: hsla(214, 40%, 16%, 0.94);\n    --lumo-shade: hsl(214, 35%, 15%);\n\n    /* Contrast */\n    --lumo-contrast-5pct: var(--lumo-shade-5pct);\n    --lumo-contrast-10pct: var(--lumo-shade-10pct);\n    --lumo-contrast-20pct: var(--lumo-shade-20pct);\n    --lumo-contrast-30pct: var(--lumo-shade-30pct);\n    --lumo-contrast-40pct: var(--lumo-shade-40pct);\n    --lumo-contrast-50pct: var(--lumo-shade-50pct);\n    --lumo-contrast-60pct: var(--lumo-shade-60pct);\n    --lumo-contrast-70pct: var(--lumo-shade-70pct);\n    --lumo-contrast-80pct: var(--lumo-shade-80pct);\n    --lumo-contrast-90pct: var(--lumo-shade-90pct);\n    --lumo-contrast: var(--lumo-shade);\n\n    /* Text */\n    --lumo-header-text-color: var(--lumo-contrast);\n    --lumo-body-text-color: var(--lumo-contrast-90pct);\n    --lumo-secondary-text-color: var(--lumo-contrast-70pct);\n    --lumo-tertiary-text-color: var(--lumo-contrast-50pct);\n    --lumo-disabled-text-color: var(--lumo-contrast-30pct);\n\n    /* Primary */\n    --lumo-primary-color: hsl(214, 100%, 48%);\n    --lumo-primary-color-50pct: hsla(214, 100%, 49%, 0.76);\n    --lumo-primary-color-10pct: hsla(214, 100%, 60%, 0.13);\n    --lumo-primary-text-color: hsl(214, 100%, 43%);\n    --lumo-primary-contrast-color: #fff;\n\n    /* Error */\n    --lumo-error-color: hsl(3, 85%, 48%);\n    --lumo-error-color-50pct: hsla(3, 85%, 49%, 0.5);\n    --lumo-error-color-10pct: hsla(3, 85%, 49%, 0.1);\n    --lumo-error-text-color: hsl(3, 89%, 42%);\n    --lumo-error-contrast-color: #fff;\n\n    /* Success */\n    --lumo-success-color: hsl(145, 72%, 30%);\n    --lumo-success-color-50pct: hsla(145, 72%, 31%, 0.5);\n    --lumo-success-color-10pct: hsla(145, 72%, 31%, 0.1);\n    --lumo-success-text-color: hsl(145, 85%, 25%);\n    --lumo-success-contrast-color: #fff;\n\n    /* Warning */\n    --lumo-warning-color: hsl(48, 100%, 50%);\n    --lumo-warning-color-10pct: hsla(48, 100%, 50%, 0.25);\n    --lumo-warning-text-color: hsl(32, 100%, 30%);\n    --lumo-warning-contrast-color: var(--lumo-shade-90pct);\n  }\n\n  /* forced-colors mode adjustments */\n  @media (forced-colors: active) {\n    html {\n      --lumo-disabled-text-color: GrayText;\n    }\n  }\n`;\naddLumoGlobalStyles('color-props', colorBase);\nconst color = css`\n  [theme~='dark'] {\n    /* Base (background) */\n    --lumo-base-color: hsl(214, 35%, 21%);\n\n    /* Tint */\n    --lumo-tint-5pct: hsla(214, 65%, 85%, 0.06);\n    --lumo-tint-10pct: hsla(214, 60%, 80%, 0.14);\n    --lumo-tint-20pct: hsla(214, 64%, 82%, 0.23);\n    --lumo-tint-30pct: hsla(214, 69%, 84%, 0.32);\n    --lumo-tint-40pct: hsla(214, 73%, 86%, 0.41);\n    --lumo-tint-50pct: hsla(214, 78%, 88%, 0.5);\n    --lumo-tint-60pct: hsla(214, 82%, 90%, 0.58);\n    --lumo-tint-70pct: hsla(214, 87%, 92%, 0.69);\n    --lumo-tint-80pct: hsla(214, 91%, 94%, 0.8);\n    --lumo-tint-90pct: hsla(214, 96%, 96%, 0.9);\n    --lumo-tint: hsl(214, 100%, 98%);\n\n    /* Shade */\n    --lumo-shade-5pct: hsla(214, 0%, 0%, 0.07);\n    --lumo-shade-10pct: hsla(214, 4%, 2%, 0.15);\n    --lumo-shade-20pct: hsla(214, 8%, 4%, 0.23);\n    --lumo-shade-30pct: hsla(214, 12%, 6%, 0.32);\n    --lumo-shade-40pct: hsla(214, 16%, 8%, 0.41);\n    --lumo-shade-50pct: hsla(214, 20%, 10%, 0.5);\n    --lumo-shade-60pct: hsla(214, 24%, 12%, 0.6);\n    --lumo-shade-70pct: hsla(214, 28%, 13%, 0.7);\n    --lumo-shade-80pct: hsla(214, 32%, 13%, 0.8);\n    --lumo-shade-90pct: hsla(214, 33%, 13%, 0.9);\n    --lumo-shade: hsl(214, 33%, 13%);\n\n    /* Contrast */\n    --lumo-contrast-5pct: var(--lumo-tint-5pct);\n    --lumo-contrast-10pct: var(--lumo-tint-10pct);\n    --lumo-contrast-20pct: var(--lumo-tint-20pct);\n    --lumo-contrast-30pct: var(--lumo-tint-30pct);\n    --lumo-contrast-40pct: var(--lumo-tint-40pct);\n    --lumo-contrast-50pct: var(--lumo-tint-50pct);\n    --lumo-contrast-60pct: var(--lumo-tint-60pct);\n    --lumo-contrast-70pct: var(--lumo-tint-70pct);\n    --lumo-contrast-80pct: var(--lumo-tint-80pct);\n    --lumo-contrast-90pct: var(--lumo-tint-90pct);\n    --lumo-contrast: var(--lumo-tint);\n\n    /* Text */\n    --lumo-header-text-color: var(--lumo-contrast);\n    --lumo-body-text-color: var(--lumo-contrast-90pct);\n    --lumo-secondary-text-color: var(--lumo-contrast-70pct);\n    --lumo-tertiary-text-color: var(--lumo-contrast-50pct);\n    --lumo-disabled-text-color: var(--lumo-contrast-30pct);\n\n    /* Primary */\n    --lumo-primary-color: hsl(214, 90%, 48%);\n    --lumo-primary-color-50pct: hsla(214, 90%, 70%, 0.69);\n    --lumo-primary-color-10pct: hsla(214, 90%, 55%, 0.13);\n    --lumo-primary-text-color: hsl(214, 90%, 77%);\n    --lumo-primary-contrast-color: #fff;\n\n    /* Error */\n    --lumo-error-color: hsl(3, 79%, 49%);\n    --lumo-error-color-50pct: hsla(3, 75%, 62%, 0.5);\n    --lumo-error-color-10pct: hsla(3, 75%, 62%, 0.14);\n    --lumo-error-text-color: hsl(3, 100%, 80%);\n\n    /* Success */\n    --lumo-success-color: hsl(145, 72%, 30%);\n    --lumo-success-color-50pct: hsla(145, 92%, 51%, 0.5);\n    --lumo-success-color-10pct: hsla(145, 92%, 51%, 0.1);\n    --lumo-success-text-color: hsl(145, 85%, 46%);\n\n    /* Warning */\n    --lumo-warning-color: hsl(43, 100%, 48%);\n    --lumo-warning-color-10pct: hsla(40, 100%, 50%, 0.2);\n    --lumo-warning-text-color: hsl(45, 100%, 60%);\n    --lumo-warning-contrast-color: var(--lumo-shade-90pct);\n  }\n\n  html {\n    color: var(--lumo-body-text-color);\n    background-color: var(--lumo-base-color);\n    color-scheme: light;\n  }\n\n  [theme~='dark'] {\n    color: var(--lumo-body-text-color);\n    background-color: var(--lumo-base-color);\n    color-scheme: dark;\n  }\n\n  h1,\n  h2,\n  h3,\n  h4,\n  h5,\n  h6 {\n    color: var(--lumo-header-text-color);\n  }\n\n  a:where(:any-link) {\n    color: var(--lumo-primary-text-color);\n  }\n\n  a:not(:any-link) {\n    color: var(--lumo-disabled-text-color);\n  }\n\n  blockquote {\n    color: var(--lumo-secondary-text-color);\n  }\n\n  code,\n  pre {\n    background-color: var(--lumo-contrast-10pct);\n    border-radius: var(--lumo-border-radius-m);\n  }\n  pre code {\n    background: transparent;\n  }\n`;\nregisterStyles('', color, {\n  moduleId: 'lumo-color'\n});\nexport { colorBase, color };","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport './version.js';\nimport { css } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nimport { addLumoGlobalStyles } from './global.js';\nconst fontIcons = css`\n  @font-face {\n    font-family: 'lumo-icons';\n    src: url(data:application/font-woff;charset=utf-8;base64,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)\n      format('woff');\n    font-weight: normal;\n    font-style: normal;\n  }\n\n  html {\n    --lumo-icons-align-center: '\\\\ea01';\n    --lumo-icons-align-left: '\\\\ea02';\n    --lumo-icons-align-right: '\\\\ea03';\n    --lumo-icons-angle-down: '\\\\ea04';\n    --lumo-icons-angle-left: '\\\\ea05';\n    --lumo-icons-angle-right: '\\\\ea06';\n    --lumo-icons-angle-up: '\\\\ea07';\n    --lumo-icons-arrow-down: '\\\\ea08';\n    --lumo-icons-arrow-left: '\\\\ea09';\n    --lumo-icons-arrow-right: '\\\\ea0a';\n    --lumo-icons-arrow-up: '\\\\ea0b';\n    --lumo-icons-bar-chart: '\\\\ea0c';\n    --lumo-icons-bell: '\\\\ea0d';\n    --lumo-icons-calendar: '\\\\ea0e';\n    --lumo-icons-checkmark: '\\\\ea0f';\n    --lumo-icons-chevron-down: '\\\\ea10';\n    --lumo-icons-chevron-left: '\\\\ea11';\n    --lumo-icons-chevron-right: '\\\\ea12';\n    --lumo-icons-chevron-up: '\\\\ea13';\n    --lumo-icons-clock: '\\\\ea14';\n    --lumo-icons-cog: '\\\\ea15';\n    --lumo-icons-cross: '\\\\ea16';\n    --lumo-icons-download: '\\\\ea17';\n    --lumo-icons-dropdown: '\\\\ea18';\n    --lumo-icons-edit: '\\\\ea19';\n    --lumo-icons-error: '\\\\ea1a';\n    --lumo-icons-eye: '\\\\ea1b';\n    --lumo-icons-eye-disabled: '\\\\ea1c';\n    --lumo-icons-menu: '\\\\ea1d';\n    --lumo-icons-minus: '\\\\ea1e';\n    --lumo-icons-ordered-list: '\\\\ea1f';\n    --lumo-icons-phone: '\\\\ea20';\n    --lumo-icons-photo: '\\\\ea21';\n    --lumo-icons-play: '\\\\ea22';\n    --lumo-icons-plus: '\\\\ea23';\n    --lumo-icons-redo: '\\\\ea24';\n    --lumo-icons-reload: '\\\\ea25';\n    --lumo-icons-search: '\\\\ea26';\n    --lumo-icons-undo: '\\\\ea27';\n    --lumo-icons-unordered-list: '\\\\ea28';\n    --lumo-icons-upload: '\\\\ea29';\n    --lumo-icons-user: '\\\\ea2a';\n  }\n`;\naddLumoGlobalStyles('font-icons', fontIcons);","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport './version.js';\nimport { css } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nimport { addLumoGlobalStyles } from './global.js';\nconst spacing = css`\n  :host {\n    /* Square */\n    --lumo-space-xs: 0.25rem;\n    --lumo-space-s: 0.5rem;\n    --lumo-space-m: 1rem;\n    --lumo-space-l: 1.5rem;\n    --lumo-space-xl: 2.5rem;\n\n    /* Wide */\n    --lumo-space-wide-xs: calc(var(--lumo-space-xs) / 2) var(--lumo-space-xs);\n    --lumo-space-wide-s: calc(var(--lumo-space-s) / 2) var(--lumo-space-s);\n    --lumo-space-wide-m: calc(var(--lumo-space-m) / 2) var(--lumo-space-m);\n    --lumo-space-wide-l: calc(var(--lumo-space-l) / 2) var(--lumo-space-l);\n    --lumo-space-wide-xl: calc(var(--lumo-space-xl) / 2) var(--lumo-space-xl);\n\n    /* Tall */\n    --lumo-space-tall-xs: var(--lumo-space-xs) calc(var(--lumo-space-xs) / 2);\n    --lumo-space-tall-s: var(--lumo-space-s) calc(var(--lumo-space-s) / 2);\n    --lumo-space-tall-m: var(--lumo-space-m) calc(var(--lumo-space-m) / 2);\n    --lumo-space-tall-l: var(--lumo-space-l) calc(var(--lumo-space-l) / 2);\n    --lumo-space-tall-xl: var(--lumo-space-xl) calc(var(--lumo-space-xl) / 2);\n  }\n`;\naddLumoGlobalStyles('spacing-props', spacing);\nexport { spacing };","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport './version.js';\nimport { css } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nimport { addLumoGlobalStyles } from './global.js';\nconst style = css`\n  :host {\n    /* Border radius */\n    --lumo-border-radius-s: 0.25em; /* Checkbox, badge, date-picker year indicator, etc */\n    --lumo-border-radius-m: var(--lumo-border-radius, 0.25em); /* Button, text field, menu overlay, etc */\n    --lumo-border-radius-l: 0.5em; /* Dialog, notification, etc */\n\n    /* Shadow */\n    --lumo-box-shadow-xs: 0 1px 4px -1px var(--lumo-shade-50pct);\n    --lumo-box-shadow-s: 0 2px 4px -1px var(--lumo-shade-20pct), 0 3px 12px -1px var(--lumo-shade-30pct);\n    --lumo-box-shadow-m: 0 2px 6px -1px var(--lumo-shade-20pct), 0 8px 24px -4px var(--lumo-shade-40pct);\n    --lumo-box-shadow-l: 0 3px 18px -2px var(--lumo-shade-20pct), 0 12px 48px -6px var(--lumo-shade-40pct);\n    --lumo-box-shadow-xl: 0 4px 24px -3px var(--lumo-shade-20pct), 0 18px 64px -8px var(--lumo-shade-40pct);\n\n    /* Clickable element cursor */\n    --lumo-clickable-cursor: default;\n  }\n`;\n\n/**\n * Default values for component-specific custom properties.\n */\nconst globals = css`\n  html {\n    /* Button */\n    --vaadin-button-background: var(--lumo-contrast-5pct);\n    --vaadin-button-border: none;\n    --vaadin-button-border-radius: var(--lumo-border-radius-m);\n    --vaadin-button-font-size: var(--lumo-font-size-m);\n    --vaadin-button-font-weight: 500;\n    --vaadin-button-height: var(--lumo-size-m);\n    --vaadin-button-margin: var(--lumo-space-xs) 0;\n    --vaadin-button-min-width: calc(var(--vaadin-button-height) * 2);\n    --vaadin-button-padding: 0 calc(var(--vaadin-button-height) / 3 + var(--lumo-border-radius-m) / 2);\n    --vaadin-button-text-color: var(--lumo-primary-text-color);\n    --vaadin-button-primary-background: var(--lumo-primary-color);\n    --vaadin-button-primary-border: none;\n    --vaadin-button-primary-font-weight: 600;\n    --vaadin-button-primary-text-color: var(--lumo-primary-contrast-color);\n    --vaadin-button-tertiary-background: transparent !important;\n    --vaadin-button-tertiary-text-color: var(--lumo-primary-text-color);\n    --vaadin-button-tertiary-font-weight: 500;\n    --vaadin-button-tertiary-padding: 0 calc(var(--vaadin-button-height) / 6);\n    /* Checkbox */\n    --vaadin-checkbox-background: var(--lumo-contrast-20pct);\n    --vaadin-checkbox-background-hover: var(--lumo-contrast-30pct);\n    --vaadin-checkbox-border-radius: var(--lumo-border-radius-s);\n    --vaadin-checkbox-checkmark-char: var(--lumo-icons-checkmark);\n    --vaadin-checkbox-checkmark-char-indeterminate: '';\n    --vaadin-checkbox-checkmark-color: var(--lumo-primary-contrast-color);\n    --vaadin-checkbox-checkmark-size: calc(var(--vaadin-checkbox-size) + 2px);\n    --vaadin-checkbox-label-color: var(--lumo-body-text-color);\n    --vaadin-checkbox-label-font-size: var(--lumo-font-size-m);\n    --vaadin-checkbox-label-padding: var(--lumo-space-xs) var(--lumo-space-s) var(--lumo-space-xs) var(--lumo-space-xs);\n    --vaadin-checkbox-size: calc(var(--lumo-size-m) / 2);\n    --vaadin-checkbox-disabled-checkmark-color: var(--lumo-contrast-30pct);\n    --vaadin-checkbox-disabled-background: var(--lumo-contrast-10pct);\n    /* Radio button */\n    --vaadin-radio-button-background: var(--lumo-contrast-20pct);\n    --vaadin-radio-button-background-hover: var(--lumo-contrast-30pct);\n    --vaadin-radio-button-dot-color: var(--lumo-primary-contrast-color);\n    --vaadin-radio-button-dot-size: 3px;\n    --vaadin-radio-button-label-color: var(--lumo-body-text-color);\n    --vaadin-radio-button-label-font-size: var(--lumo-font-size-m);\n    --vaadin-radio-button-label-padding: var(--lumo-space-xs) var(--lumo-space-s) var(--lumo-space-xs)\n      var(--lumo-space-xs);\n    --vaadin-radio-button-size: calc(var(--lumo-size-m) / 2);\n    --vaadin-radio-button-disabled-background: var(--lumo-contrast-10pct);\n    --vaadin-radio-button-disabled-dot-color: var(--lumo-contrast-30pct);\n    --vaadin-selection-color: var(--lumo-primary-color);\n    --vaadin-selection-color-text: var(--lumo-primary-text-color);\n    --vaadin-input-field-border-radius: var(--lumo-border-radius-m);\n    --vaadin-focus-ring-color: var(--lumo-primary-color-50pct);\n    --vaadin-focus-ring-width: 2px;\n    /* Label */\n    --vaadin-input-field-label-color: var(--lumo-secondary-text-color);\n    --vaadin-input-field-focused-label-color: var(--lumo-primary-text-color);\n    --vaadin-input-field-hovered-label-color: var(--lumo-body-text-color);\n    --vaadin-input-field-label-font-size: var(--lumo-font-size-s);\n    --vaadin-input-field-label-font-weight: 500;\n    /* Helper */\n    --vaadin-input-field-helper-color: var(--lumo-secondary-text-color);\n    --vaadin-input-field-helper-font-size: var(--lumo-font-size-xs);\n    --vaadin-input-field-helper-font-weight: 400;\n    --vaadin-input-field-helper-spacing: 0.4em;\n    /* Error message */\n    --vaadin-input-field-error-color: var(--lumo-error-text-color);\n    --vaadin-input-field-error-font-size: var(--lumo-font-size-xs);\n    --vaadin-input-field-error-font-weight: 400;\n    /* Input field */\n    --vaadin-input-field-background: var(--lumo-contrast-10pct);\n    --vaadin-input-field-icon-color: var(--lumo-contrast-60pct);\n    --vaadin-input-field-icon-size: var(--lumo-icon-size-m);\n    --vaadin-input-field-invalid-background: var(--lumo-error-color-10pct);\n    --vaadin-input-field-invalid-hover-highlight: var(--lumo-error-color-50pct);\n    --vaadin-input-field-disabled-background: var(--lumo-contrast-5pct);\n    --vaadin-input-field-disabled-value-color: var(--lumo-disabled-text-color);\n    --vaadin-input-field-height: var(--lumo-size-m);\n    --vaadin-input-field-hover-highlight: var(--lumo-contrast-50pct);\n    --vaadin-input-field-placeholder-color: var(--lumo-secondary-text-color);\n    --vaadin-input-field-readonly-border: 1px dashed var(--lumo-contrast-30pct);\n    --vaadin-input-field-value-color: var(--lumo-body-text-color);\n    --vaadin-input-field-value-font-size: var(--lumo-font-size-m);\n    --vaadin-input-field-value-font-weight: 400;\n  }\n`;\naddLumoGlobalStyles('style-props', style);\nexport { globals, style };","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport './version.js';\nimport { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nimport { addLumoGlobalStyles } from './global.js';\nconst font = css`\n  :host {\n    /* prettier-ignore */\n    --lumo-font-family: -apple-system, BlinkMacSystemFont, 'Roboto', 'Segoe UI', Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol';\n\n    /* Font sizes */\n    --lumo-font-size-xxs: 0.75rem;\n    --lumo-font-size-xs: 0.8125rem;\n    --lumo-font-size-s: 0.875rem;\n    --lumo-font-size-m: 1rem;\n    --lumo-font-size-l: 1.125rem;\n    --lumo-font-size-xl: 1.375rem;\n    --lumo-font-size-xxl: 1.75rem;\n    --lumo-font-size-xxxl: 2.5rem;\n\n    /* Line heights */\n    --lumo-line-height-xs: 1.25;\n    --lumo-line-height-s: 1.375;\n    --lumo-line-height-m: 1.625;\n  }\n`;\nconst typography = css`\n  body,\n  :host {\n    font-family: var(--lumo-font-family);\n    font-size: var(--lumo-font-size-m);\n    line-height: var(--lumo-line-height-m);\n    -webkit-text-size-adjust: 100%;\n    -webkit-font-smoothing: antialiased;\n    -moz-osx-font-smoothing: grayscale;\n  }\n\n  small,\n  [theme~='font-size-s'] {\n    font-size: var(--lumo-font-size-s);\n    line-height: var(--lumo-line-height-s);\n  }\n\n  [theme~='font-size-xs'] {\n    font-size: var(--lumo-font-size-xs);\n    line-height: var(--lumo-line-height-xs);\n  }\n\n  :where(h1, h2, h3, h4, h5, h6) {\n    font-weight: 600;\n    line-height: var(--lumo-line-height-xs);\n    margin-block: 0;\n  }\n\n  :where(h1) {\n    font-size: var(--lumo-font-size-xxxl);\n  }\n\n  :where(h2) {\n    font-size: var(--lumo-font-size-xxl);\n  }\n\n  :where(h3) {\n    font-size: var(--lumo-font-size-xl);\n  }\n\n  :where(h4) {\n    font-size: var(--lumo-font-size-l);\n  }\n\n  :where(h5) {\n    font-size: var(--lumo-font-size-m);\n  }\n\n  :where(h6) {\n    font-size: var(--lumo-font-size-xs);\n    text-transform: uppercase;\n    letter-spacing: 0.03em;\n  }\n\n  p,\n  blockquote {\n    margin-top: 0.5em;\n    margin-bottom: 0.75em;\n  }\n\n  a {\n    text-decoration: none;\n  }\n\n  a:where(:any-link):hover {\n    text-decoration: underline;\n  }\n\n  hr {\n    display: block;\n    align-self: stretch;\n    height: 1px;\n    border: 0;\n    padding: 0;\n    margin: var(--lumo-space-s) calc(var(--lumo-border-radius-m) / 2);\n    background-color: var(--lumo-contrast-10pct);\n  }\n\n  blockquote {\n    border-left: 2px solid var(--lumo-contrast-30pct);\n  }\n\n  b,\n  strong {\n    font-weight: 600;\n  }\n\n  /* RTL specific styles */\n  blockquote[dir='rtl'] {\n    border-left: none;\n    border-right: 2px solid var(--lumo-contrast-30pct);\n  }\n`;\nregisterStyles('', typography, {\n  moduleId: 'lumo-typography'\n});\naddLumoGlobalStyles('typography-props', font);\nexport { font, typography };","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport './version.js';\nimport { css } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nimport { addLumoGlobalStyles } from './global.js';\nconst sizing = css`\n  :host {\n    --lumo-size-xs: 1.625rem;\n    --lumo-size-s: 1.875rem;\n    --lumo-size-m: 2.25rem;\n    --lumo-size-l: 2.75rem;\n    --lumo-size-xl: 3.5rem;\n\n    /* Icons */\n    --lumo-icon-size-s: 1.25em;\n    --lumo-icon-size-m: 1.5em;\n    --lumo-icon-size-l: 2.25em;\n    /* For backwards compatibility */\n    --lumo-icon-size: var(--lumo-icon-size-m);\n  }\n`;\naddLumoGlobalStyles('sizing-props', sizing);\nexport { sizing };","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport '../color.js';\nimport '../font-icons.js';\nimport '../sizing.js';\nimport '../style.js';\nimport { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nconst fieldButton = css`\n  [part$='button'] {\n    flex: none;\n    width: 1em;\n    height: 1em;\n    line-height: 1;\n    font-size: var(--lumo-icon-size-m);\n    text-align: center;\n    color: var(--lumo-contrast-60pct);\n    transition: 0.2s color;\n    cursor: var(--lumo-clickable-cursor);\n  }\n\n  [part$='button']:hover {\n    color: var(--lumo-contrast-90pct);\n  }\n\n  :host([disabled]) [part$='button'],\n  :host([readonly]) [part$='button'] {\n    color: var(--lumo-contrast-20pct);\n    cursor: default;\n  }\n\n  [part$='button']::before {\n    font-family: 'lumo-icons';\n    display: block;\n  }\n`;\nregisterStyles('', fieldButton, {\n  moduleId: 'lumo-field-button'\n});\nexport { fieldButton };","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport '@vaadin/vaadin-lumo-styles/color.js';\nimport '@vaadin/vaadin-lumo-styles/font-icons.js';\nimport '@vaadin/vaadin-lumo-styles/spacing.js';\nimport '@vaadin/vaadin-lumo-styles/style.js';\nimport '@vaadin/vaadin-lumo-styles/typography.js';\nimport { fieldButton } from '@vaadin/vaadin-lumo-styles/mixins/field-button.js';\nimport { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nconst chip = css`\n  :host {\n    font-size: var(--lumo-font-size-xxs);\n    line-height: 1;\n    color: var(--lumo-body-text-color);\n    border-radius: var(--lumo-border-radius-s);\n    background-color: var(--lumo-contrast-20pct);\n    cursor: var(--lumo-clickable-cursor);\n    -webkit-font-smoothing: antialiased;\n    -moz-osx-font-smoothing: grayscale;\n  }\n\n  :host([disabled]) {\n    background-color: var(--lumo-contrast-10pct);\n  }\n\n  :host([focused]) [part='remove-button'] {\n    color: inherit;\n  }\n\n  :host([slot='overflow']) {\n    position: relative;\n    min-width: var(--lumo-size-xxs);\n    margin-inline-start: var(--lumo-space-s);\n  }\n\n  :host([slot='overflow'])::before,\n  :host([slot='overflow'])::after {\n    position: absolute;\n    content: '';\n    width: 100%;\n    height: 100%;\n    border-left: calc(var(--lumo-space-s) / 4) solid;\n    border-radius: var(--lumo-border-radius-s);\n    border-color: var(--lumo-contrast-30pct);\n  }\n\n  :host([slot='overflow'])::before {\n    left: calc(-1 * var(--lumo-space-s) / 2);\n  }\n\n  :host([slot='overflow'])::after {\n    left: calc(-1 * var(--lumo-space-s));\n  }\n\n  :host([count='2']) {\n    margin-inline-start: calc(var(--lumo-space-s) / 2);\n  }\n\n  :host([count='2'])::after {\n    display: none;\n  }\n\n  :host([count='1']) {\n    margin-inline-start: 0;\n  }\n\n  :host([count='1'])::before,\n  :host([count='1'])::after {\n    display: none;\n  }\n\n  [part='label'] {\n    font-weight: 500;\n    line-height: 1.25;\n  }\n\n  [part='remove-button'] {\n    display: flex;\n    align-items: center;\n    justify-content: center;\n    margin-top: -0.3125em;\n    margin-bottom: -0.3125em;\n    margin-inline-start: auto;\n    width: 1.25em;\n    height: 1.25em;\n    font-size: 1.5em;\n    transition: none;\n  }\n\n  [part='remove-button']::before {\n    content: var(--lumo-icons-cross);\n  }\n\n  :host([disabled]) [part='label'] {\n    color: var(--lumo-disabled-text-color);\n    -webkit-text-fill-color: var(--lumo-disabled-text-color);\n    pointer-events: none;\n  }\n`;\nregisterStyles('vaadin-multi-select-combo-box-chip', [fieldButton, chip], {\n  moduleId: 'lumo-multi-select-combo-box-chip'\n});","import '@vaadin/vaadin-lumo-styles/color.js';\nimport '@vaadin/vaadin-lumo-styles/sizing.js';\nimport '@vaadin/vaadin-lumo-styles/style.js';\nimport '@vaadin/vaadin-lumo-styles/typography.js';\nimport { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nregisterStyles('vaadin-input-container', css`\n    :host {\n      background: var(--_background);\n      padding: 0 calc(0.375em + var(--_input-container-radius) / 4 - 1px);\n      font-weight: 500;\n      line-height: 1;\n      position: relative;\n      cursor: text;\n      box-sizing: border-box;\n      border-radius:\n        /* See https://developer.mozilla.org/en-US/docs/Web/CSS/border-radius#syntax */\n        var(--vaadin-input-field-top-start-radius, var(--_input-container-radius))\n        var(--vaadin-input-field-top-end-radius, var(--_input-container-radius))\n        var(--vaadin-input-field-bottom-end-radius, var(--_input-container-radius))\n        var(--vaadin-input-field-bottom-start-radius, var(--_input-container-radius));\n      /* Fallback */\n      --_input-container-radius: var(--vaadin-input-field-border-radius, var(--lumo-border-radius-m));\n      --_input-height: var(--lumo-text-field-size, var(--lumo-size-m));\n      /* Default values */\n      --_background: var(--vaadin-input-field-background, var(--lumo-contrast-10pct));\n      --_hover-highlight: var(--vaadin-input-field-hover-highlight, var(--lumo-contrast-50pct));\n      --_input-border-color: var(--vaadin-input-field-border-color, var(--lumo-contrast-50pct));\n      --_icon-color: var(--vaadin-input-field-icon-color, var(--lumo-contrast-60pct));\n      --_icon-size: var(--vaadin-input-field-icon-size, var(--lumo-icon-size-m));\n      --_invalid-background: var(--vaadin-input-field-invalid-background, var(--lumo-error-color-10pct));\n      --_invalid-hover-highlight: var(--vaadin-input-field-invalid-hover-highlight, var(--lumo-error-color-50pct));\n      --_disabled-background: var(--vaadin-input-field-disabled-background, var(--lumo-contrast-5pct));\n      --_disabled-value-color: var(--vaadin-input-field-disabled-value-color, var(--lumo-disabled-text-color));\n    }\n\n    :host([dir='rtl']) {\n      border-radius:\n        /* Don't use logical props, see https://github.com/vaadin/vaadin-time-picker/issues/145 */\n        var(--vaadin-input-field-top-end-radius, var(--_input-container-radius))\n        var(--vaadin-input-field-top-start-radius, var(--_input-container-radius))\n        var(--vaadin-input-field-bottom-start-radius, var(--_input-container-radius))\n        var(--vaadin-input-field-bottom-end-radius, var(--_input-container-radius));\n    }\n\n    /* Used for hover and activation effects */\n    :host::after {\n      content: '';\n      position: absolute;\n      inset: 0;\n      border-radius: inherit;\n      pointer-events: none;\n      background: var(--_hover-highlight);\n      opacity: 0;\n      transition:\n        transform 0.15s,\n        opacity 0.2s;\n      transform-origin: 100% 0;\n    }\n\n    ::slotted(:not([slot$='fix'])) {\n      cursor: inherit;\n      min-height: var(--vaadin-input-field-height, var(--_input-height));\n      padding: 0 0.25em;\n      --_lumo-text-field-overflow-mask-image: linear-gradient(to left, transparent, #000 1.25em);\n      -webkit-mask-image: var(--_lumo-text-field-overflow-mask-image);\n      mask-image: var(--_lumo-text-field-overflow-mask-image);\n    }\n\n    /* Read-only */\n    :host([readonly]) {\n      color: var(--lumo-secondary-text-color);\n      background-color: transparent;\n      cursor: default;\n    }\n\n    :host([readonly])::after {\n      background-color: transparent;\n      opacity: 1;\n      border: var(--vaadin-input-field-readonly-border, 1px dashed var(--lumo-contrast-30pct));\n    }\n\n    /* Disabled */\n    :host([disabled]) {\n      background: var(--_disabled-background);\n    }\n\n    :host([disabled]) ::slotted(:not([slot$='fix'])) {\n      -webkit-text-fill-color: var(--_disabled-value-color);\n      color: var(--_disabled-value-color);\n    }\n\n    /* Invalid */\n    :host([invalid]) {\n      background: var(--_invalid-background);\n    }\n\n    :host([invalid]:not([readonly]))::after {\n      background: var(--_invalid-hover-highlight);\n    }\n\n    /* Slotted icons */\n    ::slotted(vaadin-icon) {\n      color: var(--_icon-color);\n      width: var(--_icon-size);\n      height: var(--_icon-size);\n    }\n\n    /* Vaadin icons are based on a 16x16 grid (unlike Lumo and Material icons with 24x24), so they look too big by default */\n    ::slotted(vaadin-icon[icon^='vaadin:']) {\n      padding: 0.25em;\n      box-sizing: border-box !important;\n    }\n\n    /* Text align */\n    :host([dir='rtl']) ::slotted(:not([slot$='fix'])) {\n      --_lumo-text-field-overflow-mask-image: linear-gradient(to right, transparent, #000 1.25em);\n    }\n\n    @-moz-document url-prefix() {\n      :host([dir='rtl']) ::slotted(:not([slot$='fix'])) {\n        mask-image: var(--_lumo-text-field-overflow-mask-image);\n      }\n    }\n\n    :host([theme~='align-left']) ::slotted(:not([slot$='fix'])) {\n      text-align: start;\n      --_lumo-text-field-overflow-mask-image: none;\n    }\n\n    :host([theme~='align-center']) ::slotted(:not([slot$='fix'])) {\n      text-align: center;\n      --_lumo-text-field-overflow-mask-image: none;\n    }\n\n    :host([theme~='align-right']) ::slotted(:not([slot$='fix'])) {\n      text-align: end;\n      --_lumo-text-field-overflow-mask-image: none;\n    }\n\n    @-moz-document url-prefix() {\n      /* Firefox is smart enough to align overflowing text to right */\n      :host([theme~='align-right']) ::slotted(:not([slot$='fix'])) {\n        --_lumo-text-field-overflow-mask-image: linear-gradient(to right, transparent 0.25em, #000 1.5em);\n      }\n    }\n\n    @-moz-document url-prefix() {\n      /* Firefox is smart enough to align overflowing text to right */\n      :host([theme~='align-left']) ::slotted(:not([slot$='fix'])) {\n        --_lumo-text-field-overflow-mask-image: linear-gradient(to left, transparent 0.25em, #000 1.5em);\n      }\n    }\n\n    /* RTL specific styles */\n    :host([dir='rtl'])::after {\n      transform-origin: 0% 0;\n    }\n\n    :host([theme~='align-left'][dir='rtl']) ::slotted(:not([slot$='fix'])) {\n      --_lumo-text-field-overflow-mask-image: none;\n    }\n\n    :host([theme~='align-center'][dir='rtl']) ::slotted(:not([slot$='fix'])) {\n      --_lumo-text-field-overflow-mask-image: none;\n    }\n\n    :host([theme~='align-right'][dir='rtl']) ::slotted(:not([slot$='fix'])) {\n      --_lumo-text-field-overflow-mask-image: none;\n    }\n\n    @-moz-document url-prefix() {\n      /* Firefox is smart enough to align overflowing text to right */\n      :host([theme~='align-right'][dir='rtl']) ::slotted(:not([slot$='fix'])) {\n        --_lumo-text-field-overflow-mask-image: linear-gradient(to right, transparent 0.25em, #000 1.5em);\n      }\n    }\n\n    @-moz-document url-prefix() {\n      /* Firefox is smart enough to align overflowing text to right */\n      :host([theme~='align-left'][dir='rtl']) ::slotted(:not([slot$='fix'])) {\n        --_lumo-text-field-overflow-mask-image: linear-gradient(to left, transparent 0.25em, #000 1.5em);\n      }\n    }\n  `, {\n  moduleId: 'lumo-input-container'\n});","import '@vaadin/vaadin-lumo-styles/font-icons.js';\nimport '@vaadin/vaadin-lumo-styles/sizing.js';\nimport '@vaadin/vaadin-lumo-styles/spacing.js';\nimport '@vaadin/vaadin-lumo-styles/style.js';\nimport '@vaadin/vaadin-lumo-styles/typography.js';\nimport { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nconst item = css`\n  :host {\n    display: flex;\n    align-items: center;\n    box-sizing: border-box;\n    font-family: var(--lumo-font-family);\n    font-size: var(--lumo-font-size-m);\n    line-height: var(--lumo-line-height-xs);\n    padding: 0.5em calc(var(--lumo-space-l) + var(--lumo-border-radius-m) / 4) 0.5em\n      var(--_lumo-list-box-item-padding-left, calc(var(--lumo-border-radius-m) / 4));\n    min-height: var(--lumo-size-m);\n    outline: none;\n    border-radius: var(--lumo-border-radius-m);\n    cursor: var(--lumo-clickable-cursor);\n    -webkit-font-smoothing: antialiased;\n    -moz-osx-font-smoothing: grayscale;\n    -webkit-tap-highlight-color: var(--lumo-primary-color-10pct);\n    --_focus-ring-color: var(--vaadin-focus-ring-color, var(--lumo-primary-color-50pct));\n    --_focus-ring-width: var(--vaadin-focus-ring-width, 2px);\n    --_selection-color-text: var(--vaadin-selection-color-text, var(--lumo-primary-text-color));\n  }\n\n  /* Checkmark */\n  [part='checkmark']::before {\n    display: var(--_lumo-item-selected-icon-display, none);\n    content: var(--lumo-icons-checkmark);\n    font-family: lumo-icons;\n    font-size: var(--lumo-icon-size-m);\n    line-height: 1;\n    font-weight: normal;\n    width: 1em;\n    height: 1em;\n    margin: calc((1 - var(--lumo-line-height-xs)) * var(--lumo-font-size-m) / 2) 0;\n    color: var(--_selection-color-text);\n    flex: none;\n    opacity: 0;\n    transition:\n      transform 0.2s cubic-bezier(0.12, 0.32, 0.54, 2),\n      opacity 0.1s;\n  }\n\n  :host([selected]) [part='checkmark']::before {\n    opacity: 1;\n  }\n\n  :host([active]:not([selected])) [part='checkmark']::before {\n    transform: scale(0.8);\n    opacity: 0;\n    transition-duration: 0s;\n  }\n\n  [part='content'] {\n    flex: auto;\n  }\n\n  /* Disabled */\n  :host([disabled]) {\n    color: var(--lumo-disabled-text-color);\n    cursor: default;\n    pointer-events: none;\n  }\n\n  /* TODO a workaround until we have \"focus-follows-mouse\". After that, use the hover style for focus-ring as well */\n  @media (any-hover: hover) {\n    :host(:hover:not([disabled])) {\n      background-color: var(--lumo-primary-color-10pct);\n    }\n  }\n\n  :host([focus-ring]:not([disabled])) {\n    box-shadow: inset 0 0 0 var(--_focus-ring-width) var(--_focus-ring-color);\n  }\n\n  /* RTL specific styles */\n  :host([dir='rtl']) {\n    padding-left: calc(var(--lumo-space-l) + var(--lumo-border-radius-m) / 4);\n    padding-right: var(--_lumo-list-box-item-padding-left, calc(var(--lumo-border-radius-m) / 4));\n  }\n\n  /* Slotted icons */\n  :host ::slotted(vaadin-icon) {\n    width: var(--lumo-icon-size-m);\n    height: var(--lumo-icon-size-m);\n  }\n`;\nregisterStyles('vaadin-item', item, {\n  moduleId: 'lumo-item'\n});\nexport { item };","import '@vaadin/vaadin-lumo-styles/color.js';\nimport '@vaadin/vaadin-lumo-styles/spacing.js';\nimport '@vaadin/vaadin-lumo-styles/style.js';\nimport { item } from '@vaadin/item/theme/lumo/vaadin-item-styles.js';\nimport { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nconst comboBoxItem = css`\n  :host {\n    transition: background-color 100ms;\n    overflow: hidden;\n    --_lumo-item-selected-icon-display: block;\n    --_focus-ring-color: var(--vaadin-focus-ring-color, var(--lumo-primary-color-50pct));\n    --_focus-ring-width: var(--vaadin-focus-ring-width, 2px);\n  }\n\n  :host([focused]:not([disabled])) {\n    box-shadow: inset 0 0 0 var(--_focus-ring-width) var(--_focus-ring-color);\n  }\n`;\nregisterStyles('vaadin-combo-box-item', [item, comboBoxItem], {\n  moduleId: 'lumo-combo-box-item'\n});\nexport { comboBoxItem };","/**\n * @license\n * Copyright (c) 2022 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport '../color.js';\nimport '../sizing.js';\nimport { css } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nconst loader = css`\n  [part~='loader'] {\n    box-sizing: border-box;\n    width: var(--lumo-icon-size-s);\n    height: var(--lumo-icon-size-s);\n    border: 2px solid transparent;\n    border-color: var(--lumo-primary-color-10pct) var(--lumo-primary-color-10pct) var(--lumo-primary-color)\n      var(--lumo-primary-color);\n    border-radius: calc(0.5 * var(--lumo-icon-size-s));\n    opacity: 0;\n    pointer-events: none;\n  }\n\n  :host(:not([loading])) [part~='loader'] {\n    display: none;\n  }\n\n  :host([loading]) [part~='loader'] {\n    animation:\n      1s linear infinite lumo-loader-rotate,\n      0.3s 0.1s lumo-loader-fade-in both;\n  }\n\n  @keyframes lumo-loader-fade-in {\n    0% {\n      opacity: 0;\n    }\n\n    100% {\n      opacity: 1;\n    }\n  }\n\n  @keyframes lumo-loader-rotate {\n    0% {\n      transform: rotate(0deg);\n    }\n\n    100% {\n      transform: rotate(360deg);\n    }\n  }\n`;\nexport { loader };","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport '../color.js';\nimport '../spacing.js';\nimport '../style.js';\nimport '../typography.js';\nimport { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nconst overlay = css`\n  :host {\n    top: var(--lumo-space-m);\n    right: var(--lumo-space-m);\n    bottom: var(--lumo-space-m);\n    left: var(--lumo-space-m);\n    /* Workaround for Edge issue (only on Surface), where an overflowing vaadin-list-box inside vaadin-select-overlay makes the overlay transparent */\n    /* stylelint-disable-next-line */\n    outline: 0px solid transparent;\n  }\n\n  [part='overlay'] {\n    background-color: var(--lumo-base-color);\n    background-image: linear-gradient(var(--lumo-tint-5pct), var(--lumo-tint-5pct));\n    border-radius: var(--lumo-border-radius-m);\n    box-shadow:\n      0 0 0 1px var(--lumo-shade-5pct),\n      var(--lumo-box-shadow-m);\n    color: var(--lumo-body-text-color);\n    font-family: var(--lumo-font-family);\n    font-size: var(--lumo-font-size-m);\n    font-weight: 400;\n    line-height: var(--lumo-line-height-m);\n    letter-spacing: 0;\n    text-transform: none;\n    -webkit-text-size-adjust: 100%;\n    -webkit-font-smoothing: antialiased;\n    -moz-osx-font-smoothing: grayscale;\n  }\n\n  [part='content'] {\n    padding: var(--lumo-space-xs);\n  }\n\n  [part='backdrop'] {\n    background-color: var(--lumo-shade-20pct);\n    animation: 0.2s lumo-overlay-backdrop-enter both;\n    will-change: opacity;\n  }\n\n  @keyframes lumo-overlay-backdrop-enter {\n    0% {\n      opacity: 0;\n    }\n  }\n\n  :host([closing]) [part='backdrop'] {\n    animation: 0.2s lumo-overlay-backdrop-exit both;\n  }\n\n  @keyframes lumo-overlay-backdrop-exit {\n    100% {\n      opacity: 0;\n    }\n  }\n\n  @keyframes lumo-overlay-dummy-animation {\n    0% {\n      opacity: 1;\n    }\n\n    100% {\n      opacity: 1;\n    }\n  }\n`;\nregisterStyles('', overlay, {\n  moduleId: 'lumo-overlay'\n});\nexport { overlay };","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport '../spacing.js';\nimport '../style.js';\nimport { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nimport { overlay } from './overlay.js';\nconst menuOverlayCore = css`\n  :host([opening]),\n  :host([closing]) {\n    animation: 0.14s lumo-overlay-dummy-animation;\n  }\n\n  [part='overlay'] {\n    will-change: opacity, transform;\n  }\n\n  :host([opening]) [part='overlay'] {\n    animation: 0.1s lumo-menu-overlay-enter ease-out both;\n  }\n\n  @keyframes lumo-menu-overlay-enter {\n    0% {\n      opacity: 0;\n      transform: translateY(-4px);\n    }\n  }\n\n  :host([closing]) [part='overlay'] {\n    animation: 0.1s lumo-menu-overlay-exit both;\n  }\n\n  @keyframes lumo-menu-overlay-exit {\n    100% {\n      opacity: 0;\n    }\n  }\n`;\nregisterStyles('', menuOverlayCore, {\n  moduleId: 'lumo-menu-overlay-core'\n});\nconst menuOverlayExt = css`\n  /* Small viewport (bottom sheet) styles */\n  /* Use direct media queries instead of the state attributes ([phone] and [fullscreen]) provided by the elements */\n  @media (max-width: 420px), (max-height: 420px) {\n    :host {\n      top: 0 !important;\n      right: 0 !important;\n      bottom: var(--vaadin-overlay-viewport-bottom, 0) !important;\n      left: 0 !important;\n      align-items: stretch !important;\n      justify-content: flex-end !important;\n    }\n\n    [part='overlay'] {\n      max-height: 50vh;\n      width: 100vw;\n      border-radius: 0;\n      box-shadow: var(--lumo-box-shadow-xl);\n    }\n\n    /* The content part scrolls instead of the overlay part, because of the gradient fade-out */\n    [part='content'] {\n      padding: 30px var(--lumo-space-m);\n      max-height: inherit;\n      box-sizing: border-box;\n      -webkit-overflow-scrolling: touch;\n      overflow: auto;\n      -webkit-mask-image: linear-gradient(transparent, #000 40px, #000 calc(100% - 40px), transparent);\n      mask-image: linear-gradient(transparent, #000 40px, #000 calc(100% - 40px), transparent);\n    }\n\n    [part='backdrop'] {\n      display: block;\n    }\n\n    /* Animations */\n\n    :host([opening]) [part='overlay'] {\n      animation: 0.2s lumo-mobile-menu-overlay-enter cubic-bezier(0.215, 0.61, 0.355, 1) both;\n    }\n\n    :host([closing]),\n    :host([closing]) [part='backdrop'] {\n      animation-delay: 0.14s;\n    }\n\n    :host([closing]) [part='overlay'] {\n      animation: 0.14s 0.14s lumo-mobile-menu-overlay-exit cubic-bezier(0.55, 0.055, 0.675, 0.19) both;\n    }\n  }\n\n  @keyframes lumo-mobile-menu-overlay-enter {\n    0% {\n      transform: translateY(150%);\n    }\n  }\n\n  @keyframes lumo-mobile-menu-overlay-exit {\n    100% {\n      transform: translateY(150%);\n    }\n  }\n`;\nconst menuOverlay = [overlay, menuOverlayCore, menuOverlayExt];\nregisterStyles('', menuOverlay, {\n  moduleId: 'lumo-menu-overlay'\n});\nexport { menuOverlayCore, menuOverlay };","import '@vaadin/vaadin-lumo-styles/color.js';\nimport '@vaadin/vaadin-lumo-styles/spacing.js';\nimport '@vaadin/vaadin-lumo-styles/style.js';\nimport { loader } from '@vaadin/vaadin-lumo-styles/mixins/loader.js';\nimport { menuOverlayCore } from '@vaadin/vaadin-lumo-styles/mixins/menu-overlay.js';\nimport { overlay } from '@vaadin/vaadin-lumo-styles/mixins/overlay.js';\nimport { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nconst comboBoxOverlay = css`\n  [part='content'] {\n    padding: 0;\n  }\n\n  /* When items are empty, the spinner needs some room */\n  :host(:not([closing])) [part~='content'] {\n    min-height: calc(2 * var(--lumo-space-s) + var(--lumo-icon-size-s));\n  }\n\n  [part~='overlay'] {\n    position: relative;\n  }\n\n  :host([top-aligned]) [part~='overlay'] {\n    margin-top: var(--lumo-space-xs);\n  }\n\n  :host([bottom-aligned]) [part~='overlay'] {\n    margin-bottom: var(--lumo-space-xs);\n  }\n`;\nconst comboBoxLoader = css`\n  [part~='loader'] {\n    position: absolute;\n    z-index: 1;\n    inset-inline: var(--lumo-space-s);\n    top: var(--lumo-space-s);\n    margin-inline: auto 0;\n  }\n`;\nregisterStyles('vaadin-combo-box-overlay', [overlay, menuOverlayCore, comboBoxOverlay, loader, comboBoxLoader, css`\n      :host {\n        --_vaadin-combo-box-items-container-border-width: var(--lumo-space-xs);\n        --_vaadin-combo-box-items-container-border-style: solid;\n      }\n    `], {\n  moduleId: 'lumo-combo-box-overlay'\n});\nexport { comboBoxLoader, comboBoxOverlay };","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport '../color.js';\nimport '../sizing.js';\nimport '../style.js';\nimport '../typography.js';\nimport { css } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nexport const helper = css`\n  :host {\n    --_helper-spacing: var(--vaadin-input-field-helper-spacing, 0.4em);\n  }\n\n  :host([has-helper]) [part='helper-text']::before {\n    content: '';\n    display: block;\n    height: var(--_helper-spacing);\n  }\n\n  [part='helper-text'] {\n    display: block;\n    color: var(--vaadin-input-field-helper-color, var(--lumo-secondary-text-color));\n    font-size: var(--vaadin-input-field-helper-font-size, var(--lumo-font-size-xs));\n    line-height: var(--lumo-line-height-xs);\n    font-weight: var(--vaadin-input-field-helper-font-weight, 400);\n    margin-left: calc(var(--lumo-border-radius-m) / 4);\n    transition: color 0.2s;\n  }\n\n  :host(:hover:not([readonly])) [part='helper-text'] {\n    color: var(--lumo-body-text-color);\n  }\n\n  :host([disabled]) [part='helper-text'] {\n    color: var(--lumo-disabled-text-color);\n    -webkit-text-fill-color: var(--lumo-disabled-text-color);\n  }\n\n  :host([has-helper][theme~='helper-above-field']) [part='helper-text']::before {\n    display: none;\n  }\n\n  :host([has-helper][theme~='helper-above-field']) [part='helper-text']::after {\n    content: '';\n    display: block;\n    height: var(--_helper-spacing);\n  }\n\n  :host([has-helper][theme~='helper-above-field']) [part='label'] {\n    order: 0;\n    padding-bottom: var(--_helper-spacing);\n  }\n\n  :host([has-helper][theme~='helper-above-field']) [part='helper-text'] {\n    order: 1;\n  }\n\n  :host([has-helper][theme~='helper-above-field']) [part='label'] + * {\n    order: 2;\n  }\n\n  :host([has-helper][theme~='helper-above-field']) [part='error-message'] {\n    order: 3;\n  }\n`;","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport '../color.js';\nimport '../spacing.js';\nimport '../style.js';\nimport '../typography.js';\nimport { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nconst requiredField = css`\n  [part='label'] {\n    align-self: flex-start;\n    color: var(--vaadin-input-field-label-color, var(--lumo-secondary-text-color));\n    font-weight: var(--vaadin-input-field-label-font-weight, 500);\n    font-size: var(--vaadin-input-field-label-font-size, var(--lumo-font-size-s));\n    margin-left: calc(var(--lumo-border-radius-m) / 4);\n    transition: color 0.2s;\n    line-height: 1;\n    padding-right: 1em;\n    padding-bottom: 0.5em;\n    /* As a workaround for diacritics being cut off, add a top padding and a\n    negative margin to compensate */\n    padding-top: 0.25em;\n    margin-top: -0.25em;\n    overflow: hidden;\n    white-space: nowrap;\n    text-overflow: ellipsis;\n    position: relative;\n    max-width: 100%;\n    box-sizing: border-box;\n  }\n\n  :host([focused]:not([readonly])) [part='label'] {\n    color: var(--vaadin-input-field-focused-label-color, var(--lumo-primary-text-color));\n  }\n\n  :host(:hover:not([readonly]):not([focused])) [part='label'] {\n    color: var(--vaadin-input-field-hovered-label-color, var(--lumo-body-text-color));\n  }\n\n  /* Touch device adjustment */\n  @media (pointer: coarse) {\n    :host(:hover:not([readonly]):not([focused])) [part='label'] {\n      color: var(--vaadin-input-field-label-color, var(--lumo-secondary-text-color));\n    }\n  }\n\n  :host([has-label])::before {\n    margin-top: calc(var(--lumo-font-size-s) * 1.5);\n  }\n\n  :host([has-label][theme~='small'])::before {\n    margin-top: calc(var(--lumo-font-size-xs) * 1.5);\n  }\n\n  :host([has-label]) {\n    padding-top: var(--lumo-space-m);\n  }\n\n  :host([has-label]) ::slotted([slot='tooltip']) {\n    --vaadin-tooltip-offset-bottom: calc((var(--lumo-space-m) - var(--lumo-space-xs)) * -1);\n  }\n\n  :host([required]) [part='required-indicator']::after {\n    content: var(--lumo-required-field-indicator, '\\\\2022');\n    transition: opacity 0.2s;\n    color: var(--lumo-required-field-indicator-color, var(--lumo-primary-text-color));\n    position: absolute;\n    right: 0;\n    width: 1em;\n    text-align: center;\n  }\n\n  :host([invalid]) [part='required-indicator']::after {\n    color: var(--lumo-required-field-indicator-color, var(--lumo-error-text-color));\n  }\n\n  [part='error-message'] {\n    margin-left: calc(var(--lumo-border-radius-m) / 4);\n    font-size: var(--vaadin-input-field-error-font-size, var(--lumo-font-size-xs));\n    line-height: var(--lumo-line-height-xs);\n    font-weight: var(--vaadin-input-field-error-font-weight, 400);\n    color: var(--vaadin-input-field-error-color, var(--lumo-error-text-color));\n    will-change: max-height;\n    transition: 0.4s max-height;\n    max-height: 5em;\n  }\n\n  :host([has-error-message]) [part='error-message']::before,\n  :host([has-error-message]) [part='error-message']::after {\n    content: '';\n    display: block;\n    height: 0.4em;\n  }\n\n  :host(:not([invalid])) [part='error-message'] {\n    max-height: 0;\n    overflow: hidden;\n  }\n\n  /* RTL specific styles */\n\n  :host([dir='rtl']) [part='label'] {\n    margin-left: 0;\n    margin-right: calc(var(--lumo-border-radius-m) / 4);\n  }\n\n  :host([dir='rtl']) [part='label'] {\n    padding-left: 1em;\n    padding-right: 0;\n  }\n\n  :host([dir='rtl']) [part='required-indicator']::after {\n    right: auto;\n    left: 0;\n  }\n\n  :host([dir='rtl']) [part='error-message'] {\n    margin-left: 0;\n    margin-right: calc(var(--lumo-border-radius-m) / 4);\n  }\n`;\nregisterStyles('', requiredField, {\n  moduleId: 'lumo-required-field'\n});\nexport { requiredField };","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport '../color.js';\nimport '../font-icons.js';\nimport '../sizing.js';\nimport '../spacing.js';\nimport '../style.js';\nimport '../typography.js';\nimport { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nimport { fieldButton } from './field-button.js';\nimport { helper } from './helper.js';\nimport { requiredField } from './required-field.js';\nconst inputField = css`\n  :host {\n    --lumo-text-field-size: var(--lumo-size-m);\n    color: var(--vaadin-input-field-value-color, var(--lumo-body-text-color));\n    font-size: var(--vaadin-input-field-value-font-size, var(--lumo-font-size-m));\n    font-weight: var(--vaadin-input-field-value-font-weight, 400);\n    font-family: var(--lumo-font-family);\n    -webkit-font-smoothing: antialiased;\n    -moz-osx-font-smoothing: grayscale;\n    -webkit-tap-highlight-color: transparent;\n    padding: var(--lumo-space-xs) 0;\n    --_focus-ring-color: var(--vaadin-focus-ring-color, var(--lumo-primary-color-50pct));\n    --_focus-ring-width: var(--vaadin-focus-ring-width, 2px);\n    --_input-height: var(--vaadin-input-field-height, var(--lumo-text-field-size));\n    --_disabled-value-color: var(--vaadin-input-field-disabled-value-color, var(--lumo-disabled-text-color));\n  }\n\n  :host::before {\n    height: var(--_input-height);\n    box-sizing: border-box;\n    display: inline-flex;\n    align-items: center;\n  }\n\n  :host([focused]) [part='input-field'] ::slotted(:is(input, textarea)) {\n    -webkit-mask-image: none;\n    mask-image: none;\n  }\n\n  ::slotted(:is(input, textarea):placeholder-shown) {\n    color: var(--vaadin-input-field-placeholder-color, var(--lumo-secondary-text-color));\n  }\n\n  /* Hover */\n  :host(:hover:not([readonly]):not([focused])) [part='input-field']::after {\n    opacity: var(--vaadin-input-field-hover-highlight-opacity, 0.1);\n  }\n\n  /* Touch device adjustment */\n  @media (pointer: coarse) {\n    :host(:hover:not([readonly]):not([focused])) [part='input-field']::after {\n      opacity: 0;\n    }\n\n    :host(:active:not([readonly]):not([focused])) [part='input-field']::after {\n      opacity: 0.2;\n    }\n  }\n\n  /* Trigger when not focusing using the keyboard */\n  :host([focused]:not([focus-ring]):not([readonly])) [part='input-field']::after {\n    transform: scaleX(0);\n    transition-duration: 0.15s, 1s;\n  }\n\n  /* Focus-ring */\n  :host([focus-ring]) [part='input-field'] {\n    box-shadow: 0 0 0 var(--_focus-ring-width) var(--_focus-ring-color);\n  }\n\n  /* Read-only and disabled */\n  :host(:is([readonly], [disabled])) ::slotted(:is(input, textarea):placeholder-shown) {\n    opacity: 0;\n  }\n\n  /* Read-only style */\n  :host([readonly]) {\n    --vaadin-input-field-border-color: transparent;\n  }\n\n  /* Disabled style */\n  :host([disabled]) {\n    pointer-events: none;\n    --vaadin-input-field-border-color: var(--lumo-contrast-20pct);\n  }\n\n  :host([disabled]) [part='label'],\n  :host([disabled]) [part='input-field'] ::slotted([slot$='fix']) {\n    color: var(--lumo-disabled-text-color);\n    -webkit-text-fill-color: var(--lumo-disabled-text-color);\n  }\n\n  :host([disabled]) [part='input-field'] ::slotted(:not([slot$='fix'])) {\n    color: var(--_disabled-value-color);\n    -webkit-text-fill-color: var(--_disabled-value-color);\n  }\n\n  /* Invalid style */\n  :host([invalid]) {\n    --vaadin-input-field-border-color: var(--lumo-error-color);\n  }\n\n  :host([invalid][focus-ring]) [part='input-field'] {\n    box-shadow: 0 0 0 2px var(--lumo-error-color-50pct);\n  }\n\n  :host([input-prevented]) [part='input-field'] {\n    animation: shake 0.15s infinite;\n  }\n\n  @keyframes shake {\n    25% {\n      transform: translateX(4px);\n    }\n    75% {\n      transform: translateX(-4px);\n    }\n  }\n\n  /* Small theme */\n  :host([theme~='small']) {\n    font-size: var(--lumo-font-size-s);\n    --lumo-text-field-size: var(--lumo-size-s);\n  }\n\n  :host([theme~='small']) [part='label'] {\n    font-size: var(--lumo-font-size-xs);\n  }\n\n  :host([theme~='small']) [part='error-message'] {\n    font-size: var(--lumo-font-size-xxs);\n  }\n\n  /* Slotted content */\n  [part='input-field'] ::slotted(:not(vaadin-icon):not(input):not(textarea)) {\n    color: var(--lumo-secondary-text-color);\n    font-weight: 400;\n  }\n\n  [part='clear-button']::before {\n    content: var(--lumo-icons-cross);\n  }\n`;\nconst inputFieldShared = [requiredField, fieldButton, helper, inputField];\nregisterStyles('', inputFieldShared, {\n  moduleId: 'lumo-input-field-shared-styles'\n});\nexport { inputField, inputFieldShared };","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport '@vaadin/input-container/theme/lumo/vaadin-input-container-styles.js';\nimport '@vaadin/vaadin-lumo-styles/color.js';\nimport '@vaadin/vaadin-lumo-styles/font-icons.js';\nimport '@vaadin/vaadin-lumo-styles/style.js';\nimport '@vaadin/vaadin-lumo-styles/typography.js';\nimport { comboBoxItem } from '@vaadin/combo-box/theme/lumo/vaadin-combo-box-item-styles.js';\nimport { comboBoxLoader, comboBoxOverlay } from '@vaadin/combo-box/theme/lumo/vaadin-combo-box-overlay-styles.js';\nimport { item } from '@vaadin/item/theme/lumo/vaadin-item-styles.js';\nimport { inputFieldShared } from '@vaadin/vaadin-lumo-styles/mixins/input-field-shared.js';\nimport { loader } from '@vaadin/vaadin-lumo-styles/mixins/loader.js';\nimport { menuOverlayCore } from '@vaadin/vaadin-lumo-styles/mixins/menu-overlay.js';\nimport { overlay } from '@vaadin/vaadin-lumo-styles/mixins/overlay.js';\nimport { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nconst multiSelectComboBoxItem = css`\n  @media (any-hover: hover) {\n    :host(:hover[readonly]) {\n      background-color: transparent;\n      cursor: default;\n    }\n  }\n`;\nregisterStyles('vaadin-multi-select-combo-box-item', [item, comboBoxItem, multiSelectComboBoxItem], {\n  moduleId: 'lumo-multi-select-combo-box-item'\n});\nregisterStyles('vaadin-multi-select-combo-box-overlay', [overlay, menuOverlayCore, comboBoxOverlay, loader, comboBoxLoader, css`\n      :host {\n        --_vaadin-multi-select-combo-box-items-container-border-width: var(--lumo-space-xs);\n        --_vaadin-multi-select-combo-box-items-container-border-style: solid;\n      }\n    `], {\n  moduleId: 'lumo-multi-select-combo-box-overlay'\n});\nregisterStyles('vaadin-multi-select-combo-box-container', css`\n    :host([auto-expand-vertically]) {\n      padding-block: var(--lumo-space-xs);\n    }\n  `, {\n  moduleId: 'lumo-multi-select-combo-box-container'\n});\nconst multiSelectComboBox = css`\n  :host([has-value]) {\n    padding-inline-start: 0;\n  }\n\n  :host([has-value]) ::slotted(input:placeholder-shown) {\n    caret-color: var(--lumo-body-text-color) !important;\n  }\n\n  [part='label'] {\n    flex-shrink: 0;\n  }\n\n  /* Override input-container styles */\n  [part='input-field'] ::slotted([slot='chip']),\n  [part='input-field'] ::slotted([slot='overflow']) {\n    min-height: auto;\n    padding: 0.3125em calc(0.5em + var(--lumo-border-radius-s) / 4);\n    color: var(--lumo-body-text-color);\n    -webkit-mask-image: none;\n    mask-image: none;\n  }\n\n  :host([auto-expand-vertically]) ::slotted([slot='chip']) {\n    margin-block: calc(var(--lumo-space-xs) / 2);\n  }\n\n  ::slotted([slot='chip']:not([readonly]):not([disabled])) {\n    padding-inline-end: 0;\n  }\n\n  :host([auto-expand-vertically]) ::slotted([slot='input']) {\n    min-height: calc(var(--lumo-text-field-size, var(--lumo-size-m)) - 2 * var(--lumo-space-xs));\n  }\n\n  ::slotted([slot='chip']:not(:last-of-type)),\n  ::slotted([slot='overflow']:not(:last-of-type)) {\n    margin-inline-end: var(--lumo-space-xs);\n  }\n\n  ::slotted([slot='chip'][focused]) {\n    background-color: var(--vaadin-selection-color, var(--lumo-primary-color));\n    color: var(--lumo-primary-contrast-color);\n  }\n\n  [part='toggle-button']::before {\n    content: var(--lumo-icons-dropdown);\n  }\n\n  :host([readonly][has-value]) [part='toggle-button'] {\n    color: var(--lumo-contrast-60pct);\n    cursor: var(--lumo-clickable-cursor);\n  }\n`;\nregisterStyles('vaadin-multi-select-combo-box', [inputFieldShared, multiSelectComboBox], {\n  moduleId: 'lumo-multi-select-combo-box'\n});","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n/* eslint-disable no-unused-vars */\n/**\n * When using Closure Compiler, JSCompiler_renameProperty(property, object) is replaced by the munged name for object[property]\n * We cannot alias this function, so we have to use a small shim that has the same behavior when not compiling.\n *\n * @param {?} prop Property name\n * @param {*} obj Reference object\n * @return {string} Potentially renamed property name\n */\nwindow.JSCompiler_renameProperty = function (prop, obj) {\n  return prop;\n};\n/* eslint-enable */\n\nexport {};","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport './boot.js';\nlet CSS_URL_RX = /(url\\()([^)]*)(\\))/g;\nlet ABS_URL = /(^\\/[^\\/])|(^#)|(^[\\w-\\d]*:)/;\nlet workingURL;\nlet resolveDoc;\n/**\n * Resolves the given URL against the provided `baseUri'.\n *\n * Note that this function performs no resolution for URLs that start\n * with `/` (absolute URLs) or `#` (hash identifiers).  For general purpose\n * URL resolution, use `window.URL`.\n *\n * @param {string} url Input URL to resolve\n * @param {?string=} baseURI Base URI to resolve the URL against\n * @return {string} resolved URL\n */\nexport function resolveUrl(url, baseURI) {\n  if (url && ABS_URL.test(url)) {\n    return url;\n  }\n  if (url === '//') {\n    return url;\n  }\n  // Lazy feature detection.\n  if (workingURL === undefined) {\n    workingURL = false;\n    try {\n      const u = new URL('b', 'http://a');\n      u.pathname = 'c%20d';\n      workingURL = u.href === 'http://a/c%20d';\n    } catch (e) {\n      // silently fail\n    }\n  }\n  if (!baseURI) {\n    baseURI = document.baseURI || window.location.href;\n  }\n  if (workingURL) {\n    try {\n      return new URL(url, baseURI).href;\n    } catch (e) {\n      // Bad url or baseURI structure. Do not attempt to resolve.\n      return url;\n    }\n  }\n  // Fallback to creating an anchor into a disconnected document.\n  if (!resolveDoc) {\n    resolveDoc = document.implementation.createHTMLDocument('temp');\n    resolveDoc.base = resolveDoc.createElement('base');\n    resolveDoc.head.appendChild(resolveDoc.base);\n    resolveDoc.anchor = resolveDoc.createElement('a');\n    resolveDoc.body.appendChild(resolveDoc.anchor);\n  }\n  resolveDoc.base.href = baseURI;\n  resolveDoc.anchor.href = url;\n  return resolveDoc.anchor.href || url;\n}\n\n/**\n * Resolves any relative URL's in the given CSS text against the provided\n * `ownerDocument`'s `baseURI`.\n *\n * @param {string} cssText CSS text to process\n * @param {string} baseURI Base URI to resolve the URL against\n * @return {string} Processed CSS text with resolved URL's\n */\nexport function resolveCss(cssText, baseURI) {\n  return cssText.replace(CSS_URL_RX, function (m, pre, url, post) {\n    return pre + '\\'' + resolveUrl(url.replace(/[\"']/g, ''), baseURI) + '\\'' + post;\n  });\n}\n\n/**\n * Returns a path from a given `url`. The path includes the trailing\n * `/` from the url.\n *\n * @param {string} url Input URL to transform\n * @return {string} resolved path\n */\nexport function pathFromUrl(url) {\n  return url.substring(0, url.lastIndexOf('/') + 1);\n}","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport './boot.js';\nimport { pathFromUrl } from './resolve-url.js';\nexport const useShadow = !window.ShadyDOM || !window.ShadyDOM.inUse;\nexport const useNativeCSSProperties = Boolean(!window.ShadyCSS || window.ShadyCSS.nativeCss);\nexport const useNativeCustomElements = !window.customElements.polyfillWrapFlushCallback;\nexport const supportsAdoptingStyleSheets = useShadow && 'adoptedStyleSheets' in Document.prototype && 'replaceSync' in CSSStyleSheet.prototype &&\n// Since spec may change, feature detect exact API we need\n(() => {\n  try {\n    const sheet = new CSSStyleSheet();\n    sheet.replaceSync('');\n    const host = document.createElement('div');\n    host.attachShadow({\n      mode: 'open'\n    });\n    host.shadowRoot.adoptedStyleSheets = [sheet];\n    return host.shadowRoot.adoptedStyleSheets[0] === sheet;\n  } catch (e) {\n    return false;\n  }\n})();\n\n/**\n * Globally settable property that is automatically assigned to\n * `ElementMixin` instances, useful for binding in templates to\n * make URL's relative to an application's root.  Defaults to the main\n * document URL, but can be overridden by users.  It may be useful to set\n * `rootPath` to provide a stable application mount path when\n * using client side routing.\n */\nexport let rootPath = window.Polymer && window.Polymer.rootPath || pathFromUrl(document.baseURI || window.location.href);\n\n/**\n * Sets the global rootPath property used by `ElementMixin` and\n * available via `rootPath`.\n *\n * @param {string} path The new root path\n * @return {void}\n */\nexport const setRootPath = function (path) {\n  rootPath = path;\n};\n\n/**\n * A global callback used to sanitize any value before inserting it into the DOM.\n * The callback signature is:\n *\n *  function sanitizeDOMValue(value, name, type, node) { ... }\n *\n * Where:\n *\n * `value` is the value to sanitize.\n * `name` is the name of an attribute or property (for example, href).\n * `type` indicates where the value is being inserted: one of property, attribute, or text.\n * `node` is the node where the value is being inserted.\n *\n * @type {(function(*,string,string,?Node):*)|undefined}\n */\nexport let sanitizeDOMValue = window.Polymer && window.Polymer.sanitizeDOMValue || undefined;\n\n/**\n * Sets the global sanitizeDOMValue available via this module's exported\n * `sanitizeDOMValue` variable.\n *\n * @param {(function(*,string,string,?Node):*)|undefined} newSanitizeDOMValue the global sanitizeDOMValue callback\n * @return {void}\n */\nexport const setSanitizeDOMValue = function (newSanitizeDOMValue) {\n  sanitizeDOMValue = newSanitizeDOMValue;\n};\n\n/**\n * Gets sanitizeDOMValue, for environments that don't well support `export let`.\n *\n * @return {(function(*,string,string,?Node):*)|undefined} sanitizeDOMValue\n */\nexport const getSanitizeDOMValue = function () {\n  return sanitizeDOMValue;\n};\n\n/**\n * Globally settable property to make Polymer Gestures use passive TouchEvent listeners when recognizing gestures.\n * When set to `true`, gestures made from touch will not be able to prevent scrolling, allowing for smoother\n * scrolling performance.\n * Defaults to `false` for backwards compatibility.\n */\nexport let passiveTouchGestures = window.Polymer && window.Polymer.setPassiveTouchGestures || false;\n\n/**\n * Sets `passiveTouchGestures` globally for all elements using Polymer Gestures.\n *\n * @param {boolean} usePassive enable or disable passive touch gestures globally\n * @return {void}\n */\nexport const setPassiveTouchGestures = function (usePassive) {\n  passiveTouchGestures = usePassive;\n};\n\n/**\n * Setting to ensure Polymer template evaluation only occurs based on tempates\n * defined in trusted script.  When true, `<dom-module>` re-registration is\n * disallowed, `<dom-bind>` is disabled, and `<dom-if>`/`<dom-repeat>`\n * templates will only evaluate in the context of a trusted element template.\n */\nexport let strictTemplatePolicy = window.Polymer && window.Polymer.strictTemplatePolicy || false;\n\n/**\n * Sets `strictTemplatePolicy` globally for all elements\n *\n * @param {boolean} useStrictPolicy enable or disable strict template policy\n *   globally\n * @return {void}\n */\nexport const setStrictTemplatePolicy = function (useStrictPolicy) {\n  strictTemplatePolicy = useStrictPolicy;\n};\n\n/**\n * Setting to enable dom-module lookup from Polymer.Element.  By default,\n * templates must be defined in script using the `static get template()`\n * getter and the `html` tag function.  To enable legacy loading of templates\n * via dom-module, set this flag to true.\n */\nexport let allowTemplateFromDomModule = window.Polymer && window.Polymer.allowTemplateFromDomModule || false;\n\n/**\n * Sets `lookupTemplateFromDomModule` globally for all elements\n *\n * @param {boolean} allowDomModule enable or disable template lookup\n *   globally\n * @return {void}\n */\nexport const setAllowTemplateFromDomModule = function (allowDomModule) {\n  allowTemplateFromDomModule = allowDomModule;\n};\n\n/**\n * Setting to skip processing style includes and re-writing urls in css styles.\n * Normally \"included\" styles are pulled into the element and all urls in styles\n * are re-written to be relative to the containing script url.\n * If no includes or relative urls are used in styles, these steps can be\n * skipped as an optimization.\n */\nexport let legacyOptimizations = window.Polymer && window.Polymer.legacyOptimizations || false;\n\n/**\n * Sets `legacyOptimizations` globally for all elements to enable optimizations\n * when only legacy based elements are used.\n *\n * @param {boolean} useLegacyOptimizations enable or disable legacy optimizations\n * includes and url rewriting\n * @return {void}\n */\nexport const setLegacyOptimizations = function (useLegacyOptimizations) {\n  legacyOptimizations = useLegacyOptimizations;\n};\n\n/**\n * Setting to add warnings useful when migrating from Polymer 1.x to 2.x.\n */\nexport let legacyWarnings = window.Polymer && window.Polymer.legacyWarnings || false;\n\n/**\n * Sets `legacyWarnings` globally for all elements to migration warnings.\n *\n * @param {boolean} useLegacyWarnings enable or disable warnings\n * @return {void}\n */\nexport const setLegacyWarnings = function (useLegacyWarnings) {\n  legacyWarnings = useLegacyWarnings;\n};\n\n/**\n * Setting to perform initial rendering synchronously when running under ShadyDOM.\n * This matches the behavior of Polymer 1.\n */\nexport let syncInitialRender = window.Polymer && window.Polymer.syncInitialRender || false;\n\n/**\n * Sets `syncInitialRender` globally for all elements to enable synchronous\n * initial rendering.\n *\n * @param {boolean} useSyncInitialRender enable or disable synchronous initial\n * rendering globally.\n * @return {void}\n */\nexport const setSyncInitialRender = function (useSyncInitialRender) {\n  syncInitialRender = useSyncInitialRender;\n};\n\n/**\n * Setting to retain the legacy Polymer 1 behavior for multi-property\n * observers around undefined values. Observers and computed property methods\n * are not called until no argument is undefined.\n */\nexport let legacyUndefined = window.Polymer && window.Polymer.legacyUndefined || false;\n\n/**\n * Sets `legacyUndefined` globally for all elements to enable legacy\n * multi-property behavior for undefined values.\n *\n * @param {boolean} useLegacyUndefined enable or disable legacy\n * multi-property behavior for undefined.\n * @return {void}\n */\nexport const setLegacyUndefined = function (useLegacyUndefined) {\n  legacyUndefined = useLegacyUndefined;\n};\n\n/**\n * Setting to ensure computed properties are computed in order to ensure\n * re-computation never occurs in a given turn.\n */\nexport let orderedComputed = window.Polymer && window.Polymer.orderedComputed || false;\n\n/**\n * Sets `orderedComputed` globally for all elements to enable ordered computed\n * property computation.\n *\n * @param {boolean} useOrderedComputed enable or disable ordered computed effects\n * @return {void}\n */\nexport const setOrderedComputed = function (useOrderedComputed) {\n  orderedComputed = useOrderedComputed;\n};\n\n/**\n * Setting to cancel synthetic click events fired by older mobile browsers. Modern browsers\n * no longer fire synthetic click events, and the cancellation behavior can interfere\n * when programmatically clicking on elements.\n */\nexport let cancelSyntheticClickEvents = true;\n\n/**\n * Sets `setCancelSyntheticEvents` globally for all elements to cancel synthetic click events.\n *\n * @param {boolean} useCancelSyntheticClickEvents enable or disable cancelling synthetic\n * events\n * @return {void}\n */\nexport const setCancelSyntheticClickEvents = function (useCancelSyntheticClickEvents) {\n  cancelSyntheticClickEvents = useCancelSyntheticClickEvents;\n};\n\n/**\n * Setting to remove nested templates inside `dom-if` and `dom-repeat` as\n * part of element template parsing.  This is a performance optimization that\n * eliminates most of the tax of needing two elements due to the loss of\n * type-extended templates as a result of the V1 specification changes.\n */\nexport let removeNestedTemplates = window.Polymer && window.Polymer.removeNestedTemplates || false;\n\n/**\n * Sets `removeNestedTemplates` globally, to eliminate nested templates\n * inside `dom-if` and `dom-repeat` as part of template parsing.\n *\n * @param {boolean} useRemoveNestedTemplates enable or disable removing nested\n *   templates during parsing\n * @return {void}\n */\nexport const setRemoveNestedTemplates = function (useRemoveNestedTemplates) {\n  removeNestedTemplates = useRemoveNestedTemplates;\n};\n\n/**\n * Setting to place `dom-if` elements in a performance-optimized mode that takes\n * advantage of lighter-weight host runtime template stamping to eliminate the\n * need for an intermediate Templatizer `TemplateInstance` to mange the nodes\n * stamped by `dom-if`.  Under this setting, any Templatizer-provided API's\n * such as `modelForElement` will not be available for nodes stamped by\n * `dom-if`.\n */\nexport let fastDomIf = window.Polymer && window.Polymer.fastDomIf || false;\n\n/**\n * Sets `fastDomIf` globally, to put `dom-if` in a performance-optimized mode.\n *\n * @param {boolean} useFastDomIf enable or disable `dom-if` fast-mode\n * @return {void}\n */\nexport const setFastDomIf = function (useFastDomIf) {\n  fastDomIf = useFastDomIf;\n};\n\n/**\n * Setting to disable `dom-change` and `rendered-item-count` events from\n * `dom-if` and `dom-repeat`. Users can opt back into `dom-change` events by\n * setting the `notify-dom-change` attribute (`notifyDomChange: true` property)\n * to `dom-if`/`don-repeat` instances.\n */\nexport let suppressTemplateNotifications = window.Polymer && window.Polymer.suppressTemplateNotifications || false;\n\n/**\n * Sets `suppressTemplateNotifications` globally, to disable `dom-change` and\n * `rendered-item-count` events from `dom-if` and `dom-repeat`.\n *\n * @param {boolean} suppress enable or disable `suppressTemplateNotifications`\n * @return {void}\n */\nexport const setSuppressTemplateNotifications = function (suppress) {\n  suppressTemplateNotifications = suppress;\n};\n\n/**\n * Setting to disable use of dynamic attributes. This is an optimization\n * to avoid setting `observedAttributes`. Instead attributes are read\n * once at create time and set/removeAttribute are patched.\n */\nexport let legacyNoObservedAttributes = window.Polymer && window.Polymer.legacyNoObservedAttributes || false;\n\n/**\n * Sets `legacyNoObservedAttributes` globally, to disable `observedAttributes`.\n *\n * @param {boolean} noObservedAttributes enable or disable `legacyNoObservedAttributes`\n * @return {void}\n */\nexport const setLegacyNoObservedAttributes = function (noObservedAttributes) {\n  legacyNoObservedAttributes = noObservedAttributes;\n};\n\n/**\n * Setting to enable use of `adoptedStyleSheets` for sharing style sheets\n * between component instances' shadow roots, if the app uses built Shady CSS\n * styles.\n */\nexport let useAdoptedStyleSheetsWithBuiltCSS = window.Polymer && window.Polymer.useAdoptedStyleSheetsWithBuiltCSS || false;\n\n/**\n * Sets `useAdoptedStyleSheetsWithBuiltCSS` globally.\n *\n * @param {boolean} value enable or disable `useAdoptedStyleSheetsWithBuiltCSS`\n * @return {void}\n */\nexport const setUseAdoptedStyleSheetsWithBuiltCSS = function (value) {\n  useAdoptedStyleSheetsWithBuiltCSS = value;\n};","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport './boot.js';\n\n// unique global id for deduping mixins.\nlet dedupeId = 0;\n\n/**\n * @constructor\n * @extends {Function}\n * @private\n */\nfunction MixinFunction() {}\n/** @type {(WeakMap | undefined)} */\nMixinFunction.prototype.__mixinApplications;\n/** @type {(Object | undefined)} */\nMixinFunction.prototype.__mixinSet;\n\n/* eslint-disable valid-jsdoc */\n/**\n * Wraps an ES6 class expression mixin such that the mixin is only applied\n * if it has not already been applied its base argument. Also memoizes mixin\n * applications.\n *\n * @template T\n * @param {T} mixin ES6 class expression mixin to wrap\n * @return {T}\n * @suppress {invalidCasts}\n */\nexport const dedupingMixin = function (mixin) {\n  let mixinApplications = /** @type {!MixinFunction} */mixin.__mixinApplications;\n  if (!mixinApplications) {\n    mixinApplications = new WeakMap();\n    /** @type {!MixinFunction} */\n    mixin.__mixinApplications = mixinApplications;\n  }\n  // maintain a unique id for each mixin\n  let mixinDedupeId = dedupeId++;\n  function dedupingMixin(base) {\n    let baseSet = /** @type {!MixinFunction} */base.__mixinSet;\n    if (baseSet && baseSet[mixinDedupeId]) {\n      return base;\n    }\n    let map = mixinApplications;\n    let extended = map.get(base);\n    if (!extended) {\n      extended = /** @type {!Function} */mixin(base);\n      map.set(base, extended);\n      // copy inherited mixin set from the extended class, or the base class\n      // NOTE: we avoid use of Set here because some browser (IE11)\n      // cannot extend a base Set via the constructor.\n      let mixinSet = Object.create(/** @type {!MixinFunction} */extended.__mixinSet || baseSet || null);\n      mixinSet[mixinDedupeId] = true;\n      /** @type {!MixinFunction} */\n      extended.__mixinSet = mixinSet;\n    }\n    return extended;\n  }\n  return dedupingMixin;\n};\n/* eslint-enable valid-jsdoc */","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport '../utils/boot.js';\nimport { resolveUrl, pathFromUrl } from '../utils/resolve-url.js';\nimport { strictTemplatePolicy } from '../utils/settings.js';\nlet modules = {};\nlet lcModules = {};\n/**\n * Sets a dom-module into the global registry by id.\n *\n * @param {string} id dom-module id\n * @param {DomModule} module dom-module instance\n * @return {void}\n */\nfunction setModule(id, module) {\n  // store id separate from lowercased id so that\n  // in all cases mixedCase id will stored distinctly\n  // and lowercase version is a fallback\n  modules[id] = lcModules[id.toLowerCase()] = module;\n}\n/**\n * Retrieves a dom-module from the global registry by id.\n *\n * @param {string} id dom-module id\n * @return {DomModule!} dom-module instance\n */\nfunction findModule(id) {\n  return modules[id] || lcModules[id.toLowerCase()];\n}\nfunction styleOutsideTemplateCheck(inst) {\n  if (inst.querySelector('style')) {\n    console.warn('dom-module %s has style outside template', inst.id);\n  }\n}\n\n/**\n * The `dom-module` element registers the dom it contains to the name given\n * by the module's id attribute. It provides a unified database of dom\n * accessible via its static `import` API.\n *\n * A key use case of `dom-module` is for providing custom element `<template>`s\n * via HTML imports that are parsed by the native HTML parser, that can be\n * relocated during a bundling pass and still looked up by `id`.\n *\n * Example:\n *\n *     <dom-module id=\"foo\">\n *       <img src=\"stuff.png\">\n *     </dom-module>\n *\n * Then in code in some other location that cannot access the dom-module above\n *\n *     let img = customElements.get('dom-module').import('foo', 'img');\n *\n * @customElement\n * @extends HTMLElement\n * @summary Custom element that provides a registry of relocatable DOM content\n *   by `id` that is agnostic to bundling.\n * @unrestricted\n */\nexport class DomModule extends HTMLElement {\n  /** @override */\n  static get observedAttributes() {\n    return ['id'];\n  }\n\n  /**\n   * Retrieves the element specified by the css `selector` in the module\n   * registered by `id`. For example, this.import('foo', 'img');\n   * @param {string} id The id of the dom-module in which to search.\n   * @param {string=} selector The css selector by which to find the element.\n   * @return {Element} Returns the element which matches `selector` in the\n   * module registered at the specified `id`.\n   *\n   * @export\n   * @nocollapse Referred to indirectly in style-gather.js\n   */\n  static import(id, selector) {\n    if (id) {\n      let m = findModule(id);\n      if (m && selector) {\n        return m.querySelector(selector);\n      }\n      return m;\n    }\n    return null;\n  }\n\n  /* eslint-disable no-unused-vars */\n  /**\n   * @param {string} name Name of attribute.\n   * @param {?string} old Old value of attribute.\n   * @param {?string} value Current value of attribute.\n   * @param {?string} namespace Attribute namespace.\n   * @return {void}\n   * @override\n   */\n  attributeChangedCallback(name, old, value, namespace) {\n    if (old !== value) {\n      this.register();\n    }\n  }\n  /* eslint-enable no-unused-args */\n\n  /**\n   * The absolute URL of the original location of this `dom-module`.\n   *\n   * This value will differ from this element's `ownerDocument` in the\n   * following ways:\n   * - Takes into account any `assetpath` attribute added during bundling\n   *   to indicate the original location relative to the bundled location\n   * - Uses the HTMLImports polyfill's `importForElement` API to ensure\n   *   the path is relative to the import document's location since\n   *   `ownerDocument` is not currently polyfilled\n   */\n  get assetpath() {\n    // Don't override existing assetpath.\n    if (!this.__assetpath) {\n      // note: assetpath set via an attribute must be relative to this\n      // element's location; accommodate polyfilled HTMLImports\n      const owner = window.HTMLImports && HTMLImports.importForElement ? HTMLImports.importForElement(this) || document : this.ownerDocument;\n      const url = resolveUrl(this.getAttribute('assetpath') || '', owner.baseURI);\n      this.__assetpath = pathFromUrl(url);\n    }\n    return this.__assetpath;\n  }\n\n  /**\n   * Registers the dom-module at a given id. This method should only be called\n   * when a dom-module is imperatively created. For\n   * example, `document.createElement('dom-module').register('foo')`.\n   * @param {string=} id The id at which to register the dom-module.\n   * @return {void}\n   */\n  register(id) {\n    id = id || this.id;\n    if (id) {\n      // Under strictTemplatePolicy, reject and null out any re-registered\n      // dom-module since it is ambiguous whether first-in or last-in is trusted\n      if (strictTemplatePolicy && findModule(id) !== undefined) {\n        setModule(id, null);\n        throw new Error(`strictTemplatePolicy: dom-module ${id} re-registered`);\n      }\n      this.id = id;\n      setModule(id, this);\n      styleOutsideTemplateCheck(this);\n    }\n  }\n}\nDomModule.prototype['modules'] = modules;\ncustomElements.define('dom-module', DomModule);","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n/**\n * Module with utilities for collection CSS text from `<templates>`, external\n * stylesheets, and `dom-module`s.\n *\n * @summary Module with utilities for collection CSS text from various sources.\n */\n\nimport { DomModule } from '../elements/dom-module.js';\nimport { resolveCss } from './resolve-url.js';\nconst MODULE_STYLE_LINK_SELECTOR = 'link[rel=import][type~=css]';\nconst INCLUDE_ATTR = 'include';\nconst SHADY_UNSCOPED_ATTR = 'shady-unscoped';\n\n/**\n * @param {string} moduleId .\n * @return {?DomModule} .\n */\nfunction importModule(moduleId) {\n  return /** @type {?DomModule} */DomModule.import(moduleId);\n}\nfunction styleForImport(importDoc) {\n  // NOTE: polyfill affordance.\n  // under the HTMLImports polyfill, there will be no 'body',\n  // but the import pseudo-doc can be used directly.\n  let container = importDoc.body ? importDoc.body : importDoc;\n  const importCss = resolveCss(container.textContent, importDoc.baseURI);\n  const style = document.createElement('style');\n  style.textContent = importCss;\n  return style;\n}\n\n/** @typedef {{assetpath: string}} */\nlet templateWithAssetPath; // eslint-disable-line no-unused-vars\n\n/**\n * Returns a list of <style> elements in a space-separated list of `dom-module`s.\n *\n * @function\n * @param {string} moduleIds List of dom-module id's within which to\n * search for css.\n * @return {!Array<!HTMLStyleElement>} Array of contained <style> elements\n */\nexport function stylesFromModules(moduleIds) {\n  const modules = moduleIds.trim().split(/\\s+/);\n  const styles = [];\n  for (let i = 0; i < modules.length; i++) {\n    styles.push(...stylesFromModule(modules[i]));\n  }\n  return styles;\n}\n\n/**\n * Returns a list of <style> elements in a given `dom-module`.\n * Styles in a `dom-module` can come either from `<style>`s within the\n * first `<template>`, or else from one or more\n * `<link rel=\"import\" type=\"css\">` links outside the template.\n *\n * @param {string} moduleId dom-module id to gather styles from\n * @return {!Array<!HTMLStyleElement>} Array of contained styles.\n */\nexport function stylesFromModule(moduleId) {\n  const m = importModule(moduleId);\n  if (!m) {\n    console.warn('Could not find style data in module named', moduleId);\n    return [];\n  }\n  if (m._styles === undefined) {\n    const styles = [];\n    // module imports: <link rel=\"import\" type=\"css\">\n    styles.push(..._stylesFromModuleImports(m));\n    // include css from the first template in the module\n    const template = /** @type {?HTMLTemplateElement} */\n    m.querySelector('template');\n    if (template) {\n      styles.push(...stylesFromTemplate(template, /** @type {templateWithAssetPath} */m.assetpath));\n    }\n    m._styles = styles;\n  }\n  return m._styles;\n}\n\n/**\n * Returns the `<style>` elements within a given template.\n *\n * @param {!HTMLTemplateElement} template Template to gather styles from\n * @param {string=} baseURI baseURI for style content\n * @return {!Array<!HTMLStyleElement>} Array of styles\n */\nexport function stylesFromTemplate(template, baseURI) {\n  if (!template._styles) {\n    const styles = [];\n    // if element is a template, get content from its .content\n    const e$ = template.content.querySelectorAll('style');\n    for (let i = 0; i < e$.length; i++) {\n      let e = e$[i];\n      // support style sharing by allowing styles to \"include\"\n      // other dom-modules that contain styling\n      let include = e.getAttribute(INCLUDE_ATTR);\n      if (include) {\n        styles.push(...stylesFromModules(include).filter(function (item, index, self) {\n          return self.indexOf(item) === index;\n        }));\n      }\n      if (baseURI) {\n        e.textContent = resolveCss(e.textContent, /** @type {string} */baseURI);\n      }\n      styles.push(e);\n    }\n    template._styles = styles;\n  }\n  return template._styles;\n}\n\n/**\n * Returns a list of <style> elements  from stylesheets loaded via `<link rel=\"import\" type=\"css\">` links within the specified `dom-module`.\n *\n * @param {string} moduleId Id of `dom-module` to gather CSS from\n * @return {!Array<!HTMLStyleElement>} Array of contained styles.\n */\nexport function stylesFromModuleImports(moduleId) {\n  let m = importModule(moduleId);\n  return m ? _stylesFromModuleImports(m) : [];\n}\n\n/**\n * @param {!HTMLElement} module dom-module element that could contain `<link rel=\"import\" type=\"css\">` styles\n * @return {!Array<!HTMLStyleElement>} Array of contained styles\n */\nfunction _stylesFromModuleImports(module) {\n  const styles = [];\n  const p$ = module.querySelectorAll(MODULE_STYLE_LINK_SELECTOR);\n  for (let i = 0; i < p$.length; i++) {\n    let p = p$[i];\n    if (p.import) {\n      const importDoc = p.import;\n      const unscoped = p.hasAttribute(SHADY_UNSCOPED_ATTR);\n      if (unscoped && !importDoc._unscopedStyle) {\n        const style = styleForImport(importDoc);\n        style.setAttribute(SHADY_UNSCOPED_ATTR, '');\n        importDoc._unscopedStyle = style;\n      } else if (!importDoc._style) {\n        importDoc._style = styleForImport(importDoc);\n      }\n      styles.push(unscoped ? importDoc._unscopedStyle : importDoc._style);\n    }\n  }\n  return styles;\n}\n\n/**\n *\n * Returns CSS text of styles in a space-separated list of `dom-module`s.\n * Note: This method is deprecated, use `stylesFromModules` instead.\n *\n * @deprecated\n * @param {string} moduleIds List of dom-module id's within which to\n * search for css.\n * @return {string} Concatenated CSS content from specified `dom-module`s\n */\nexport function cssFromModules(moduleIds) {\n  let modules = moduleIds.trim().split(/\\s+/);\n  let cssText = '';\n  for (let i = 0; i < modules.length; i++) {\n    cssText += cssFromModule(modules[i]);\n  }\n  return cssText;\n}\n\n/**\n * Returns CSS text of styles in a given `dom-module`.  CSS in a `dom-module`\n * can come either from `<style>`s within the first `<template>`, or else\n * from one or more `<link rel=\"import\" type=\"css\">` links outside the\n * template.\n *\n * Any `<styles>` processed are removed from their original location.\n * Note: This method is deprecated, use `styleFromModule` instead.\n *\n * @deprecated\n * @param {string} moduleId dom-module id to gather styles from\n * @return {string} Concatenated CSS content from specified `dom-module`\n */\nexport function cssFromModule(moduleId) {\n  let m = importModule(moduleId);\n  if (m && m._cssText === undefined) {\n    // module imports: <link rel=\"import\" type=\"css\">\n    let cssText = _cssFromModuleImports(m);\n    // include css from the first template in the module\n    let t = /** @type {?HTMLTemplateElement} */m.querySelector('template');\n    if (t) {\n      cssText += cssFromTemplate(t, /** @type {templateWithAssetPath} */m.assetpath);\n    }\n    m._cssText = cssText || null;\n  }\n  if (!m) {\n    console.warn('Could not find style data in module named', moduleId);\n  }\n  return m && m._cssText || '';\n}\n\n/**\n * Returns CSS text of `<styles>` within a given template.\n *\n * Any `<styles>` processed are removed from their original location.\n * Note: This method is deprecated, use `styleFromTemplate` instead.\n *\n * @deprecated\n * @param {!HTMLTemplateElement} template Template to gather styles from\n * @param {string} baseURI Base URI to resolve the URL against\n * @return {string} Concatenated CSS content from specified template\n */\nexport function cssFromTemplate(template, baseURI) {\n  let cssText = '';\n  const e$ = stylesFromTemplate(template, baseURI);\n  // if element is a template, get content from its .content\n  for (let i = 0; i < e$.length; i++) {\n    let e = e$[i];\n    if (e.parentNode) {\n      e.parentNode.removeChild(e);\n    }\n    cssText += e.textContent;\n  }\n  return cssText;\n}\n\n/**\n * Returns CSS text from stylesheets loaded via `<link rel=\"import\" type=\"css\">`\n * links within the specified `dom-module`.\n *\n * Note: This method is deprecated, use `stylesFromModuleImports` instead.\n *\n * @deprecated\n *\n * @param {string} moduleId Id of `dom-module` to gather CSS from\n * @return {string} Concatenated CSS content from links in specified `dom-module`\n */\nexport function cssFromModuleImports(moduleId) {\n  let m = importModule(moduleId);\n  return m ? _cssFromModuleImports(m) : '';\n}\n\n/**\n * @deprecated\n * @param {!HTMLElement} module dom-module element that could contain `<link rel=\"import\" type=\"css\">` styles\n * @return {string} Concatenated CSS content from links in the dom-module\n */\nfunction _cssFromModuleImports(module) {\n  let cssText = '';\n  let styles = _stylesFromModuleImports(module);\n  for (let i = 0; i < styles.length; i++) {\n    cssText += styles[i].textContent;\n  }\n  return cssText;\n}","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n/* eslint-disable valid-jsdoc */\n/**\n * Node wrapper to ensure ShadowDOM safe operation regardless of polyfill\n * presence or mode. Note that with the introduction of `ShadyDOM.noPatch`,\n * a node wrapper must be used to access ShadowDOM API.\n * This is similar to using `Polymer.dom` but relies exclusively\n * on the presence of the ShadyDOM polyfill rather than requiring the loading\n * of legacy (Polymer.dom) API.\n * @type {function(Node):Node}\n */\nexport const wrap = window['ShadyDOM'] && window['ShadyDOM']['noPatch'] && window['ShadyDOM']['wrap'] ? window['ShadyDOM']['wrap'] : window['ShadyDOM'] ? n => ShadyDOM['patch'](n) : n => n;","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport './boot.js';\n\n/**\n * Module with utilities for manipulating structured data path strings.\n *\n * @summary Module with utilities for manipulating structured data path strings.\n */\n\n/**\n * Returns true if the given string is a structured data path (has dots).\n *\n * Example:\n *\n * ```\n * isPath('foo.bar.baz') // true\n * isPath('foo')         // false\n * ```\n *\n * @param {string} path Path string\n * @return {boolean} True if the string contained one or more dots\n */\nexport function isPath(path) {\n  return path.indexOf('.') >= 0;\n}\n\n/**\n * Returns the root property name for the given path.\n *\n * Example:\n *\n * ```\n * root('foo.bar.baz') // 'foo'\n * root('foo')         // 'foo'\n * ```\n *\n * @param {string} path Path string\n * @return {string} Root property name\n */\nexport function root(path) {\n  let dotIndex = path.indexOf('.');\n  if (dotIndex === -1) {\n    return path;\n  }\n  return path.slice(0, dotIndex);\n}\n\n/**\n * Given `base` is `foo.bar`, `foo` is an ancestor, `foo.bar` is not\n * Returns true if the given path is an ancestor of the base path.\n *\n * Example:\n *\n * ```\n * isAncestor('foo.bar', 'foo')         // true\n * isAncestor('foo.bar', 'foo.bar')     // false\n * isAncestor('foo.bar', 'foo.bar.baz') // false\n * ```\n *\n * @param {string} base Path string to test against.\n * @param {string} path Path string to test.\n * @return {boolean} True if `path` is an ancestor of `base`.\n */\nexport function isAncestor(base, path) {\n  //     base.startsWith(path + '.');\n  return base.indexOf(path + '.') === 0;\n}\n\n/**\n * Given `base` is `foo.bar`, `foo.bar.baz` is an descendant\n *\n * Example:\n *\n * ```\n * isDescendant('foo.bar', 'foo.bar.baz') // true\n * isDescendant('foo.bar', 'foo.bar')     // false\n * isDescendant('foo.bar', 'foo')         // false\n * ```\n *\n * @param {string} base Path string to test against.\n * @param {string} path Path string to test.\n * @return {boolean} True if `path` is a descendant of `base`.\n */\nexport function isDescendant(base, path) {\n  //     path.startsWith(base + '.');\n  return path.indexOf(base + '.') === 0;\n}\n\n/**\n * Replaces a previous base path with a new base path, preserving the\n * remainder of the path.\n *\n * User must ensure `path` has a prefix of `base`.\n *\n * Example:\n *\n * ```\n * translate('foo.bar', 'zot', 'foo.bar.baz') // 'zot.baz'\n * ```\n *\n * @param {string} base Current base string to remove\n * @param {string} newBase New base string to replace with\n * @param {string} path Path to translate\n * @return {string} Translated string\n */\nexport function translate(base, newBase, path) {\n  return newBase + path.slice(base.length);\n}\n\n/**\n * @param {string} base Path string to test against\n * @param {string} path Path string to test\n * @return {boolean} True if `path` is equal to `base`\n */\nexport function matches(base, path) {\n  return base === path || isAncestor(base, path) || isDescendant(base, path);\n}\n\n/**\n * Converts array-based paths to flattened path.  String-based paths\n * are returned as-is.\n *\n * Example:\n *\n * ```\n * normalize(['foo.bar', 0, 'baz'])  // 'foo.bar.0.baz'\n * normalize('foo.bar.0.baz')        // 'foo.bar.0.baz'\n * ```\n *\n * @param {string | !Array<string|number>} path Input path\n * @return {string} Flattened path\n */\nexport function normalize(path) {\n  if (Array.isArray(path)) {\n    let parts = [];\n    for (let i = 0; i < path.length; i++) {\n      let args = path[i].toString().split('.');\n      for (let j = 0; j < args.length; j++) {\n        parts.push(args[j]);\n      }\n    }\n    return parts.join('.');\n  } else {\n    return path;\n  }\n}\n\n/**\n * Splits a path into an array of property names. Accepts either arrays\n * of path parts or strings.\n *\n * Example:\n *\n * ```\n * split(['foo.bar', 0, 'baz'])  // ['foo', 'bar', '0', 'baz']\n * split('foo.bar.0.baz')        // ['foo', 'bar', '0', 'baz']\n * ```\n *\n * @param {string | !Array<string|number>} path Input path\n * @return {!Array<string>} Array of path parts\n * @suppress {checkTypes}\n */\nexport function split(path) {\n  if (Array.isArray(path)) {\n    return normalize(path).split('.');\n  }\n  return path.toString().split('.');\n}\n\n/**\n * Reads a value from a path.  If any sub-property in the path is `undefined`,\n * this method returns `undefined` (will never throw.\n *\n * @param {Object} root Object from which to dereference path from\n * @param {string | !Array<string|number>} path Path to read\n * @param {Object=} info If an object is provided to `info`, the normalized\n *  (flattened) path will be set to `info.path`.\n * @return {*} Value at path, or `undefined` if the path could not be\n *  fully dereferenced.\n */\nexport function get(root, path, info) {\n  let prop = root;\n  let parts = split(path);\n  // Loop over path parts[0..n-1] and dereference\n  for (let i = 0; i < parts.length; i++) {\n    if (!prop) {\n      return;\n    }\n    let part = parts[i];\n    prop = prop[part];\n  }\n  if (info) {\n    info.path = parts.join('.');\n  }\n  return prop;\n}\n\n/**\n * Sets a value to a path.  If any sub-property in the path is `undefined`,\n * this method will no-op.\n *\n * @param {Object} root Object from which to dereference path from\n * @param {string | !Array<string|number>} path Path to set\n * @param {*} value Value to set to path\n * @return {string | undefined} The normalized version of the input path\n */\nexport function set(root, path, value) {\n  let prop = root;\n  let parts = split(path);\n  let last = parts[parts.length - 1];\n  if (parts.length > 1) {\n    // Loop over path parts[0..n-2] and dereference\n    for (let i = 0; i < parts.length - 1; i++) {\n      let part = parts[i];\n      prop = prop[part];\n      if (!prop) {\n        return;\n      }\n    }\n    // Set value to object at end of path\n    prop[last] = value;\n  } else {\n    // Simple property set\n    prop[path] = value;\n  }\n  return parts.join('.');\n}\n\n/**\n * Returns true if the given string is a structured data path (has dots).\n *\n * This function is deprecated.  Use `isPath` instead.\n *\n * Example:\n *\n * ```\n * isDeep('foo.bar.baz') // true\n * isDeep('foo')         // false\n * ```\n *\n * @deprecated\n * @param {string} path Path string\n * @return {boolean} True if the string contained one or more dots\n */\nexport const isDeep = isPath;","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport './boot.js';\nconst caseMap = {};\nconst DASH_TO_CAMEL = /-[a-z]/g;\nconst CAMEL_TO_DASH = /([A-Z])/g;\n\n/**\n * @fileoverview Module with utilities for converting between \"dash-case\" and\n * \"camelCase\" identifiers.\n */\n\n/**\n * Converts \"dash-case\" identifier (e.g. `foo-bar-baz`) to \"camelCase\"\n * (e.g. `fooBarBaz`).\n *\n * @param {string} dash Dash-case identifier\n * @return {string} Camel-case representation of the identifier\n */\nexport function dashToCamelCase(dash) {\n  return caseMap[dash] || (caseMap[dash] = dash.indexOf('-') < 0 ? dash : dash.replace(DASH_TO_CAMEL, m => m[1].toUpperCase()));\n}\n\n/**\n * Converts \"camelCase\" identifier (e.g. `fooBarBaz`) to \"dash-case\"\n * (e.g. `foo-bar-baz`).\n *\n * @param {string} camel Camel-case identifier\n * @return {string} Dash-case representation of the identifier\n */\nexport function camelToDashCase(camel) {\n  return caseMap[camel] || (caseMap[camel] = camel.replace(CAMEL_TO_DASH, '-$1').toLowerCase());\n}","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n/**\n * @fileoverview\n *\n * This module provides a number of strategies for enqueuing asynchronous\n * tasks. Each sub-module provides a standard `run(fn)` interface that returns a\n * handle, and a `cancel(handle)` interface for canceling async tasks before\n * they run.\n *\n * @summary Module that provides a number of strategies for enqueuing\n * asynchronous tasks.\n */\n\nimport './boot.js';\n\n// Microtask implemented using Mutation Observer\nlet microtaskCurrHandle = 0;\nlet microtaskLastHandle = 0;\nlet microtaskCallbacks = [];\nlet microtaskNodeContent = 0;\nlet microtaskScheduled = false;\nlet microtaskNode = document.createTextNode('');\nnew window.MutationObserver(microtaskFlush).observe(microtaskNode, {\n  characterData: true\n});\nfunction microtaskFlush() {\n  microtaskScheduled = false;\n  const len = microtaskCallbacks.length;\n  for (let i = 0; i < len; i++) {\n    let cb = microtaskCallbacks[i];\n    if (cb) {\n      try {\n        cb();\n      } catch (e) {\n        setTimeout(() => {\n          throw e;\n        });\n      }\n    }\n  }\n  microtaskCallbacks.splice(0, len);\n  microtaskLastHandle += len;\n}\n\n/**\n * Async interface wrapper around `setTimeout`.\n *\n * @namespace\n * @summary Async interface wrapper around `setTimeout`.\n */\nconst timeOut = {\n  /**\n   * Returns a sub-module with the async interface providing the provided\n   * delay.\n   *\n   * @memberof timeOut\n   * @param {number=} delay Time to wait before calling callbacks in ms\n   * @return {!AsyncInterface} An async timeout interface\n   */\n  after(delay) {\n    return {\n      run(fn) {\n        return window.setTimeout(fn, delay);\n      },\n      cancel(handle) {\n        window.clearTimeout(handle);\n      }\n    };\n  },\n  /**\n   * Enqueues a function called in the next task.\n   *\n   * @memberof timeOut\n   * @param {!Function} fn Callback to run\n   * @param {number=} delay Delay in milliseconds\n   * @return {number} Handle used for canceling task\n   */\n  run(fn, delay) {\n    return window.setTimeout(fn, delay);\n  },\n  /**\n   * Cancels a previously enqueued `timeOut` callback.\n   *\n   * @memberof timeOut\n   * @param {number} handle Handle returned from `run` of callback to cancel\n   * @return {void}\n   */\n  cancel(handle) {\n    window.clearTimeout(handle);\n  }\n};\nexport { timeOut };\n\n/**\n * Async interface wrapper around `requestAnimationFrame`.\n *\n * @namespace\n * @summary Async interface wrapper around `requestAnimationFrame`.\n */\nconst animationFrame = {\n  /**\n   * Enqueues a function called at `requestAnimationFrame` timing.\n   *\n   * @memberof animationFrame\n   * @param {function(number):void} fn Callback to run\n   * @return {number} Handle used for canceling task\n   */\n  run(fn) {\n    return window.requestAnimationFrame(fn);\n  },\n  /**\n   * Cancels a previously enqueued `animationFrame` callback.\n   *\n   * @memberof animationFrame\n   * @param {number} handle Handle returned from `run` of callback to cancel\n   * @return {void}\n   */\n  cancel(handle) {\n    window.cancelAnimationFrame(handle);\n  }\n};\nexport { animationFrame };\n\n/**\n * Async interface wrapper around `requestIdleCallback`.  Falls back to\n * `setTimeout` on browsers that do not support `requestIdleCallback`.\n *\n * @namespace\n * @summary Async interface wrapper around `requestIdleCallback`.\n */\nconst idlePeriod = {\n  /**\n   * Enqueues a function called at `requestIdleCallback` timing.\n   *\n   * @memberof idlePeriod\n   * @param {function(!IdleDeadline):void} fn Callback to run\n   * @return {number} Handle used for canceling task\n   */\n  run(fn) {\n    return window.requestIdleCallback ? window.requestIdleCallback(fn) : window.setTimeout(fn, 16);\n  },\n  /**\n   * Cancels a previously enqueued `idlePeriod` callback.\n   *\n   * @memberof idlePeriod\n   * @param {number} handle Handle returned from `run` of callback to cancel\n   * @return {void}\n   */\n  cancel(handle) {\n    window.cancelIdleCallback ? window.cancelIdleCallback(handle) : window.clearTimeout(handle);\n  }\n};\nexport { idlePeriod };\n\n/**\n * Async interface for enqueuing callbacks that run at microtask timing.\n *\n * Note that microtask timing is achieved via a single `MutationObserver`,\n * and thus callbacks enqueued with this API will all run in a single\n * batch, and not interleaved with other microtasks such as promises.\n * Promises are avoided as an implementation choice for the time being\n * due to Safari bugs that cause Promises to lack microtask guarantees.\n *\n * @namespace\n * @summary Async interface for enqueuing callbacks that run at microtask\n *   timing.\n */\nconst microTask = {\n  /**\n   * Enqueues a function called at microtask timing.\n   *\n   * @memberof microTask\n   * @param {!Function=} callback Callback to run\n   * @return {number} Handle used for canceling task\n   */\n  run(callback) {\n    if (!microtaskScheduled) {\n      microtaskScheduled = true;\n      microtaskNode.textContent = microtaskNodeContent++;\n    }\n    microtaskCallbacks.push(callback);\n    return microtaskCurrHandle++;\n  },\n  /**\n   * Cancels a previously enqueued `microTask` callback.\n   *\n   * @memberof microTask\n   * @param {number} handle Handle returned from `run` of callback to cancel\n   * @return {void}\n   */\n  cancel(handle) {\n    const idx = handle - microtaskLastHandle;\n    if (idx >= 0) {\n      if (!microtaskCallbacks[idx]) {\n        throw new Error('invalid async handle: ' + handle);\n      }\n      microtaskCallbacks[idx] = null;\n    }\n  }\n};\nexport { microTask };","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport '../utils/boot.js';\nimport { dedupingMixin } from '../utils/mixin.js';\nimport { microTask } from '../utils/async.js';\nimport { wrap } from '../utils/wrap.js';\n\n/** @const {!AsyncInterface} */\nconst microtask = microTask;\n\n/**\n * Element class mixin that provides basic meta-programming for creating one\n * or more property accessors (getter/setter pair) that enqueue an async\n * (batched) `_propertiesChanged` callback.\n *\n * For basic usage of this mixin, call `MyClass.createProperties(props)`\n * once at class definition time to create property accessors for properties\n * named in props, implement `_propertiesChanged` to react as desired to\n * property changes, and implement `static get observedAttributes()` and\n * include lowercase versions of any property names that should be set from\n * attributes. Last, call `this._enableProperties()` in the element's\n * `connectedCallback` to enable the accessors.\n *\n * @mixinFunction\n * @polymer\n * @summary Element class mixin for reacting to property changes from\n *   generated property accessors.\n * @template T\n * @param {function(new:T)} superClass Class to apply mixin to.\n * @return {function(new:T)} superClass with mixin applied.\n */\nexport const PropertiesChanged = dedupingMixin(\n/**\n * @template T\n * @param {function(new:T)} superClass Class to apply mixin to.\n * @return {function(new:T)} superClass with mixin applied.\n */\nsuperClass => {\n  /**\n   * @polymer\n   * @mixinClass\n   * @implements {Polymer_PropertiesChanged}\n   * @unrestricted\n   */\n  class PropertiesChanged extends superClass {\n    /**\n     * Creates property accessors for the given property names.\n     * @param {!Object} props Object whose keys are names of accessors.\n     * @return {void}\n     * @protected\n     * @nocollapse\n     */\n    static createProperties(props) {\n      const proto = this.prototype;\n      for (let prop in props) {\n        // don't stomp an existing accessor\n        if (!(prop in proto)) {\n          proto._createPropertyAccessor(prop);\n        }\n      }\n    }\n\n    /**\n     * Returns an attribute name that corresponds to the given property.\n     * The attribute name is the lowercased property name. Override to\n     * customize this mapping.\n     * @param {string} property Property to convert\n     * @return {string} Attribute name corresponding to the given property.\n     *\n     * @protected\n     * @nocollapse\n     */\n    static attributeNameForProperty(property) {\n      return property.toLowerCase();\n    }\n\n    /**\n     * Override point to provide a type to which to deserialize a value to\n     * a given property.\n     * @param {string} name Name of property\n     *\n     * @protected\n     * @nocollapse\n     */\n    static typeForProperty(name) {} //eslint-disable-line no-unused-vars\n\n    /**\n     * Creates a setter/getter pair for the named property with its own\n     * local storage.  The getter returns the value in the local storage,\n     * and the setter calls `_setProperty`, which updates the local storage\n     * for the property and enqueues a `_propertiesChanged` callback.\n     *\n     * This method may be called on a prototype or an instance.  Calling\n     * this method may overwrite a property value that already exists on\n     * the prototype/instance by creating the accessor.\n     *\n     * @param {string} property Name of the property\n     * @param {boolean=} readOnly When true, no setter is created; the\n     *   protected `_setProperty` function must be used to set the property\n     * @return {void}\n     * @protected\n     * @override\n     */\n    _createPropertyAccessor(property, readOnly) {\n      this._addPropertyToAttributeMap(property);\n      if (!this.hasOwnProperty(JSCompiler_renameProperty('__dataHasAccessor', this))) {\n        this.__dataHasAccessor = Object.assign({}, this.__dataHasAccessor);\n      }\n      if (!this.__dataHasAccessor[property]) {\n        this.__dataHasAccessor[property] = true;\n        this._definePropertyAccessor(property, readOnly);\n      }\n    }\n\n    /**\n     * Adds the given `property` to a map matching attribute names\n     * to property names, using `attributeNameForProperty`. This map is\n     * used when deserializing attribute values to properties.\n     *\n     * @param {string} property Name of the property\n     * @override\n     */\n    _addPropertyToAttributeMap(property) {\n      if (!this.hasOwnProperty(JSCompiler_renameProperty('__dataAttributes', this))) {\n        this.__dataAttributes = Object.assign({}, this.__dataAttributes);\n      }\n      // This check is technically not correct; it's an optimization that\n      // assumes that if a _property_ name is already in the map (note this is\n      // an attr->property map), the property mapped directly to the attribute\n      // and it has already been mapped.  This would fail if\n      // `attributeNameForProperty` were overridden such that this was not the\n      // case.\n      let attr = this.__dataAttributes[property];\n      if (!attr) {\n        attr = this.constructor.attributeNameForProperty(property);\n        this.__dataAttributes[attr] = property;\n      }\n      return attr;\n    }\n\n    /**\n     * Defines a property accessor for the given property.\n     * @param {string} property Name of the property\n     * @param {boolean=} readOnly When true, no setter is created\n     * @return {void}\n     * @override\n     */\n    _definePropertyAccessor(property, readOnly) {\n      Object.defineProperty(this, property, {\n        /* eslint-disable valid-jsdoc */\n        /** @this {PropertiesChanged} */\n        get() {\n          // Inline for perf instead of using `_getProperty`\n          return this.__data[property];\n        },\n        /** @this {PropertiesChanged} */\n        set: readOnly ? function () {} : function (value) {\n          // Inline for perf instead of using `_setProperty`\n          if (this._setPendingProperty(property, value, true)) {\n            this._invalidateProperties();\n          }\n        }\n        /* eslint-enable */\n      });\n    }\n    constructor() {\n      super();\n      /** @type {boolean} */\n      this.__dataEnabled = false;\n      this.__dataReady = false;\n      this.__dataInvalid = false;\n      this.__data = {};\n      this.__dataPending = null;\n      this.__dataOld = null;\n      this.__dataInstanceProps = null;\n      /** @type {number} */\n      // NOTE: used to track re-entrant calls to `_flushProperties`\n      this.__dataCounter = 0;\n      this.__serializing = false;\n      this._initializeProperties();\n    }\n\n    /**\n     * Lifecycle callback called when properties are enabled via\n     * `_enableProperties`.\n     *\n     * Users may override this function to implement behavior that is\n     * dependent on the element having its property data initialized, e.g.\n     * from defaults (initialized from `constructor`, `_initializeProperties`),\n     * `attributeChangedCallback`, or values propagated from host e.g. via\n     * bindings.  `super.ready()` must be called to ensure the data system\n     * becomes enabled.\n     *\n     * @return {void}\n     * @public\n     * @override\n     */\n    ready() {\n      this.__dataReady = true;\n      this._flushProperties();\n    }\n\n    /**\n     * Initializes the local storage for property accessors.\n     *\n     * Provided as an override point for performing any setup work prior\n     * to initializing the property accessor system.\n     *\n     * @return {void}\n     * @protected\n     * @override\n     */\n    _initializeProperties() {\n      // Capture instance properties; these will be set into accessors\n      // during first flush. Don't set them here, since we want\n      // these to overwrite defaults/constructor assignments\n      for (let p in this.__dataHasAccessor) {\n        if (this.hasOwnProperty(p)) {\n          this.__dataInstanceProps = this.__dataInstanceProps || {};\n          this.__dataInstanceProps[p] = this[p];\n          delete this[p];\n        }\n      }\n    }\n\n    /**\n     * Called at ready time with bag of instance properties that overwrote\n     * accessors when the element upgraded.\n     *\n     * The default implementation sets these properties back into the\n     * setter at ready time.  This method is provided as an override\n     * point for customizing or providing more efficient initialization.\n     *\n     * @param {Object} props Bag of property values that were overwritten\n     *   when creating property accessors.\n     * @return {void}\n     * @protected\n     * @override\n     */\n    _initializeInstanceProperties(props) {\n      Object.assign(this, props);\n    }\n\n    /**\n     * Updates the local storage for a property (via `_setPendingProperty`)\n     * and enqueues a `_proeprtiesChanged` callback.\n     *\n     * @param {string} property Name of the property\n     * @param {*} value Value to set\n     * @return {void}\n     * @protected\n     * @override\n     */\n    _setProperty(property, value) {\n      if (this._setPendingProperty(property, value)) {\n        this._invalidateProperties();\n      }\n    }\n\n    /**\n     * Returns the value for the given property.\n     * @param {string} property Name of property\n     * @return {*} Value for the given property\n     * @protected\n     * @override\n     */\n    _getProperty(property) {\n      return this.__data[property];\n    }\n\n    /* eslint-disable no-unused-vars */\n    /**\n     * Updates the local storage for a property, records the previous value,\n     * and adds it to the set of \"pending changes\" that will be passed to the\n     * `_propertiesChanged` callback.  This method does not enqueue the\n     * `_propertiesChanged` callback.\n     *\n     * @param {string} property Name of the property\n     * @param {*} value Value to set\n     * @param {boolean=} ext Not used here; affordance for closure\n     * @return {boolean} Returns true if the property changed\n     * @protected\n     * @override\n     */\n    _setPendingProperty(property, value, ext) {\n      let old = this.__data[property];\n      let changed = this._shouldPropertyChange(property, value, old);\n      if (changed) {\n        if (!this.__dataPending) {\n          this.__dataPending = {};\n          this.__dataOld = {};\n        }\n        // Ensure old is captured from the last turn\n        if (this.__dataOld && !(property in this.__dataOld)) {\n          this.__dataOld[property] = old;\n        }\n        this.__data[property] = value;\n        this.__dataPending[property] = value;\n      }\n      return changed;\n    }\n    /* eslint-enable */\n\n    /**\n     * @param {string} property Name of the property\n     * @return {boolean} Returns true if the property is pending.\n     */\n    _isPropertyPending(property) {\n      return !!(this.__dataPending && this.__dataPending.hasOwnProperty(property));\n    }\n\n    /**\n     * Marks the properties as invalid, and enqueues an async\n     * `_propertiesChanged` callback.\n     *\n     * @return {void}\n     * @protected\n     * @override\n     */\n    _invalidateProperties() {\n      if (!this.__dataInvalid && this.__dataReady) {\n        this.__dataInvalid = true;\n        microtask.run(() => {\n          if (this.__dataInvalid) {\n            this.__dataInvalid = false;\n            this._flushProperties();\n          }\n        });\n      }\n    }\n\n    /**\n     * Call to enable property accessor processing. Before this method is\n     * called accessor values will be set but side effects are\n     * queued. When called, any pending side effects occur immediately.\n     * For elements, generally `connectedCallback` is a normal spot to do so.\n     * It is safe to call this method multiple times as it only turns on\n     * property accessors once.\n     *\n     * @return {void}\n     * @protected\n     * @override\n     */\n    _enableProperties() {\n      if (!this.__dataEnabled) {\n        this.__dataEnabled = true;\n        if (this.__dataInstanceProps) {\n          this._initializeInstanceProperties(this.__dataInstanceProps);\n          this.__dataInstanceProps = null;\n        }\n        this.ready();\n      }\n    }\n\n    /**\n     * Calls the `_propertiesChanged` callback with the current set of\n     * pending changes (and old values recorded when pending changes were\n     * set), and resets the pending set of changes. Generally, this method\n     * should not be called in user code.\n     *\n     * @return {void}\n     * @protected\n     * @override\n     */\n    _flushProperties() {\n      this.__dataCounter++;\n      const props = this.__data;\n      const changedProps = this.__dataPending;\n      const old = this.__dataOld;\n      if (this._shouldPropertiesChange(props, changedProps, old)) {\n        this.__dataPending = null;\n        this.__dataOld = null;\n        this._propertiesChanged(props, changedProps, old);\n      }\n      this.__dataCounter--;\n    }\n\n    /**\n     * Called in `_flushProperties` to determine if `_propertiesChanged`\n     * should be called. The default implementation returns true if\n     * properties are pending. Override to customize when\n     * `_propertiesChanged` is called.\n     * @param {!Object} currentProps Bag of all current accessor values\n     * @param {?Object} changedProps Bag of properties changed since the last\n     *   call to `_propertiesChanged`\n     * @param {?Object} oldProps Bag of previous values for each property\n     *   in `changedProps`\n     * @return {boolean} true if changedProps is truthy\n     * @override\n     */\n    _shouldPropertiesChange(currentProps, changedProps, oldProps) {\n      // eslint-disable-line no-unused-vars\n      return Boolean(changedProps);\n    }\n\n    /**\n     * Callback called when any properties with accessors created via\n     * `_createPropertyAccessor` have been set.\n     *\n     * @param {!Object} currentProps Bag of all current accessor values\n     * @param {?Object} changedProps Bag of properties changed since the last\n     *   call to `_propertiesChanged`\n     * @param {?Object} oldProps Bag of previous values for each property\n     *   in `changedProps`\n     * @return {void}\n     * @protected\n     * @override\n     */\n    _propertiesChanged(currentProps, changedProps, oldProps) {// eslint-disable-line no-unused-vars\n    }\n\n    /**\n     * Method called to determine whether a property value should be\n     * considered as a change and cause the `_propertiesChanged` callback\n     * to be enqueued.\n     *\n     * The default implementation returns `true` if a strict equality\n     * check fails. The method always returns false for `NaN`.\n     *\n     * Override this method to e.g. provide stricter checking for\n     * Objects/Arrays when using immutable patterns.\n     *\n     * @param {string} property Property name\n     * @param {*} value New property value\n     * @param {*} old Previous property value\n     * @return {boolean} Whether the property should be considered a change\n     *   and enqueue a `_proeprtiesChanged` callback\n     * @protected\n     * @override\n     */\n    _shouldPropertyChange(property, value, old) {\n      return (\n        // Strict equality check\n        old !== value && (\n        // This ensures (old==NaN, value==NaN) always returns false\n        old === old || value === value)\n      );\n    }\n\n    /**\n     * Implements native Custom Elements `attributeChangedCallback` to\n     * set an attribute value to a property via `_attributeToProperty`.\n     *\n     * @param {string} name Name of attribute that changed\n     * @param {?string} old Old attribute value\n     * @param {?string} value New attribute value\n     * @param {?string} namespace Attribute namespace.\n     * @return {void}\n     * @suppress {missingProperties} Super may or may not implement the callback\n     * @override\n     */\n    attributeChangedCallback(name, old, value, namespace) {\n      if (old !== value) {\n        this._attributeToProperty(name, value);\n      }\n      if (super.attributeChangedCallback) {\n        super.attributeChangedCallback(name, old, value, namespace);\n      }\n    }\n\n    /**\n     * Deserializes an attribute to its associated property.\n     *\n     * This method calls the `_deserializeValue` method to convert the string to\n     * a typed value.\n     *\n     * @param {string} attribute Name of attribute to deserialize.\n     * @param {?string} value of the attribute.\n     * @param {*=} type type to deserialize to, defaults to the value\n     * returned from `typeForProperty`\n     * @return {void}\n     * @override\n     */\n    _attributeToProperty(attribute, value, type) {\n      if (!this.__serializing) {\n        const map = this.__dataAttributes;\n        const property = map && map[attribute] || attribute;\n        this[property] = this._deserializeValue(value, type || this.constructor.typeForProperty(property));\n      }\n    }\n\n    /**\n     * Serializes a property to its associated attribute.\n     *\n     * @suppress {invalidCasts} Closure can't figure out `this` is an element.\n     *\n     * @param {string} property Property name to reflect.\n     * @param {string=} attribute Attribute name to reflect to.\n     * @param {*=} value Property value to refect.\n     * @return {void}\n     * @override\n     */\n    _propertyToAttribute(property, attribute, value) {\n      this.__serializing = true;\n      value = arguments.length < 3 ? this[property] : value;\n      this._valueToNodeAttribute(/** @type {!HTMLElement} */this, value, attribute || this.constructor.attributeNameForProperty(property));\n      this.__serializing = false;\n    }\n\n    /**\n     * Sets a typed value to an HTML attribute on a node.\n     *\n     * This method calls the `_serializeValue` method to convert the typed\n     * value to a string.  If the `_serializeValue` method returns `undefined`,\n     * the attribute will be removed (this is the default for boolean\n     * type `false`).\n     *\n     * @param {Element} node Element to set attribute to.\n     * @param {*} value Value to serialize.\n     * @param {string} attribute Attribute name to serialize to.\n     * @return {void}\n     * @override\n     */\n    _valueToNodeAttribute(node, value, attribute) {\n      const str = this._serializeValue(value);\n      if (attribute === 'class' || attribute === 'name' || attribute === 'slot') {\n        node = /** @type {?Element} */wrap(node);\n      }\n      if (str === undefined) {\n        node.removeAttribute(attribute);\n      } else {\n        node.setAttribute(attribute,\n        // Closure's type for `setAttribute`'s second parameter incorrectly\n        // excludes `TrustedScript`.\n        str === '' && window.trustedTypes ? (/** @type {?} */window.trustedTypes.emptyScript) : str);\n      }\n    }\n\n    /**\n     * Converts a typed JavaScript value to a string.\n     *\n     * This method is called when setting JS property values to\n     * HTML attributes.  Users may override this method to provide\n     * serialization for custom types.\n     *\n     * @param {*} value Property value to serialize.\n     * @return {string | undefined} String serialized from the provided\n     * property  value.\n     * @override\n     */\n    _serializeValue(value) {\n      switch (typeof value) {\n        case 'boolean':\n          return value ? '' : undefined;\n        default:\n          return value != null ? value.toString() : undefined;\n      }\n    }\n\n    /**\n     * Converts a string to a typed JavaScript value.\n     *\n     * This method is called when reading HTML attribute values to\n     * JS properties.  Users may override this method to provide\n     * deserialization for custom `type`s. Types for `Boolean`, `String`,\n     * and `Number` convert attributes to the expected types.\n     *\n     * @param {?string} value Value to deserialize.\n     * @param {*=} type Type to deserialize the string to.\n     * @return {*} Typed value deserialized from the provided string.\n     * @override\n     */\n    _deserializeValue(value, type) {\n      switch (type) {\n        case Boolean:\n          return value !== null;\n        case Number:\n          return Number(value);\n        default:\n          return value;\n      }\n    }\n  }\n  return PropertiesChanged;\n});","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport '../utils/boot.js';\nimport { dedupingMixin } from '../utils/mixin.js';\nimport { camelToDashCase, dashToCamelCase } from '../utils/case-map.js';\nimport { PropertiesChanged } from './properties-changed.js';\n\n// Save map of native properties; this forms a blacklist or properties\n// that won't have their values \"saved\" by `saveAccessorValue`, since\n// reading from an HTMLElement accessor from the context of a prototype throws\nconst nativeProperties = {};\nlet proto = HTMLElement.prototype;\nwhile (proto) {\n  let props = Object.getOwnPropertyNames(proto);\n  for (let i = 0; i < props.length; i++) {\n    nativeProperties[props[i]] = true;\n  }\n  proto = Object.getPrototypeOf(proto);\n}\nconst isTrustedType = (() => {\n  if (!window.trustedTypes) {\n    return () => false;\n  }\n  return val => trustedTypes.isHTML(val) || trustedTypes.isScript(val) || trustedTypes.isScriptURL(val);\n})();\n\n/**\n * Used to save the value of a property that will be overridden with\n * an accessor. If the `model` is a prototype, the values will be saved\n * in `__dataProto`, and it's up to the user (or downstream mixin) to\n * decide how/when to set these values back into the accessors.\n * If `model` is already an instance (it has a `__data` property), then\n * the value will be set as a pending property, meaning the user should\n * call `_invalidateProperties` or `_flushProperties` to take effect\n *\n * @param {Object} model Prototype or instance\n * @param {string} property Name of property\n * @return {void}\n * @private\n */\nfunction saveAccessorValue(model, property) {\n  // Don't read/store value for any native properties since they could throw\n  if (!nativeProperties[property]) {\n    let value = model[property];\n    if (value !== undefined) {\n      if (model.__data) {\n        // Adding accessor to instance; update the property\n        // It is the user's responsibility to call _flushProperties\n        model._setPendingProperty(property, value);\n      } else {\n        // Adding accessor to proto; save proto's value for instance-time use\n        if (!model.__dataProto) {\n          model.__dataProto = {};\n        } else if (!model.hasOwnProperty(JSCompiler_renameProperty('__dataProto', model))) {\n          model.__dataProto = Object.create(model.__dataProto);\n        }\n        model.__dataProto[property] = value;\n      }\n    }\n  }\n}\n\n/**\n * Element class mixin that provides basic meta-programming for creating one\n * or more property accessors (getter/setter pair) that enqueue an async\n * (batched) `_propertiesChanged` callback.\n *\n * For basic usage of this mixin:\n *\n * -   Declare attributes to observe via the standard `static get\n *     observedAttributes()`. Use `dash-case` attribute names to represent\n *     `camelCase` property names.\n * -   Implement the `_propertiesChanged` callback on the class.\n * -   Call `MyClass.createPropertiesForAttributes()` **once** on the class to\n *     generate property accessors for each observed attribute. This must be\n *     called before the first instance is created, for example, by calling it\n *     before calling `customElements.define`. It can also be called lazily from\n *     the element's `constructor`, as long as it's guarded so that the call is\n *     only made once, when the first instance is created.\n * -   Call `this._enableProperties()` in the element's `connectedCallback` to\n *     enable the accessors.\n *\n * Any `observedAttributes` will automatically be\n * deserialized via `attributeChangedCallback` and set to the associated\n * property using `dash-case`-to-`camelCase` convention.\n *\n * @mixinFunction\n * @polymer\n * @appliesMixin PropertiesChanged\n * @summary Element class mixin for reacting to property changes from\n *   generated property accessors.\n * @template T\n * @param {function(new:T)} superClass Class to apply mixin to.\n * @return {function(new:T)} superClass with mixin applied.\n */\nexport const PropertyAccessors = dedupingMixin(superClass => {\n  /**\n   * @constructor\n   * @implements {Polymer_PropertiesChanged}\n   * @unrestricted\n   * @private\n   */\n  const base = PropertiesChanged(superClass);\n\n  /**\n   * @polymer\n   * @mixinClass\n   * @implements {Polymer_PropertyAccessors}\n   * @extends {base}\n   * @unrestricted\n   */\n  class PropertyAccessors extends base {\n    /**\n     * Generates property accessors for all attributes in the standard\n     * static `observedAttributes` array.\n     *\n     * Attribute names are mapped to property names using the `dash-case` to\n     * `camelCase` convention\n     *\n     * @return {void}\n     * @nocollapse\n     */\n    static createPropertiesForAttributes() {\n      let a$ = /** @type {?} */this.observedAttributes;\n      for (let i = 0; i < a$.length; i++) {\n        this.prototype._createPropertyAccessor(dashToCamelCase(a$[i]));\n      }\n    }\n\n    /**\n     * Returns an attribute name that corresponds to the given property.\n     * By default, converts camel to dash case, e.g. `fooBar` to `foo-bar`.\n     * @param {string} property Property to convert\n     * @return {string} Attribute name corresponding to the given property.\n     *\n     * @protected\n     * @nocollapse\n     */\n    static attributeNameForProperty(property) {\n      return camelToDashCase(property);\n    }\n\n    /**\n     * Overrides PropertiesChanged implementation to initialize values for\n     * accessors created for values that already existed on the element\n     * prototype.\n     *\n     * @return {void}\n     * @protected\n     * @override\n     */\n    _initializeProperties() {\n      if (this.__dataProto) {\n        this._initializeProtoProperties(this.__dataProto);\n        this.__dataProto = null;\n      }\n      super._initializeProperties();\n    }\n\n    /**\n     * Called at instance time with bag of properties that were overwritten\n     * by accessors on the prototype when accessors were created.\n     *\n     * The default implementation sets these properties back into the\n     * setter at instance time.  This method is provided as an override\n     * point for customizing or providing more efficient initialization.\n     *\n     * @param {Object} props Bag of property values that were overwritten\n     *   when creating property accessors.\n     * @return {void}\n     * @protected\n     * @override\n     */\n    _initializeProtoProperties(props) {\n      for (let p in props) {\n        this._setProperty(p, props[p]);\n      }\n    }\n\n    /**\n     * Ensures the element has the given attribute. If it does not,\n     * assigns the given value to the attribute.\n     *\n     * @suppress {invalidCasts} Closure can't figure out `this` is infact an\n     *     element\n     *\n     * @param {string} attribute Name of attribute to ensure is set.\n     * @param {string} value of the attribute.\n     * @return {void}\n     * @override\n     */\n    _ensureAttribute(attribute, value) {\n      const el = /** @type {!HTMLElement} */this;\n      if (!el.hasAttribute(attribute)) {\n        this._valueToNodeAttribute(el, value, attribute);\n      }\n    }\n\n    /**\n     * Overrides PropertiesChanged implemention to serialize objects as JSON.\n     *\n     * @param {*} value Property value to serialize.\n     * @return {string | undefined} String serialized from the provided property\n     *     value.\n     * @override\n     */\n    _serializeValue(value) {\n      /* eslint-disable no-fallthrough */\n      switch (typeof value) {\n        case 'object':\n          if (value instanceof Date) {\n            return value.toString();\n          } else if (value) {\n            if (isTrustedType(value)) {\n              /**\n               * Here `value` isn't actually a string, but it should be\n               * passed into APIs that normally expect a string, like\n               * elem.setAttribute.\n               */\n              return /** @type {?} */value;\n            }\n            try {\n              return JSON.stringify(value);\n            } catch (x) {\n              return '';\n            }\n          }\n        default:\n          return super._serializeValue(value);\n      }\n    }\n\n    /**\n     * Converts a string to a typed JavaScript value.\n     *\n     * This method is called by Polymer when reading HTML attribute values to\n     * JS properties.  Users may override this method on Polymer element\n     * prototypes to provide deserialization for custom `type`s.  Note,\n     * the `type` argument is the value of the `type` field provided in the\n     * `properties` configuration object for a given property, and is\n     * by convention the constructor for the type to deserialize.\n     *\n     *\n     * @param {?string} value Attribute value to deserialize.\n     * @param {*=} type Type to deserialize the string to.\n     * @return {*} Typed value deserialized from the provided string.\n     * @override\n     */\n    _deserializeValue(value, type) {\n      /**\n       * @type {*}\n       */\n      let outValue;\n      switch (type) {\n        case Object:\n          try {\n            outValue = JSON.parse(/** @type {string} */value);\n          } catch (x) {\n            // allow non-JSON literals like Strings and Numbers\n            outValue = value;\n          }\n          break;\n        case Array:\n          try {\n            outValue = JSON.parse(/** @type {string} */value);\n          } catch (x) {\n            outValue = null;\n            console.warn(`Polymer::Attributes: couldn't decode Array as JSON: ${value}`);\n          }\n          break;\n        case Date:\n          outValue = isNaN(value) ? String(value) : Number(value);\n          outValue = new Date(outValue);\n          break;\n        default:\n          outValue = super._deserializeValue(value, type);\n          break;\n      }\n      return outValue;\n    }\n    /* eslint-enable no-fallthrough */\n\n    /**\n     * Overrides PropertiesChanged implementation to save existing prototype\n     * property value so that it can be reset.\n     * @param {string} property Name of the property\n     * @param {boolean=} readOnly When true, no setter is created\n     *\n     * When calling on a prototype, any overwritten values are saved in\n     * `__dataProto`, and it is up to the subclasser to decide how/when\n     * to set those properties back into the accessor.  When calling on an\n     * instance, the overwritten value is set via `_setPendingProperty`,\n     * and the user should call `_invalidateProperties` or `_flushProperties`\n     * for the values to take effect.\n     * @protected\n     * @return {void}\n     * @override\n     */\n    _definePropertyAccessor(property, readOnly) {\n      saveAccessorValue(this, property);\n      super._definePropertyAccessor(property, readOnly);\n    }\n\n    /**\n     * Returns true if this library created an accessor for the given property.\n     *\n     * @param {string} property Property name\n     * @return {boolean} True if an accessor was created\n     * @override\n     */\n    _hasAccessor(property) {\n      return this.__dataHasAccessor && this.__dataHasAccessor[property];\n    }\n\n    /**\n     * Returns true if the specified property has a pending change.\n     *\n     * @param {string} prop Property name\n     * @return {boolean} True if property has a pending change\n     * @protected\n     * @override\n     */\n    _isPropertyPending(prop) {\n      return Boolean(this.__dataPending && prop in this.__dataPending);\n    }\n  }\n  return PropertyAccessors;\n});","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport '../utils/boot.js';\nimport { dedupingMixin } from '../utils/mixin.js';\n\n// 1.x backwards-compatible auto-wrapper for template type extensions\n// This is a clear layering violation and gives favored-nation status to\n// dom-if and dom-repeat templates.  This is a conceit we're choosing to keep\n// a.) to ease 1.x backwards-compatibility due to loss of `is`, and\n// b.) to maintain if/repeat capability in parser-constrained elements\n//     (e.g. table, select) in lieu of native CE type extensions without\n//     massive new invention in this space (e.g. directive system)\nconst templateExtensions = {\n  'dom-if': true,\n  'dom-repeat': true\n};\nlet placeholderBugDetect = false;\nlet placeholderBug = false;\nfunction hasPlaceholderBug() {\n  if (!placeholderBugDetect) {\n    placeholderBugDetect = true;\n    const t = document.createElement('textarea');\n    t.placeholder = 'a';\n    placeholderBug = t.placeholder === t.textContent;\n  }\n  return placeholderBug;\n}\n\n/**\n * Some browsers have a bug with textarea, where placeholder text is copied as\n * a textnode child of the textarea.\n *\n * If the placeholder is a binding, this can break template stamping in two\n * ways.\n *\n * One issue is that when the `placeholder` attribute is removed when the\n * binding is processed, the textnode child of the textarea is deleted, and the\n * template info tries to bind into that node.\n *\n * With `legacyOptimizations` in use, when the template is stamped and the\n * `textarea.textContent` binding is processed, no corresponding node is found\n * because it was removed during parsing. An exception is generated when this\n * binding is updated.\n *\n * With `legacyOptimizations` not in use, the template is cloned before\n * processing and this changes the above behavior. The cloned template also has\n * a value property set to the placeholder and textContent. This prevents the\n * removal of the textContent when the placeholder attribute is removed.\n * Therefore the exception does not occur. However, there is an extra\n * unnecessary binding.\n *\n * @param {!Node} node Check node for placeholder bug\n * @return {void}\n */\nfunction fixPlaceholder(node) {\n  if (hasPlaceholderBug() && node.localName === 'textarea' && node.placeholder && node.placeholder === node.textContent) {\n    node.textContent = null;\n  }\n}\n\n/**\n * Copies an attribute from one element to another, converting the value to a\n * `TrustedScript` if it is named like a Polymer template event listener.\n *\n * @param {!Element} dest The element to set the attribute on\n * @param {!Element} src The element to read the attribute from\n * @param {string} name The name of the attribute\n */\nconst copyAttributeWithTemplateEventPolicy = (() => {\n  /**\n   * This `TrustedTypePolicy` is used to work around a Chrome bug in the Trusted\n   * Types API where any attribute that starts with `on` may only be set to a\n   * `TrustedScript` value, even if that attribute would not cause an event\n   * listener to be created. (See https://crbug.com/993268 for details.)\n   *\n   * Polymer's template system allows `<dom-if>` and `<dom-repeat>` to be\n   * written using the `<template is=\"...\">` syntax, even if there is no UA\n   * support for custom element extensions of built-in elements. In doing so, it\n   * copies attributes from the original `<template>` to a newly created\n   * `<dom-if>` or `<dom-repeat>`, which can trigger the bug mentioned above if\n   * any of those attributes uses Polymer's `on-` syntax for event listeners.\n   * (Note, the value of these `on-` listeners is not evaluated as script: it is\n   * the name of a member function of a component that will be used as the event\n   * listener.)\n   *\n   * @type {!TrustedTypePolicy|undefined}\n   */\n  const polymerTemplateEventAttributePolicy = window.trustedTypes && window.trustedTypes.createPolicy('polymer-template-event-attribute-policy', {\n    createScript: x => x\n  });\n  return (dest, src, name) => {\n    const value = src.getAttribute(name);\n    if (polymerTemplateEventAttributePolicy && name.startsWith('on-')) {\n      dest.setAttribute(name, polymerTemplateEventAttributePolicy.createScript(value, name));\n      return;\n    }\n    dest.setAttribute(name, value);\n  };\n})();\nfunction wrapTemplateExtension(node) {\n  let is = node.getAttribute('is');\n  if (is && templateExtensions[is]) {\n    let t = node;\n    t.removeAttribute('is');\n    node = t.ownerDocument.createElement(is);\n    t.parentNode.replaceChild(node, t);\n    node.appendChild(t);\n    while (t.attributes.length) {\n      const name = t.attributes[0].name;\n      copyAttributeWithTemplateEventPolicy(node, t, name);\n      t.removeAttribute(name);\n    }\n  }\n  return node;\n}\nfunction findTemplateNode(root, nodeInfo) {\n  // recursively ascend tree until we hit root\n  let parent = nodeInfo.parentInfo && findTemplateNode(root, nodeInfo.parentInfo);\n  // unwind the stack, returning the indexed node at each level\n  if (parent) {\n    // note: marginally faster than indexing via childNodes\n    // (http://jsperf.com/childnodes-lookup)\n    for (let n = parent.firstChild, i = 0; n; n = n.nextSibling) {\n      if (nodeInfo.parentIndex === i++) {\n        return n;\n      }\n    }\n  } else {\n    return root;\n  }\n}\n\n// construct `$` map (from id annotations)\nfunction applyIdToMap(inst, map, node, nodeInfo) {\n  if (nodeInfo.id) {\n    map[nodeInfo.id] = node;\n  }\n}\n\n// install event listeners (from event annotations)\nfunction applyEventListener(inst, node, nodeInfo) {\n  if (nodeInfo.events && nodeInfo.events.length) {\n    for (let j = 0, e$ = nodeInfo.events, e; j < e$.length && (e = e$[j]); j++) {\n      inst._addMethodEventListenerToNode(node, e.name, e.value, inst);\n    }\n  }\n}\n\n// push configuration references at configure time\nfunction applyTemplateInfo(inst, node, nodeInfo, parentTemplateInfo) {\n  if (nodeInfo.templateInfo) {\n    // Give the node an instance of this templateInfo and set its parent\n    node._templateInfo = nodeInfo.templateInfo;\n    node._parentTemplateInfo = parentTemplateInfo;\n  }\n}\nfunction createNodeEventHandler(context, eventName, methodName) {\n  // Instances can optionally have a _methodHost which allows redirecting where\n  // to find methods. Currently used by `templatize`.\n  context = context._methodHost || context;\n  let handler = function (e) {\n    if (context[methodName]) {\n      context[methodName](e, e.detail);\n    } else {\n      console.warn('listener method `' + methodName + '` not defined');\n    }\n  };\n  return handler;\n}\n\n/**\n * Element mixin that provides basic template parsing and stamping, including\n * the following template-related features for stamped templates:\n *\n * - Declarative event listeners (`on-eventname=\"listener\"`)\n * - Map of node id's to stamped node instances (`this.$.id`)\n * - Nested template content caching/removal and re-installation (performance\n *   optimization)\n *\n * @mixinFunction\n * @polymer\n * @summary Element class mixin that provides basic template parsing and stamping\n */\nexport const TemplateStamp = dedupingMixin(\n/**\n * @template T\n * @param {function(new:T)} superClass Class to apply mixin to.\n * @return {function(new:T)} superClass with mixin applied.\n */\nsuperClass => {\n  /**\n   * @polymer\n   * @mixinClass\n   * @implements {Polymer_TemplateStamp}\n   */\n  class TemplateStamp extends superClass {\n    /**\n     * Scans a template to produce template metadata.\n     *\n     * Template-specific metadata are stored in the object returned, and node-\n     * specific metadata are stored in objects in its flattened `nodeInfoList`\n     * array.  Only nodes in the template that were parsed as nodes of\n     * interest contain an object in `nodeInfoList`.  Each `nodeInfo` object\n     * contains an `index` (`childNodes` index in parent) and optionally\n     * `parent`, which points to node info of its parent (including its index).\n     *\n     * The template metadata object returned from this method has the following\n     * structure (many fields optional):\n     *\n     * ```js\n     *   {\n     *     // Flattened list of node metadata (for nodes that generated metadata)\n     *     nodeInfoList: [\n     *       {\n     *         // `id` attribute for any nodes with id's for generating `$` map\n     *         id: {string},\n     *         // `on-event=\"handler\"` metadata\n     *         events: [\n     *           {\n     *             name: {string},   // event name\n     *             value: {string},  // handler method name\n     *           }, ...\n     *         ],\n     *         // Notes when the template contained a `<slot>` for shady DOM\n     *         // optimization purposes\n     *         hasInsertionPoint: {boolean},\n     *         // For nested `<template>`` nodes, nested template metadata\n     *         templateInfo: {object}, // nested template metadata\n     *         // Metadata to allow efficient retrieval of instanced node\n     *         // corresponding to this metadata\n     *         parentInfo: {number},   // reference to parent nodeInfo>\n     *         parentIndex: {number},  // index in parent's `childNodes` collection\n     *         infoIndex: {number},    // index of this `nodeInfo` in `templateInfo.nodeInfoList`\n     *       },\n     *       ...\n     *     ],\n     *     // When true, the template had the `strip-whitespace` attribute\n     *     // or was nested in a template with that setting\n     *     stripWhitespace: {boolean},\n     *     // For nested templates, nested template content is moved into\n     *     // a document fragment stored here; this is an optimization to\n     *     // avoid the cost of nested template cloning\n     *     content: {DocumentFragment}\n     *   }\n     * ```\n     *\n     * This method kicks off a recursive treewalk as follows:\n     *\n     * ```\n     *    _parseTemplate <---------------------+\n     *      _parseTemplateContent              |\n     *        _parseTemplateNode  <------------|--+\n     *          _parseTemplateNestedTemplate --+  |\n     *          _parseTemplateChildNodes ---------+\n     *          _parseTemplateNodeAttributes\n     *            _parseTemplateNodeAttribute\n     *\n     * ```\n     *\n     * These methods may be overridden to add custom metadata about templates\n     * to either `templateInfo` or `nodeInfo`.\n     *\n     * Note that this method may be destructive to the template, in that\n     * e.g. event annotations may be removed after being noted in the\n     * template metadata.\n     *\n     * @param {!HTMLTemplateElement} template Template to parse\n     * @param {TemplateInfo=} outerTemplateInfo Template metadata from the outer\n     *   template, for parsing nested templates\n     * @return {!TemplateInfo} Parsed template metadata\n     * @nocollapse\n     */\n    static _parseTemplate(template, outerTemplateInfo) {\n      // since a template may be re-used, memo-ize metadata\n      if (!template._templateInfo) {\n        // TODO(rictic): fix typing\n        let /** ? */templateInfo = template._templateInfo = {};\n        templateInfo.nodeInfoList = [];\n        templateInfo.nestedTemplate = Boolean(outerTemplateInfo);\n        templateInfo.stripWhiteSpace = outerTemplateInfo && outerTemplateInfo.stripWhiteSpace || template.hasAttribute && template.hasAttribute('strip-whitespace');\n        // TODO(rictic): fix typing\n        this._parseTemplateContent(template, templateInfo, /** @type {?} */{\n          parent: null\n        });\n      }\n      return template._templateInfo;\n    }\n\n    /**\n     * See docs for _parseTemplateNode.\n     *\n     * @param {!HTMLTemplateElement} template .\n     * @param {!TemplateInfo} templateInfo .\n     * @param {!NodeInfo} nodeInfo .\n     * @return {boolean} .\n     * @nocollapse\n     */\n    static _parseTemplateContent(template, templateInfo, nodeInfo) {\n      return this._parseTemplateNode(template.content, templateInfo, nodeInfo);\n    }\n\n    /**\n     * Parses template node and adds template and node metadata based on\n     * the current node, and its `childNodes` and `attributes`.\n     *\n     * This method may be overridden to add custom node or template specific\n     * metadata based on this node.\n     *\n     * @param {Node} node Node to parse\n     * @param {!TemplateInfo} templateInfo Template metadata for current template\n     * @param {!NodeInfo} nodeInfo Node metadata for current template.\n     * @return {boolean} `true` if the visited node added node-specific\n     *   metadata to `nodeInfo`\n     * @nocollapse\n     */\n    static _parseTemplateNode(node, templateInfo, nodeInfo) {\n      let noted = false;\n      let element = /** @type {!HTMLTemplateElement} */node;\n      if (element.localName == 'template' && !element.hasAttribute('preserve-content')) {\n        noted = this._parseTemplateNestedTemplate(element, templateInfo, nodeInfo) || noted;\n      } else if (element.localName === 'slot') {\n        // For ShadyDom optimization, indicating there is an insertion point\n        templateInfo.hasInsertionPoint = true;\n      }\n      fixPlaceholder(element);\n      if (element.firstChild) {\n        this._parseTemplateChildNodes(element, templateInfo, nodeInfo);\n      }\n      if (element.hasAttributes && element.hasAttributes()) {\n        noted = this._parseTemplateNodeAttributes(element, templateInfo, nodeInfo) || noted;\n      }\n      // Checking `nodeInfo.noted` allows a child node of this node (who gets\n      // access to `parentInfo`) to cause the parent to be noted, which\n      // otherwise has no return path via `_parseTemplateChildNodes` (used by\n      // some optimizations)\n      return noted || nodeInfo.noted;\n    }\n\n    /**\n     * Parses template child nodes for the given root node.\n     *\n     * This method also wraps whitelisted legacy template extensions\n     * (`is=\"dom-if\"` and `is=\"dom-repeat\"`) with their equivalent element\n     * wrappers, collapses text nodes, and strips whitespace from the template\n     * if the `templateInfo.stripWhitespace` setting was provided.\n     *\n     * @param {Node} root Root node whose `childNodes` will be parsed\n     * @param {!TemplateInfo} templateInfo Template metadata for current template\n     * @param {!NodeInfo} nodeInfo Node metadata for current template.\n     * @return {void}\n     */\n    static _parseTemplateChildNodes(root, templateInfo, nodeInfo) {\n      if (root.localName === 'script' || root.localName === 'style') {\n        return;\n      }\n      for (let node = root.firstChild, parentIndex = 0, next; node; node = next) {\n        // Wrap templates\n        if (node.localName == 'template') {\n          node = wrapTemplateExtension(node);\n        }\n        // collapse adjacent textNodes: fixes an IE issue that can cause\n        // text nodes to be inexplicably split =(\n        // note that root.normalize() should work but does not so we do this\n        // manually.\n        next = node.nextSibling;\n        if (node.nodeType === Node.TEXT_NODE) {\n          let /** Node */n = next;\n          while (n && n.nodeType === Node.TEXT_NODE) {\n            node.textContent += n.textContent;\n            next = n.nextSibling;\n            root.removeChild(n);\n            n = next;\n          }\n          // optionally strip whitespace\n          if (templateInfo.stripWhiteSpace && !node.textContent.trim()) {\n            root.removeChild(node);\n            continue;\n          }\n        }\n        let childInfo = /** @type {!NodeInfo} */{\n          parentIndex,\n          parentInfo: nodeInfo\n        };\n        if (this._parseTemplateNode(node, templateInfo, childInfo)) {\n          childInfo.infoIndex = templateInfo.nodeInfoList.push(childInfo) - 1;\n        }\n        // Increment if not removed\n        if (node.parentNode) {\n          parentIndex++;\n        }\n      }\n    }\n\n    /**\n     * Parses template content for the given nested `<template>`.\n     *\n     * Nested template info is stored as `templateInfo` in the current node's\n     * `nodeInfo`. `template.content` is removed and stored in `templateInfo`.\n     * It will then be the responsibility of the host to set it back to the\n     * template and for users stamping nested templates to use the\n     * `_contentForTemplate` method to retrieve the content for this template\n     * (an optimization to avoid the cost of cloning nested template content).\n     *\n     * @param {HTMLTemplateElement} node Node to parse (a <template>)\n     * @param {TemplateInfo} outerTemplateInfo Template metadata for current template\n     *   that includes the template `node`\n     * @param {!NodeInfo} nodeInfo Node metadata for current template.\n     * @return {boolean} `true` if the visited node added node-specific\n     *   metadata to `nodeInfo`\n     * @nocollapse\n     */\n    static _parseTemplateNestedTemplate(node, outerTemplateInfo, nodeInfo) {\n      // TODO(rictic): the type of node should be non-null\n      let element = /** @type {!HTMLTemplateElement} */node;\n      let templateInfo = this._parseTemplate(element, outerTemplateInfo);\n      let content = templateInfo.content = element.content.ownerDocument.createDocumentFragment();\n      content.appendChild(element.content);\n      nodeInfo.templateInfo = templateInfo;\n      return true;\n    }\n\n    /**\n     * Parses template node attributes and adds node metadata to `nodeInfo`\n     * for nodes of interest.\n     *\n     * @param {Element} node Node to parse\n     * @param {!TemplateInfo} templateInfo Template metadata for current\n     *     template\n     * @param {!NodeInfo} nodeInfo Node metadata for current template.\n     * @return {boolean} `true` if the visited node added node-specific\n     *   metadata to `nodeInfo`\n     * @nocollapse\n     */\n    static _parseTemplateNodeAttributes(node, templateInfo, nodeInfo) {\n      // Make copy of original attribute list, since the order may change\n      // as attributes are added and removed\n      let noted = false;\n      let attrs = Array.from(node.attributes);\n      for (let i = attrs.length - 1, a; a = attrs[i]; i--) {\n        noted = this._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, a.name, a.value) || noted;\n      }\n      return noted;\n    }\n\n    /**\n     * Parses a single template node attribute and adds node metadata to\n     * `nodeInfo` for attributes of interest.\n     *\n     * This implementation adds metadata for `on-event=\"handler\"` attributes\n     * and `id` attributes.\n     *\n     * @param {Element} node Node to parse\n     * @param {!TemplateInfo} templateInfo Template metadata for current template\n     * @param {!NodeInfo} nodeInfo Node metadata for current template.\n     * @param {string} name Attribute name\n     * @param {string} value Attribute value\n     * @return {boolean} `true` if the visited node added node-specific\n     *   metadata to `nodeInfo`\n     * @nocollapse\n     */\n    static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {\n      // events (on-*)\n      if (name.slice(0, 3) === 'on-') {\n        node.removeAttribute(name);\n        nodeInfo.events = nodeInfo.events || [];\n        nodeInfo.events.push({\n          name: name.slice(3),\n          value\n        });\n        return true;\n      }\n      // static id\n      else if (name === 'id') {\n        nodeInfo.id = value;\n        return true;\n      }\n      return false;\n    }\n\n    /**\n     * Returns the `content` document fragment for a given template.\n     *\n     * For nested templates, Polymer performs an optimization to cache nested\n     * template content to avoid the cost of cloning deeply nested templates.\n     * This method retrieves the cached content for a given template.\n     *\n     * @param {HTMLTemplateElement} template Template to retrieve `content` for\n     * @return {DocumentFragment} Content fragment\n     * @nocollapse\n     */\n    static _contentForTemplate(template) {\n      let templateInfo = /** @type {HTMLTemplateElementWithInfo} */template._templateInfo;\n      return templateInfo && templateInfo.content || template.content;\n    }\n\n    /**\n     * Clones the provided template content and returns a document fragment\n     * containing the cloned dom.\n     *\n     * The template is parsed (once and memoized) using this library's\n     * template parsing features, and provides the following value-added\n     * features:\n     * * Adds declarative event listeners for `on-event=\"handler\"` attributes\n     * * Generates an \"id map\" for all nodes with id's under `$` on returned\n     *   document fragment\n     * * Passes template info including `content` back to templates as\n     *   `_templateInfo` (a performance optimization to avoid deep template\n     *   cloning)\n     *\n     * Note that the memoized template parsing process is destructive to the\n     * template: attributes for bindings and declarative event listeners are\n     * removed after being noted in notes, and any nested `<template>.content`\n     * is removed and stored in notes as well.\n     *\n     * @param {!HTMLTemplateElement} template Template to stamp\n     * @param {TemplateInfo=} templateInfo Optional template info associated\n     *   with the template to be stamped; if omitted the template will be\n     *   automatically parsed.\n     * @return {!StampedTemplate} Cloned template content\n     * @override\n     */\n    _stampTemplate(template, templateInfo) {\n      // Polyfill support: bootstrap the template if it has not already been\n      if (template && !template.content && window.HTMLTemplateElement && HTMLTemplateElement.decorate) {\n        HTMLTemplateElement.decorate(template);\n      }\n      // Accepting the `templateInfo` via an argument allows for creating\n      // instances of the `templateInfo` by the caller, useful for adding\n      // instance-time information to the prototypical data\n      templateInfo = templateInfo || this.constructor._parseTemplate(template);\n      let nodeInfo = templateInfo.nodeInfoList;\n      let content = templateInfo.content || template.content;\n      let dom = /** @type {DocumentFragment} */document.importNode(content, true);\n      // NOTE: ShadyDom optimization indicating there is an insertion point\n      dom.__noInsertionPoint = !templateInfo.hasInsertionPoint;\n      let nodes = dom.nodeList = new Array(nodeInfo.length);\n      dom.$ = {};\n      for (let i = 0, l = nodeInfo.length, info; i < l && (info = nodeInfo[i]); i++) {\n        let node = nodes[i] = findTemplateNode(dom, info);\n        applyIdToMap(this, dom.$, node, info);\n        applyTemplateInfo(this, node, info, templateInfo);\n        applyEventListener(this, node, info);\n      }\n      dom = /** @type {!StampedTemplate} */dom; // eslint-disable-line no-self-assign\n      return dom;\n    }\n\n    /**\n     * Adds an event listener by method name for the event provided.\n     *\n     * This method generates a handler function that looks up the method\n     * name at handling time.\n     *\n     * @param {!EventTarget} node Node to add listener on\n     * @param {string} eventName Name of event\n     * @param {string} methodName Name of method\n     * @param {*=} context Context the method will be called on (defaults\n     *   to `node`)\n     * @return {Function} Generated handler function\n     * @override\n     */\n    _addMethodEventListenerToNode(node, eventName, methodName, context) {\n      context = context || node;\n      let handler = createNodeEventHandler(context, eventName, methodName);\n      this._addEventListenerToNode(node, eventName, handler);\n      return handler;\n    }\n\n    /**\n     * Override point for adding custom or simulated event handling.\n     *\n     * @param {!EventTarget} node Node to add event listener to\n     * @param {string} eventName Name of event\n     * @param {function(!Event):void} handler Listener function to add\n     * @return {void}\n     * @override\n     */\n    _addEventListenerToNode(node, eventName, handler) {\n      node.addEventListener(eventName, handler);\n    }\n\n    /**\n     * Override point for adding custom or simulated event handling.\n     *\n     * @param {!EventTarget} node Node to remove event listener from\n     * @param {string} eventName Name of event\n     * @param {function(!Event):void} handler Listener function to remove\n     * @return {void}\n     * @override\n     */\n    _removeEventListenerFromNode(node, eventName, handler) {\n      node.removeEventListener(eventName, handler);\n    }\n  }\n  return TemplateStamp;\n});","/**\n * @fileoverview\n * @suppress {checkPrototypalTypes}\n * @license Copyright (c) 2017 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport '../utils/boot.js';\nimport { wrap } from '../utils/wrap.js';\nimport { dedupingMixin } from '../utils/mixin.js';\nimport { root, isAncestor, isDescendant, get, translate, isPath, set, normalize } from '../utils/path.js';\n/* for notify, reflect */\nimport { camelToDashCase, dashToCamelCase } from '../utils/case-map.js';\nimport { PropertyAccessors } from './property-accessors.js';\n/* for annotated effects */\nimport { TemplateStamp } from './template-stamp.js';\nimport { sanitizeDOMValue, legacyUndefined, orderedComputed, removeNestedTemplates, fastDomIf } from '../utils/settings.js';\n\n// Monotonically increasing unique ID used for de-duping effects triggered\n// from multiple properties in the same turn\nlet dedupeId = 0;\nconst NOOP = [];\n\n/**\n * Property effect types; effects are stored on the prototype using these keys\n * @enum {string}\n */\nconst TYPES = {\n  COMPUTE: '__computeEffects',\n  REFLECT: '__reflectEffects',\n  NOTIFY: '__notifyEffects',\n  PROPAGATE: '__propagateEffects',\n  OBSERVE: '__observeEffects',\n  READ_ONLY: '__readOnly'\n};\nconst COMPUTE_INFO = '__computeInfo';\n\n/** @const {!RegExp} */\nconst capitalAttributeRegex = /[A-Z]/;\n\n/**\n * @typedef {{\n * name: (string | undefined),\n * structured: (boolean | undefined),\n * wildcard: (boolean | undefined)\n * }}\n */\nlet DataTrigger; //eslint-disable-line no-unused-vars\n\n/**\n * @typedef {{\n * info: ?,\n * trigger: (!DataTrigger | undefined),\n * fn: (!Function | undefined)\n * }}\n */\nlet DataEffect; //eslint-disable-line no-unused-vars\n\n/**\n * Ensures that the model has an own-property map of effects for the given type.\n * The model may be a prototype or an instance.\n *\n * Property effects are stored as arrays of effects by property in a map,\n * by named type on the model. e.g.\n *\n *   __computeEffects: {\n *     foo: [ ... ],\n *     bar: [ ... ]\n *   }\n *\n * If the model does not yet have an effect map for the type, one is created\n * and returned.  If it does, but it is not an own property (i.e. the\n * prototype had effects), the the map is deeply cloned and the copy is\n * set on the model and returned, ready for new effects to be added.\n *\n * @param {Object} model Prototype or instance\n * @param {string} type Property effect type\n * @param {boolean=} cloneArrays Clone any arrays assigned to the map when\n *   extending a superclass map onto this subclass\n * @return {Object} The own-property map of effects for the given type\n * @private\n */\nfunction ensureOwnEffectMap(model, type, cloneArrays) {\n  let effects = model[type];\n  if (!effects) {\n    effects = model[type] = {};\n  } else if (!model.hasOwnProperty(type)) {\n    effects = model[type] = Object.create(model[type]);\n    if (cloneArrays) {\n      for (let p in effects) {\n        let protoFx = effects[p];\n        // Perf optimization over Array.slice\n        let instFx = effects[p] = Array(protoFx.length);\n        for (let i = 0; i < protoFx.length; i++) {\n          instFx[i] = protoFx[i];\n        }\n      }\n    }\n  }\n  return effects;\n}\n\n// -- effects ----------------------------------------------\n\n/**\n * Runs all effects of a given type for the given set of property changes\n * on an instance.\n *\n * @param {!Polymer_PropertyEffects} inst The instance with effects to run\n * @param {?Object} effects Object map of property-to-Array of effects\n * @param {?Object} props Bag of current property changes\n * @param {?Object=} oldProps Bag of previous values for changed properties\n * @param {boolean=} hasPaths True with `props` contains one or more paths\n * @param {*=} extraArgs Additional metadata to pass to effect function\n * @return {boolean} True if an effect ran for this property\n * @private\n */\nfunction runEffects(inst, effects, props, oldProps, hasPaths, extraArgs) {\n  if (effects) {\n    let ran = false;\n    const id = dedupeId++;\n    for (let prop in props) {\n      // Inline `runEffectsForProperty` for perf.\n      let rootProperty = hasPaths ? root(prop) : prop;\n      let fxs = effects[rootProperty];\n      if (fxs) {\n        for (let i = 0, l = fxs.length, fx; i < l && (fx = fxs[i]); i++) {\n          if ((!fx.info || fx.info.lastRun !== id) && (!hasPaths || pathMatchesTrigger(prop, fx.trigger))) {\n            if (fx.info) {\n              fx.info.lastRun = id;\n            }\n            fx.fn(inst, prop, props, oldProps, fx.info, hasPaths, extraArgs);\n            ran = true;\n          }\n        }\n      }\n    }\n    return ran;\n  }\n  return false;\n}\n\n/**\n * Runs a list of effects for a given property.\n *\n * @param {!Polymer_PropertyEffects} inst The instance with effects to run\n * @param {!Object} effects Object map of property-to-Array of effects\n * @param {number} dedupeId Counter used for de-duping effects\n * @param {string} prop Name of changed property\n * @param {*} props Changed properties\n * @param {*} oldProps Old properties\n * @param {boolean=} hasPaths True with `props` contains one or more paths\n * @param {*=} extraArgs Additional metadata to pass to effect function\n * @return {boolean} True if an effect ran for this property\n * @private\n */\nfunction runEffectsForProperty(inst, effects, dedupeId, prop, props, oldProps, hasPaths, extraArgs) {\n  let ran = false;\n  let rootProperty = hasPaths ? root(prop) : prop;\n  let fxs = effects[rootProperty];\n  if (fxs) {\n    for (let i = 0, l = fxs.length, fx; i < l && (fx = fxs[i]); i++) {\n      if ((!fx.info || fx.info.lastRun !== dedupeId) && (!hasPaths || pathMatchesTrigger(prop, fx.trigger))) {\n        if (fx.info) {\n          fx.info.lastRun = dedupeId;\n        }\n        fx.fn(inst, prop, props, oldProps, fx.info, hasPaths, extraArgs);\n        ran = true;\n      }\n    }\n  }\n  return ran;\n}\n\n/**\n * Determines whether a property/path that has changed matches the trigger\n * criteria for an effect.  A trigger is a descriptor with the following\n * structure, which matches the descriptors returned from `parseArg`.\n * e.g. for `foo.bar.*`:\n * ```\n * trigger: {\n *   name: 'a.b',\n *   structured: true,\n *   wildcard: true\n * }\n * ```\n * If no trigger is given, the path is deemed to match.\n *\n * @param {string} path Path or property that changed\n * @param {?DataTrigger} trigger Descriptor\n * @return {boolean} Whether the path matched the trigger\n */\nfunction pathMatchesTrigger(path, trigger) {\n  if (trigger) {\n    let triggerPath = /** @type {string} */trigger.name;\n    return triggerPath == path || !!(trigger.structured && isAncestor(triggerPath, path)) || !!(trigger.wildcard && isDescendant(triggerPath, path));\n  } else {\n    return true;\n  }\n}\n\n/**\n * Implements the \"observer\" effect.\n *\n * Calls the method with `info.methodName` on the instance, passing the\n * new and old values.\n *\n * @param {!Polymer_PropertyEffects} inst The instance the effect will be run on\n * @param {string} property Name of property\n * @param {Object} props Bag of current property changes\n * @param {Object} oldProps Bag of previous values for changed properties\n * @param {?} info Effect metadata\n * @return {void}\n * @private\n */\nfunction runObserverEffect(inst, property, props, oldProps, info) {\n  let fn = typeof info.method === \"string\" ? inst[info.method] : info.method;\n  let changedProp = info.property;\n  if (fn) {\n    fn.call(inst, inst.__data[changedProp], oldProps[changedProp]);\n  } else if (!info.dynamicFn) {\n    console.warn('observer method `' + info.method + '` not defined');\n  }\n}\n\n/**\n * Runs \"notify\" effects for a set of changed properties.\n *\n * This method differs from the generic `runEffects` method in that it\n * will dispatch path notification events in the case that the property\n * changed was a path and the root property for that path didn't have a\n * \"notify\" effect.  This is to maintain 1.0 behavior that did not require\n * `notify: true` to ensure object sub-property notifications were\n * sent.\n *\n * @param {!Polymer_PropertyEffects} inst The instance with effects to run\n * @param {Object} notifyProps Bag of properties to notify\n * @param {Object} props Bag of current property changes\n * @param {Object} oldProps Bag of previous values for changed properties\n * @param {boolean} hasPaths True with `props` contains one or more paths\n * @return {void}\n * @private\n */\nfunction runNotifyEffects(inst, notifyProps, props, oldProps, hasPaths) {\n  // Notify\n  let fxs = inst[TYPES.NOTIFY];\n  let notified;\n  let id = dedupeId++;\n  // Try normal notify effects; if none, fall back to try path notification\n  for (let prop in notifyProps) {\n    if (notifyProps[prop]) {\n      if (fxs && runEffectsForProperty(inst, fxs, id, prop, props, oldProps, hasPaths)) {\n        notified = true;\n      } else if (hasPaths && notifyPath(inst, prop, props)) {\n        notified = true;\n      }\n    }\n  }\n  // Flush host if we actually notified and host was batching\n  // And the host has already initialized clients; this prevents\n  // an issue with a host observing data changes before clients are ready.\n  let host;\n  if (notified && (host = inst.__dataHost) && host._invalidateProperties) {\n    host._invalidateProperties();\n  }\n}\n\n/**\n * Dispatches {property}-changed events with path information in the detail\n * object to indicate a sub-path of the property was changed.\n *\n * @param {!Polymer_PropertyEffects} inst The element from which to fire the\n *     event\n * @param {string} path The path that was changed\n * @param {Object} props Bag of current property changes\n * @return {boolean} Returns true if the path was notified\n * @private\n */\nfunction notifyPath(inst, path, props) {\n  let rootProperty = root(path);\n  if (rootProperty !== path) {\n    let eventName = camelToDashCase(rootProperty) + '-changed';\n    dispatchNotifyEvent(inst, eventName, props[path], path);\n    return true;\n  }\n  return false;\n}\n\n/**\n * Dispatches {property}-changed events to indicate a property (or path)\n * changed.\n *\n * @param {!Polymer_PropertyEffects} inst The element from which to fire the\n *     event\n * @param {string} eventName The name of the event to send\n *     ('{property}-changed')\n * @param {*} value The value of the changed property\n * @param {string | null | undefined} path If a sub-path of this property\n *     changed, the path that changed (optional).\n * @return {void}\n * @private\n * @suppress {invalidCasts}\n */\nfunction dispatchNotifyEvent(inst, eventName, value, path) {\n  let detail = {\n    value: value,\n    queueProperty: true\n  };\n  if (path) {\n    detail.path = path;\n  }\n  // As a performance optimization, we could elide the wrap here since notifying\n  // events are non-bubbling and shouldn't need retargeting. However, a very\n  // small number of internal tests failed in obscure ways, which may indicate\n  // user code relied on timing differences resulting from ShadyDOM flushing\n  // as a result of the wrapped `dispatchEvent`.\n  wrap(/** @type {!HTMLElement} */inst).dispatchEvent(new CustomEvent(eventName, {\n    detail\n  }));\n}\n\n/**\n * Implements the \"notify\" effect.\n *\n * Dispatches a non-bubbling event named `info.eventName` on the instance\n * with a detail object containing the new `value`.\n *\n * @param {!Polymer_PropertyEffects} inst The instance the effect will be run on\n * @param {string} property Name of property\n * @param {Object} props Bag of current property changes\n * @param {Object} oldProps Bag of previous values for changed properties\n * @param {?} info Effect metadata\n * @param {boolean} hasPaths True with `props` contains one or more paths\n * @return {void}\n * @private\n */\nfunction runNotifyEffect(inst, property, props, oldProps, info, hasPaths) {\n  let rootProperty = hasPaths ? root(property) : property;\n  let path = rootProperty != property ? property : null;\n  let value = path ? get(inst, path) : inst.__data[property];\n  if (path && value === undefined) {\n    value = props[property]; // specifically for .splices\n  }\n  dispatchNotifyEvent(inst, info.eventName, value, path);\n}\n\n/**\n * Handler function for 2-way notification events. Receives context\n * information captured in the `addNotifyListener` closure from the\n * `__notifyListeners` metadata.\n *\n * Sets the value of the notified property to the host property or path.  If\n * the event contained path information, translate that path to the host\n * scope's name for that path first.\n *\n * @param {CustomEvent} event Notification event (e.g. '<property>-changed')\n * @param {!Polymer_PropertyEffects} inst Host element instance handling the\n *     notification event\n * @param {string} fromProp Child element property that was bound\n * @param {string} toPath Host property/path that was bound\n * @param {boolean} negate Whether the binding was negated\n * @return {void}\n * @private\n */\nfunction handleNotification(event, inst, fromProp, toPath, negate) {\n  let value;\n  let detail = /** @type {Object} */event.detail;\n  let fromPath = detail && detail.path;\n  if (fromPath) {\n    toPath = translate(fromProp, toPath, fromPath);\n    value = detail && detail.value;\n  } else {\n    value = event.currentTarget[fromProp];\n  }\n  value = negate ? !value : value;\n  if (!inst[TYPES.READ_ONLY] || !inst[TYPES.READ_ONLY][toPath]) {\n    if (inst._setPendingPropertyOrPath(toPath, value, true, Boolean(fromPath)) && (!detail || !detail.queueProperty)) {\n      inst._invalidateProperties();\n    }\n  }\n}\n\n/**\n * Implements the \"reflect\" effect.\n *\n * Sets the attribute named `info.attrName` to the given property value.\n *\n * @param {!Polymer_PropertyEffects} inst The instance the effect will be run on\n * @param {string} property Name of property\n * @param {Object} props Bag of current property changes\n * @param {Object} oldProps Bag of previous values for changed properties\n * @param {?} info Effect metadata\n * @return {void}\n * @private\n */\nfunction runReflectEffect(inst, property, props, oldProps, info) {\n  let value = inst.__data[property];\n  if (sanitizeDOMValue) {\n    value = sanitizeDOMValue(value, info.attrName, 'attribute', /** @type {Node} */inst);\n  }\n  inst._propertyToAttribute(property, info.attrName, value);\n}\n\n/**\n * Runs \"computed\" effects for a set of changed properties.\n *\n * This method differs from the generic `runEffects` method in that it\n * continues to run computed effects based on the output of each pass until\n * there are no more newly computed properties.  This ensures that all\n * properties that will be computed by the initial set of changes are\n * computed before other effects (binding propagation, observers, and notify)\n * run.\n *\n * @param {!Polymer_PropertyEffects} inst The instance the effect will be run on\n * @param {?Object} changedProps Bag of changed properties\n * @param {?Object} oldProps Bag of previous values for changed properties\n * @param {boolean} hasPaths True with `props` contains one or more paths\n * @return {void}\n * @private\n */\nfunction runComputedEffects(inst, changedProps, oldProps, hasPaths) {\n  let computeEffects = inst[TYPES.COMPUTE];\n  if (computeEffects) {\n    if (orderedComputed) {\n      // Runs computed effects in efficient order by keeping a topologically-\n      // sorted queue of compute effects to run, and inserting subsequently\n      // invalidated effects as they are run\n      dedupeId++;\n      const order = getComputedOrder(inst);\n      const queue = [];\n      for (let p in changedProps) {\n        enqueueEffectsFor(p, computeEffects, queue, order, hasPaths);\n      }\n      let info;\n      while (info = queue.shift()) {\n        if (runComputedEffect(inst, '', changedProps, oldProps, info)) {\n          enqueueEffectsFor(info.methodInfo, computeEffects, queue, order, hasPaths);\n        }\n      }\n      Object.assign(/** @type {!Object} */oldProps, inst.__dataOld);\n      Object.assign(/** @type {!Object} */changedProps, inst.__dataPending);\n      inst.__dataPending = null;\n    } else {\n      // Original Polymer 2.x computed effects order, which continues running\n      // effects until no further computed properties have been invalidated\n      let inputProps = changedProps;\n      while (runEffects(inst, computeEffects, inputProps, oldProps, hasPaths)) {\n        Object.assign(/** @type {!Object} */oldProps, inst.__dataOld);\n        Object.assign(/** @type {!Object} */changedProps, inst.__dataPending);\n        inputProps = inst.__dataPending;\n        inst.__dataPending = null;\n      }\n    }\n  }\n}\n\n/**\n * Inserts a computed effect into a queue, given the specified order. Performs\n * the insert using a binary search.\n *\n * Used by `orderedComputed: true` computed property algorithm.\n *\n * @param {Object} info Property effects metadata\n * @param {Array<Object>} queue Ordered queue of effects\n * @param {Map<string,number>} order Map of computed property name->topological\n *   sort order\n */\nconst insertEffect = (info, queue, order) => {\n  let start = 0;\n  let end = queue.length - 1;\n  let idx = -1;\n  while (start <= end) {\n    const mid = start + end >> 1;\n    // Note `methodInfo` is where the computed property name is stored in\n    // the effect metadata\n    const cmp = order.get(queue[mid].methodInfo) - order.get(info.methodInfo);\n    if (cmp < 0) {\n      start = mid + 1;\n    } else if (cmp > 0) {\n      end = mid - 1;\n    } else {\n      idx = mid;\n      break;\n    }\n  }\n  if (idx < 0) {\n    idx = end + 1;\n  }\n  queue.splice(idx, 0, info);\n};\n\n/**\n * Inserts all downstream computed effects invalidated by the specified property\n * into the topologically-sorted queue of effects to be run.\n *\n * Used by `orderedComputed: true` computed property algorithm.\n *\n * @param {string} prop Property name\n * @param {Object} computeEffects Computed effects for this element\n * @param {Array<Object>} queue Topologically-sorted queue of computed effects\n *   to be run\n * @param {Map<string,number>} order Map of computed property name->topological\n *   sort order\n * @param {boolean} hasPaths True with `changedProps` contains one or more paths\n */\nconst enqueueEffectsFor = (prop, computeEffects, queue, order, hasPaths) => {\n  const rootProperty = hasPaths ? root(prop) : prop;\n  const fxs = computeEffects[rootProperty];\n  if (fxs) {\n    for (let i = 0; i < fxs.length; i++) {\n      const fx = fxs[i];\n      if (fx.info.lastRun !== dedupeId && (!hasPaths || pathMatchesTrigger(prop, fx.trigger))) {\n        fx.info.lastRun = dedupeId;\n        insertEffect(fx.info, queue, order);\n      }\n    }\n  }\n};\n\n/**\n * Generates and retrieves a memoized map of computed property name to its\n * topologically-sorted order.\n *\n * The map is generated by first assigning a \"dependency count\" to each property\n * (defined as number properties it depends on, including its method for\n * \"dynamic functions\"). Any properties that have no dependencies are added to\n * the `ready` queue, which are properties whose order can be added to the final\n * order map. Properties are popped off the `ready` queue one by one and a.) added as\n * the next property in the order map, and b.) each property that it is a\n * dependency for has its dep count decremented (and if that property's dep\n * count goes to zero, it is added to the `ready` queue), until all properties\n * have been visited and ordered.\n *\n * Used by `orderedComputed: true` computed property algorithm.\n *\n * @param {!Polymer_PropertyEffects} inst The instance to retrieve the computed\n *   effect order for.\n * @return {Map<string,number>} Map of computed property name->topological sort\n *   order\n */\nfunction getComputedOrder(inst) {\n  let ordered = inst.constructor.__orderedComputedDeps;\n  if (!ordered) {\n    ordered = new Map();\n    const effects = inst[TYPES.COMPUTE];\n    let _dependencyCounts = dependencyCounts(inst),\n      counts = _dependencyCounts.counts,\n      ready = _dependencyCounts.ready,\n      total = _dependencyCounts.total;\n    let curr;\n    while (curr = ready.shift()) {\n      ordered.set(curr, ordered.size);\n      const computedByCurr = effects[curr];\n      if (computedByCurr) {\n        computedByCurr.forEach(fx => {\n          // Note `methodInfo` is where the computed property name is stored\n          const computedProp = fx.info.methodInfo;\n          --total;\n          if (--counts[computedProp] === 0) {\n            ready.push(computedProp);\n          }\n        });\n      }\n    }\n    if (total !== 0) {\n      const el = /** @type {HTMLElement} */inst;\n      console.warn(`Computed graph for ${el.localName} incomplete; circular?`);\n    }\n    inst.constructor.__orderedComputedDeps = ordered;\n  }\n  return ordered;\n}\n\n/**\n * Generates a map of property-to-dependency count (`counts`, where \"dependency\n * count\" is the number of dependencies a given property has assuming it is a\n * computed property, otherwise 0).  It also returns a pre-populated list of\n * `ready` properties that have no dependencies and a `total` count, which is\n * used for error-checking the graph.\n *\n * Used by `orderedComputed: true` computed property algorithm.\n *\n * @param {!Polymer_PropertyEffects} inst The instance to generate dependency\n *   counts for.\n * @return {!Object} Object containing `counts` map (property-to-dependency\n *   count) and pre-populated `ready` array of properties that had zero\n *   dependencies.\n */\nfunction dependencyCounts(inst) {\n  const infoForComputed = inst[COMPUTE_INFO];\n  const counts = {};\n  const computedDeps = inst[TYPES.COMPUTE];\n  const ready = [];\n  let total = 0;\n  // Count dependencies for each computed property\n  for (let p in infoForComputed) {\n    const info = infoForComputed[p];\n    // Be sure to add the method name itself in case of \"dynamic functions\"\n    total += counts[p] = info.args.filter(a => !a.literal).length + (info.dynamicFn ? 1 : 0);\n  }\n  // Build list of ready properties (that aren't themselves computed)\n  for (let p in computedDeps) {\n    if (!infoForComputed[p]) {\n      ready.push(p);\n    }\n  }\n  return {\n    counts,\n    ready,\n    total\n  };\n}\n\n/**\n * Implements the \"computed property\" effect by running the method with the\n * values of the arguments specified in the `info` object and setting the\n * return value to the computed property specified.\n *\n * @param {!Polymer_PropertyEffects} inst The instance the effect will be run on\n * @param {string} property Name of property\n * @param {?Object} changedProps Bag of current property changes\n * @param {?Object} oldProps Bag of previous values for changed properties\n * @param {?} info Effect metadata\n * @return {boolean} True when the property being computed changed\n * @private\n */\nfunction runComputedEffect(inst, property, changedProps, oldProps, info) {\n  // Dirty check dependencies and run if any invalid\n  let result = runMethodEffect(inst, property, changedProps, oldProps, info);\n  // Abort if method returns a no-op result\n  if (result === NOOP) {\n    return false;\n  }\n  let computedProp = info.methodInfo;\n  if (inst.__dataHasAccessor && inst.__dataHasAccessor[computedProp]) {\n    return inst._setPendingProperty(computedProp, result, true);\n  } else {\n    inst[computedProp] = result;\n    return false;\n  }\n}\n\n/**\n * Computes path changes based on path links set up using the `linkPaths`\n * API.\n *\n * @param {!Polymer_PropertyEffects} inst The instance whose props are changing\n * @param {string} path Path that has changed\n * @param {*} value Value of changed path\n * @return {void}\n * @private\n */\nfunction computeLinkedPaths(inst, path, value) {\n  let links = inst.__dataLinkedPaths;\n  if (links) {\n    let link;\n    for (let a in links) {\n      let b = links[a];\n      if (isDescendant(a, path)) {\n        link = translate(a, b, path);\n        inst._setPendingPropertyOrPath(link, value, true, true);\n      } else if (isDescendant(b, path)) {\n        link = translate(b, a, path);\n        inst._setPendingPropertyOrPath(link, value, true, true);\n      }\n    }\n  }\n}\n\n// -- bindings ----------------------------------------------\n\n/**\n * Adds binding metadata to the current `nodeInfo`, and binding effects\n * for all part dependencies to `templateInfo`.\n *\n * @param {Function} constructor Class that `_parseTemplate` is currently\n *   running on\n * @param {TemplateInfo} templateInfo Template metadata for current template\n * @param {NodeInfo} nodeInfo Node metadata for current template node\n * @param {string} kind Binding kind, either 'property', 'attribute', or 'text'\n * @param {string} target Target property name\n * @param {!Array<!BindingPart>} parts Array of binding part metadata\n * @param {string=} literal Literal text surrounding binding parts (specified\n *   only for 'property' bindings, since these must be initialized as part\n *   of boot-up)\n * @return {void}\n * @private\n */\nfunction addBinding(constructor, templateInfo, nodeInfo, kind, target, parts, literal) {\n  // Create binding metadata and add to nodeInfo\n  nodeInfo.bindings = nodeInfo.bindings || [];\n  let /** Binding */binding = {\n    kind,\n    target,\n    parts,\n    literal,\n    isCompound: parts.length !== 1\n  };\n  nodeInfo.bindings.push(binding);\n  // Add listener info to binding metadata\n  if (shouldAddListener(binding)) {\n    let _binding$parts$ = binding.parts[0],\n      event = _binding$parts$.event,\n      negate = _binding$parts$.negate;\n    binding.listenerEvent = event || camelToDashCase(target) + '-changed';\n    binding.listenerNegate = negate;\n  }\n  // Add \"propagate\" property effects to templateInfo\n  let index = templateInfo.nodeInfoList.length;\n  for (let i = 0; i < binding.parts.length; i++) {\n    let part = binding.parts[i];\n    part.compoundIndex = i;\n    addEffectForBindingPart(constructor, templateInfo, binding, part, index);\n  }\n}\n\n/**\n * Adds property effects to the given `templateInfo` for the given binding\n * part.\n *\n * @param {Function} constructor Class that `_parseTemplate` is currently\n *   running on\n * @param {TemplateInfo} templateInfo Template metadata for current template\n * @param {!Binding} binding Binding metadata\n * @param {!BindingPart} part Binding part metadata\n * @param {number} index Index into `nodeInfoList` for this node\n * @return {void}\n */\nfunction addEffectForBindingPart(constructor, templateInfo, binding, part, index) {\n  if (!part.literal) {\n    if (binding.kind === 'attribute' && binding.target[0] === '-') {\n      console.warn('Cannot set attribute ' + binding.target + ' because \"-\" is not a valid attribute starting character');\n    } else {\n      let dependencies = part.dependencies;\n      let info = {\n        index,\n        binding,\n        part,\n        evaluator: constructor\n      };\n      for (let j = 0; j < dependencies.length; j++) {\n        let trigger = dependencies[j];\n        if (typeof trigger == 'string') {\n          trigger = parseArg(trigger);\n          trigger.wildcard = true;\n        }\n        constructor._addTemplatePropertyEffect(templateInfo, trigger.rootProperty, {\n          fn: runBindingEffect,\n          info,\n          trigger\n        });\n      }\n    }\n  }\n}\n\n/**\n * Implements the \"binding\" (property/path binding) effect.\n *\n * Note that binding syntax is overridable via `_parseBindings` and\n * `_evaluateBinding`.  This method will call `_evaluateBinding` for any\n * non-literal parts returned from `_parseBindings`.  However,\n * there is no support for _path_ bindings via custom binding parts,\n * as this is specific to Polymer's path binding syntax.\n *\n * @param {!Polymer_PropertyEffects} inst The instance the effect will be run on\n * @param {string} path Name of property\n * @param {Object} props Bag of current property changes\n * @param {Object} oldProps Bag of previous values for changed properties\n * @param {?} info Effect metadata\n * @param {boolean} hasPaths True with `props` contains one or more paths\n * @param {Array} nodeList List of nodes associated with `nodeInfoList` template\n *   metadata\n * @return {void}\n * @private\n */\nfunction runBindingEffect(inst, path, props, oldProps, info, hasPaths, nodeList) {\n  let node = nodeList[info.index];\n  let binding = info.binding;\n  let part = info.part;\n  // Subpath notification: transform path and set to client\n  // e.g.: foo=\"{{obj.sub}}\", path: 'obj.sub.prop', set 'foo.prop'=obj.sub.prop\n  if (hasPaths && part.source && path.length > part.source.length && binding.kind == 'property' && !binding.isCompound && node.__isPropertyEffectsClient && node.__dataHasAccessor && node.__dataHasAccessor[binding.target]) {\n    let value = props[path];\n    path = translate(part.source, binding.target, path);\n    if (node._setPendingPropertyOrPath(path, value, false, true)) {\n      inst._enqueueClient(node);\n    }\n  } else {\n    let value = info.evaluator._evaluateBinding(inst, part, path, props, oldProps, hasPaths);\n    // Propagate value to child\n    // Abort if value is a no-op result\n    if (value !== NOOP) {\n      applyBindingValue(inst, node, binding, part, value);\n    }\n  }\n}\n\n/**\n * Sets the value for an \"binding\" (binding) effect to a node,\n * either as a property or attribute.\n *\n * @param {!Polymer_PropertyEffects} inst The instance owning the binding effect\n * @param {Node} node Target node for binding\n * @param {!Binding} binding Binding metadata\n * @param {!BindingPart} part Binding part metadata\n * @param {*} value Value to set\n * @return {void}\n * @private\n */\nfunction applyBindingValue(inst, node, binding, part, value) {\n  value = computeBindingValue(node, value, binding, part);\n  if (sanitizeDOMValue) {\n    value = sanitizeDOMValue(value, binding.target, binding.kind, node);\n  }\n  if (binding.kind == 'attribute') {\n    // Attribute binding\n    inst._valueToNodeAttribute(/** @type {Element} */node, value, binding.target);\n  } else {\n    // Property binding\n    let prop = binding.target;\n    if (node.__isPropertyEffectsClient && node.__dataHasAccessor && node.__dataHasAccessor[prop]) {\n      if (!node[TYPES.READ_ONLY] || !node[TYPES.READ_ONLY][prop]) {\n        if (node._setPendingProperty(prop, value)) {\n          inst._enqueueClient(node);\n        }\n      }\n    } else {\n      // In legacy no-batching mode, bindings applied before dataReady are\n      // equivalent to the \"apply config\" phase, which only set managed props\n      inst._setUnmanagedPropertyToNode(node, prop, value);\n    }\n  }\n}\n\n/**\n * Transforms an \"binding\" effect value based on compound & negation\n * effect metadata, as well as handling for special-case properties\n *\n * @param {Node} node Node the value will be set to\n * @param {*} value Value to set\n * @param {!Binding} binding Binding metadata\n * @param {!BindingPart} part Binding part metadata\n * @return {*} Transformed value to set\n * @private\n */\nfunction computeBindingValue(node, value, binding, part) {\n  if (binding.isCompound) {\n    let storage = node.__dataCompoundStorage[binding.target];\n    storage[part.compoundIndex] = value;\n    value = storage.join('');\n  }\n  if (binding.kind !== 'attribute') {\n    // Some browsers serialize `undefined` to `\"undefined\"`\n    if (binding.target === 'textContent' || binding.target === 'value' && (node.localName === 'input' || node.localName === 'textarea')) {\n      value = value == undefined ? '' : value;\n    }\n  }\n  return value;\n}\n\n/**\n * Returns true if a binding's metadata meets all the requirements to allow\n * 2-way binding, and therefore a `<property>-changed` event listener should be\n * added:\n * - used curly braces\n * - is a property (not attribute) binding\n * - is not a textContent binding\n * - is not compound\n *\n * @param {!Binding} binding Binding metadata\n * @return {boolean} True if 2-way listener should be added\n * @private\n */\nfunction shouldAddListener(binding) {\n  return Boolean(binding.target) && binding.kind != 'attribute' && binding.kind != 'text' && !binding.isCompound && binding.parts[0].mode === '{';\n}\n\n/**\n * Setup compound binding storage structures, notify listeners, and dataHost\n * references onto the bound nodeList.\n *\n * @param {!Polymer_PropertyEffects} inst Instance that bas been previously\n *     bound\n * @param {TemplateInfo} templateInfo Template metadata\n * @return {void}\n * @private\n */\nfunction setupBindings(inst, templateInfo) {\n  // Setup compound storage, dataHost, and notify listeners\n  let nodeList = templateInfo.nodeList,\n    nodeInfoList = templateInfo.nodeInfoList;\n  if (nodeInfoList.length) {\n    for (let i = 0; i < nodeInfoList.length; i++) {\n      let info = nodeInfoList[i];\n      let node = nodeList[i];\n      let bindings = info.bindings;\n      if (bindings) {\n        for (let i = 0; i < bindings.length; i++) {\n          let binding = bindings[i];\n          setupCompoundStorage(node, binding);\n          addNotifyListener(node, inst, binding);\n        }\n      }\n      // This ensures all bound elements have a host set, regardless\n      // of whether they upgrade synchronous to creation\n      node.__dataHost = inst;\n    }\n  }\n}\n\n/**\n * Initializes `__dataCompoundStorage` local storage on a bound node with\n * initial literal data for compound bindings, and sets the joined\n * literal parts to the bound property.\n *\n * When changes to compound parts occur, they are first set into the compound\n * storage array for that property, and then the array is joined to result in\n * the final value set to the property/attribute.\n *\n * @param {Node} node Bound node to initialize\n * @param {Binding} binding Binding metadata\n * @return {void}\n * @private\n */\nfunction setupCompoundStorage(node, binding) {\n  if (binding.isCompound) {\n    // Create compound storage map\n    let storage = node.__dataCompoundStorage || (node.__dataCompoundStorage = {});\n    let parts = binding.parts;\n    // Copy literals from parts into storage for this binding\n    let literals = new Array(parts.length);\n    for (let j = 0; j < parts.length; j++) {\n      literals[j] = parts[j].literal;\n    }\n    let target = binding.target;\n    storage[target] = literals;\n    // Configure properties with their literal parts\n    if (binding.literal && binding.kind == 'property') {\n      // Note, className needs style scoping so this needs wrapping.\n      // We may also want to consider doing this for `textContent` and\n      // `innerHTML`.\n      if (target === 'className') {\n        node = wrap(node);\n      }\n      node[target] = binding.literal;\n    }\n  }\n}\n\n/**\n * Adds a 2-way binding notification event listener to the node specified\n *\n * @param {Object} node Child element to add listener to\n * @param {!Polymer_PropertyEffects} inst Host element instance to handle\n *     notification event\n * @param {Binding} binding Binding metadata\n * @return {void}\n * @private\n */\nfunction addNotifyListener(node, inst, binding) {\n  if (binding.listenerEvent) {\n    let part = binding.parts[0];\n    node.addEventListener(binding.listenerEvent, function (e) {\n      handleNotification(e, inst, binding.target, part.source, part.negate);\n    });\n  }\n}\n\n// -- for method-based effects (complexObserver & computed) --------------\n\n/**\n * Adds property effects for each argument in the method signature (and\n * optionally, for the method name if `dynamic` is true) that calls the\n * provided effect function.\n *\n * @param {Element | Object} model Prototype or instance\n * @param {!MethodSignature} sig Method signature metadata\n * @param {string} type Type of property effect to add\n * @param {Function} effectFn Function to run when arguments change\n * @param {*=} methodInfo Effect-specific information to be included in\n *   method effect metadata\n * @param {boolean|Object=} dynamicFn Boolean or object map indicating whether\n *   method names should be included as a dependency to the effect. Note,\n *   defaults to true if the signature is static (sig.static is true).\n * @return {!Object} Effect metadata for this method effect\n * @private\n */\nfunction createMethodEffect(model, sig, type, effectFn, methodInfo, dynamicFn) {\n  dynamicFn = sig.static || dynamicFn && (typeof dynamicFn !== 'object' || dynamicFn[sig.methodName]);\n  let info = {\n    methodName: sig.methodName,\n    args: sig.args,\n    methodInfo,\n    dynamicFn\n  };\n  for (let i = 0, arg; i < sig.args.length && (arg = sig.args[i]); i++) {\n    if (!arg.literal) {\n      model._addPropertyEffect(arg.rootProperty, type, {\n        fn: effectFn,\n        info: info,\n        trigger: arg\n      });\n    }\n  }\n  if (dynamicFn) {\n    model._addPropertyEffect(sig.methodName, type, {\n      fn: effectFn,\n      info: info\n    });\n  }\n  return info;\n}\n\n/**\n * Calls a method with arguments marshaled from properties on the instance\n * based on the method signature contained in the effect metadata.\n *\n * Multi-property observers, computed properties, and inline computing\n * functions call this function to invoke the method, then use the return\n * value accordingly.\n *\n * @param {!Polymer_PropertyEffects} inst The instance the effect will be run on\n * @param {string} property Name of property\n * @param {Object} props Bag of current property changes\n * @param {Object} oldProps Bag of previous values for changed properties\n * @param {?} info Effect metadata\n * @return {*} Returns the return value from the method invocation\n * @private\n */\nfunction runMethodEffect(inst, property, props, oldProps, info) {\n  // Instances can optionally have a _methodHost which allows redirecting where\n  // to find methods. Currently used by `templatize`.\n  let context = inst._methodHost || inst;\n  let fn = context[info.methodName];\n  if (fn) {\n    let args = inst._marshalArgs(info.args, property, props);\n    return args === NOOP ? NOOP : fn.apply(context, args);\n  } else if (!info.dynamicFn) {\n    console.warn('method `' + info.methodName + '` not defined');\n  }\n}\nconst emptyArray = [];\n\n// Regular expressions used for binding\nconst IDENT = '(?:' + '[a-zA-Z_$][\\\\w.:$\\\\-*]*' + ')';\nconst NUMBER = '(?:' + '[-+]?[0-9]*\\\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';\nconst SQUOTE_STRING = '(?:' + '\\'(?:[^\\'\\\\\\\\]|\\\\\\\\.)*\\'' + ')';\nconst DQUOTE_STRING = '(?:' + '\"(?:[^\"\\\\\\\\]|\\\\\\\\.)*\"' + ')';\nconst STRING = '(?:' + SQUOTE_STRING + '|' + DQUOTE_STRING + ')';\nconst ARGUMENT = '(?:(' + IDENT + '|' + NUMBER + '|' + STRING + ')\\\\s*' + ')';\nconst ARGUMENTS = '(?:' + ARGUMENT + '(?:,\\\\s*' + ARGUMENT + ')*' + ')';\nconst ARGUMENT_LIST = '(?:' + '\\\\(\\\\s*' + '(?:' + ARGUMENTS + '?' + ')' + '\\\\)\\\\s*' + ')';\nconst BINDING = '(' + IDENT + '\\\\s*' + ARGUMENT_LIST + '?' + ')'; // Group 3\nconst OPEN_BRACKET = '(\\\\[\\\\[|{{)' + '\\\\s*';\nconst CLOSE_BRACKET = '(?:]]|}})';\nconst NEGATE = '(?:(!)\\\\s*)?'; // Group 2\nconst EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;\nconst bindingRegex = new RegExp(EXPRESSION, \"g\");\n\n/**\n * Create a string from binding parts of all the literal parts\n *\n * @param {!Array<BindingPart>} parts All parts to stringify\n * @return {string} String made from the literal parts\n */\nfunction literalFromParts(parts) {\n  let s = '';\n  for (let i = 0; i < parts.length; i++) {\n    let literal = parts[i].literal;\n    s += literal || '';\n  }\n  return s;\n}\n\n/**\n * Parses an expression string for a method signature, and returns a metadata\n * describing the method in terms of `methodName`, `static` (whether all the\n * arguments are literals), and an array of `args`\n *\n * @param {string} expression The expression to parse\n * @return {?MethodSignature} The method metadata object if a method expression was\n *   found, otherwise `undefined`\n * @private\n */\nfunction parseMethod(expression) {\n  // tries to match valid javascript property names\n  let m = expression.match(/([^\\s]+?)\\(([\\s\\S]*)\\)/);\n  if (m) {\n    let methodName = m[1];\n    let sig = {\n      methodName,\n      static: true,\n      args: emptyArray\n    };\n    if (m[2].trim()) {\n      // replace escaped commas with comma entity, split on un-escaped commas\n      let args = m[2].replace(/\\\\,/g, '&comma;').split(',');\n      return parseArgs(args, sig);\n    } else {\n      return sig;\n    }\n  }\n  return null;\n}\n\n/**\n * Parses an array of arguments and sets the `args` property of the supplied\n * signature metadata object. Sets the `static` property to false if any\n * argument is a non-literal.\n *\n * @param {!Array<string>} argList Array of argument names\n * @param {!MethodSignature} sig Method signature metadata object\n * @return {!MethodSignature} The updated signature metadata object\n * @private\n */\nfunction parseArgs(argList, sig) {\n  sig.args = argList.map(function (rawArg) {\n    let arg = parseArg(rawArg);\n    if (!arg.literal) {\n      sig.static = false;\n    }\n    return arg;\n  }, this);\n  return sig;\n}\n\n/**\n * Parses an individual argument, and returns an argument metadata object\n * with the following fields:\n *\n *   {\n *     value: 'prop',        // property/path or literal value\n *     literal: false,       // whether argument is a literal\n *     structured: false,    // whether the property is a path\n *     rootProperty: 'prop', // the root property of the path\n *     wildcard: false       // whether the argument was a wildcard '.*' path\n *   }\n *\n * @param {string} rawArg The string value of the argument\n * @return {!MethodArg} Argument metadata object\n * @private\n */\nfunction parseArg(rawArg) {\n  // clean up whitespace\n  let arg = rawArg.trim()\n  // replace comma entity with comma\n  .replace(/&comma;/g, ',')\n  // repair extra escape sequences; note only commas strictly need\n  // escaping, but we allow any other char to be escaped since its\n  // likely users will do this\n  .replace(/\\\\(.)/g, '$1');\n  // basic argument descriptor\n  let a = {\n    name: arg,\n    value: '',\n    literal: false\n  };\n  // detect literal value (must be String or Number)\n  let fc = arg[0];\n  if (fc === '-') {\n    fc = arg[1];\n  }\n  if (fc >= '0' && fc <= '9') {\n    fc = '#';\n  }\n  switch (fc) {\n    case \"'\":\n    case '\"':\n      a.value = arg.slice(1, -1);\n      a.literal = true;\n      break;\n    case '#':\n      a.value = Number(arg);\n      a.literal = true;\n      break;\n  }\n  // if not literal, look for structured path\n  if (!a.literal) {\n    a.rootProperty = root(arg);\n    // detect structured path (has dots)\n    a.structured = isPath(arg);\n    if (a.structured) {\n      a.wildcard = arg.slice(-2) == '.*';\n      if (a.wildcard) {\n        a.name = arg.slice(0, -2);\n      }\n    }\n  }\n  return a;\n}\nfunction getArgValue(data, props, path) {\n  let value = get(data, path);\n  // when data is not stored e.g. `splices`, get the value from changedProps\n  // TODO(kschaaf): Note, this can cause a rare issue where the wildcard\n  // info.value could pull a stale value out of changedProps during a reentrant\n  // change that sets the value back to undefined.\n  // https://github.com/Polymer/polymer/issues/5479\n  if (value === undefined) {\n    value = props[path];\n  }\n  return value;\n}\n\n// data api\n\n/**\n * Sends array splice notifications (`.splices` and `.length`)\n *\n * Note: this implementation only accepts normalized paths\n *\n * @param {!Polymer_PropertyEffects} inst Instance to send notifications to\n * @param {Array} array The array the mutations occurred on\n * @param {string} path The path to the array that was mutated\n * @param {Array} splices Array of splice records\n * @return {void}\n * @private\n */\nfunction notifySplices(inst, array, path, splices) {\n  const splicesData = {\n    indexSplices: splices\n  };\n  // Legacy behavior stored splices in `__data__` so it was *not* ephemeral.\n  // To match this behavior, we store splices directly on the array.\n  if (legacyUndefined && !inst._overrideLegacyUndefined) {\n    array.splices = splicesData;\n  }\n  inst.notifyPath(path + '.splices', splicesData);\n  inst.notifyPath(path + '.length', array.length);\n  // Clear splice data only when it's stored on the array.\n  if (legacyUndefined && !inst._overrideLegacyUndefined) {\n    splicesData.indexSplices = [];\n  }\n}\n\n/**\n * Creates a splice record and sends an array splice notification for\n * the described mutation\n *\n * Note: this implementation only accepts normalized paths\n *\n * @param {!Polymer_PropertyEffects} inst Instance to send notifications to\n * @param {Array} array The array the mutations occurred on\n * @param {string} path The path to the array that was mutated\n * @param {number} index Index at which the array mutation occurred\n * @param {number} addedCount Number of added items\n * @param {Array} removed Array of removed items\n * @return {void}\n * @private\n */\nfunction notifySplice(inst, array, path, index, addedCount, removed) {\n  notifySplices(inst, array, path, [{\n    index: index,\n    addedCount: addedCount,\n    removed: removed,\n    object: array,\n    type: 'splice'\n  }]);\n}\n\n/**\n * Returns an upper-cased version of the string.\n *\n * @param {string} name String to uppercase\n * @return {string} Uppercased string\n * @private\n */\nfunction upper(name) {\n  return name[0].toUpperCase() + name.substring(1);\n}\n\n/**\n * Element class mixin that provides meta-programming for Polymer's template\n * binding and data observation (collectively, \"property effects\") system.\n *\n * This mixin uses provides the following key static methods for adding\n * property effects to an element class:\n * - `addPropertyEffect`\n * - `createPropertyObserver`\n * - `createMethodObserver`\n * - `createNotifyingProperty`\n * - `createReadOnlyProperty`\n * - `createReflectedProperty`\n * - `createComputedProperty`\n * - `bindTemplate`\n *\n * Each method creates one or more property accessors, along with metadata\n * used by this mixin's implementation of `_propertiesChanged` to perform\n * the property effects.\n *\n * Underscored versions of the above methods also exist on the element\n * prototype for adding property effects on instances at runtime.\n *\n * Note that this mixin overrides several `PropertyAccessors` methods, in\n * many cases to maintain guarantees provided by the Polymer 1.x features;\n * notably it changes property accessors to be synchronous by default\n * whereas the default when using `PropertyAccessors` standalone is to be\n * async by default.\n *\n * @mixinFunction\n * @polymer\n * @appliesMixin TemplateStamp\n * @appliesMixin PropertyAccessors\n * @summary Element class mixin that provides meta-programming for Polymer's\n * template binding and data observation system.\n */\nexport const PropertyEffects = dedupingMixin(superClass => {\n  /**\n   * @constructor\n   * @implements {Polymer_PropertyAccessors}\n   * @implements {Polymer_TemplateStamp}\n   * @unrestricted\n   * @private\n   */\n  const propertyEffectsBase = TemplateStamp(PropertyAccessors(superClass));\n\n  /**\n   * @polymer\n   * @mixinClass\n   * @implements {Polymer_PropertyEffects}\n   * @extends {propertyEffectsBase}\n   * @unrestricted\n   */\n  class PropertyEffects extends propertyEffectsBase {\n    constructor() {\n      super();\n      /** @type {boolean} */\n      // Used to identify users of this mixin, ala instanceof\n      this.__isPropertyEffectsClient = true;\n      /** @type {boolean} */\n      this.__dataClientsReady;\n      /** @type {Array} */\n      this.__dataPendingClients;\n      /** @type {Object} */\n      this.__dataToNotify;\n      /** @type {Object} */\n      this.__dataLinkedPaths;\n      /** @type {boolean} */\n      this.__dataHasPaths;\n      /** @type {Object} */\n      this.__dataCompoundStorage;\n      /** @type {Polymer_PropertyEffects} */\n      this.__dataHost;\n      /** @type {!Object} */\n      this.__dataTemp;\n      /** @type {boolean} */\n      this.__dataClientsInitialized;\n      /** @type {!Object} */\n      this.__data;\n      /** @type {!Object|null} */\n      this.__dataPending;\n      /** @type {!Object} */\n      this.__dataOld;\n      /** @type {Object} */\n      this.__computeEffects;\n      /** @type {Object} */\n      this.__computeInfo;\n      /** @type {Object} */\n      this.__reflectEffects;\n      /** @type {Object} */\n      this.__notifyEffects;\n      /** @type {Object} */\n      this.__propagateEffects;\n      /** @type {Object} */\n      this.__observeEffects;\n      /** @type {Object} */\n      this.__readOnly;\n      /** @type {!TemplateInfo} */\n      this.__templateInfo;\n      /** @type {boolean} */\n      this._overrideLegacyUndefined;\n    }\n    get PROPERTY_EFFECT_TYPES() {\n      return TYPES;\n    }\n\n    /**\n     * @override\n     * @return {void}\n     */\n    _initializeProperties() {\n      super._initializeProperties();\n      this._registerHost();\n      this.__dataClientsReady = false;\n      this.__dataPendingClients = null;\n      this.__dataToNotify = null;\n      this.__dataLinkedPaths = null;\n      this.__dataHasPaths = false;\n      // May be set on instance prior to upgrade\n      this.__dataCompoundStorage = this.__dataCompoundStorage || null;\n      this.__dataHost = this.__dataHost || null;\n      this.__dataTemp = {};\n      this.__dataClientsInitialized = false;\n    }\n    _registerHost() {\n      if (hostStack.length) {\n        let host = hostStack[hostStack.length - 1];\n        host._enqueueClient(this);\n        // This ensures even non-bound elements have a host set, as\n        // long as they upgrade synchronously\n        this.__dataHost = host;\n      }\n    }\n\n    /**\n     * Overrides `PropertyAccessors` implementation to provide a\n     * more efficient implementation of initializing properties from\n     * the prototype on the instance.\n     *\n     * @override\n     * @param {Object} props Properties to initialize on the prototype\n     * @return {void}\n     */\n    _initializeProtoProperties(props) {\n      this.__data = Object.create(props);\n      this.__dataPending = Object.create(props);\n      this.__dataOld = {};\n    }\n\n    /**\n     * Overrides `PropertyAccessors` implementation to avoid setting\n     * `_setProperty`'s `shouldNotify: true`.\n     *\n     * @override\n     * @param {Object} props Properties to initialize on the instance\n     * @return {void}\n     */\n    _initializeInstanceProperties(props) {\n      let readOnly = this[TYPES.READ_ONLY];\n      for (let prop in props) {\n        if (!readOnly || !readOnly[prop]) {\n          this.__dataPending = this.__dataPending || {};\n          this.__dataOld = this.__dataOld || {};\n          this.__data[prop] = this.__dataPending[prop] = props[prop];\n        }\n      }\n    }\n\n    // Prototype setup ----------------------------------------\n\n    /**\n     * Equivalent to static `addPropertyEffect` API but can be called on\n     * an instance to add effects at runtime.  See that method for\n     * full API docs.\n     *\n     * @override\n     * @param {string} property Property that should trigger the effect\n     * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES\n     * @param {Object=} effect Effect metadata object\n     * @return {void}\n     * @protected\n     */\n    _addPropertyEffect(property, type, effect) {\n      this._createPropertyAccessor(property, type == TYPES.READ_ONLY);\n      // effects are accumulated into arrays per property based on type\n      let effects = ensureOwnEffectMap(this, type, true)[property];\n      if (!effects) {\n        effects = this[type][property] = [];\n      }\n      effects.push(effect);\n    }\n\n    /**\n     * Removes the given property effect.\n     *\n     * @override\n     * @param {string} property Property the effect was associated with\n     * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES\n     * @param {Object=} effect Effect metadata object to remove\n     * @return {void}\n     */\n    _removePropertyEffect(property, type, effect) {\n      let effects = ensureOwnEffectMap(this, type, true)[property];\n      let idx = effects.indexOf(effect);\n      if (idx >= 0) {\n        effects.splice(idx, 1);\n      }\n    }\n\n    /**\n     * Returns whether the current prototype/instance has a property effect\n     * of a certain type.\n     *\n     * @override\n     * @param {string} property Property name\n     * @param {string=} type Effect type, from this.PROPERTY_EFFECT_TYPES\n     * @return {boolean} True if the prototype/instance has an effect of this\n     *     type\n     * @protected\n     */\n    _hasPropertyEffect(property, type) {\n      let effects = this[type];\n      return Boolean(effects && effects[property]);\n    }\n\n    /**\n     * Returns whether the current prototype/instance has a \"read only\"\n     * accessor for the given property.\n     *\n     * @override\n     * @param {string} property Property name\n     * @return {boolean} True if the prototype/instance has an effect of this\n     *     type\n     * @protected\n     */\n    _hasReadOnlyEffect(property) {\n      return this._hasPropertyEffect(property, TYPES.READ_ONLY);\n    }\n\n    /**\n     * Returns whether the current prototype/instance has a \"notify\"\n     * property effect for the given property.\n     *\n     * @override\n     * @param {string} property Property name\n     * @return {boolean} True if the prototype/instance has an effect of this\n     *     type\n     * @protected\n     */\n    _hasNotifyEffect(property) {\n      return this._hasPropertyEffect(property, TYPES.NOTIFY);\n    }\n\n    /**\n     * Returns whether the current prototype/instance has a \"reflect to\n     * attribute\" property effect for the given property.\n     *\n     * @override\n     * @param {string} property Property name\n     * @return {boolean} True if the prototype/instance has an effect of this\n     *     type\n     * @protected\n     */\n    _hasReflectEffect(property) {\n      return this._hasPropertyEffect(property, TYPES.REFLECT);\n    }\n\n    /**\n     * Returns whether the current prototype/instance has a \"computed\"\n     * property effect for the given property.\n     *\n     * @override\n     * @param {string} property Property name\n     * @return {boolean} True if the prototype/instance has an effect of this\n     *     type\n     * @protected\n     */\n    _hasComputedEffect(property) {\n      return this._hasPropertyEffect(property, TYPES.COMPUTE);\n    }\n\n    // Runtime ----------------------------------------\n\n    /**\n     * Sets a pending property or path.  If the root property of the path in\n     * question had no accessor, the path is set, otherwise it is enqueued\n     * via `_setPendingProperty`.\n     *\n     * This function isolates relatively expensive functionality necessary\n     * for the public API (`set`, `setProperties`, `notifyPath`, and property\n     * change listeners via {{...}} bindings), such that it is only done\n     * when paths enter the system, and not at every propagation step.  It\n     * also sets a `__dataHasPaths` flag on the instance which is used to\n     * fast-path slower path-matching code in the property effects host paths.\n     *\n     * `path` can be a path string or array of path parts as accepted by the\n     * public API.\n     *\n     * @override\n     * @param {string | !Array<number|string>} path Path to set\n     * @param {*} value Value to set\n     * @param {boolean=} shouldNotify Set to true if this change should\n     *  cause a property notification event dispatch\n     * @param {boolean=} isPathNotification If the path being set is a path\n     *   notification of an already changed value, as opposed to a request\n     *   to set and notify the change.  In the latter `false` case, a dirty\n     *   check is performed and then the value is set to the path before\n     *   enqueuing the pending property change.\n     * @return {boolean} Returns true if the property/path was enqueued in\n     *   the pending changes bag.\n     * @protected\n     */\n    _setPendingPropertyOrPath(path, value, shouldNotify, isPathNotification) {\n      if (isPathNotification || root(Array.isArray(path) ? path[0] : path) !== path) {\n        // Dirty check changes being set to a path against the actual object,\n        // since this is the entry point for paths into the system; from here\n        // the only dirty checks are against the `__dataTemp` cache to prevent\n        // duplicate work in the same turn only. Note, if this was a notification\n        // of a change already set to a path (isPathNotification: true),\n        // we always let the change through and skip the `set` since it was\n        // already dirty checked at the point of entry and the underlying\n        // object has already been updated\n        if (!isPathNotification) {\n          let old = get(this, path);\n          path = /** @type {string} */set(this, path, value);\n          // Use property-accessor's simpler dirty check\n          if (!path || !super._shouldPropertyChange(path, value, old)) {\n            return false;\n          }\n        }\n        this.__dataHasPaths = true;\n        if (this._setPendingProperty(/**@type{string}*/path, value, shouldNotify)) {\n          computeLinkedPaths(this, /**@type{string}*/path, value);\n          return true;\n        }\n      } else {\n        if (this.__dataHasAccessor && this.__dataHasAccessor[path]) {\n          return this._setPendingProperty(/**@type{string}*/path, value, shouldNotify);\n        } else {\n          this[path] = value;\n        }\n      }\n      return false;\n    }\n\n    /**\n     * Applies a value to a non-Polymer element/node's property.\n     *\n     * The implementation makes a best-effort at binding interop:\n     * Some native element properties have side-effects when\n     * re-setting the same value (e.g. setting `<input>.value` resets the\n     * cursor position), so we do a dirty-check before setting the value.\n     * However, for better interop with non-Polymer custom elements that\n     * accept objects, we explicitly re-set object changes coming from the\n     * Polymer world (which may include deep object changes without the\n     * top reference changing), erring on the side of providing more\n     * information.\n     *\n     * Users may override this method to provide alternate approaches.\n     *\n     * @override\n     * @param {!Node} node The node to set a property on\n     * @param {string} prop The property to set\n     * @param {*} value The value to set\n     * @return {void}\n     * @protected\n     */\n    _setUnmanagedPropertyToNode(node, prop, value) {\n      // It is a judgment call that resetting primitives is\n      // \"bad\" and resettings objects is also \"good\"; alternatively we could\n      // implement a whitelist of tag & property values that should never\n      // be reset (e.g. <input>.value && <select>.value)\n      if (value !== node[prop] || typeof value == 'object') {\n        // Note, className needs style scoping so this needs wrapping.\n        if (prop === 'className') {\n          node = /** @type {!Node} */wrap(node);\n        }\n        node[prop] = value;\n      }\n    }\n\n    /**\n     * Overrides the `PropertiesChanged` implementation to introduce special\n     * dirty check logic depending on the property & value being set:\n     *\n     * 1. Any value set to a path (e.g. 'obj.prop': 42 or 'obj.prop': {...})\n     *    Stored in `__dataTemp`, dirty checked against `__dataTemp`\n     * 2. Object set to simple property (e.g. 'prop': {...})\n     *    Stored in `__dataTemp` and `__data`, dirty checked against\n     *    `__dataTemp` by default implementation of `_shouldPropertyChange`\n     * 3. Primitive value set to simple property (e.g. 'prop': 42)\n     *    Stored in `__data`, dirty checked against `__data`\n     *\n     * The dirty-check is important to prevent cycles due to two-way\n     * notification, but paths and objects are only dirty checked against any\n     * previous value set during this turn via a \"temporary cache\" that is\n     * cleared when the last `_propertiesChanged` exits. This is so:\n     * a. any cached array paths (e.g. 'array.3.prop') may be invalidated\n     *    due to array mutations like shift/unshift/splice; this is fine\n     *    since path changes are dirty-checked at user entry points like `set`\n     * b. dirty-checking for objects only lasts one turn to allow the user\n     *    to mutate the object in-place and re-set it with the same identity\n     *    and have all sub-properties re-propagated in a subsequent turn.\n     *\n     * The temp cache is not necessarily sufficient to prevent invalid array\n     * paths, since a splice can happen during the same turn (with pathological\n     * user code); we could introduce a \"fixup\" for temporarily cached array\n     * paths if needed: https://github.com/Polymer/polymer/issues/4227\n     *\n     * @override\n     * @param {string} property Name of the property\n     * @param {*} value Value to set\n     * @param {boolean=} shouldNotify True if property should fire notification\n     *   event (applies only for `notify: true` properties)\n     * @return {boolean} Returns true if the property changed\n     */\n    _setPendingProperty(property, value, shouldNotify) {\n      let propIsPath = this.__dataHasPaths && isPath(property);\n      let prevProps = propIsPath ? this.__dataTemp : this.__data;\n      if (this._shouldPropertyChange(property, value, prevProps[property])) {\n        if (!this.__dataPending) {\n          this.__dataPending = {};\n          this.__dataOld = {};\n        }\n        // Ensure old is captured from the last turn\n        if (!(property in this.__dataOld)) {\n          this.__dataOld[property] = this.__data[property];\n        }\n        // Paths are stored in temporary cache (cleared at end of turn),\n        // which is used for dirty-checking, all others stored in __data\n        if (propIsPath) {\n          this.__dataTemp[property] = value;\n        } else {\n          this.__data[property] = value;\n        }\n        // All changes go into pending property bag, passed to _propertiesChanged\n        this.__dataPending[property] = value;\n        // Track properties that should notify separately\n        if (propIsPath || this[TYPES.NOTIFY] && this[TYPES.NOTIFY][property]) {\n          this.__dataToNotify = this.__dataToNotify || {};\n          this.__dataToNotify[property] = shouldNotify;\n        }\n        return true;\n      }\n      return false;\n    }\n\n    /**\n     * Overrides base implementation to ensure all accessors set `shouldNotify`\n     * to true, for per-property notification tracking.\n     *\n     * @override\n     * @param {string} property Name of the property\n     * @param {*} value Value to set\n     * @return {void}\n     */\n    _setProperty(property, value) {\n      if (this._setPendingProperty(property, value, true)) {\n        this._invalidateProperties();\n      }\n    }\n\n    /**\n     * Overrides `PropertyAccessor`'s default async queuing of\n     * `_propertiesChanged`: if `__dataReady` is false (has not yet been\n     * manually flushed), the function no-ops; otherwise flushes\n     * `_propertiesChanged` synchronously.\n     *\n     * @override\n     * @return {void}\n     */\n    _invalidateProperties() {\n      if (this.__dataReady) {\n        this._flushProperties();\n      }\n    }\n\n    /**\n     * Enqueues the given client on a list of pending clients, whose\n     * pending property changes can later be flushed via a call to\n     * `_flushClients`.\n     *\n     * @override\n     * @param {Object} client PropertyEffects client to enqueue\n     * @return {void}\n     * @protected\n     */\n    _enqueueClient(client) {\n      this.__dataPendingClients = this.__dataPendingClients || [];\n      if (client !== this) {\n        this.__dataPendingClients.push(client);\n      }\n    }\n\n    /**\n     * Flushes any clients previously enqueued via `_enqueueClient`, causing\n     * their `_flushProperties` method to run.\n     *\n     * @override\n     * @return {void}\n     * @protected\n     */\n    _flushClients() {\n      if (!this.__dataClientsReady) {\n        this.__dataClientsReady = true;\n        this._readyClients();\n        // Override point where accessors are turned on; importantly,\n        // this is after clients have fully readied, providing a guarantee\n        // that any property effects occur only after all clients are ready.\n        this.__dataReady = true;\n      } else {\n        this.__enableOrFlushClients();\n      }\n    }\n\n    // NOTE: We ensure clients either enable or flush as appropriate. This\n    // handles two corner cases:\n    // (1) clients flush properly when connected/enabled before the host\n    // enables; e.g.\n    //   (a) Templatize stamps with no properties and does not flush and\n    //   (b) the instance is inserted into dom and\n    //   (c) then the instance flushes.\n    // (2) clients enable properly when not connected/enabled when the host\n    // flushes; e.g.\n    //   (a) a template is runtime stamped and not yet connected/enabled\n    //   (b) a host sets a property, causing stamped dom to flush\n    //   (c) the stamped dom enables.\n    __enableOrFlushClients() {\n      let clients = this.__dataPendingClients;\n      if (clients) {\n        this.__dataPendingClients = null;\n        for (let i = 0; i < clients.length; i++) {\n          let client = clients[i];\n          if (!client.__dataEnabled) {\n            client._enableProperties();\n          } else if (client.__dataPending) {\n            client._flushProperties();\n          }\n        }\n      }\n    }\n\n    /**\n     * Perform any initial setup on client dom. Called before the first\n     * `_flushProperties` call on client dom and before any element\n     * observers are called.\n     *\n     * @override\n     * @return {void}\n     * @protected\n     */\n    _readyClients() {\n      this.__enableOrFlushClients();\n    }\n\n    /**\n     * Sets a bag of property changes to this instance, and\n     * synchronously processes all effects of the properties as a batch.\n     *\n     * Property names must be simple properties, not paths.  Batched\n     * path propagation is not supported.\n     *\n     * @override\n     * @param {Object} props Bag of one or more key-value pairs whose key is\n     *   a property and value is the new value to set for that property.\n     * @param {boolean=} setReadOnly When true, any private values set in\n     *   `props` will be set. By default, `setProperties` will not set\n     *   `readOnly: true` root properties.\n     * @return {void}\n     * @public\n     */\n    setProperties(props, setReadOnly) {\n      for (let path in props) {\n        if (setReadOnly || !this[TYPES.READ_ONLY] || !this[TYPES.READ_ONLY][path]) {\n          //TODO(kschaaf): explicitly disallow paths in setProperty?\n          // wildcard observers currently only pass the first changed path\n          // in the `info` object, and you could do some odd things batching\n          // paths, e.g. {'foo.bar': {...}, 'foo': null}\n          this._setPendingPropertyOrPath(path, props[path], true);\n        }\n      }\n      this._invalidateProperties();\n    }\n\n    /**\n     * Overrides `PropertyAccessors` so that property accessor\n     * side effects are not enabled until after client dom is fully ready.\n     * Also calls `_flushClients` callback to ensure client dom is enabled\n     * that was not enabled as a result of flushing properties.\n     *\n     * @override\n     * @return {void}\n     */\n    ready() {\n      // It is important that `super.ready()` is not called here as it\n      // immediately turns on accessors. Instead, we wait until `readyClients`\n      // to enable accessors to provide a guarantee that clients are ready\n      // before processing any accessors side effects.\n      this._flushProperties();\n      // If no data was pending, `_flushProperties` will not `flushClients`\n      // so ensure this is done.\n      if (!this.__dataClientsReady) {\n        this._flushClients();\n      }\n      // Before ready, client notifications do not trigger _flushProperties.\n      // Therefore a flush is necessary here if data has been set.\n      if (this.__dataPending) {\n        this._flushProperties();\n      }\n    }\n\n    /**\n     * Implements `PropertyAccessors`'s properties changed callback.\n     *\n     * Runs each class of effects for the batch of changed properties in\n     * a specific order (compute, propagate, reflect, observe, notify).\n     *\n     * @override\n     * @param {!Object} currentProps Bag of all current accessor values\n     * @param {?Object} changedProps Bag of properties changed since the last\n     *   call to `_propertiesChanged`\n     * @param {?Object} oldProps Bag of previous values for each property\n     *   in `changedProps`\n     * @return {void}\n     */\n    _propertiesChanged(currentProps, changedProps, oldProps) {\n      // ----------------------------\n      // let c = Object.getOwnPropertyNames(changedProps || {});\n      // window.debug && console.group(this.localName + '#' + this.id + ': ' + c);\n      // if (window.debug) { debugger; }\n      // ----------------------------\n      let hasPaths = this.__dataHasPaths;\n      this.__dataHasPaths = false;\n      let notifyProps;\n      // Compute properties\n      runComputedEffects(this, changedProps, oldProps, hasPaths);\n      // Clear notify properties prior to possible reentry (propagate, observe),\n      // but after computing effects have a chance to add to them\n      notifyProps = this.__dataToNotify;\n      this.__dataToNotify = null;\n      // Propagate properties to clients\n      this._propagatePropertyChanges(changedProps, oldProps, hasPaths);\n      // Flush clients\n      this._flushClients();\n      // Reflect properties\n      runEffects(this, this[TYPES.REFLECT], changedProps, oldProps, hasPaths);\n      // Observe properties\n      runEffects(this, this[TYPES.OBSERVE], changedProps, oldProps, hasPaths);\n      // Notify properties to host\n      if (notifyProps) {\n        runNotifyEffects(this, notifyProps, changedProps, oldProps, hasPaths);\n      }\n      // Clear temporary cache at end of turn\n      if (this.__dataCounter == 1) {\n        this.__dataTemp = {};\n      }\n      // ----------------------------\n      // window.debug && console.groupEnd(this.localName + '#' + this.id + ': ' + c);\n      // ----------------------------\n    }\n\n    /**\n     * Called to propagate any property changes to stamped template nodes\n     * managed by this element.\n     *\n     * @override\n     * @param {Object} changedProps Bag of changed properties\n     * @param {Object} oldProps Bag of previous values for changed properties\n     * @param {boolean} hasPaths True with `props` contains one or more paths\n     * @return {void}\n     * @protected\n     */\n    _propagatePropertyChanges(changedProps, oldProps, hasPaths) {\n      if (this[TYPES.PROPAGATE]) {\n        runEffects(this, this[TYPES.PROPAGATE], changedProps, oldProps, hasPaths);\n      }\n      if (this.__templateInfo) {\n        this._runEffectsForTemplate(this.__templateInfo, changedProps, oldProps, hasPaths);\n      }\n    }\n    _runEffectsForTemplate(templateInfo, changedProps, oldProps, hasPaths) {\n      const baseRunEffects = (changedProps, hasPaths) => {\n        runEffects(this, templateInfo.propertyEffects, changedProps, oldProps, hasPaths, templateInfo.nodeList);\n        for (let info = templateInfo.firstChild; info; info = info.nextSibling) {\n          this._runEffectsForTemplate(info, changedProps, oldProps, hasPaths);\n        }\n      };\n      if (templateInfo.runEffects) {\n        templateInfo.runEffects(baseRunEffects, changedProps, hasPaths);\n      } else {\n        baseRunEffects(changedProps, hasPaths);\n      }\n    }\n\n    /**\n     * Aliases one data path as another, such that path notifications from one\n     * are routed to the other.\n     *\n     * @override\n     * @param {string | !Array<string|number>} to Target path to link.\n     * @param {string | !Array<string|number>} from Source path to link.\n     * @return {void}\n     * @public\n     */\n    linkPaths(to, from) {\n      to = normalize(to);\n      from = normalize(from);\n      this.__dataLinkedPaths = this.__dataLinkedPaths || {};\n      this.__dataLinkedPaths[to] = from;\n    }\n\n    /**\n     * Removes a data path alias previously established with `_linkPaths`.\n     *\n     * Note, the path to unlink should be the target (`to`) used when\n     * linking the paths.\n     *\n     * @override\n     * @param {string | !Array<string|number>} path Target path to unlink.\n     * @return {void}\n     * @public\n     */\n    unlinkPaths(path) {\n      path = normalize(path);\n      if (this.__dataLinkedPaths) {\n        delete this.__dataLinkedPaths[path];\n      }\n    }\n\n    /**\n     * Notify that an array has changed.\n     *\n     * Example:\n     *\n     *     this.items = [ {name: 'Jim'}, {name: 'Todd'}, {name: 'Bill'} ];\n     *     ...\n     *     this.items.splice(1, 1, {name: 'Sam'});\n     *     this.items.push({name: 'Bob'});\n     *     this.notifySplices('items', [\n     *       { index: 1, removed: [{name: 'Todd'}], addedCount: 1,\n     *         object: this.items, type: 'splice' },\n     *       { index: 3, removed: [], addedCount: 1,\n     *         object: this.items, type: 'splice'}\n     *     ]);\n     *\n     * @param {string} path Path that should be notified.\n     * @param {Array} splices Array of splice records indicating ordered\n     *   changes that occurred to the array. Each record should have the\n     *   following fields:\n     *    * index: index at which the change occurred\n     *    * removed: array of items that were removed from this index\n     *    * addedCount: number of new items added at this index\n     *    * object: a reference to the array in question\n     *    * type: the string literal 'splice'\n     *\n     *   Note that splice records _must_ be normalized such that they are\n     *   reported in index order (raw results from `Object.observe` are not\n     *   ordered and must be normalized/merged before notifying).\n     *\n     * @override\n     * @return {void}\n     * @public\n     */\n    notifySplices(path, splices) {\n      let info = {\n        path: ''\n      };\n      let array = /** @type {Array} */get(this, path, info);\n      notifySplices(this, array, info.path, splices);\n    }\n\n    /**\n     * Convenience method for reading a value from a path.\n     *\n     * Note, if any part in the path is undefined, this method returns\n     * `undefined` (this method does not throw when dereferencing undefined\n     * paths).\n     *\n     * @override\n     * @param {(string|!Array<(string|number)>)} path Path to the value\n     *   to read.  The path may be specified as a string (e.g. `foo.bar.baz`)\n     *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that\n     *   bracketed expressions are not supported; string-based path parts\n     *   *must* be separated by dots.  Note that when dereferencing array\n     *   indices, the index may be used as a dotted part directly\n     *   (e.g. `users.12.name` or `['users', 12, 'name']`).\n     * @param {Object=} root Root object from which the path is evaluated.\n     * @return {*} Value at the path, or `undefined` if any part of the path\n     *   is undefined.\n     * @public\n     */\n    get(path, root) {\n      return get(root || this, path);\n    }\n\n    /**\n     * Convenience method for setting a value to a path and notifying any\n     * elements bound to the same path.\n     *\n     * Note, if any part in the path except for the last is undefined,\n     * this method does nothing (this method does not throw when\n     * dereferencing undefined paths).\n     *\n     * @override\n     * @param {(string|!Array<(string|number)>)} path Path to the value\n     *   to write.  The path may be specified as a string (e.g. `'foo.bar.baz'`)\n     *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that\n     *   bracketed expressions are not supported; string-based path parts\n     *   *must* be separated by dots.  Note that when dereferencing array\n     *   indices, the index may be used as a dotted part directly\n     *   (e.g. `'users.12.name'` or `['users', 12, 'name']`).\n     * @param {*} value Value to set at the specified path.\n     * @param {Object=} root Root object from which the path is evaluated.\n     *   When specified, no notification will occur.\n     * @return {void}\n     * @public\n     */\n    set(path, value, root) {\n      if (root) {\n        set(root, path, value);\n      } else {\n        if (!this[TYPES.READ_ONLY] || !this[TYPES.READ_ONLY][(/** @type {string} */path)]) {\n          if (this._setPendingPropertyOrPath(path, value, true)) {\n            this._invalidateProperties();\n          }\n        }\n      }\n    }\n\n    /**\n     * Adds items onto the end of the array at the path specified.\n     *\n     * The arguments after `path` and return value match that of\n     * `Array.prototype.push`.\n     *\n     * This method notifies other paths to the same array that a\n     * splice occurred to the array.\n     *\n     * @override\n     * @param {string | !Array<string|number>} path Path to array.\n     * @param {...*} items Items to push onto array\n     * @return {number} New length of the array.\n     * @public\n     */\n    push(path) {\n      let info = {\n        path: ''\n      };\n      let array = /** @type {Array}*/get(this, path, info);\n      let len = array.length;\n      for (var _len = arguments.length, items = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n        items[_key - 1] = arguments[_key];\n      }\n      let ret = array.push(...items);\n      if (items.length) {\n        notifySplice(this, array, info.path, len, items.length, []);\n      }\n      return ret;\n    }\n\n    /**\n     * Removes an item from the end of array at the path specified.\n     *\n     * The arguments after `path` and return value match that of\n     * `Array.prototype.pop`.\n     *\n     * This method notifies other paths to the same array that a\n     * splice occurred to the array.\n     *\n     * @override\n     * @param {string | !Array<string|number>} path Path to array.\n     * @return {*} Item that was removed.\n     * @public\n     */\n    pop(path) {\n      let info = {\n        path: ''\n      };\n      let array = /** @type {Array} */get(this, path, info);\n      let hadLength = Boolean(array.length);\n      let ret = array.pop();\n      if (hadLength) {\n        notifySplice(this, array, info.path, array.length, 0, [ret]);\n      }\n      return ret;\n    }\n\n    /**\n     * Starting from the start index specified, removes 0 or more items\n     * from the array and inserts 0 or more new items in their place.\n     *\n     * The arguments after `path` and return value match that of\n     * `Array.prototype.splice`.\n     *\n     * This method notifies other paths to the same array that a\n     * splice occurred to the array.\n     *\n     * @override\n     * @param {string | !Array<string|number>} path Path to array.\n     * @param {number} start Index from which to start removing/inserting.\n     * @param {number=} deleteCount Number of items to remove.\n     * @param {...*} items Items to insert into array.\n     * @return {!Array} Array of removed items.\n     * @public\n     */\n    splice(path, start, deleteCount) {\n      for (var _len2 = arguments.length, items = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {\n        items[_key2 - 3] = arguments[_key2];\n      }\n      let info = {\n        path: ''\n      };\n      let array = /** @type {Array} */get(this, path, info);\n      // Normalize fancy native splice handling of crazy start values\n      if (start < 0) {\n        start = array.length - Math.floor(-start);\n      } else if (start) {\n        start = Math.floor(start);\n      }\n      // array.splice does different things based on the number of arguments\n      // you pass in. Therefore, array.splice(0) and array.splice(0, undefined)\n      // do different things. In the former, the whole array is cleared. In the\n      // latter, no items are removed.\n      // This means that we need to detect whether 1. one of the arguments\n      // is actually passed in and then 2. determine how many arguments\n      // we should pass on to the native array.splice\n      //\n      let ret;\n      // Omit any additional arguments if they were not passed in\n      if (arguments.length === 2) {\n        ret = array.splice(start);\n        // Either start was undefined and the others were defined, but in this\n        // case we can safely pass on all arguments\n        //\n        // Note: this includes the case where none of the arguments were passed in,\n        // e.g. this.splice('array'). However, if both start and deleteCount\n        // are undefined, array.splice will not modify the array (as expected)\n      } else {\n        ret = array.splice(start, deleteCount, ...items);\n      }\n      // At the end, check whether any items were passed in (e.g. insertions)\n      // or if the return array contains items (e.g. deletions).\n      // Only notify if items were added or deleted.\n      if (items.length || ret.length) {\n        notifySplice(this, array, info.path, start, items.length, ret);\n      }\n      return ret;\n    }\n\n    /**\n     * Removes an item from the beginning of array at the path specified.\n     *\n     * The arguments after `path` and return value match that of\n     * `Array.prototype.pop`.\n     *\n     * This method notifies other paths to the same array that a\n     * splice occurred to the array.\n     *\n     * @override\n     * @param {string | !Array<string|number>} path Path to array.\n     * @return {*} Item that was removed.\n     * @public\n     */\n    shift(path) {\n      let info = {\n        path: ''\n      };\n      let array = /** @type {Array} */get(this, path, info);\n      let hadLength = Boolean(array.length);\n      let ret = array.shift();\n      if (hadLength) {\n        notifySplice(this, array, info.path, 0, 0, [ret]);\n      }\n      return ret;\n    }\n\n    /**\n     * Adds items onto the beginning of the array at the path specified.\n     *\n     * The arguments after `path` and return value match that of\n     * `Array.prototype.push`.\n     *\n     * This method notifies other paths to the same array that a\n     * splice occurred to the array.\n     *\n     * @override\n     * @param {string | !Array<string|number>} path Path to array.\n     * @param {...*} items Items to insert info array\n     * @return {number} New length of the array.\n     * @public\n     */\n    unshift(path) {\n      let info = {\n        path: ''\n      };\n      let array = /** @type {Array} */get(this, path, info);\n      for (var _len3 = arguments.length, items = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {\n        items[_key3 - 1] = arguments[_key3];\n      }\n      let ret = array.unshift(...items);\n      if (items.length) {\n        notifySplice(this, array, info.path, 0, items.length, []);\n      }\n      return ret;\n    }\n\n    /**\n     * Notify that a path has changed.\n     *\n     * Example:\n     *\n     *     this.item.user.name = 'Bob';\n     *     this.notifyPath('item.user.name');\n     *\n     * @override\n     * @param {string} path Path that should be notified.\n     * @param {*=} value Value at the path (optional).\n     * @return {void}\n     * @public\n     */\n    notifyPath(path, value) {\n      /** @type {string} */\n      let propPath;\n      if (arguments.length == 1) {\n        // Get value if not supplied\n        let info = {\n          path: ''\n        };\n        value = get(this, path, info);\n        propPath = info.path;\n      } else if (Array.isArray(path)) {\n        // Normalize path if needed\n        propPath = normalize(path);\n      } else {\n        propPath = /** @type{string} */path;\n      }\n      if (this._setPendingPropertyOrPath(propPath, value, true, true)) {\n        this._invalidateProperties();\n      }\n    }\n\n    /**\n     * Equivalent to static `createReadOnlyProperty` API but can be called on\n     * an instance to add effects at runtime.  See that method for\n     * full API docs.\n     *\n     * @override\n     * @param {string} property Property name\n     * @param {boolean=} protectedSetter Creates a custom protected setter\n     *   when `true`.\n     * @return {void}\n     * @protected\n     */\n    _createReadOnlyProperty(property, protectedSetter) {\n      this._addPropertyEffect(property, TYPES.READ_ONLY);\n      if (protectedSetter) {\n        this['_set' + upper(property)] = /** @this {PropertyEffects} */function (value) {\n          this._setProperty(property, value);\n        };\n      }\n    }\n\n    /**\n     * Equivalent to static `createPropertyObserver` API but can be called on\n     * an instance to add effects at runtime.  See that method for\n     * full API docs.\n     *\n     * @override\n     * @param {string} property Property name\n     * @param {string|function(*,*)} method Function or name of observer method\n     *     to call\n     * @param {boolean=} dynamicFn Whether the method name should be included as\n     *   a dependency to the effect.\n     * @return {void}\n     * @protected\n     */\n    _createPropertyObserver(property, method, dynamicFn) {\n      let info = {\n        property,\n        method,\n        dynamicFn: Boolean(dynamicFn)\n      };\n      this._addPropertyEffect(property, TYPES.OBSERVE, {\n        fn: runObserverEffect,\n        info,\n        trigger: {\n          name: property\n        }\n      });\n      if (dynamicFn) {\n        this._addPropertyEffect(/** @type {string} */method, TYPES.OBSERVE, {\n          fn: runObserverEffect,\n          info,\n          trigger: {\n            name: method\n          }\n        });\n      }\n    }\n\n    /**\n     * Equivalent to static `createMethodObserver` API but can be called on\n     * an instance to add effects at runtime.  See that method for\n     * full API docs.\n     *\n     * @override\n     * @param {string} expression Method expression\n     * @param {boolean|Object=} dynamicFn Boolean or object map indicating\n     *   whether method names should be included as a dependency to the effect.\n     * @return {void}\n     * @protected\n     */\n    _createMethodObserver(expression, dynamicFn) {\n      let sig = parseMethod(expression);\n      if (!sig) {\n        throw new Error(\"Malformed observer expression '\" + expression + \"'\");\n      }\n      createMethodEffect(this, sig, TYPES.OBSERVE, runMethodEffect, null, dynamicFn);\n    }\n\n    /**\n     * Equivalent to static `createNotifyingProperty` API but can be called on\n     * an instance to add effects at runtime.  See that method for\n     * full API docs.\n     *\n     * @override\n     * @param {string} property Property name\n     * @return {void}\n     * @protected\n     */\n    _createNotifyingProperty(property) {\n      this._addPropertyEffect(property, TYPES.NOTIFY, {\n        fn: runNotifyEffect,\n        info: {\n          eventName: camelToDashCase(property) + '-changed',\n          property: property\n        }\n      });\n    }\n\n    /**\n     * Equivalent to static `createReflectedProperty` API but can be called on\n     * an instance to add effects at runtime.  See that method for\n     * full API docs.\n     *\n     * @override\n     * @param {string} property Property name\n     * @return {void}\n     * @protected\n     * @suppress {missingProperties} go/missingfnprops\n     */\n    _createReflectedProperty(property) {\n      let attr = this.constructor.attributeNameForProperty(property);\n      if (attr[0] === '-') {\n        console.warn('Property ' + property + ' cannot be reflected to attribute ' + attr + ' because \"-\" is not a valid starting attribute name. Use a lowercase first letter for the property instead.');\n      } else {\n        this._addPropertyEffect(property, TYPES.REFLECT, {\n          fn: runReflectEffect,\n          info: {\n            attrName: attr\n          }\n        });\n      }\n    }\n\n    /**\n     * Equivalent to static `createComputedProperty` API but can be called on\n     * an instance to add effects at runtime.  See that method for\n     * full API docs.\n     *\n     * @override\n     * @param {string} property Name of computed property to set\n     * @param {string} expression Method expression\n     * @param {boolean|Object=} dynamicFn Boolean or object map indicating\n     *   whether method names should be included as a dependency to the effect.\n     * @return {void}\n     * @protected\n     */\n    _createComputedProperty(property, expression, dynamicFn) {\n      let sig = parseMethod(expression);\n      if (!sig) {\n        throw new Error(\"Malformed computed expression '\" + expression + \"'\");\n      }\n      const info = createMethodEffect(this, sig, TYPES.COMPUTE, runComputedEffect, property, dynamicFn);\n      // Effects are normally stored as map of dependency->effect, but for\n      // ordered computation, we also need tree of computedProp->dependencies\n      ensureOwnEffectMap(this, COMPUTE_INFO)[property] = info;\n    }\n\n    /**\n     * Gather the argument values for a method specified in the provided array\n     * of argument metadata.\n     *\n     * The `path` and `value` arguments are used to fill in wildcard descriptor\n     * when the method is being called as a result of a path notification.\n     *\n     * @param {!Array<!MethodArg>} args Array of argument metadata\n     * @param {string} path Property/path name that triggered the method effect\n     * @param {Object} props Bag of current property changes\n     * @return {!Array<*>} Array of argument values\n     * @private\n     */\n    _marshalArgs(args, path, props) {\n      const data = this.__data;\n      const values = [];\n      for (let i = 0, l = args.length; i < l; i++) {\n        let _args$i = args[i],\n          name = _args$i.name,\n          structured = _args$i.structured,\n          wildcard = _args$i.wildcard,\n          value = _args$i.value,\n          literal = _args$i.literal;\n        if (!literal) {\n          if (wildcard) {\n            const matches = isDescendant(name, path);\n            const pathValue = getArgValue(data, props, matches ? path : name);\n            value = {\n              path: matches ? path : name,\n              value: pathValue,\n              base: matches ? get(data, name) : pathValue\n            };\n          } else {\n            value = structured ? getArgValue(data, props, name) : data[name];\n          }\n        }\n        // When the `legacyUndefined` flag is enabled, pass a no-op value\n        // so that the observer, computed property, or compound binding is aborted.\n        if (legacyUndefined && !this._overrideLegacyUndefined && value === undefined && args.length > 1) {\n          return NOOP;\n        }\n        values[i] = value;\n      }\n      return values;\n    }\n\n    // -- static class methods ------------\n\n    /**\n     * Ensures an accessor exists for the specified property, and adds\n     * to a list of \"property effects\" that will run when the accessor for\n     * the specified property is set.  Effects are grouped by \"type\", which\n     * roughly corresponds to a phase in effect processing.  The effect\n     * metadata should be in the following form:\n     *\n     *     {\n     *       fn: effectFunction, // Reference to function to call to perform effect\n     *       info: { ... }       // Effect metadata passed to function\n     *       trigger: {          // Optional triggering metadata; if not provided\n     *         name: string      // the property is treated as a wildcard\n     *         structured: boolean\n     *         wildcard: boolean\n     *       }\n     *     }\n     *\n     * Effects are called from `_propertiesChanged` in the following order by\n     * type:\n     *\n     * 1. COMPUTE\n     * 2. PROPAGATE\n     * 3. REFLECT\n     * 4. OBSERVE\n     * 5. NOTIFY\n     *\n     * Effect functions are called with the following signature:\n     *\n     *     effectFunction(inst, path, props, oldProps, info, hasPaths)\n     *\n     * @param {string} property Property that should trigger the effect\n     * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES\n     * @param {Object=} effect Effect metadata object\n     * @return {void}\n     * @protected\n     * @nocollapse\n     */\n    static addPropertyEffect(property, type, effect) {\n      this.prototype._addPropertyEffect(property, type, effect);\n    }\n\n    /**\n     * Creates a single-property observer for the given property.\n     *\n     * @param {string} property Property name\n     * @param {string|function(*,*)} method Function or name of observer method to call\n     * @param {boolean=} dynamicFn Whether the method name should be included as\n     *   a dependency to the effect.\n     * @return {void}\n     * @protected\n     * @nocollapse\n     */\n    static createPropertyObserver(property, method, dynamicFn) {\n      this.prototype._createPropertyObserver(property, method, dynamicFn);\n    }\n\n    /**\n     * Creates a multi-property \"method observer\" based on the provided\n     * expression, which should be a string in the form of a normal JavaScript\n     * function signature: `'methodName(arg1, [..., argn])'`.  Each argument\n     * should correspond to a property or path in the context of this\n     * prototype (or instance), or may be a literal string or number.\n     *\n     * @param {string} expression Method expression\n     * @param {boolean|Object=} dynamicFn Boolean or object map indicating\n     * @return {void}\n     *   whether method names should be included as a dependency to the effect.\n     * @protected\n     * @nocollapse\n     */\n    static createMethodObserver(expression, dynamicFn) {\n      this.prototype._createMethodObserver(expression, dynamicFn);\n    }\n\n    /**\n     * Causes the setter for the given property to dispatch `<property>-changed`\n     * events to notify of changes to the property.\n     *\n     * @param {string} property Property name\n     * @return {void}\n     * @protected\n     * @nocollapse\n     */\n    static createNotifyingProperty(property) {\n      this.prototype._createNotifyingProperty(property);\n    }\n\n    /**\n     * Creates a read-only accessor for the given property.\n     *\n     * To set the property, use the protected `_setProperty` API.\n     * To create a custom protected setter (e.g. `_setMyProp()` for\n     * property `myProp`), pass `true` for `protectedSetter`.\n     *\n     * Note, if the property will have other property effects, this method\n     * should be called first, before adding other effects.\n     *\n     * @param {string} property Property name\n     * @param {boolean=} protectedSetter Creates a custom protected setter\n     *   when `true`.\n     * @return {void}\n     * @protected\n     * @nocollapse\n     */\n    static createReadOnlyProperty(property, protectedSetter) {\n      this.prototype._createReadOnlyProperty(property, protectedSetter);\n    }\n\n    /**\n     * Causes the setter for the given property to reflect the property value\n     * to a (dash-cased) attribute of the same name.\n     *\n     * @param {string} property Property name\n     * @return {void}\n     * @protected\n     * @nocollapse\n     */\n    static createReflectedProperty(property) {\n      this.prototype._createReflectedProperty(property);\n    }\n\n    /**\n     * Creates a computed property whose value is set to the result of the\n     * method described by the given `expression` each time one or more\n     * arguments to the method changes.  The expression should be a string\n     * in the form of a normal JavaScript function signature:\n     * `'methodName(arg1, [..., argn])'`\n     *\n     * @param {string} property Name of computed property to set\n     * @param {string} expression Method expression\n     * @param {boolean|Object=} dynamicFn Boolean or object map indicating whether\n     *   method names should be included as a dependency to the effect.\n     * @return {void}\n     * @protected\n     * @nocollapse\n     */\n    static createComputedProperty(property, expression, dynamicFn) {\n      this.prototype._createComputedProperty(property, expression, dynamicFn);\n    }\n\n    /**\n     * Parses the provided template to ensure binding effects are created\n     * for them, and then ensures property accessors are created for any\n     * dependent properties in the template.  Binding effects for bound\n     * templates are stored in a linked list on the instance so that\n     * templates can be efficiently stamped and unstamped.\n     *\n     * @param {!HTMLTemplateElement} template Template containing binding\n     *   bindings\n     * @return {!TemplateInfo} Template metadata object\n     * @protected\n     * @nocollapse\n     */\n    static bindTemplate(template) {\n      return this.prototype._bindTemplate(template);\n    }\n\n    // -- binding ----------------------------------------------\n\n    /*\n     * Overview of binding flow:\n     *\n     * During finalization (`instanceBinding==false`, `wasPreBound==false`):\n     *  `_bindTemplate(t, false)` called directly during finalization - parses\n     *  the template (for the first time), and then assigns that _prototypical_\n     *  template info to `__preboundTemplateInfo` _on the prototype_; note in\n     *  this case `wasPreBound` is false; this is the first time we're binding\n     *  it, thus we create accessors.\n     *\n     * During first stamping (`instanceBinding==true`, `wasPreBound==true`):\n     *   `_stampTemplate` calls `_bindTemplate(t, true)`: the `templateInfo`\n     *   returned matches the prebound one, and so this is `wasPreBound == true`\n     *   state; thus we _skip_ creating accessors, but _do_ create an instance\n     *   of the template info to serve as the start of our linked list (needs to\n     *   be an instance, not the prototypical one, so that we can add `nodeList`\n     *   to it to contain the `nodeInfo`-ordered list of instance nodes for\n     *   bindings, and so we can chain runtime-stamped template infos off of\n     *   it). At this point, the call to `_stampTemplate` calls\n     *   `applyTemplateInfo` for each nested `<template>` found during parsing\n     *   to hand prototypical `_templateInfo` to them; we also pass the _parent_\n     *   `templateInfo` to the `<template>` so that we have the instance-time\n     *   parent to link the `templateInfo` under in the case it was\n     *   runtime-stamped.\n     *\n     * During subsequent runtime stamping (`instanceBinding==true`,\n     *   `wasPreBound==false`): `_stampTemplate` calls `_bindTemplate(t, true)`\n     *   - here `templateInfo` is guaranteed to _not_ match the prebound one,\n     *   because it was either a different template altogether, or even if it\n     *   was the same template, the step above created a instance of the info;\n     *   in this case `wasPreBound == false`, so we _do_ create accessors, _and_\n     *   link a instance into the linked list.\n     */\n\n    /**\n     * Equivalent to static `bindTemplate` API but can be called on an instance\n     * to add effects at runtime.  See that method for full API docs.\n     *\n     * This method may be called on the prototype (for prototypical template\n     * binding, to avoid creating accessors every instance) once per prototype,\n     * and will be called with `runtimeBinding: true` by `_stampTemplate` to\n     * create and link an instance of the template metadata associated with a\n     * particular stamping.\n     *\n     * @override\n     * @param {!HTMLTemplateElement} template Template containing binding\n     * bindings\n     * @param {boolean=} instanceBinding When false (default), performs\n     * \"prototypical\" binding of the template and overwrites any previously\n     * bound template for the class. When true (as passed from\n     * `_stampTemplate`), the template info is instanced and linked into the\n     * list of bound templates.\n     * @return {!TemplateInfo} Template metadata object; for `runtimeBinding`,\n     * this is an instance of the prototypical template info\n     * @protected\n     * @suppress {missingProperties} go/missingfnprops\n     */\n    _bindTemplate(template, instanceBinding) {\n      let templateInfo = this.constructor._parseTemplate(template);\n      let wasPreBound = this.__preBoundTemplateInfo == templateInfo;\n      // Optimization: since this is called twice for proto-bound templates,\n      // don't attempt to recreate accessors if this template was pre-bound\n      if (!wasPreBound) {\n        for (let prop in templateInfo.propertyEffects) {\n          this._createPropertyAccessor(prop);\n        }\n      }\n      if (instanceBinding) {\n        // For instance-time binding, create instance of template metadata\n        // and link into tree of templates if necessary\n        templateInfo = /** @type {!TemplateInfo} */Object.create(templateInfo);\n        templateInfo.wasPreBound = wasPreBound;\n        if (!this.__templateInfo) {\n          // Set the info to the root of the tree\n          this.__templateInfo = templateInfo;\n        } else {\n          // Append this template info onto the end of its parent template's\n          // list, which will determine the tree structure via which property\n          // effects are run; if this template was not nested in another\n          // template, use the root template (the first stamped one) as the\n          // parent. Note, `parent` is the `templateInfo` instance for this\n          // template's parent (containing) template, which was set up in\n          // `applyTemplateInfo`.  While a given template's `parent` is set\n          // apriori, it is only added to the parent's child list at the point\n          // that it is being bound, since a template may or may not ever be\n          // stamped, and may be stamped more than once (in which case instances\n          // of the template info will be in the tree under its parent more than\n          // once).\n          const parent = template._parentTemplateInfo || this.__templateInfo;\n          const previous = parent.lastChild;\n          templateInfo.parent = parent;\n          parent.lastChild = templateInfo;\n          templateInfo.previousSibling = previous;\n          if (previous) {\n            previous.nextSibling = templateInfo;\n          } else {\n            parent.firstChild = templateInfo;\n          }\n        }\n      } else {\n        this.__preBoundTemplateInfo = templateInfo;\n      }\n      return templateInfo;\n    }\n\n    /**\n     * Adds a property effect to the given template metadata, which is run\n     * at the \"propagate\" stage of `_propertiesChanged` when the template\n     * has been bound to the element via `_bindTemplate`.\n     *\n     * The `effect` object should match the format in `_addPropertyEffect`.\n     *\n     * @param {Object} templateInfo Template metadata to add effect to\n     * @param {string} prop Property that should trigger the effect\n     * @param {Object=} effect Effect metadata object\n     * @return {void}\n     * @protected\n     * @nocollapse\n     */\n    static _addTemplatePropertyEffect(templateInfo, prop, effect) {\n      let hostProps = templateInfo.hostProps = templateInfo.hostProps || {};\n      hostProps[prop] = true;\n      let effects = templateInfo.propertyEffects = templateInfo.propertyEffects || {};\n      let propEffects = effects[prop] = effects[prop] || [];\n      propEffects.push(effect);\n    }\n\n    /**\n     * Stamps the provided template and performs instance-time setup for\n     * Polymer template features, including data bindings, declarative event\n     * listeners, and the `this.$` map of `id`'s to nodes.  A document fragment\n     * is returned containing the stamped DOM, ready for insertion into the\n     * DOM.\n     *\n     * This method may be called more than once; however note that due to\n     * `shadycss` polyfill limitations, only styles from templates prepared\n     * using `ShadyCSS.prepareTemplate` will be correctly polyfilled (scoped\n     * to the shadow root and support CSS custom properties), and note that\n     * `ShadyCSS.prepareTemplate` may only be called once per element. As such,\n     * any styles required by in runtime-stamped templates must be included\n     * in the main element template.\n     *\n     * @param {!HTMLTemplateElement} template Template to stamp\n     * @param {TemplateInfo=} templateInfo Optional bound template info associated\n     *   with the template to be stamped; if omitted the template will be\n     *   automatically bound.\n     * @return {!StampedTemplate} Cloned template content\n     * @override\n     * @protected\n     */\n    _stampTemplate(template, templateInfo) {\n      templateInfo = templateInfo || (/** @type {!TemplateInfo} */this._bindTemplate(template, true));\n      // Ensures that created dom is `_enqueueClient`'d to this element so\n      // that it can be flushed on next call to `_flushProperties`\n      hostStack.push(this);\n      let dom = super._stampTemplate(template, templateInfo);\n      hostStack.pop();\n      // Add template-instance-specific data to instanced templateInfo\n      templateInfo.nodeList = dom.nodeList;\n      // Capture child nodes to allow unstamping of non-prototypical templates\n      if (!templateInfo.wasPreBound) {\n        let nodes = templateInfo.childNodes = [];\n        for (let n = dom.firstChild; n; n = n.nextSibling) {\n          nodes.push(n);\n        }\n      }\n      dom.templateInfo = templateInfo;\n      // Setup compound storage, 2-way listeners, and dataHost for bindings\n      setupBindings(this, templateInfo);\n      // Flush properties into template nodes; the check on `__dataClientsReady`\n      // ensures we don't needlessly run effects for an element's initial\n      // prototypical template stamping since they will happen as a part of the\n      // first call to `_propertiesChanged`. This flag is set to true\n      // after running the initial propagate effects, and immediately before\n      // flushing clients. Since downstream clients could cause stamping on\n      // this host (e.g. a fastDomIf `dom-if` being forced to render\n      // synchronously), this flag ensures effects for runtime-stamped templates\n      // are run at this point during the initial element boot-up.\n      if (this.__dataClientsReady) {\n        this._runEffectsForTemplate(templateInfo, this.__data, null, false);\n        this._flushClients();\n      }\n      return dom;\n    }\n\n    /**\n     * Removes and unbinds the nodes previously contained in the provided\n     * DocumentFragment returned from `_stampTemplate`.\n     *\n     * @override\n     * @param {!StampedTemplate} dom DocumentFragment previously returned\n     *   from `_stampTemplate` associated with the nodes to be removed\n     * @return {void}\n     * @protected\n     */\n    _removeBoundDom(dom) {\n      // Unlink template info; Note that while the child is unlinked from its\n      // parent list, a template's `parent` reference is never removed, since\n      // this is is determined by the tree structure and applied at\n      // `applyTemplateInfo` time.\n      const templateInfo = dom.templateInfo;\n      const previousSibling = templateInfo.previousSibling,\n        nextSibling = templateInfo.nextSibling,\n        parent = templateInfo.parent;\n      if (previousSibling) {\n        previousSibling.nextSibling = nextSibling;\n      } else if (parent) {\n        parent.firstChild = nextSibling;\n      }\n      if (nextSibling) {\n        nextSibling.previousSibling = previousSibling;\n      } else if (parent) {\n        parent.lastChild = previousSibling;\n      }\n      templateInfo.nextSibling = templateInfo.previousSibling = null;\n      // Remove stamped nodes\n      let nodes = templateInfo.childNodes;\n      for (let i = 0; i < nodes.length; i++) {\n        let node = nodes[i];\n        wrap(wrap(node).parentNode).removeChild(node);\n      }\n    }\n\n    /**\n     * Overrides default `TemplateStamp` implementation to add support for\n     * parsing bindings from `TextNode`'s' `textContent`.  A `bindings`\n     * array is added to `nodeInfo` and populated with binding metadata\n     * with information capturing the binding target, and a `parts` array\n     * with one or more metadata objects capturing the source(s) of the\n     * binding.\n     *\n     * @param {Node} node Node to parse\n     * @param {TemplateInfo} templateInfo Template metadata for current template\n     * @param {NodeInfo} nodeInfo Node metadata for current template node\n     * @return {boolean} `true` if the visited node added node-specific\n     *   metadata to `nodeInfo`\n     * @protected\n     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do\n     * @nocollapse\n     */\n    static _parseTemplateNode(node, templateInfo, nodeInfo) {\n      // TODO(https://github.com/google/closure-compiler/issues/3240):\n      //     Change back to just super.methodCall()\n      let noted = propertyEffectsBase._parseTemplateNode.call(this, node, templateInfo, nodeInfo);\n      if (node.nodeType === Node.TEXT_NODE) {\n        let parts = this._parseBindings(node.textContent, templateInfo);\n        if (parts) {\n          // Initialize the textContent with any literal parts\n          // NOTE: default to a space here so the textNode remains; some browsers\n          // (IE) omit an empty textNode following cloneNode/importNode.\n          node.textContent = literalFromParts(parts) || ' ';\n          addBinding(this, templateInfo, nodeInfo, 'text', 'textContent', parts);\n          noted = true;\n        }\n      }\n      return noted;\n    }\n\n    /**\n     * Overrides default `TemplateStamp` implementation to add support for\n     * parsing bindings from attributes.  A `bindings`\n     * array is added to `nodeInfo` and populated with binding metadata\n     * with information capturing the binding target, and a `parts` array\n     * with one or more metadata objects capturing the source(s) of the\n     * binding.\n     *\n     * @param {Element} node Node to parse\n     * @param {TemplateInfo} templateInfo Template metadata for current template\n     * @param {NodeInfo} nodeInfo Node metadata for current template node\n     * @param {string} name Attribute name\n     * @param {string} value Attribute value\n     * @return {boolean} `true` if the visited node added node-specific\n     *   metadata to `nodeInfo`\n     * @protected\n     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do\n     * @nocollapse\n     */\n    static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {\n      let parts = this._parseBindings(value, templateInfo);\n      if (parts) {\n        // Attribute or property\n        let origName = name;\n        let kind = 'property';\n        // The only way we see a capital letter here is if the attr has\n        // a capital letter in it per spec. In this case, to make sure\n        // this binding works, we go ahead and make the binding to the attribute.\n        if (capitalAttributeRegex.test(name)) {\n          kind = 'attribute';\n        } else if (name[name.length - 1] == '$') {\n          name = name.slice(0, -1);\n          kind = 'attribute';\n        }\n        // Initialize attribute bindings with any literal parts\n        let literal = literalFromParts(parts);\n        if (literal && kind == 'attribute') {\n          // Ensure a ShadyCSS template scoped style is not removed\n          // when a class$ binding's initial literal value is set.\n          if (name == 'class' && node.hasAttribute('class')) {\n            literal += ' ' + node.getAttribute(name);\n          }\n          node.setAttribute(name, literal);\n        }\n        // support disable-upgrade\n        if (kind == 'attribute' && origName == 'disable-upgrade$') {\n          node.setAttribute(name, '');\n        }\n        // Clear attribute before removing, since IE won't allow removing\n        // `value` attribute if it previously had a value (can't\n        // unconditionally set '' before removing since attributes with `$`\n        // can't be set using setAttribute)\n        if (node.localName === 'input' && origName === 'value') {\n          node.setAttribute(origName, '');\n        }\n        // Remove annotation\n        node.removeAttribute(origName);\n        // Case hackery: attributes are lower-case, but bind targets\n        // (properties) are case sensitive. Gambit is to map dash-case to\n        // camel-case: `foo-bar` becomes `fooBar`.\n        // Attribute bindings are excepted.\n        if (kind === 'property') {\n          name = dashToCamelCase(name);\n        }\n        addBinding(this, templateInfo, nodeInfo, kind, name, parts, literal);\n        return true;\n      } else {\n        // TODO(https://github.com/google/closure-compiler/issues/3240):\n        //     Change back to just super.methodCall()\n        return propertyEffectsBase._parseTemplateNodeAttribute.call(this, node, templateInfo, nodeInfo, name, value);\n      }\n    }\n\n    /**\n     * Overrides default `TemplateStamp` implementation to add support for\n     * binding the properties that a nested template depends on to the template\n     * as `_host_<property>`.\n     *\n     * @param {Node} node Node to parse\n     * @param {TemplateInfo} templateInfo Template metadata for current template\n     * @param {NodeInfo} nodeInfo Node metadata for current template node\n     * @return {boolean} `true` if the visited node added node-specific\n     *   metadata to `nodeInfo`\n     * @protected\n     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do\n     * @nocollapse\n     */\n    static _parseTemplateNestedTemplate(node, templateInfo, nodeInfo) {\n      // TODO(https://github.com/google/closure-compiler/issues/3240):\n      //     Change back to just super.methodCall()\n      let noted = propertyEffectsBase._parseTemplateNestedTemplate.call(this, node, templateInfo, nodeInfo);\n      const parent = node.parentNode;\n      const nestedTemplateInfo = nodeInfo.templateInfo;\n      const isDomIf = parent.localName === 'dom-if';\n      const isDomRepeat = parent.localName === 'dom-repeat';\n      // Remove nested template and redirect its host bindings & templateInfo\n      // onto the parent (dom-if/repeat element)'s nodeInfo\n      if (removeNestedTemplates && (isDomIf || isDomRepeat)) {\n        parent.removeChild(node);\n        // Use the parent's nodeInfo (for the dom-if/repeat) to record the\n        // templateInfo, and use that for any host property bindings below\n        nodeInfo = nodeInfo.parentInfo;\n        nodeInfo.templateInfo = nestedTemplateInfo;\n        // Ensure the parent dom-if/repeat is noted since it now may have host\n        // bindings; it may not have been if it did not have its own bindings\n        nodeInfo.noted = true;\n        noted = false;\n      }\n      // Merge host props into outer template and add bindings\n      let hostProps = nestedTemplateInfo.hostProps;\n      if (fastDomIf && isDomIf) {\n        // `fastDomIf` mode uses runtime-template stamping to add accessors/\n        // effects to properties used in its template; as such we don't need to\n        // tax the host element with `_host_` bindings for the `dom-if`.\n        // However, in the event it is nested in a `dom-repeat`, it is still\n        // important that its host properties are added to the\n        // TemplateInstance's `hostProps` so that they are forwarded to the\n        // TemplateInstance.\n        if (hostProps) {\n          templateInfo.hostProps = Object.assign(templateInfo.hostProps || {}, hostProps);\n          // Ensure the dom-if is noted so that it has a __dataHost, since\n          // `fastDomIf` uses the host for runtime template stamping; note this\n          // was already ensured above in the `removeNestedTemplates` case\n          if (!removeNestedTemplates) {\n            nodeInfo.parentInfo.noted = true;\n          }\n        }\n      } else {\n        let mode = '{';\n        for (let source in hostProps) {\n          let parts = [{\n            mode,\n            source,\n            dependencies: [source],\n            hostProp: true\n          }];\n          addBinding(this, templateInfo, nodeInfo, 'property', '_host_' + source, parts);\n        }\n      }\n      return noted;\n    }\n\n    /**\n     * Called to parse text in a template (either attribute values or\n     * textContent) into binding metadata.\n     *\n     * Any overrides of this method should return an array of binding part\n     * metadata  representing one or more bindings found in the provided text\n     * and any \"literal\" text in between.  Any non-literal parts will be passed\n     * to `_evaluateBinding` when any dependencies change.  The only required\n     * fields of each \"part\" in the returned array are as follows:\n     *\n     * - `dependencies` - Array containing trigger metadata for each property\n     *   that should trigger the binding to update\n     * - `literal` - String containing text if the part represents a literal;\n     *   in this case no `dependencies` are needed\n     *\n     * Additional metadata for use by `_evaluateBinding` may be provided in\n     * each part object as needed.\n     *\n     * The default implementation handles the following types of bindings\n     * (one or more may be intermixed with literal strings):\n     * - Property binding: `[[prop]]`\n     * - Path binding: `[[object.prop]]`\n     * - Negated property or path bindings: `[[!prop]]` or `[[!object.prop]]`\n     * - Two-way property or path bindings (supports negation):\n     *   `{{prop}}`, `{{object.prop}}`, `{{!prop}}` or `{{!object.prop}}`\n     * - Inline computed method (supports negation):\n     *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`\n     *\n     * The default implementation uses a regular expression for best\n     * performance. However, the regular expression uses a white-list of\n     * allowed characters in a data-binding, which causes problems for\n     * data-bindings that do use characters not in this white-list.\n     *\n     * Instead of updating the white-list with all allowed characters,\n     * there is a StrictBindingParser (see lib/mixins/strict-binding-parser)\n     * that uses a state machine instead. This state machine is able to handle\n     * all characters. However, it is slightly less performant, therefore we\n     * extracted it into a separate optional mixin.\n     *\n     * @param {string} text Text to parse from attribute or textContent\n     * @param {Object} templateInfo Current template metadata\n     * @return {Array<!BindingPart>} Array of binding part metadata\n     * @protected\n     * @nocollapse\n     */\n    static _parseBindings(text, templateInfo) {\n      let parts = [];\n      let lastIndex = 0;\n      let m;\n      // Example: \"literal1{{prop}}literal2[[!compute(foo,bar)]]final\"\n      // Regex matches:\n      //        Iteration 1:  Iteration 2:\n      // m[1]: '{{'          '[['\n      // m[2]: ''            '!'\n      // m[3]: 'prop'        'compute(foo,bar)'\n      while ((m = bindingRegex.exec(text)) !== null) {\n        // Add literal part\n        if (m.index > lastIndex) {\n          parts.push({\n            literal: text.slice(lastIndex, m.index)\n          });\n        }\n        // Add binding part\n        let mode = m[1][0];\n        let negate = Boolean(m[2]);\n        let source = m[3].trim();\n        let customEvent = false,\n          notifyEvent = '',\n          colon = -1;\n        if (mode == '{' && (colon = source.indexOf('::')) > 0) {\n          notifyEvent = source.substring(colon + 2);\n          source = source.substring(0, colon);\n          customEvent = true;\n        }\n        let signature = parseMethod(source);\n        let dependencies = [];\n        if (signature) {\n          // Inline computed function\n          let args = signature.args,\n            methodName = signature.methodName;\n          for (let i = 0; i < args.length; i++) {\n            let arg = args[i];\n            if (!arg.literal) {\n              dependencies.push(arg);\n            }\n          }\n          let dynamicFns = templateInfo.dynamicFns;\n          if (dynamicFns && dynamicFns[methodName] || signature.static) {\n            dependencies.push(methodName);\n            signature.dynamicFn = true;\n          }\n        } else {\n          // Property or path\n          dependencies.push(source);\n        }\n        parts.push({\n          source,\n          mode,\n          negate,\n          customEvent,\n          signature,\n          dependencies,\n          event: notifyEvent\n        });\n        lastIndex = bindingRegex.lastIndex;\n      }\n      // Add a final literal part\n      if (lastIndex && lastIndex < text.length) {\n        let literal = text.substring(lastIndex);\n        if (literal) {\n          parts.push({\n            literal: literal\n          });\n        }\n      }\n      if (parts.length) {\n        return parts;\n      } else {\n        return null;\n      }\n    }\n\n    /**\n     * Called to evaluate a previously parsed binding part based on a set of\n     * one or more changed dependencies.\n     *\n     * @param {!Polymer_PropertyEffects} inst Element that should be used as\n     *     scope for binding dependencies\n     * @param {BindingPart} part Binding part metadata\n     * @param {string} path Property/path that triggered this effect\n     * @param {Object} props Bag of current property changes\n     * @param {Object} oldProps Bag of previous values for changed properties\n     * @param {boolean} hasPaths True with `props` contains one or more paths\n     * @return {*} Value the binding part evaluated to\n     * @protected\n     * @nocollapse\n     */\n    static _evaluateBinding(inst, part, path, props, oldProps, hasPaths) {\n      let value;\n      if (part.signature) {\n        value = runMethodEffect(inst, path, props, oldProps, part.signature);\n      } else if (path != part.source) {\n        value = get(inst, part.source);\n      } else {\n        if (hasPaths && isPath(path)) {\n          value = get(inst, path);\n        } else {\n          value = inst.__data[path];\n        }\n      }\n      if (part.negate) {\n        value = !value;\n      }\n      return value;\n    }\n  }\n  return PropertyEffects;\n});\n\n/**\n * Stack for enqueuing client dom created by a host element.\n *\n * By default elements are flushed via `_flushProperties` when\n * `connectedCallback` is called. Elements attach their client dom to\n * themselves at `ready` time which results from this first flush.\n * This provides an ordering guarantee that the client dom an element\n * creates is flushed before the element itself (i.e. client `ready`\n * fires before host `ready`).\n *\n * However, if `_flushProperties` is called *before* an element is connected,\n * as for example `Templatize` does, this ordering guarantee cannot be\n * satisfied because no elements are connected. (Note: Bound elements that\n * receive data do become enqueued clients and are properly ordered but\n * unbound elements are not.)\n *\n * To maintain the desired \"client before host\" ordering guarantee for this\n * case we rely on the \"host stack. Client nodes registers themselves with\n * the creating host element when created. This ensures that all client dom\n * is readied in the proper order, maintaining the desired guarantee.\n *\n * @private\n */\nconst hostStack = [];","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n/**\n * Total number of Polymer element instances created.\n * @type {number}\n */\nexport let instanceCount = 0;\nexport function incrementInstanceCount() {\n  instanceCount++;\n}\n\n/**\n * Array of Polymer element classes that have been finalized.\n * @type {!Array<!PolymerElementConstructor>}\n */\nexport const registrations = [];\n\n/**\n * @param {!PolymerElementConstructor} prototype Element prototype to log\n * @private\n */\nfunction _regLog(prototype) {\n  console.log('[' + /** @type {?} */prototype.is + ']: registered');\n}\n\n/**\n * Registers a class prototype for telemetry purposes.\n * @param {!PolymerElementConstructor} prototype Element prototype to register\n * @protected\n */\nexport function register(prototype) {\n  registrations.push(prototype);\n}\n\n/**\n * Logs all elements registered with an `is` to the console.\n * @public\n */\nexport function dumpRegistrations() {\n  registrations.forEach(_regLog);\n}","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport '../utils/boot.js';\nimport { dedupingMixin } from '../utils/mixin.js';\nimport { register, incrementInstanceCount } from '../utils/telemetry.js';\nimport { PropertiesChanged } from './properties-changed.js';\n\n/**\n * Creates a copy of `props` with each property normalized such that\n * upgraded it is an object with at least a type property { type: Type}.\n *\n * @param {!Object} props Properties to normalize\n * @return {!Object} Copy of input `props` with normalized properties that\n * are in the form {type: Type}\n * @private\n */\nfunction normalizeProperties(props) {\n  const output = {};\n  for (let p in props) {\n    const o = props[p];\n    output[p] = typeof o === 'function' ? {\n      type: o\n    } : o;\n  }\n  return output;\n}\n\n/**\n * Mixin that provides a minimal starting point to using the PropertiesChanged\n * mixin by providing a mechanism to declare properties in a static\n * getter (e.g. static get properties() { return { foo: String } }). Changes\n * are reported via the `_propertiesChanged` method.\n *\n * This mixin provides no specific support for rendering. Users are expected\n * to create a ShadowRoot and put content into it and update it in whatever\n * way makes sense. This can be done in reaction to properties changing by\n * implementing `_propertiesChanged`.\n *\n * @mixinFunction\n * @polymer\n * @appliesMixin PropertiesChanged\n * @summary Mixin that provides a minimal starting point for using\n * the PropertiesChanged mixin by providing a declarative `properties` object.\n * @template T\n * @param {function(new:T)} superClass Class to apply mixin to.\n * @return {function(new:T)} superClass with mixin applied.\n */\nexport const PropertiesMixin = dedupingMixin(superClass => {\n  /**\n   * @constructor\n   * @implements {Polymer_PropertiesChanged}\n   * @private\n   */\n  const base = PropertiesChanged(superClass);\n\n  /**\n   * Returns the super class constructor for the given class, if it is an\n   * instance of the PropertiesMixin.\n   *\n   * @param {!PropertiesMixinConstructor} constructor PropertiesMixin constructor\n   * @return {?PropertiesMixinConstructor} Super class constructor\n   */\n  function superPropertiesClass(constructor) {\n    const superCtor = Object.getPrototypeOf(constructor);\n\n    // Note, the `PropertiesMixin` class below only refers to the class\n    // generated by this call to the mixin; the instanceof test only works\n    // because the mixin is deduped and guaranteed only to apply once, hence\n    // all constructors in a proto chain will see the same `PropertiesMixin`\n    return superCtor.prototype instanceof PropertiesMixin ? (/** @type {!PropertiesMixinConstructor} */superCtor) : null;\n  }\n\n  /**\n   * Returns a memoized version of the `properties` object for the\n   * given class. Properties not in object format are converted to at\n   * least {type}.\n   *\n   * @param {PropertiesMixinConstructor} constructor PropertiesMixin constructor\n   * @return {Object} Memoized properties object\n   */\n  function ownProperties(constructor) {\n    if (!constructor.hasOwnProperty(JSCompiler_renameProperty('__ownProperties', constructor))) {\n      let props = null;\n      if (constructor.hasOwnProperty(JSCompiler_renameProperty('properties', constructor))) {\n        const properties = constructor.properties;\n        if (properties) {\n          props = normalizeProperties(properties);\n        }\n      }\n      constructor.__ownProperties = props;\n    }\n    return constructor.__ownProperties;\n  }\n\n  /**\n   * @polymer\n   * @mixinClass\n   * @extends {base}\n   * @implements {Polymer_PropertiesMixin}\n   * @unrestricted\n   */\n  class PropertiesMixin extends base {\n    /**\n     * Implements standard custom elements getter to observes the attributes\n     * listed in `properties`.\n     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do\n     * @nocollapse\n     */\n    static get observedAttributes() {\n      if (!this.hasOwnProperty(JSCompiler_renameProperty('__observedAttributes', this))) {\n        register(this.prototype);\n        const props = this._properties;\n        this.__observedAttributes = props ? Object.keys(props).map(p => this.prototype._addPropertyToAttributeMap(p)) : [];\n      }\n      return this.__observedAttributes;\n    }\n\n    /**\n     * Finalizes an element definition, including ensuring any super classes\n     * are also finalized. This includes ensuring property\n     * accessors exist on the element prototype. This method calls\n     * `_finalizeClass` to finalize each constructor in the prototype chain.\n     * @return {void}\n     * @nocollapse\n     */\n    static finalize() {\n      if (!this.hasOwnProperty(JSCompiler_renameProperty('__finalized', this))) {\n        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */this);\n        if (superCtor) {\n          superCtor.finalize();\n        }\n        this.__finalized = true;\n        this._finalizeClass();\n      }\n    }\n\n    /**\n     * Finalize an element class. This includes ensuring property\n     * accessors exist on the element prototype. This method is called by\n     * `finalize` and finalizes the class constructor.\n     *\n     * @protected\n     * @nocollapse\n     */\n    static _finalizeClass() {\n      const props = ownProperties(/** @type {!PropertiesMixinConstructor} */this);\n      if (props) {\n        /** @type {?} */this.createProperties(props);\n      }\n    }\n\n    /**\n     * Returns a memoized version of all properties, including those inherited\n     * from super classes. Properties not in object format are converted to\n     * at least {type}.\n     *\n     * @return {Object} Object containing properties for this class\n     * @protected\n     * @nocollapse\n     */\n    static get _properties() {\n      if (!this.hasOwnProperty(JSCompiler_renameProperty('__properties', this))) {\n        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */this);\n        this.__properties = Object.assign({}, superCtor && superCtor._properties, ownProperties(/** @type {PropertiesMixinConstructor} */this));\n      }\n      return this.__properties;\n    }\n\n    /**\n     * Overrides `PropertiesChanged` method to return type specified in the\n     * static `properties` object for the given property.\n     * @param {string} name Name of property\n     * @return {*} Type to which to deserialize attribute\n     *\n     * @protected\n     * @nocollapse\n     */\n    static typeForProperty(name) {\n      const info = this._properties[name];\n      return info && info.type;\n    }\n\n    /**\n     * Overrides `PropertiesChanged` method and adds a call to\n     * `finalize` which lazily configures the element's property accessors.\n     * @override\n     * @return {void}\n     */\n    _initializeProperties() {\n      incrementInstanceCount();\n      this.constructor.finalize();\n      super._initializeProperties();\n    }\n\n    /**\n     * Called when the element is added to a document.\n     * Calls `_enableProperties` to turn on property system from\n     * `PropertiesChanged`.\n     * @suppress {missingProperties} Super may or may not implement the callback\n     * @return {void}\n     * @override\n     */\n    connectedCallback() {\n      if (super.connectedCallback) {\n        super.connectedCallback();\n      }\n      this._enableProperties();\n    }\n\n    /**\n     * Called when the element is removed from a document\n     * @suppress {missingProperties} Super may or may not implement the callback\n     * @return {void}\n     * @override\n     */\n    disconnectedCallback() {\n      if (super.disconnectedCallback) {\n        super.disconnectedCallback();\n      }\n    }\n  }\n  return PropertiesMixin;\n});","/**\n * @fileoverview\n * @suppress {checkPrototypalTypes}\n * @license Copyright (c) 2017 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\nimport '../utils/boot.js';\nimport { rootPath, strictTemplatePolicy, allowTemplateFromDomModule, legacyOptimizations, legacyWarnings, syncInitialRender, supportsAdoptingStyleSheets, useAdoptedStyleSheetsWithBuiltCSS } from '../utils/settings.js';\nimport { dedupingMixin } from '../utils/mixin.js';\nimport { stylesFromTemplate, stylesFromModuleImports } from '../utils/style-gather.js';\nimport { pathFromUrl, resolveCss, resolveUrl } from '../utils/resolve-url.js';\nimport { DomModule } from '../elements/dom-module.js';\nimport { PropertyEffects } from './property-effects.js';\nimport { PropertiesMixin } from './properties-mixin.js';\nimport { wrap } from '../utils/wrap.js';\n\n/**\n * Current Polymer version in Semver notation.\n * @type {string} Semver notation of the current version of Polymer.\n */\nexport const version = '3.5.2';\nexport const builtCSS = window.ShadyCSS && window.ShadyCSS['cssBuild'];\n\n/**\n * Element class mixin that provides the core API for Polymer's meta-programming\n * features including template stamping, data-binding, attribute deserialization,\n * and property change observation.\n *\n * Subclassers may provide the following static getters to return metadata\n * used to configure Polymer's features for the class:\n *\n * - `static get is()`: When the template is provided via a `dom-module`,\n *   users should return the `dom-module` id from a static `is` getter.  If\n *   no template is needed or the template is provided directly via the\n *   `template` getter, there is no need to define `is` for the element.\n *\n * - `static get template()`: Users may provide the template directly (as\n *   opposed to via `dom-module`) by implementing a static `template` getter.\n *   The getter must return an `HTMLTemplateElement`.\n *\n * - `static get properties()`: Should return an object describing\n *   property-related metadata used by Polymer features (key: property name\n *   value: object containing property metadata). Valid keys in per-property\n *   metadata include:\n *   - `type` (String|Number|Object|Array|...): Used by\n *     `attributeChangedCallback` to determine how string-based attributes\n *     are deserialized to JavaScript property values.\n *   - `notify` (boolean): Causes a change in the property to fire a\n *     non-bubbling event called `<property>-changed`. Elements that have\n *     enabled two-way binding to the property use this event to observe changes.\n *   - `readOnly` (boolean): Creates a getter for the property, but no setter.\n *     To set a read-only property, use the private setter method\n *     `_setProperty(property, value)`.\n *   - `observer` (string): Observer method name that will be called when\n *     the property changes. The arguments of the method are\n *     `(value, previousValue)`.\n *   - `computed` (string): String describing method and dependent properties\n *     for computing the value of this property (e.g. `'computeFoo(bar, zot)'`).\n *     Computed properties are read-only by default and can only be changed\n *     via the return value of the computing method.\n *\n * - `static get observers()`: Array of strings describing multi-property\n *   observer methods and their dependent properties (e.g.\n *   `'observeABC(a, b, c)'`).\n *\n * The base class provides default implementations for the following standard\n * custom element lifecycle callbacks; users may override these, but should\n * call the super method to ensure\n * - `constructor`: Run when the element is created or upgraded\n * - `connectedCallback`: Run each time the element is connected to the\n *   document\n * - `disconnectedCallback`: Run each time the element is disconnected from\n *   the document\n * - `attributeChangedCallback`: Run each time an attribute in\n *   `observedAttributes` is set or removed (note: this element's default\n *   `observedAttributes` implementation will automatically return an array\n *   of dash-cased attributes based on `properties`)\n *\n * @mixinFunction\n * @polymer\n * @appliesMixin PropertyEffects\n * @appliesMixin PropertiesMixin\n * @property rootPath {string} Set to the value of `rootPath`,\n *   which defaults to the main document path\n * @property importPath {string} Set to the value of the class's static\n *   `importPath` property, which defaults to the path of this element's\n *   `dom-module` (when `is` is used), but can be overridden for other\n *   import strategies.\n * @summary Element class mixin that provides the core API for Polymer's\n * meta-programming features.\n * @template T\n * @param {function(new:T)} superClass Class to apply mixin to.\n * @return {function(new:T)} superClass with mixin applied.\n */\nexport const ElementMixin = dedupingMixin(base => {\n  /**\n   * @constructor\n   * @implements {Polymer_PropertyEffects}\n   * @implements {Polymer_PropertiesMixin}\n   * @extends {HTMLElement}\n   * @private\n   */\n  const polymerElementBase = PropertiesMixin(PropertyEffects(base));\n\n  /**\n   * Returns a list of properties with default values.\n   * This list is created as an optimization since it is a subset of\n   * the list returned from `_properties`.\n   * This list is used in `_initializeProperties` to set property defaults.\n   *\n   * @param {PolymerElementConstructor} constructor Element class\n   * @return {PolymerElementProperties} Flattened properties for this class\n   *   that have default values\n   * @private\n   */\n  function propertyDefaults(constructor) {\n    if (!constructor.hasOwnProperty(JSCompiler_renameProperty('__propertyDefaults', constructor))) {\n      constructor.__propertyDefaults = null;\n      let props = constructor._properties;\n      for (let p in props) {\n        let info = props[p];\n        if ('value' in info) {\n          constructor.__propertyDefaults = constructor.__propertyDefaults || {};\n          constructor.__propertyDefaults[p] = info;\n        }\n      }\n    }\n    return constructor.__propertyDefaults;\n  }\n\n  /**\n   * Returns a memoized version of the `observers` array.\n   * @param {PolymerElementConstructor} constructor Element class\n   * @return {Array} Array containing own observers for the given class\n   * @protected\n   */\n  function ownObservers(constructor) {\n    if (!constructor.hasOwnProperty(JSCompiler_renameProperty('__ownObservers', constructor))) {\n      constructor.__ownObservers = constructor.hasOwnProperty(JSCompiler_renameProperty('observers', constructor)) ? /** @type {PolymerElementConstructor} */constructor.observers : null;\n    }\n    return constructor.__ownObservers;\n  }\n\n  /**\n   * Creates effects for a property.\n   *\n   * Note, once a property has been set to\n   * `readOnly`, `computed`, `reflectToAttribute`, or `notify`\n   * these values may not be changed. For example, a subclass cannot\n   * alter these settings. However, additional `observers` may be added\n   * by subclasses.\n   *\n   * The info object should contain property metadata as follows:\n   *\n   * * `type`: {function} type to which an attribute matching the property\n   * is deserialized. Note the property is camel-cased from a dash-cased\n   * attribute. For example, 'foo-bar' attribute is deserialized to a\n   * property named 'fooBar'.\n   *\n   * * `readOnly`: {boolean} creates a readOnly property and\n   * makes a private setter for the private of the form '_setFoo' for a\n   * property 'foo',\n   *\n   * * `computed`: {string} creates a computed property. A computed property\n   * is also automatically set to `readOnly: true`. The value is calculated\n   * by running a method and arguments parsed from the given string. For\n   * example 'compute(foo)' will compute a given property when the\n   * 'foo' property changes by executing the 'compute' method. This method\n   * must return the computed value.\n   *\n   * * `reflectToAttribute`: {boolean} If true, the property value is reflected\n   * to an attribute of the same name. Note, the attribute is dash-cased\n   * so a property named 'fooBar' is reflected as 'foo-bar'.\n   *\n   * * `notify`: {boolean} sends a non-bubbling notification event when\n   * the property changes. For example, a property named 'foo' sends an\n   * event named 'foo-changed' with `event.detail` set to the value of\n   * the property.\n   *\n   * * observer: {string} name of a method that runs when the property\n   * changes. The arguments of the method are (value, previousValue).\n   *\n   * Note: Users may want control over modifying property\n   * effects via subclassing. For example, a user might want to make a\n   * reflectToAttribute property not do so in a subclass. We've chosen to\n   * disable this because it leads to additional complication.\n   * For example, a readOnly effect generates a special setter. If a subclass\n   * disables the effect, the setter would fail unexpectedly.\n   * Based on feedback, we may want to try to make effects more malleable\n   * and/or provide an advanced api for manipulating them.\n   *\n   * @param {!PolymerElement} proto Element class prototype to add accessors\n   *   and effects to\n   * @param {string} name Name of the property.\n   * @param {Object} info Info object from which to create property effects.\n   * Supported keys:\n   * @param {Object} allProps Flattened map of all properties defined in this\n   *   element (including inherited properties)\n   * @return {void}\n   * @private\n   */\n  function createPropertyFromConfig(proto, name, info, allProps) {\n    // computed forces readOnly...\n    if (info.computed) {\n      info.readOnly = true;\n    }\n    // Note, since all computed properties are readOnly, this prevents\n    // adding additional computed property effects (which leads to a confusing\n    // setup where multiple triggers for setting a property)\n    // While we do have `hasComputedEffect` this is set on the property's\n    // dependencies rather than itself.\n    if (info.computed) {\n      if (proto._hasReadOnlyEffect(name)) {\n        console.warn(`Cannot redefine computed property '${name}'.`);\n      } else {\n        proto._createComputedProperty(name, info.computed, allProps);\n      }\n    }\n    if (info.readOnly && !proto._hasReadOnlyEffect(name)) {\n      proto._createReadOnlyProperty(name, !info.computed);\n    } else if (info.readOnly === false && proto._hasReadOnlyEffect(name)) {\n      console.warn(`Cannot make readOnly property '${name}' non-readOnly.`);\n    }\n    if (info.reflectToAttribute && !proto._hasReflectEffect(name)) {\n      proto._createReflectedProperty(name);\n    } else if (info.reflectToAttribute === false && proto._hasReflectEffect(name)) {\n      console.warn(`Cannot make reflected property '${name}' non-reflected.`);\n    }\n    if (info.notify && !proto._hasNotifyEffect(name)) {\n      proto._createNotifyingProperty(name);\n    } else if (info.notify === false && proto._hasNotifyEffect(name)) {\n      console.warn(`Cannot make notify property '${name}' non-notify.`);\n    }\n    // always add observer\n    if (info.observer) {\n      proto._createPropertyObserver(name, info.observer, allProps[info.observer]);\n    }\n    // always create the mapping from attribute back to property for deserialization.\n    proto._addPropertyToAttributeMap(name);\n  }\n\n  /**\n   * Process all style elements in the element template. Styles with the\n   * `include` attribute are processed such that any styles in\n   * the associated \"style modules\" are included in the element template.\n   * @param {PolymerElementConstructor} klass Element class\n   * @param {!HTMLTemplateElement} template Template to process\n   * @param {string} is Name of element\n   * @param {string} baseURI Base URI for element\n   * @private\n   */\n  function processElementStyles(klass, template, is, baseURI) {\n    if (!builtCSS) {\n      const templateStyles = template.content.querySelectorAll('style');\n      const stylesWithImports = stylesFromTemplate(template);\n      // insert styles from <link rel=\"import\" type=\"css\"> at the top of the template\n      const linkedStyles = stylesFromModuleImports(is);\n      const firstTemplateChild = template.content.firstElementChild;\n      for (let idx = 0; idx < linkedStyles.length; idx++) {\n        let s = linkedStyles[idx];\n        s.textContent = klass._processStyleText(s.textContent, baseURI);\n        template.content.insertBefore(s, firstTemplateChild);\n      }\n      // keep track of the last \"concrete\" style in the template we have encountered\n      let templateStyleIndex = 0;\n      // ensure all gathered styles are actually in this template.\n      for (let i = 0; i < stylesWithImports.length; i++) {\n        let s = stylesWithImports[i];\n        let templateStyle = templateStyles[templateStyleIndex];\n        // if the style is not in this template, it's been \"included\" and\n        // we put a clone of it in the template before the style that included it\n        if (templateStyle !== s) {\n          s = s.cloneNode(true);\n          templateStyle.parentNode.insertBefore(s, templateStyle);\n        } else {\n          templateStyleIndex++;\n        }\n        s.textContent = klass._processStyleText(s.textContent, baseURI);\n      }\n    }\n    if (window.ShadyCSS) {\n      window.ShadyCSS.prepareTemplate(template, is);\n    }\n    // Support for `adoptedStylesheets` relies on using native Shadow DOM\n    // and built CSS. Built CSS is required because runtime transformation of\n    // `@apply` is not supported. This is because ShadyCSS relies on being able\n    // to update a `style` element in the element template and this is\n    // removed when using `adoptedStyleSheets`.\n    // Note, it would be more efficient to allow style includes to become\n    // separate stylesheets; however, because of `@apply` these are\n    // potentially not shareable and sharing the ones that could be shared\n    // would require some coordination. To keep it simple, all the includes\n    // and styles are collapsed into a single shareable stylesheet.\n    if (useAdoptedStyleSheetsWithBuiltCSS && builtCSS && supportsAdoptingStyleSheets) {\n      // Remove styles in template and make a shareable stylesheet\n      const styles = template.content.querySelectorAll('style');\n      if (styles) {\n        let css = '';\n        Array.from(styles).forEach(s => {\n          css += s.textContent;\n          s.parentNode.removeChild(s);\n        });\n        klass._styleSheet = new CSSStyleSheet();\n        klass._styleSheet.replaceSync(css);\n      }\n    }\n  }\n\n  /**\n   * Look up template from dom-module for element\n   *\n   * @param {string} is Element name to look up\n   * @return {?HTMLTemplateElement|undefined} Template found in dom module, or\n   *   undefined if not found\n   * @protected\n   */\n  function getTemplateFromDomModule(is) {\n    let template = null;\n    // Under strictTemplatePolicy in 3.x+, dom-module lookup is only allowed\n    // when opted-in via allowTemplateFromDomModule\n    if (is && (!strictTemplatePolicy || allowTemplateFromDomModule)) {\n      template = /** @type {?HTMLTemplateElement} */\n      DomModule.import(is, 'template');\n      // Under strictTemplatePolicy, require any element with an `is`\n      // specified to have a dom-module\n      if (strictTemplatePolicy && !template) {\n        throw new Error(`strictTemplatePolicy: expecting dom-module or null template for ${is}`);\n      }\n    }\n    return template;\n  }\n\n  /**\n   * @polymer\n   * @mixinClass\n   * @unrestricted\n   * @implements {Polymer_ElementMixin}\n   * @extends {polymerElementBase}\n   */\n  class PolymerElement extends polymerElementBase {\n    /**\n     * Current Polymer version in Semver notation.\n     * @type {string} Semver notation of the current version of Polymer.\n     * @nocollapse\n     */\n    static get polymerElementVersion() {\n      return version;\n    }\n\n    /**\n     * Override of PropertiesMixin _finalizeClass to create observers and\n     * find the template.\n     * @return {void}\n     * @protected\n     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do\n     * @nocollapse\n     */\n    static _finalizeClass() {\n      // TODO(https://github.com/google/closure-compiler/issues/3240):\n      //     Change back to just super.methodCall()\n      polymerElementBase._finalizeClass.call(this);\n      const observers = ownObservers(this);\n      if (observers) {\n        this.createObservers(observers, this._properties);\n      }\n      this._prepareTemplate();\n    }\n\n    /** @nocollapse */\n    static _prepareTemplate() {\n      // note: create \"working\" template that is finalized at instance time\n      let template = /** @type {PolymerElementConstructor} */this.template;\n      if (template) {\n        if (typeof template === 'string') {\n          console.error('template getter must return HTMLTemplateElement');\n          template = null;\n        } else if (!legacyOptimizations) {\n          template = template.cloneNode(true);\n        }\n      }\n\n      /** @override */\n      this.prototype._template = template;\n    }\n\n    /**\n     * Override of PropertiesChanged createProperties to create accessors\n     * and property effects for all of the properties.\n     * @param {!Object} props .\n     * @return {void}\n     * @protected\n     * @nocollapse\n     */\n    static createProperties(props) {\n      for (let p in props) {\n        createPropertyFromConfig(/** @type {?} */this.prototype, p, props[p], props);\n      }\n    }\n\n    /**\n     * Creates observers for the given `observers` array.\n     * Leverages `PropertyEffects` to create observers.\n     * @param {Object} observers Array of observer descriptors for\n     *   this class\n     * @param {Object} dynamicFns Object containing keys for any properties\n     *   that are functions and should trigger the effect when the function\n     *   reference is changed\n     * @return {void}\n     * @protected\n     * @nocollapse\n     */\n    static createObservers(observers, dynamicFns) {\n      const proto = this.prototype;\n      for (let i = 0; i < observers.length; i++) {\n        proto._createMethodObserver(observers[i], dynamicFns);\n      }\n    }\n\n    /**\n     * Returns the template that will be stamped into this element's shadow root.\n     *\n     * If a `static get is()` getter is defined, the default implementation will\n     * return the first `<template>` in a `dom-module` whose `id` matches this\n     * element's `is` (note that a `_template` property on the class prototype\n     * takes precedence over the `dom-module` template, to maintain legacy\n     * element semantics; a subclass will subsequently fall back to its super\n     * class template if neither a `prototype._template` or a `dom-module` for\n     * the class's `is` was found).\n     *\n     * Users may override this getter to return an arbitrary template\n     * (in which case the `is` getter is unnecessary). The template returned\n     * must be an `HTMLTemplateElement`.\n     *\n     * Note that when subclassing, if the super class overrode the default\n     * implementation and the subclass would like to provide an alternate\n     * template via a `dom-module`, it should override this getter and\n     * return `DomModule.import(this.is, 'template')`.\n     *\n     * If a subclass would like to modify the super class template, it should\n     * clone it rather than modify it in place.  If the getter does expensive\n     * work such as cloning/modifying a template, it should memoize the\n     * template for maximum performance:\n     *\n     *   let memoizedTemplate;\n     *   class MySubClass extends MySuperClass {\n     *     static get template() {\n     *       if (!memoizedTemplate) {\n     *         memoizedTemplate = super.template.cloneNode(true);\n     *         let subContent = document.createElement('div');\n     *         subContent.textContent = 'This came from MySubClass';\n     *         memoizedTemplate.content.appendChild(subContent);\n     *       }\n     *       return memoizedTemplate;\n     *     }\n     *   }\n     *\n     * @return {!HTMLTemplateElement|string} Template to be stamped\n     * @nocollapse\n     */\n    static get template() {\n      // Explanation of template-related properties:\n      // - constructor.template (this getter): the template for the class.\n      //     This can come from the prototype (for legacy elements), from a\n      //     dom-module, or from the super class's template (or can be overridden\n      //     altogether by the user)\n      // - constructor._template: memoized version of constructor.template\n      // - prototype._template: working template for the element, which will be\n      //     parsed and modified in place. It is a cloned version of\n      //     constructor.template, saved in _finalizeClass(). Note that before\n      //     this getter is called, for legacy elements this could be from a\n      //     _template field on the info object passed to Polymer(), a behavior,\n      //     or set in registered(); once the static getter runs, a clone of it\n      //     will overwrite it on the prototype as the working template.\n      if (!this.hasOwnProperty(JSCompiler_renameProperty('_template', this))) {\n        let protoTemplate = this.prototype.hasOwnProperty(JSCompiler_renameProperty('_template', this.prototype)) ? this.prototype._template : undefined;\n        // Accept a function for the legacy Polymer({_template:...}) field for\n        // lazy parsing\n        if (typeof protoTemplate === 'function') {\n          protoTemplate = protoTemplate();\n        }\n        this._template =\n        // If user has put template on prototype (e.g. in legacy via registered\n        // callback or info object), prefer that first. Note that `null` is\n        // used as a sentinel to indicate \"no template\" and can be used to\n        // override a super template, whereas `undefined` is used as a\n        // sentinel to mean \"fall-back to default template lookup\" via\n        // dom-module and/or super.template.\n        protoTemplate !== undefined ? protoTemplate :\n        // Look in dom-module associated with this element's is\n        this.hasOwnProperty(JSCompiler_renameProperty('is', this)) && getTemplateFromDomModule(/** @type {PolymerElementConstructor}*/this.is) ||\n        // Next look for superclass template (call the super impl this\n        // way so that `this` points to the superclass)\n        Object.getPrototypeOf(/** @type {PolymerElementConstructor}*/this.prototype).constructor.template;\n      }\n      return this._template;\n    }\n\n    /**\n     * Set the template.\n     *\n     * @param {!HTMLTemplateElement|string} value Template to set.\n     * @nocollapse\n     */\n    static set template(value) {\n      this._template = value;\n    }\n\n    /**\n     * Path matching the url from which the element was imported.\n     *\n     * This path is used to resolve url's in template style cssText.\n     * The `importPath` property is also set on element instances and can be\n     * used to create bindings relative to the import path.\n     *\n     * For elements defined in ES modules, users should implement\n     * `static get importMeta() { return import.meta; }`, and the default\n     * implementation of `importPath` will  return `import.meta.url`'s path.\n     * For elements defined in HTML imports, this getter will return the path\n     * to the document containing a `dom-module` element matching this\n     * element's static `is` property.\n     *\n     * Note, this path should contain a trailing `/`.\n     *\n     * @return {string} The import path for this element class\n     * @suppress {missingProperties}\n     * @nocollapse\n     */\n    static get importPath() {\n      if (!this.hasOwnProperty(JSCompiler_renameProperty('_importPath', this))) {\n        const meta = this.importMeta;\n        if (meta) {\n          this._importPath = pathFromUrl(meta.url);\n        } else {\n          const module = DomModule.import(/** @type {PolymerElementConstructor} */this.is);\n          this._importPath = module && module.assetpath || Object.getPrototypeOf(/** @type {PolymerElementConstructor}*/this.prototype).constructor.importPath;\n        }\n      }\n      return this._importPath;\n    }\n    constructor() {\n      super();\n      /** @type {HTMLTemplateElement} */\n      this._template;\n      /** @type {string} */\n      this._importPath;\n      /** @type {string} */\n      this.rootPath;\n      /** @type {string} */\n      this.importPath;\n      /** @type {StampedTemplate | HTMLElement | ShadowRoot} */\n      this.root;\n      /** @type {!Object<string, !Element>} */\n      this.$;\n    }\n\n    /**\n     * Overrides the default `PropertyAccessors` to ensure class\n     * metaprogramming related to property accessors and effects has\n     * completed (calls `finalize`).\n     *\n     * It also initializes any property defaults provided via `value` in\n     * `properties` metadata.\n     *\n     * @return {void}\n     * @override\n     * @suppress {invalidCasts,missingProperties} go/missingfnprops\n     */\n    _initializeProperties() {\n      this.constructor.finalize();\n      // note: finalize template when we have access to `localName` to\n      // avoid dependence on `is` for polyfilling styling.\n      this.constructor._finalizeTemplate(/** @type {!HTMLElement} */this.localName);\n      super._initializeProperties();\n      // set path defaults\n      this.rootPath = rootPath;\n      this.importPath = this.constructor.importPath;\n      // apply property defaults...\n      let p$ = propertyDefaults(this.constructor);\n      if (!p$) {\n        return;\n      }\n      for (let p in p$) {\n        let info = p$[p];\n        if (this._canApplyPropertyDefault(p)) {\n          let value = typeof info.value == 'function' ? info.value.call(this) : info.value;\n          // Set via `_setProperty` if there is an accessor, to enable\n          // initializing readOnly property defaults\n          if (this._hasAccessor(p)) {\n            this._setPendingProperty(p, value, true);\n          } else {\n            this[p] = value;\n          }\n        }\n      }\n    }\n\n    /**\n     * Determines if a property dfeault can be applied. For example, this\n     * prevents a default from being applied when a property that has no\n     * accessor is overridden by its host before upgrade (e.g. via a binding).\n     * @override\n     * @param {string} property Name of the property\n     * @return {boolean} Returns true if the property default can be applied.\n     */\n    _canApplyPropertyDefault(property) {\n      return !this.hasOwnProperty(property);\n    }\n\n    /**\n     * Gather style text for a style element in the template.\n     *\n     * @param {string} cssText Text containing styling to process\n     * @param {string} baseURI Base URI to rebase CSS paths against\n     * @return {string} The processed CSS text\n     * @protected\n     * @nocollapse\n     */\n    static _processStyleText(cssText, baseURI) {\n      return resolveCss(cssText, baseURI);\n    }\n\n    /**\n    * Configures an element `proto` to function with a given `template`.\n    * The element name `is` and extends `ext` must be specified for ShadyCSS\n    * style scoping.\n    *\n    * @param {string} is Tag name (or type extension name) for this element\n    * @return {void}\n    * @protected\n    * @nocollapse\n    */\n    static _finalizeTemplate(is) {\n      /** @const {HTMLTemplateElement} */\n      const template = this.prototype._template;\n      if (template && !template.__polymerFinalized) {\n        template.__polymerFinalized = true;\n        const importPath = this.importPath;\n        const baseURI = importPath ? resolveUrl(importPath) : '';\n        // e.g. support `include=\"module-name\"`, and ShadyCSS\n        processElementStyles(this, template, is, baseURI);\n        this.prototype._bindTemplate(template);\n      }\n    }\n\n    /**\n     * Provides a default implementation of the standard Custom Elements\n     * `connectedCallback`.\n     *\n     * The default implementation enables the property effects system and\n     * flushes any pending properties, and updates shimmed CSS properties\n     * when using the ShadyCSS scoping/custom properties polyfill.\n     *\n     * @override\n     * @suppress {missingProperties, invalidCasts} Super may or may not\n     *     implement the callback\n     * @return {void}\n     */\n    connectedCallback() {\n      if (window.ShadyCSS && this._template) {\n        window.ShadyCSS.styleElement(/** @type {!HTMLElement} */this);\n      }\n      super.connectedCallback();\n    }\n\n    /**\n     * Stamps the element template.\n     *\n     * @return {void}\n     * @override\n     */\n    ready() {\n      if (this._template) {\n        this.root = this._stampTemplate(this._template);\n        this.$ = this.root.$;\n      }\n      super.ready();\n    }\n\n    /**\n     * Implements `PropertyEffects`'s `_readyClients` call. Attaches\n     * element dom by calling `_attachDom` with the dom stamped from the\n     * element's template via `_stampTemplate`. Note that this allows\n     * client dom to be attached to the element prior to any observers\n     * running.\n     *\n     * @return {void}\n     * @override\n     */\n    _readyClients() {\n      if (this._template) {\n        this.root = this._attachDom(/** @type {StampedTemplate} */this.root);\n      }\n      // The super._readyClients here sets the clients initialized flag.\n      // We must wait to do this until after client dom is created/attached\n      // so that this flag can be checked to prevent notifications fired\n      // during this process from being handled before clients are ready.\n      super._readyClients();\n    }\n\n    /**\n     * Attaches an element's stamped dom to itself. By default,\n     * this method creates a `shadowRoot` and adds the dom to it.\n     * However, this method may be overridden to allow an element\n     * to put its dom in another location.\n     *\n     * @override\n     * @throws {Error}\n     * @suppress {missingReturn}\n     * @param {StampedTemplate} dom to attach to the element.\n     * @return {ShadowRoot} node to which the dom has been attached.\n     */\n    _attachDom(dom) {\n      const n = wrap(this);\n      if (n.attachShadow) {\n        if (dom) {\n          if (!n.shadowRoot) {\n            n.attachShadow({\n              mode: 'open',\n              shadyUpgradeFragment: dom\n            });\n            n.shadowRoot.appendChild(dom);\n            // When `adoptedStyleSheets` is supported a stylesheet is made\n            // available on the element constructor.\n            if (this.constructor._styleSheet) {\n              n.shadowRoot.adoptedStyleSheets = [this.constructor._styleSheet];\n            }\n          }\n          if (syncInitialRender && window.ShadyDOM) {\n            window.ShadyDOM.flushInitial(n.shadowRoot);\n          }\n          return n.shadowRoot;\n        }\n        return null;\n      } else {\n        throw new Error('ShadowDOM not available. ' +\n        // TODO(sorvell): move to compile-time conditional when supported\n        'PolymerElement can create dom as children instead of in ' + 'ShadowDOM by setting `this.root = this;\\` before \\`ready\\`.');\n      }\n    }\n\n    /**\n     * When using the ShadyCSS scoping and custom property shim, causes all\n     * shimmed styles in this element (and its subtree) to be updated\n     * based on current custom property values.\n     *\n     * The optional parameter overrides inline custom property styles with an\n     * object of properties where the keys are CSS properties, and the values\n     * are strings.\n     *\n     * Example: `this.updateStyles({'--color': 'blue'})`\n     *\n     * These properties are retained unless a value of `null` is set.\n     *\n     * Note: This function does not support updating CSS mixins.\n     * You can not dynamically change the value of an `@apply`.\n     *\n     * @override\n     * @param {Object=} properties Bag of custom property key/values to\n     *   apply to this element.\n     * @return {void}\n     * @suppress {invalidCasts}\n     */\n    updateStyles(properties) {\n      if (window.ShadyCSS) {\n        window.ShadyCSS.styleSubtree(/** @type {!HTMLElement} */this, properties);\n      }\n    }\n\n    /**\n     * Rewrites a given URL relative to a base URL. The base URL defaults to\n     * the original location of the document containing the `dom-module` for\n     * this element. This method will return the same URL before and after\n     * bundling.\n     *\n     * Note that this function performs no resolution for URLs that start\n     * with `/` (absolute URLs) or `#` (hash identifiers).  For general purpose\n     * URL resolution, use `window.URL`.\n     *\n     * @override\n     * @param {string} url URL to resolve.\n     * @param {string=} base Optional base URL to resolve against, defaults\n     * to the element's `importPath`\n     * @return {string} Rewritten URL relative to base\n     */\n    resolveUrl(url, base) {\n      if (!base && this.importPath) {\n        base = resolveUrl(this.importPath);\n      }\n      return resolveUrl(url, base);\n    }\n\n    /**\n     * Overrides `PropertyEffects` to add map of dynamic functions on\n     * template info, for consumption by `PropertyEffects` template binding\n     * code. This map determines which method templates should have accessors\n     * created for them.\n     *\n     * @param {!HTMLTemplateElement} template Template\n     * @param {!TemplateInfo} templateInfo Template metadata for current template\n     * @param {!NodeInfo} nodeInfo Node metadata for current template.\n     * @return {boolean} .\n     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do\n     * @nocollapse\n     */\n    static _parseTemplateContent(template, templateInfo, nodeInfo) {\n      templateInfo.dynamicFns = templateInfo.dynamicFns || this._properties;\n      // TODO(https://github.com/google/closure-compiler/issues/3240):\n      //     Change back to just super.methodCall()\n      return polymerElementBase._parseTemplateContent.call(this, template, templateInfo, nodeInfo);\n    }\n\n    /**\n     * Overrides `PropertyEffects` to warn on use of undeclared properties in\n     * template.\n     *\n     * @param {Object} templateInfo Template metadata to add effect to\n     * @param {string} prop Property that should trigger the effect\n     * @param {Object=} effect Effect metadata object\n     * @return {void}\n     * @protected\n     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do\n     * @nocollapse\n     */\n    static _addTemplatePropertyEffect(templateInfo, prop, effect) {\n      // Warn if properties are used in template without being declared.\n      // Properties must be listed in `properties` to be included in\n      // `observedAttributes` since CE V1 reads that at registration time, and\n      // since we want to keep template parsing lazy, we can't automatically\n      // add undeclared properties used in templates to `observedAttributes`.\n      // The warning is only enabled in `legacyOptimizations` mode, since\n      // we don't want to spam existing users who might have adopted the\n      // shorthand when attribute deserialization is not important.\n      if (legacyWarnings && !(prop in this._properties) &&\n      // Methods used in templates with no dependencies (or only literal\n      // dependencies) become accessors with template effects; ignore these\n      !(effect.info.part.signature && effect.info.part.signature.static) &&\n      // Warnings for bindings added to nested templates are handled by\n      // templatizer so ignore both the host-to-template bindings\n      // (`hostProp`) and TemplateInstance-to-child bindings\n      // (`nestedTemplate`)\n      !effect.info.part.hostProp && !templateInfo.nestedTemplate) {\n        console.warn(`Property '${prop}' used in template but not declared in 'properties'; ` + `attribute will not be observed.`);\n      }\n      // TODO(https://github.com/google/closure-compiler/issues/3240):\n      //     Change back to just super.methodCall()\n      return polymerElementBase._addTemplatePropertyEffect.call(this, templateInfo, prop, effect);\n    }\n  }\n  return PolymerElement;\n});\n\n/**\n * When using the ShadyCSS scoping and custom property shim, causes all\n * shimmed `styles` (via `custom-style`) in the document (and its subtree)\n * to be updated based on current custom property values.\n *\n * The optional parameter overrides inline custom property styles with an\n * object of properties where the keys are CSS properties, and the values\n * are strings.\n *\n * Example: `updateStyles({'--color': 'blue'})`\n *\n * These properties are retained unless a value of `null` is set.\n *\n * @param {Object=} props Bag of custom property key/values to\n *   apply to the document.\n * @return {void}\n */\nexport const updateStyles = function (props) {\n  if (window.ShadyCSS) {\n    window.ShadyCSS.styleDocument(props);\n  }\n};","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport './boot.js';\n\n/**\n * Our TrustedTypePolicy for HTML which is declared using the Polymer html\n * template tag function.\n *\n * That HTML is a developer-authored constant, and is parsed with innerHTML\n * before any untrusted expressions have been mixed in. Therefor it is\n * considered safe by construction.\n *\n * @type {!TrustedTypePolicy|undefined}\n */\nconst policy = window.trustedTypes && trustedTypes.createPolicy('polymer-html-literal', {\n  createHTML: s => s\n});\n\n/**\n * Class representing a static string value which can be used to filter\n * strings by asseting that they have been created via this class. The\n * `value` property returns the string passed to the constructor.\n */\nclass LiteralString {\n  /**\n   * @param {!ITemplateArray} strings Constant parts of tagged template literal\n   * @param {!Array<*>} values Variable parts of tagged template literal\n   */\n  constructor(strings, values) {\n    assertValidTemplateStringParameters(strings, values);\n    const string = values.reduce((acc, v, idx) => acc + literalValue(v) + strings[idx + 1], strings[0]);\n    /** @type {string} */\n    this.value = string.toString();\n  }\n  /**\n   * @return {string} LiteralString string value\n   * @override\n   */\n  toString() {\n    return this.value;\n  }\n}\n\n/**\n * @param {*} value Object to stringify into HTML\n * @return {string} HTML stringified form of `obj`\n */\nfunction literalValue(value) {\n  if (value instanceof LiteralString) {\n    return /** @type {!LiteralString} */value.value;\n  } else {\n    throw new Error(`non-literal value passed to Polymer's htmlLiteral function: ${value}`);\n  }\n}\n\n/**\n * @param {*} value Object to stringify into HTML\n * @return {string} HTML stringified form of `obj`\n */\nfunction htmlValue(value) {\n  if (value instanceof HTMLTemplateElement) {\n    // This might be an mXSS risk – mainly in the case where this template\n    // contains untrusted content that was believed to be sanitized.\n    // However we can't just use the XMLSerializer here because it misencodes\n    // `>` characters inside style tags.\n    // For an example of an actual case that hit this encoding issue,\n    // see b/198592167\n    return /** @type {!HTMLTemplateElement } */value.innerHTML;\n  } else if (value instanceof LiteralString) {\n    return literalValue(value);\n  } else {\n    throw new Error(`non-template value passed to Polymer's html function: ${value}`);\n  }\n}\n\n/**\n * A template literal tag that creates an HTML <template> element from the\n * contents of the string.\n *\n * This allows you to write a Polymer Template in JavaScript.\n *\n * Templates can be composed by interpolating `HTMLTemplateElement`s in\n * expressions in the JavaScript template literal. The nested template's\n * `innerHTML` is included in the containing template.  The only other\n * values allowed in expressions are those returned from `htmlLiteral`\n * which ensures only literal values from JS source ever reach the HTML, to\n * guard against XSS risks.\n *\n * All other values are disallowed in expressions to help prevent XSS\n * attacks; however, `htmlLiteral` can be used to compose static\n * string values into templates. This is useful to compose strings into\n * places that do not accept html, like the css text of a `style`\n * element.\n *\n * Example:\n *\n *     static get template() {\n *       return html`\n *         <style>:host{ content:\"...\" }</style>\n *         <div class=\"shadowed\">${this.partialTemplate}</div>\n *         ${super.template}\n *       `;\n *     }\n *     static get partialTemplate() { return html`<span>Partial!</span>`; }\n *\n * @param {!ITemplateArray} strings Constant parts of tagged template literal\n * @param {...*} values Variable parts of tagged template literal\n * @return {!HTMLTemplateElement} Constructed HTMLTemplateElement\n */\nexport const html = function html(strings) {\n  for (var _len = arguments.length, values = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    values[_key - 1] = arguments[_key];\n  }\n  assertValidTemplateStringParameters(strings, values);\n  const template = /** @type {!HTMLTemplateElement} */document.createElement('template');\n  let value = values.reduce((acc, v, idx) => acc + htmlValue(v) + strings[idx + 1], strings[0]);\n  if (policy) {\n    value = policy.createHTML(value);\n  }\n  template.innerHTML = value;\n  return template;\n};\n\n/**\n * @param {!ITemplateArray} strings Constant parts of tagged template literal\n * @param {!Array<*>} values Array of values from quasis\n */\nconst assertValidTemplateStringParameters = (strings, values) => {\n  // Note: if/when https://github.com/tc39/proposal-array-is-template-object\n  // is standardized, use that instead when available, as it can perform an\n  // unforgable check (though of course, the function itself can be forged).\n  if (!Array.isArray(strings) || !Array.isArray(strings.raw) || values.length !== strings.length - 1) {\n    // This is either caused by a browser bug, a compiler bug, or someone\n    // calling the html template tag function as a regular function.\n    //\n    throw new TypeError('Invalid call to the html template tag');\n  }\n};\n\n/**\n * An html literal tag that can be used with `html` to compose.\n * a literal string.\n *\n * Example:\n *\n *     static get template() {\n *       return html`\n *         <style>\n *           :host { display: block; }\n *           ${this.styleTemplate()}\n *         </style>\n *         <div class=\"shadowed\">${staticValue}</div>\n *         ${super.template}\n *       `;\n *     }\n *     static get styleTemplate() {\n *        return htmlLiteral`.shadowed { background: gray; }`;\n *     }\n *\n * @param {!ITemplateArray} strings Constant parts of tagged template literal\n * @param {...*} values Variable parts of tagged template literal\n * @return {!LiteralString} Constructed literal string\n */\nexport const htmlLiteral = function (strings) {\n  for (var _len2 = arguments.length, values = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n    values[_key2 - 1] = arguments[_key2];\n  }\n  return new LiteralString(strings, values);\n};","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport { ElementMixin, version } from './lib/mixins/element-mixin.js';\nexport { html } from './lib/utils/html-tag.js';\nexport { version };\n\n/**\n * Base class that provides the core API for Polymer's meta-programming\n * features including template stamping, data-binding, attribute deserialization,\n * and property change observation.\n *\n * @customElement\n * @polymer\n * @constructor\n * @implements {Polymer_ElementMixin}\n * @extends HTMLElement\n * @appliesMixin ElementMixin\n * @summary Custom element base class that provides the core API for Polymer's\n *   key meta-programming features including template stamping, data-binding,\n *   attribute deserialization, and property change observation\n */\nexport const PolymerElement = ElementMixin(HTMLElement);","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { html, PolymerElement } from '@polymer/polymer/polymer-element.js';\nimport { defineCustomElement } from '@vaadin/component-base/src/define.js';\nimport { ThemableMixin } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\n\n/**\n * An element used by `<vaadin-multi-select-combo-box>` to display selected items.\n *\n * ### Styling\n *\n * The following shadow DOM parts are available for styling:\n *\n * Part name        | Description\n * -----------------|-------------\n * `label`          | Element containing the label\n * `remove-button`  | Remove button\n *\n * See [Styling Components](https://vaadin.com/docs/latest/styling/styling-components) documentation.\n *\n * @customElement\n * @extends HTMLElement\n * @private\n */\nclass MultiSelectComboBoxChip extends ThemableMixin(PolymerElement) {\n  static get is() {\n    return 'vaadin-multi-select-combo-box-chip';\n  }\n  static get properties() {\n    return {\n      disabled: {\n        type: Boolean,\n        reflectToAttribute: true\n      },\n      readonly: {\n        type: Boolean,\n        reflectToAttribute: true\n      },\n      label: {\n        type: String\n      },\n      item: {\n        type: Object\n      }\n    };\n  }\n  static get template() {\n    return html`\n      <style>\n        :host {\n          display: inline-flex;\n          align-items: center;\n          align-self: center;\n          white-space: nowrap;\n          box-sizing: border-box;\n        }\n\n        [part='label'] {\n          overflow: hidden;\n          text-overflow: ellipsis;\n        }\n\n        :host([hidden]),\n        :host(:is([readonly], [disabled], [slot='overflow'])) [part='remove-button'] {\n          display: none !important;\n        }\n\n        @media (forced-colors: active) {\n          :host {\n            outline: 1px solid;\n            outline-offset: -1px;\n          }\n        }\n      </style>\n      <div part=\"label\">[[label]]</div>\n      <div part=\"remove-button\" on-click=\"_onRemoveClick\"></div>\n    `;\n  }\n\n  /** @private */\n  _onRemoveClick(event) {\n    event.stopPropagation();\n    this.dispatchEvent(new CustomEvent('item-removed', {\n      detail: {\n        item: this.item\n      },\n      bubbles: true,\n      composed: true\n    }));\n  }\n}\ndefineCustomElement(MultiSelectComboBoxChip);","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n/**\n * Array of Vaadin custom element classes that have been subscribed to the dir changes.\n */\nconst directionSubscribers = [];\nfunction alignDirs(element, documentDir) {\n  let elementDir = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : element.getAttribute('dir');\n  if (documentDir) {\n    element.setAttribute('dir', documentDir);\n  } else if (elementDir != null) {\n    element.removeAttribute('dir');\n  }\n}\nfunction getDocumentDir() {\n  return document.documentElement.getAttribute('dir');\n}\nfunction directionUpdater() {\n  const documentDir = getDocumentDir();\n  directionSubscribers.forEach(element => {\n    alignDirs(element, documentDir);\n  });\n}\nconst directionObserver = new MutationObserver(directionUpdater);\ndirectionObserver.observe(document.documentElement, {\n  attributes: true,\n  attributeFilter: ['dir']\n});\n\n/**\n * A mixin to handle `dir` attribute based on the one set on the `<html>` element.\n *\n * @polymerMixin\n */\nexport const DirMixin = superClass => class VaadinDirMixin extends superClass {\n  static get properties() {\n    return {\n      /**\n       * @protected\n       */\n      dir: {\n        type: String,\n        value: '',\n        reflectToAttribute: true,\n        converter: {\n          fromAttribute: attr => {\n            return !attr ? '' : attr;\n          },\n          toAttribute: prop => {\n            return prop === '' ? null : prop;\n          }\n        }\n      }\n    };\n  }\n\n  /**\n   * @return {boolean}\n   * @protected\n   */\n  get __isRTL() {\n    return this.getAttribute('dir') === 'rtl';\n  }\n\n  /** @protected */\n  connectedCallback() {\n    super.connectedCallback();\n    if (!this.hasAttribute('dir') || this.__restoreSubscription) {\n      this.__subscribe();\n      alignDirs(this, getDocumentDir(), null);\n    }\n  }\n\n  /** @protected */\n  attributeChangedCallback(name, oldValue, newValue) {\n    super.attributeChangedCallback(name, oldValue, newValue);\n    if (name !== 'dir') {\n      return;\n    }\n    const documentDir = getDocumentDir();\n\n    // New value equals to the document direction and the element is not subscribed to the changes\n    const newValueEqlDocDir = newValue === documentDir && directionSubscribers.indexOf(this) === -1;\n    // Value was emptied and the element is not subscribed to the changes\n    const newValueEmptied = !newValue && oldValue && directionSubscribers.indexOf(this) === -1;\n    // New value is different and the old equals to document direction and the element is not subscribed to the changes\n    const newDiffValue = newValue !== documentDir && oldValue === documentDir;\n    if (newValueEqlDocDir || newValueEmptied) {\n      this.__subscribe();\n      alignDirs(this, documentDir, newValue);\n    } else if (newDiffValue) {\n      this.__unsubscribe();\n    }\n  }\n\n  /** @protected */\n  disconnectedCallback() {\n    super.disconnectedCallback();\n    this.__restoreSubscription = directionSubscribers.includes(this);\n    this.__unsubscribe();\n  }\n\n  /** @protected */\n  _valueToNodeAttribute(node, value, attribute) {\n    // Override default Polymer attribute reflection to match native behavior of HTMLElement.dir property\n    // If the property contains an empty string then it should not create an empty attribute\n    if (attribute === 'dir' && value === '' && !node.hasAttribute('dir')) {\n      return;\n    }\n    super._valueToNodeAttribute(node, value, attribute);\n  }\n\n  /** @protected */\n  _attributeToProperty(attribute, value, type) {\n    // Override default Polymer attribute reflection to match native behavior of HTMLElement.dir property\n    // If the attribute is removed, then the dir property should contain an empty string instead of null\n    if (attribute === 'dir' && !value) {\n      this.dir = '';\n    } else {\n      super._attributeToProperty(attribute, value, type);\n    }\n  }\n\n  /** @private */\n  __subscribe() {\n    if (!directionSubscribers.includes(this)) {\n      directionSubscribers.push(this);\n    }\n  }\n\n  /** @private */\n  __unsubscribe() {\n    if (directionSubscribers.includes(this)) {\n      directionSubscribers.splice(directionSubscribers.indexOf(this), 1);\n    }\n  }\n};","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n/**\n * @polymerMixin\n */\nexport const InputContainerMixin = superClass => class InputContainerMixinClass extends superClass {\n  static get properties() {\n    return {\n      /**\n       * If true, the user cannot interact with this element.\n       */\n      disabled: {\n        type: Boolean,\n        reflectToAttribute: true\n      },\n      /**\n       * Set to true to make this element read-only.\n       */\n      readonly: {\n        type: Boolean,\n        reflectToAttribute: true\n      },\n      /**\n       * Set to true when the element is invalid.\n       */\n      invalid: {\n        type: Boolean,\n        reflectToAttribute: true\n      }\n    };\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n    this.addEventListener('pointerdown', event => {\n      if (event.target === this) {\n        // Prevent direct clicks to the input container from blurring the input\n        event.preventDefault();\n      }\n    });\n    this.addEventListener('click', event => {\n      if (event.target === this) {\n        // The vaadin-input-container element was directly clicked,\n        // focus any focusable child element from the default slot\n        this.shadowRoot.querySelector('slot:not([name])').assignedNodes({\n          flatten: true\n        }).forEach(node => node.focus && node.focus());\n      }\n    });\n  }\n};","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { html, PolymerElement } from '@polymer/polymer';\nimport { defineCustomElement } from '@vaadin/component-base/src/define.js';\nimport { DirMixin } from '@vaadin/component-base/src/dir-mixin.js';\nimport { registerStyles, ThemableMixin } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nimport { InputContainerMixin } from './vaadin-input-container-mixin.js';\nimport { inputContainerStyles } from './vaadin-input-container-styles.js';\nregisterStyles('vaadin-input-container', inputContainerStyles, {\n  moduleId: 'vaadin-input-container-styles'\n});\n\n/**\n * @customElement\n * @extends HTMLElement\n * @mixes ThemableMixin\n * @mixes DirMixin\n * @mixes InputContainerMixin\n */\nexport class InputContainer extends InputContainerMixin(ThemableMixin(DirMixin(PolymerElement))) {\n  static get is() {\n    return 'vaadin-input-container';\n  }\n  static get template() {\n    return html`\n      <slot name=\"prefix\"></slot>\n      <slot></slot>\n      <slot name=\"suffix\"></slot>\n    `;\n  }\n}\ndefineCustomElement(InputContainer);","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { css } from 'lit';\nexport const inputContainerStyles = css`\n  :host {\n    display: flex;\n    align-items: center;\n    flex: 0 1 auto;\n    border-radius:\n            /* See https://developer.mozilla.org/en-US/docs/Web/CSS/border-radius */\n      var(--vaadin-input-field-top-start-radius, var(--__border-radius))\n      var(--vaadin-input-field-top-end-radius, var(--__border-radius))\n      var(--vaadin-input-field-bottom-end-radius, var(--__border-radius))\n      var(--vaadin-input-field-bottom-start-radius, var(--__border-radius));\n    --_border-radius: var(--vaadin-input-field-border-radius, 0);\n    --_input-border-width: var(--vaadin-input-field-border-width, 0);\n    --_input-border-color: var(--vaadin-input-field-border-color, transparent);\n    box-shadow: inset 0 0 0 var(--_input-border-width, 0) var(--_input-border-color);\n  }\n\n  :host([dir='rtl']) {\n    border-radius:\n            /* Don't use logical props, see https://github.com/vaadin/vaadin-time-picker/issues/145 */\n      var(--vaadin-input-field-top-end-radius, var(--_border-radius))\n      var(--vaadin-input-field-top-start-radius, var(--_border-radius))\n      var(--vaadin-input-field-bottom-start-radius, var(--_border-radius))\n      var(--vaadin-input-field-bottom-end-radius, var(--_border-radius));\n  }\n\n  :host([hidden]) {\n    display: none !important;\n  }\n\n  /* Reset the native input styles */\n  ::slotted(input) {\n    -webkit-appearance: none;\n    -moz-appearance: none;\n    flex: auto;\n    white-space: nowrap;\n    overflow: hidden;\n    width: 100%;\n    height: 100%;\n    outline: none;\n    margin: 0;\n    padding: 0;\n    border: 0;\n    border-radius: 0;\n    min-width: 0;\n    font: inherit;\n    line-height: normal;\n    color: inherit;\n    background-color: transparent;\n    /* Disable default invalid style in Firefox */\n    box-shadow: none;\n  }\n\n  ::slotted(*) {\n    flex: none;\n  }\n\n  ::slotted(:is(input, textarea))::placeholder {\n    /* Use ::slotted(input:placeholder-shown) in themes to style the placeholder. */\n    /* because ::slotted(...)::placeholder does not work in Safari. */\n    font: inherit;\n    color: inherit;\n    /* Override default opacity in Firefox */\n    opacity: 1;\n  }\n`;","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { defineCustomElement } from '@vaadin/component-base/src/define.js';\nimport { InputContainer } from '@vaadin/input-container/src/vaadin-input-container.js';\nimport { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nregisterStyles('vaadin-multi-select-combo-box-container', css`\n    #wrapper {\n      display: flex;\n      width: 100%;\n      min-width: 0;\n    }\n\n    :host([auto-expand-vertically]) #wrapper {\n      flex-wrap: wrap;\n    }\n  `, {\n  moduleId: 'vaadin-multi-select-combo-box-container-styles'\n});\nlet memoizedTemplate;\n\n/**\n * An element used internally by `<vaadin-multi-select-combo-box>`. Not intended to be used separately.\n *\n * @customElement\n * @extends InputContainer\n * @private\n */\nclass MultiSelectComboBoxContainer extends InputContainer {\n  static get is() {\n    return 'vaadin-multi-select-combo-box-container';\n  }\n  static get template() {\n    if (!memoizedTemplate) {\n      memoizedTemplate = super.template.cloneNode(true);\n      const content = memoizedTemplate.content;\n      const slots = content.querySelectorAll('slot');\n      const wrapper = document.createElement('div');\n      wrapper.setAttribute('id', 'wrapper');\n      content.insertBefore(wrapper, slots[2]);\n      wrapper.appendChild(slots[0]);\n      wrapper.appendChild(slots[1]);\n    }\n    return memoizedTemplate;\n  }\n  static get properties() {\n    return {\n      /**\n       * Set to true to not collapse selected items chips into the overflow\n       * chip and instead always expand vertically, causing input field to\n       * wrap into multiple lines when width is limited.\n       * @attr {boolean} auto-expand-vertically\n       */\n      autoExpandVertically: {\n        type: Boolean,\n        reflectToAttribute: true\n      }\n    };\n  }\n}\ndefineCustomElement(MultiSelectComboBoxContainer);","/**\n * @license\n * Copyright (c) 2015 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n/**\n * @polymerMixin\n */\nexport const ComboBoxItemMixin = superClass => class ComboBoxItemMixinClass extends superClass {\n  static get properties() {\n    return {\n      /**\n       * The index of the item.\n       */\n      index: {\n        type: Number\n      },\n      /**\n       * The item to render.\n       */\n      item: {\n        type: Object\n      },\n      /**\n       * The text to render in the item.\n       */\n      label: {\n        type: String\n      },\n      /**\n       * True when item is selected.\n       */\n      selected: {\n        type: Boolean,\n        value: false,\n        reflectToAttribute: true\n      },\n      /**\n       * True when item is focused.\n       */\n      focused: {\n        type: Boolean,\n        value: false,\n        reflectToAttribute: true\n      },\n      /**\n       * Custom function for rendering the item content.\n       */\n      renderer: {\n        type: Function\n      }\n    };\n  }\n  static get observers() {\n    return ['__rendererOrItemChanged(renderer, index, item, selected, focused)', '__updateLabel(label, renderer)'];\n  }\n  static get observedAttributes() {\n    return [...super.observedAttributes, 'hidden'];\n  }\n  attributeChangedCallback(name, oldValue, newValue) {\n    if (name === 'hidden' && newValue !== null) {\n      // The element is being hidden (by virtualizer). Mark one of the __rendererOrItemChanged\n      // dependencies as undefined to make sure it's called when the element is shown again\n      // and assigned properties with possibly identical values as before hiding.\n      this.index = undefined;\n    } else {\n      super.attributeChangedCallback(name, oldValue, newValue);\n    }\n  }\n\n  /** @protected */\n  connectedCallback() {\n    super.connectedCallback();\n    this._owner = this.parentNode.owner;\n    const hostDir = this._owner.getAttribute('dir');\n    if (hostDir) {\n      this.setAttribute('dir', hostDir);\n    }\n  }\n\n  /**\n   * Requests an update for the content of the item.\n   * While performing the update, it invokes the renderer passed in the `renderer` property.\n   *\n   * It is not guaranteed that the update happens immediately (synchronously) after it is requested.\n   */\n  requestContentUpdate() {\n    if (!this.renderer) {\n      return;\n    }\n    const model = {\n      index: this.index,\n      item: this.item,\n      focused: this.focused,\n      selected: this.selected\n    };\n    this.renderer(this, this._owner, model);\n  }\n\n  /** @private */\n  __rendererOrItemChanged(renderer, index, item) {\n    if (item === undefined || index === undefined) {\n      return;\n    }\n    if (this._oldRenderer !== renderer) {\n      this.innerHTML = '';\n      // Whenever a Lit-based renderer is used, it assigns a Lit part to the node it was rendered into.\n      // When clearing the rendered content, this part needs to be manually disposed of.\n      // Otherwise, using a Lit-based renderer on the same node will throw an exception or render nothing afterward.\n      delete this._$litPart$;\n    }\n    if (renderer) {\n      this._oldRenderer = renderer;\n      this.requestContentUpdate();\n    }\n  }\n\n  /** @private */\n  __updateLabel(label, renderer) {\n    if (renderer) {\n      return;\n    }\n    this.textContent = label;\n  }\n};","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { html, PolymerElement } from '@polymer/polymer/polymer-element.js';\nimport { ComboBoxItemMixin } from '@vaadin/combo-box/src/vaadin-combo-box-item-mixin.js';\nimport { defineCustomElement } from '@vaadin/component-base/src/define.js';\nimport { DirMixin } from '@vaadin/component-base/src/dir-mixin.js';\nimport { ThemableMixin } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\n\n/**\n * An item element used by the `<vaadin-multi-select-combo-box>` dropdown.\n *\n * ### Styling\n *\n * The following shadow DOM parts are available for styling:\n *\n * Part name   | Description\n * ------------|--------------\n * `checkmark` | The graphical checkmark shown for a selected item\n * `content`   | The element that wraps the item content\n *\n * The following state attributes are exposed for styling:\n *\n * Attribute    | Description\n * -------------|-------------\n * `selected`   | Set when the item is selected\n * `focused`    | Set when the item is focused\n *\n * See [Styling Components](https://vaadin.com/docs/latest/styling/styling-components) documentation.\n *\n * @customElement\n * @mixes ComboBoxItemMixin\n * @mixes ThemableMixin\n * @mixes DirMixin\n * @private\n */\nexport class MultiSelectComboBoxItem extends ComboBoxItemMixin(ThemableMixin(DirMixin(PolymerElement))) {\n  static get is() {\n    return 'vaadin-multi-select-combo-box-item';\n  }\n  static get template() {\n    return html`\n      <style>\n        :host {\n          display: block;\n        }\n\n        :host([hidden]) {\n          display: none !important;\n        }\n      </style>\n      <span part=\"checkmark\" aria-hidden=\"true\"></span>\n      <div part=\"content\">\n        <slot></slot>\n      </div>\n    `;\n  }\n}\ndefineCustomElement(MultiSelectComboBoxItem);","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n// We consider the keyboard to be active if the window has received a keydown\n// event since the last mousedown event.\nlet keyboardActive = false;\n\n// Listen for top-level keydown and mousedown events.\n// Use capture phase so we detect events even if they're handled.\nwindow.addEventListener('keydown', () => {\n  keyboardActive = true;\n}, {\n  capture: true\n});\nwindow.addEventListener('mousedown', () => {\n  keyboardActive = false;\n}, {\n  capture: true\n});\n\n/**\n * Returns the actually focused element by traversing shadow\n * trees recursively to ensure it's the leaf element.\n *\n * @return {Element}\n */\nexport function getDeepActiveElement() {\n  let host = document.activeElement || document.body;\n  while (host.shadowRoot && host.shadowRoot.activeElement) {\n    host = host.shadowRoot.activeElement;\n  }\n  return host;\n}\n\n/**\n * Returns true if the window has received a keydown\n * event since the last mousedown event.\n *\n * @return {boolean}\n */\nexport function isKeyboardActive() {\n  return keyboardActive;\n}\n\n/**\n * Returns true if the element is hidden directly with `display: none` or `visibility: hidden`,\n * false otherwise.\n *\n * The method doesn't traverse the element's ancestors, it only checks for the CSS properties\n * set directly to or inherited by the element.\n *\n * @param {HTMLElement} element\n * @return {boolean}\n */\nfunction isElementHiddenDirectly(element) {\n  // Check inline style first to save a re-flow.\n  const style = element.style;\n  if (style.visibility === 'hidden' || style.display === 'none') {\n    return true;\n  }\n  const computedStyle = window.getComputedStyle(element);\n  if (computedStyle.visibility === 'hidden' || computedStyle.display === 'none') {\n    return true;\n  }\n  return false;\n}\n\n/**\n * Returns if element `a` has lower tab order compared to element `b`\n * (both elements are assumed to be focusable and tabbable).\n * Elements with tabindex = 0 have lower tab order compared to elements\n * with tabindex > 0.\n * If both have same tabindex, it returns false.\n *\n * @param {HTMLElement} a\n * @param {HTMLElement} b\n * @return {boolean}\n */\nfunction hasLowerTabOrder(a, b) {\n  // Normalize tabIndexes\n  // e.g. in Firefox `<div contenteditable>` has `tabIndex = -1`\n  const ati = Math.max(a.tabIndex, 0);\n  const bti = Math.max(b.tabIndex, 0);\n  return ati === 0 || bti === 0 ? bti > ati : ati > bti;\n}\n\n/**\n * Merge sort iterator, merges the two arrays into one, sorted by tabindex.\n *\n * @param {HTMLElement[]} left\n * @param {HTMLElement[]} right\n * @return {HTMLElement[]}\n */\nfunction mergeSortByTabIndex(left, right) {\n  const result = [];\n  while (left.length > 0 && right.length > 0) {\n    if (hasLowerTabOrder(left[0], right[0])) {\n      result.push(right.shift());\n    } else {\n      result.push(left.shift());\n    }\n  }\n  return result.concat(left, right);\n}\n\n/**\n * Sorts an array of elements by tabindex. Returns a new array.\n *\n * @param {HTMLElement[]} elements\n * @return {HTMLElement[]}\n */\nfunction sortElementsByTabIndex(elements) {\n  // Implement a merge sort as Array.prototype.sort does a non-stable sort\n  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort\n  const len = elements.length;\n  if (len < 2) {\n    return elements;\n  }\n  const pivot = Math.ceil(len / 2);\n  const left = sortElementsByTabIndex(elements.slice(0, pivot));\n  const right = sortElementsByTabIndex(elements.slice(pivot));\n  return mergeSortByTabIndex(left, right);\n}\n\n/**\n * Returns true if the element is hidden, false otherwise.\n *\n * An element is treated as hidden when any of the following conditions are met:\n * - the element itself or one of its ancestors has `display: none`.\n * - the element has or inherits `visibility: hidden`.\n *\n * @param {HTMLElement} element\n * @return {boolean}\n */\nexport function isElementHidden(element) {\n  // `offsetParent` is `null` when the element itself\n  // or one of its ancestors is hidden with `display: none`.\n  // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetParent\n  // However `offsetParent` is also null when the element is using fixed\n  // positioning, so additionally check if the element takes up layout space.\n  if (element.offsetParent === null && element.clientWidth === 0 && element.clientHeight === 0) {\n    return true;\n  }\n  return isElementHiddenDirectly(element);\n}\n\n/**\n * Returns true if the element is focusable, otherwise false.\n *\n * The list of focusable elements is taken from http://stackoverflow.com/a/1600194/4228703.\n * However, there isn't a definite list, it's up to the browser.\n * The only standard we have is DOM Level 2 HTML https://www.w3.org/TR/DOM-Level-2-HTML/html.html,\n * according to which the only elements that have a `focus()` method are:\n * - HTMLInputElement\n * - HTMLSelectElement\n * - HTMLTextAreaElement\n * - HTMLAnchorElement\n *\n * This notably omits HTMLButtonElement and HTMLAreaElement.\n * Referring to these tests with tabbables in different browsers\n * http://allyjs.io/data-tables/focusable.html\n *\n * @param {HTMLElement} element\n * @return {boolean}\n */\nexport function isElementFocusable(element) {\n  // The element cannot be focused if its `tabindex` attribute is set to `-1`.\n  if (element.matches('[tabindex=\"-1\"]')) {\n    return false;\n  }\n\n  // Elements that cannot be focused if they have a `disabled` attribute.\n  if (element.matches('input, select, textarea, button, object')) {\n    return element.matches(':not([disabled])');\n  }\n\n  // Elements that can be focused even if they have a `disabled` attribute.\n  return element.matches('a[href], area[href], iframe, [tabindex], [contentEditable]');\n}\n\n/**\n * Returns true if the element is focused, false otherwise.\n *\n * @param {HTMLElement} element\n * @return {boolean}\n */\nexport function isElementFocused(element) {\n  return element.getRootNode().activeElement === element;\n}\n\n/**\n * Returns the normalized element tabindex. If not focusable, returns -1.\n * It checks for the attribute \"tabindex\" instead of the element property\n * `tabIndex` since browsers assign different values to it.\n * e.g. in Firefox `<div contenteditable>` has `tabIndex = -1`\n *\n * @param {HTMLElement} element\n * @return {number}\n */\nfunction normalizeTabIndex(element) {\n  if (!isElementFocusable(element)) {\n    return -1;\n  }\n  const tabIndex = element.getAttribute('tabindex') || 0;\n  return Number(tabIndex);\n}\n\n/**\n * Searches for nodes that are tabbable and adds them to the `result` array.\n * Returns if the `result` array needs to be sorted by tabindex.\n *\n * @param {Node} node The starting point for the search; added to `result` if tabbable.\n * @param {HTMLElement[]} result\n * @return {boolean}\n * @private\n */\nfunction collectFocusableNodes(node, result) {\n  if (node.nodeType !== Node.ELEMENT_NODE || isElementHiddenDirectly(node)) {\n    // Don't traverse children if the node is not an HTML element or not visible.\n    return false;\n  }\n  const element = /** @type {HTMLElement} */node;\n  const tabIndex = normalizeTabIndex(element);\n  let needsSort = tabIndex > 0;\n  if (tabIndex >= 0) {\n    result.push(element);\n  }\n  let children = [];\n  if (element.localName === 'slot') {\n    children = element.assignedNodes({\n      flatten: true\n    });\n  } else {\n    // Use shadow root if possible, will check for distributed nodes.\n    children = (element.shadowRoot || element).children;\n  }\n  [...children].forEach(child => {\n    // Ensure method is always invoked to collect focusable children.\n    needsSort = collectFocusableNodes(child, result) || needsSort;\n  });\n  return needsSort;\n}\n\n/**\n * Returns a tab-ordered array of focusable elements for a root element.\n * The resulting array will include the root element if it is focusable.\n *\n * The method traverses nodes in shadow DOM trees too if any.\n *\n * @param {HTMLElement} element\n * @return {HTMLElement[]}\n */\nexport function getFocusableElements(element) {\n  const focusableElements = [];\n  const needsSortByTabIndex = collectFocusableNodes(element, focusableElements);\n  // If there is at least one element with tabindex > 0,\n  // we need to sort the final array by tabindex.\n  if (needsSortByTabIndex) {\n    return sortElementsByTabIndex(focusableElements);\n  }\n  return focusableElements;\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n/**\n * Returns an array of ancestor root nodes for the given node.\n *\n * A root node is either a document node or a document fragment node (Shadow Root).\n * The array is collected by a bottom-up DOM traversing that starts with the given node\n * and involves both the light DOM and ancestor shadow DOM trees.\n *\n * @param {Node} node\n * @return {Node[]}\n */\nexport function getAncestorRootNodes(node) {\n  const result = [];\n  while (node) {\n    if (node.nodeType === Node.DOCUMENT_NODE) {\n      result.push(node);\n      break;\n    }\n    if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n      result.push(node);\n      node = node.host;\n      continue;\n    }\n    if (node.assignedSlot) {\n      node = node.assignedSlot;\n      continue;\n    }\n    node = node.parentNode;\n  }\n  return result;\n}\n\n/**\n * Returns the list of flattened elements for the given `node`.\n * This list consists of a node's children and, for any children that are\n * `<slot>` elements, the expanded flattened list of `assignedElements`.\n *\n * @param {Node} node\n * @return {Element[]}\n */\nexport function getFlattenedElements(node) {\n  const result = [];\n  let elements;\n  if (node.localName === 'slot') {\n    elements = node.assignedElements();\n  } else {\n    result.push(node);\n    elements = [...node.children];\n  }\n  elements.forEach(elem => result.push(...getFlattenedElements(elem)));\n  return result;\n}\n\n/**\n * Traverses the given node and its parents, including those that are across\n * the shadow root boundaries, until it finds a node that matches the selector.\n *\n * @param {string} selector The CSS selector to match against\n * @param {Node} node The starting node for the traversal\n * @return {Node | null} The closest matching element, or null if no match is found\n */\nexport function getClosestElement(selector, node) {\n  if (!node) {\n    return null;\n  }\n  return node.closest(selector) || getClosestElement(selector, node.getRootNode().host);\n}\n\n/**\n * Takes a string with values separated by space and returns a set the values\n *\n * @param {string} value\n * @return {Set<string>}\n */\nexport function deserializeAttributeValue(value) {\n  if (!value) {\n    return new Set();\n  }\n  return new Set(value.split(' '));\n}\n\n/**\n * Takes a set of string values and returns a string with values separated by space\n *\n * @param {Set<string>} values\n * @return {string}\n */\nexport function serializeAttributeValue(values) {\n  return values ? [...values].join(' ') : '';\n}\n\n/**\n * Adds a value to an attribute containing space-delimited values.\n *\n * @param {HTMLElement} element\n * @param {string} attr\n * @param {string} value\n */\nexport function addValueToAttribute(element, attr, value) {\n  const values = deserializeAttributeValue(element.getAttribute(attr));\n  values.add(value);\n  element.setAttribute(attr, serializeAttributeValue(values));\n}\n\n/**\n * Removes a value from an attribute containing space-delimited values.\n * If the value is the last one, the whole attribute is removed.\n *\n * @param {HTMLElement} element\n * @param {string} attr\n * @param {string} value\n */\nexport function removeValueFromAttribute(element, attr, value) {\n  const values = deserializeAttributeValue(element.getAttribute(attr));\n  values.delete(value);\n  if (values.size === 0) {\n    element.removeAttribute(attr);\n    return;\n  }\n  element.setAttribute(attr, serializeAttributeValue(values));\n}\n\n/**\n * Returns true if the given node is an empty text node, false otherwise.\n *\n * @param {Node} node\n * @return {boolean}\n */\nexport function isEmptyTextNode(node) {\n  return node.nodeType === Node.TEXT_NODE && node.textContent.trim() === '';\n}","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { getAncestorRootNodes } from '@vaadin/component-base/src/dom-utils.js';\nimport { observeMove } from './vaadin-overlay-utils.js';\nconst PROP_NAMES_VERTICAL = {\n  start: 'top',\n  end: 'bottom'\n};\nconst PROP_NAMES_HORIZONTAL = {\n  start: 'left',\n  end: 'right'\n};\nconst targetResizeObserver = new ResizeObserver(entries => {\n  setTimeout(() => {\n    entries.forEach(entry => {\n      if (entry.target.__overlay) {\n        entry.target.__overlay._updatePosition();\n      }\n    });\n  });\n});\n\n/**\n * @polymerMixin\n */\nexport const PositionMixin = superClass => class PositionMixin extends superClass {\n  static get properties() {\n    return {\n      /**\n       * The element next to which this overlay should be aligned.\n       * The position of the overlay relative to the positionTarget can be adjusted\n       * with properties `horizontalAlign`, `verticalAlign`, `noHorizontalOverlap`\n       * and `noVerticalOverlap`.\n       */\n      positionTarget: {\n        type: Object,\n        value: null,\n        sync: true\n      },\n      /**\n       * When `positionTarget` is set, this property defines whether to align the overlay's\n       * left or right side to the target element by default.\n       * Possible values are `start` and `end`.\n       * RTL is taken into account when interpreting the value.\n       * The overlay is automatically flipped to the opposite side when it doesn't fit into\n       * the default side defined by this property.\n       *\n       * @attr {start|end} horizontal-align\n       */\n      horizontalAlign: {\n        type: String,\n        value: 'start',\n        sync: true\n      },\n      /**\n       * When `positionTarget` is set, this property defines whether to align the overlay's\n       * top or bottom side to the target element by default.\n       * Possible values are `top` and `bottom`.\n       * The overlay is automatically flipped to the opposite side when it doesn't fit into\n       * the default side defined by this property.\n       *\n       * @attr {top|bottom} vertical-align\n       */\n      verticalAlign: {\n        type: String,\n        value: 'top',\n        sync: true\n      },\n      /**\n       * When `positionTarget` is set, this property defines whether the overlay should overlap\n       * the target element in the x-axis, or be positioned right next to it.\n       *\n       * @attr {boolean} no-horizontal-overlap\n       */\n      noHorizontalOverlap: {\n        type: Boolean,\n        value: false,\n        sync: true\n      },\n      /**\n       * When `positionTarget` is set, this property defines whether the overlay should overlap\n       * the target element in the y-axis, or be positioned right above/below it.\n       *\n       * @attr {boolean} no-vertical-overlap\n       */\n      noVerticalOverlap: {\n        type: Boolean,\n        value: false,\n        sync: true\n      },\n      /**\n       * If the overlay content has no intrinsic height, this property can be used to set\n       * the minimum vertical space (in pixels) required by the overlay. Setting a value to\n       * the property effectively disables the content measurement in favor of using this\n       * fixed value for determining the open direction.\n       *\n       * @attr {number} required-vertical-space\n       */\n      requiredVerticalSpace: {\n        type: Number,\n        value: 0,\n        sync: true\n      }\n    };\n  }\n  static get observers() {\n    return ['__positionSettingsChanged(horizontalAlign, verticalAlign, noHorizontalOverlap, noVerticalOverlap, requiredVerticalSpace)', '__overlayOpenedChanged(opened, positionTarget)'];\n  }\n  constructor() {\n    super();\n    this.__onScroll = this.__onScroll.bind(this);\n    this._updatePosition = this._updatePosition.bind(this);\n  }\n\n  /** @protected */\n  connectedCallback() {\n    super.connectedCallback();\n    if (this.opened) {\n      this.__addUpdatePositionEventListeners();\n    }\n  }\n\n  /** @protected */\n  disconnectedCallback() {\n    super.disconnectedCallback();\n    this.__removeUpdatePositionEventListeners();\n  }\n\n  /** @private */\n  __addUpdatePositionEventListeners() {\n    window.visualViewport.addEventListener('resize', this._updatePosition);\n    window.visualViewport.addEventListener('scroll', this.__onScroll, true);\n    this.__positionTargetAncestorRootNodes = getAncestorRootNodes(this.positionTarget);\n    this.__positionTargetAncestorRootNodes.forEach(node => {\n      node.addEventListener('scroll', this.__onScroll, true);\n    });\n    if (this.positionTarget) {\n      this.__observePositionTargetMove = observeMove(this.positionTarget, () => {\n        this._updatePosition();\n      });\n    }\n  }\n\n  /** @private */\n  __removeUpdatePositionEventListeners() {\n    window.visualViewport.removeEventListener('resize', this._updatePosition);\n    window.visualViewport.removeEventListener('scroll', this.__onScroll, true);\n    if (this.__positionTargetAncestorRootNodes) {\n      this.__positionTargetAncestorRootNodes.forEach(node => {\n        node.removeEventListener('scroll', this.__onScroll, true);\n      });\n      this.__positionTargetAncestorRootNodes = null;\n    }\n    if (this.__observePositionTargetMove) {\n      this.__observePositionTargetMove();\n      this.__observePositionTargetMove = null;\n    }\n  }\n\n  /** @private */\n  __overlayOpenedChanged(opened, positionTarget) {\n    this.__removeUpdatePositionEventListeners();\n    if (positionTarget) {\n      positionTarget.__overlay = null;\n      targetResizeObserver.unobserve(positionTarget);\n      if (opened) {\n        this.__addUpdatePositionEventListeners();\n        positionTarget.__overlay = this;\n        targetResizeObserver.observe(positionTarget);\n      }\n    }\n    if (opened) {\n      const computedStyle = getComputedStyle(this);\n      if (!this.__margins) {\n        this.__margins = {};\n        ['top', 'bottom', 'left', 'right'].forEach(propName => {\n          this.__margins[propName] = parseInt(computedStyle[propName], 10);\n        });\n      }\n      this._updatePosition();\n      // Schedule another position update (to cover virtual keyboard opening for example)\n      requestAnimationFrame(() => this._updatePosition());\n    }\n  }\n  __positionSettingsChanged() {\n    this._updatePosition();\n  }\n\n  /** @private */\n  __onScroll(e) {\n    // If the scroll event occurred inside the overlay, ignore it.\n    if (e.target instanceof Node && this.contains(e.target)) {\n      return;\n    }\n    this._updatePosition();\n  }\n  _updatePosition() {\n    if (!this.positionTarget || !this.opened || !this.__margins) {\n      return;\n    }\n    const targetRect = this.positionTarget.getBoundingClientRect();\n    if (targetRect.width === 0 && targetRect.height === 0 && this.opened) {\n      this.opened = false;\n      return;\n    }\n\n    // Detect the desired alignment and update the layout accordingly\n    const shouldAlignStartVertically = this.__shouldAlignStartVertically(targetRect);\n    this.style.justifyContent = shouldAlignStartVertically ? 'flex-start' : 'flex-end';\n    const isRTL = this.__isRTL;\n    const shouldAlignStartHorizontally = this.__shouldAlignStartHorizontally(targetRect, isRTL);\n    const flexStart = !isRTL && shouldAlignStartHorizontally || isRTL && !shouldAlignStartHorizontally;\n    this.style.alignItems = flexStart ? 'flex-start' : 'flex-end';\n\n    // Get the overlay rect after possible overlay alignment changes\n    const overlayRect = this.getBoundingClientRect();\n\n    // Obtain vertical positioning properties\n    const verticalProps = this.__calculatePositionInOneDimension(targetRect, overlayRect, this.noVerticalOverlap, PROP_NAMES_VERTICAL, this, shouldAlignStartVertically);\n\n    // Obtain horizontal positioning properties\n    const horizontalProps = this.__calculatePositionInOneDimension(targetRect, overlayRect, this.noHorizontalOverlap, PROP_NAMES_HORIZONTAL, this, shouldAlignStartHorizontally);\n\n    // Apply the positioning properties to the overlay\n    Object.assign(this.style, verticalProps, horizontalProps);\n    this.toggleAttribute('bottom-aligned', !shouldAlignStartVertically);\n    this.toggleAttribute('top-aligned', shouldAlignStartVertically);\n    this.toggleAttribute('end-aligned', !flexStart);\n    this.toggleAttribute('start-aligned', flexStart);\n  }\n  __shouldAlignStartHorizontally(targetRect, rtl) {\n    // Using previous size to fix a case where window resize may cause the overlay to be squeezed\n    // smaller than its current space before the fit-calculations.\n    const contentWidth = Math.max(this.__oldContentWidth || 0, this.$.overlay.offsetWidth);\n    this.__oldContentWidth = this.$.overlay.offsetWidth;\n    const viewportWidth = Math.min(window.innerWidth, document.documentElement.clientWidth);\n    const defaultAlignLeft = !rtl && this.horizontalAlign === 'start' || rtl && this.horizontalAlign === 'end';\n    return this.__shouldAlignStart(targetRect, contentWidth, viewportWidth, this.__margins, defaultAlignLeft, this.noHorizontalOverlap, PROP_NAMES_HORIZONTAL);\n  }\n  __shouldAlignStartVertically(targetRect) {\n    // Using previous size to fix a case where window resize may cause the overlay to be squeezed\n    // smaller than its current space before the fit-calculations.\n    const contentHeight = this.requiredVerticalSpace || Math.max(this.__oldContentHeight || 0, this.$.overlay.offsetHeight);\n    this.__oldContentHeight = this.$.overlay.offsetHeight;\n    const viewportHeight = Math.min(window.innerHeight, document.documentElement.clientHeight);\n    const defaultAlignTop = this.verticalAlign === 'top';\n    return this.__shouldAlignStart(targetRect, contentHeight, viewportHeight, this.__margins, defaultAlignTop, this.noVerticalOverlap, PROP_NAMES_VERTICAL);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/max-params\n  __shouldAlignStart(targetRect, contentSize, viewportSize, margins, defaultAlignStart, noOverlap, propNames) {\n    const spaceForStartAlignment = viewportSize - targetRect[noOverlap ? propNames.end : propNames.start] - margins[propNames.end];\n    const spaceForEndAlignment = targetRect[noOverlap ? propNames.start : propNames.end] - margins[propNames.start];\n    const spaceForDefaultAlignment = defaultAlignStart ? spaceForStartAlignment : spaceForEndAlignment;\n    const spaceForOtherAlignment = defaultAlignStart ? spaceForEndAlignment : spaceForStartAlignment;\n    const shouldGoToDefaultSide = spaceForDefaultAlignment > spaceForOtherAlignment || spaceForDefaultAlignment > contentSize;\n    return defaultAlignStart === shouldGoToDefaultSide;\n  }\n\n  /**\n   * Returns an adjusted value after resizing the browser window,\n   * to avoid wrong calculations when e.g. previously set `bottom`\n   * CSS property value is larger than the updated viewport height.\n   * See https://github.com/vaadin/web-components/issues/4604\n   */\n  __adjustBottomProperty(cssPropNameToSet, propNames, currentValue) {\n    let adjustedProp;\n    if (cssPropNameToSet === propNames.end) {\n      // Adjust horizontally\n      if (propNames.end === PROP_NAMES_VERTICAL.end) {\n        const viewportHeight = Math.min(window.innerHeight, document.documentElement.clientHeight);\n        if (currentValue > viewportHeight && this.__oldViewportHeight) {\n          const heightDiff = this.__oldViewportHeight - viewportHeight;\n          adjustedProp = currentValue - heightDiff;\n        }\n        this.__oldViewportHeight = viewportHeight;\n      }\n\n      // Adjust vertically\n      if (propNames.end === PROP_NAMES_HORIZONTAL.end) {\n        const viewportWidth = Math.min(window.innerWidth, document.documentElement.clientWidth);\n        if (currentValue > viewportWidth && this.__oldViewportWidth) {\n          const widthDiff = this.__oldViewportWidth - viewportWidth;\n          adjustedProp = currentValue - widthDiff;\n        }\n        this.__oldViewportWidth = viewportWidth;\n      }\n    }\n    return adjustedProp;\n  }\n\n  /**\n   * Returns an object with CSS position properties to set,\n   * e.g. { top: \"100px\" }\n   */\n  // eslint-disable-next-line @typescript-eslint/max-params\n  __calculatePositionInOneDimension(targetRect, overlayRect, noOverlap, propNames, overlay, shouldAlignStart) {\n    const cssPropNameToSet = shouldAlignStart ? propNames.start : propNames.end;\n    const cssPropNameToClear = shouldAlignStart ? propNames.end : propNames.start;\n    const currentValue = parseFloat(overlay.style[cssPropNameToSet] || getComputedStyle(overlay)[cssPropNameToSet]);\n    const adjustedValue = this.__adjustBottomProperty(cssPropNameToSet, propNames, currentValue);\n    const diff = overlayRect[shouldAlignStart ? propNames.start : propNames.end] - targetRect[noOverlap === shouldAlignStart ? propNames.end : propNames.start];\n    const valueToSet = adjustedValue ? `${adjustedValue}px` : `${currentValue + diff * (shouldAlignStart ? -1 : 1)}px`;\n    return {\n      [cssPropNameToSet]: valueToSet,\n      [cssPropNameToClear]: ''\n    };\n  }\n};","/**\n * @license\n * Copyright (c) 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n/**\n * Observe moving an element around on a page.\n *\n * Based on the idea from https://samthor.au/2021/observing-dom/ as implemented in Floating UI\n * https://github.com/floating-ui/floating-ui/blob/58ed169/packages/dom/src/autoUpdate.ts#L45\n *\n * @param {HTMLElement} element\n * @param {Function} callback\n * @return {Function}\n */\nexport function observeMove(element, callback) {\n  let io = null;\n  const root = document.documentElement;\n  function cleanup() {\n    io && io.disconnect();\n    io = null;\n  }\n  function refresh() {\n    let skip = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n    let threshold = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;\n    cleanup();\n    const _element$getBoundingC = element.getBoundingClientRect(),\n      left = _element$getBoundingC.left,\n      top = _element$getBoundingC.top,\n      width = _element$getBoundingC.width,\n      height = _element$getBoundingC.height;\n    if (!skip) {\n      callback();\n    }\n    if (!width || !height) {\n      return;\n    }\n    const insetTop = Math.floor(top);\n    const insetRight = Math.floor(root.clientWidth - (left + width));\n    const insetBottom = Math.floor(root.clientHeight - (top + height));\n    const insetLeft = Math.floor(left);\n    const rootMargin = `${-insetTop}px ${-insetRight}px ${-insetBottom}px ${-insetLeft}px`;\n    const options = {\n      rootMargin,\n      threshold: Math.max(0, Math.min(1, threshold)) || 1\n    };\n    let isFirstUpdate = true;\n    function handleObserve(entries) {\n      let ratio = entries[0].intersectionRatio;\n      if (ratio !== threshold) {\n        if (!isFirstUpdate) {\n          return refresh();\n        }\n\n        // It's possible for the watched element to not be at perfect 1.0 visibility when we create\n        // the IntersectionObserver. This has a couple of causes:\n        //   - elements being on partial pixels\n        //   - elements being hidden offscreen (e.g., <html> has `overflow: hidden`)\n        //   - delays: if your DOM change occurs due to e.g., page resize, you can see elements\n        //     behind their actual position\n        //\n        // In all of these cases, refresh but with this lower ratio of threshold. When the element\n        // moves beneath _that_ new value, the user will get notified.\n        if (ratio === 0.0) {\n          ratio = 0.0000001; // Just needs to be non-zero\n        }\n        refresh(false, ratio);\n      }\n      isFirstUpdate = false;\n    }\n    io = new IntersectionObserver(handleObserve, options);\n    io.observe(element);\n  }\n  refresh(true);\n  return cleanup;\n}","/**\n * @license\n * Copyright (c) 2015 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { isElementFocusable } from '@vaadin/a11y-base/src/focus-utils.js';\nimport { PositionMixin } from '@vaadin/overlay/src/vaadin-overlay-position-mixin.js';\n\n/**\n * @polymerMixin\n * @mixes PositionMixin\n */\nexport const ComboBoxOverlayMixin = superClass => class ComboBoxOverlayMixin extends PositionMixin(superClass) {\n  static get observers() {\n    return ['_setOverlayWidth(positionTarget, opened)'];\n  }\n  constructor() {\n    super();\n    this.requiredVerticalSpace = 200;\n  }\n\n  /** @protected */\n  connectedCallback() {\n    super.connectedCallback();\n    const comboBox = this._comboBox;\n    const hostDir = comboBox && comboBox.getAttribute('dir');\n    if (hostDir) {\n      this.setAttribute('dir', hostDir);\n    }\n  }\n\n  /**\n   * Override method inherited from `Overlay`\n   * to not close on position target click.\n   *\n   * @param {Event} event\n   * @return {boolean}\n   * @protected\n   */\n  _shouldCloseOnOutsideClick(event) {\n    const eventPath = event.composedPath();\n    return !eventPath.includes(this.positionTarget) && !eventPath.includes(this);\n  }\n\n  /**\n   * @protected\n   * @override\n   */\n  _mouseDownListener(event) {\n    super._mouseDownListener(event);\n\n    // Prevent global mousedown event to avoid losing focus on outside click,\n    // unless the clicked element is also focusable (e.g. in date-time-picker).\n    if (this._shouldCloseOnOutsideClick(event) && !isElementFocusable(event.composedPath()[0])) {\n      event.preventDefault();\n    }\n  }\n\n  /** @protected */\n  _updateOverlayWidth() {\n    const propPrefix = this.localName;\n    this.style.setProperty(`--_${propPrefix}-default-width`, `${this.positionTarget.clientWidth}px`);\n    const customWidth = getComputedStyle(this._comboBox).getPropertyValue(`--${propPrefix}-width`);\n    if (customWidth === '') {\n      this.style.removeProperty(`--${propPrefix}-width`);\n    } else {\n      this.style.setProperty(`--${propPrefix}-width`, customWidth);\n    }\n  }\n\n  /** @private */\n  _setOverlayWidth(positionTarget, opened) {\n    if (positionTarget && opened) {\n      this._updateOverlayWidth();\n      this._updatePosition();\n    }\n  }\n};","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n/**\n * Module for scheduling flushable pre-render and post-render tasks.\n *\n * @summary Module for scheduling flushable pre-render and post-render tasks.\n */\n\nimport './boot.js';\nlet scheduled = false;\nlet beforeRenderQueue = [];\nlet afterRenderQueue = [];\nfunction schedule() {\n  scheduled = true;\n  // before next render\n  requestAnimationFrame(function () {\n    scheduled = false;\n    flushQueue(beforeRenderQueue);\n    // after the render\n    setTimeout(function () {\n      runQueue(afterRenderQueue);\n    });\n  });\n}\nfunction flushQueue(queue) {\n  while (queue.length) {\n    callMethod(queue.shift());\n  }\n}\nfunction runQueue(queue) {\n  for (let i = 0, l = queue.length; i < l; i++) {\n    callMethod(queue.shift());\n  }\n}\nfunction callMethod(info) {\n  const context = info[0];\n  const callback = info[1];\n  const args = info[2];\n  try {\n    callback.apply(context, args);\n  } catch (e) {\n    setTimeout(() => {\n      throw e;\n    });\n  }\n}\n\n/**\n * Flushes all `beforeNextRender` tasks, followed by all `afterNextRender`\n * tasks.\n *\n * @return {void}\n */\nexport function flush() {\n  while (beforeRenderQueue.length || afterRenderQueue.length) {\n    flushQueue(beforeRenderQueue);\n    flushQueue(afterRenderQueue);\n  }\n  scheduled = false;\n}\n\n/**\n * Enqueues a callback which will be run before the next render, at\n * `requestAnimationFrame` timing.\n *\n * This method is useful for enqueuing work that requires DOM measurement,\n * since measurement may not be reliable in custom element callbacks before\n * the first render, as well as for batching measurement tasks in general.\n *\n * Tasks in this queue may be flushed by calling `flush()`.\n *\n * @param {*} context Context object the callback function will be bound to\n * @param {function(...*):void} callback Callback function\n * @param {!Array=} args An array of arguments to call the callback function with\n * @return {void}\n */\nexport function beforeNextRender(context, callback, args) {\n  if (!scheduled) {\n    schedule();\n  }\n  beforeRenderQueue.push([context, callback, args]);\n}\n\n/**\n * Enqueues a callback which will be run after the next render, equivalent\n * to one task (`setTimeout`) after the next `requestAnimationFrame`.\n *\n * This method is useful for tuning the first-render performance of an\n * element or application by deferring non-critical work until after the\n * first paint.  Typical non-render-critical work may include adding UI\n * event listeners and aria attributes.\n *\n * @param {*} context Context object the callback function will be bound to\n * @param {function(...*):void} callback Callback function\n * @param {!Array=} args An array of arguments to call the callback function with\n * @return {void}\n */\nexport function afterNextRender(context, callback, args) {\n  if (!scheduled) {\n    schedule();\n  }\n  afterRenderQueue.push([context, callback, args]);\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\nconst testUserAgent = regexp => regexp.test(navigator.userAgent);\nconst testPlatform = regexp => regexp.test(navigator.platform);\nconst testVendor = regexp => regexp.test(navigator.vendor);\nexport const isAndroid = testUserAgent(/Android/u);\nexport const isChrome = testUserAgent(/Chrome/u) && testVendor(/Google Inc/u);\nexport const isFirefox = testUserAgent(/Firefox/u);\n\n// IPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.\nexport const isIPad = testPlatform(/^iPad/u) || testPlatform(/^Mac/u) && navigator.maxTouchPoints > 1;\nexport const isIPhone = testPlatform(/^iPhone/u);\nexport const isIOS = isIPhone || isIPad;\nexport const isSafari = testUserAgent(/^((?!chrome|android).)*safari/iu);\nexport const isTouch = (() => {\n  try {\n    document.createEvent('TouchEvent');\n    return true;\n  } catch (_) {\n    return false;\n  }\n})();","/**\n * @license\n * Copyright (c) 2017 Anton Korzunov\n * SPDX-License-Identifier: MIT\n */\n\n/**\n * @fileoverview\n *\n * This module includes JS code copied from the `aria-hidden` package:\n * https://github.com/theKashey/aria-hidden/blob/master/src/index.ts\n */\n\n/** @type {WeakMap<Element, number>} */\nlet counterMap = new WeakMap();\n\n/** @type {WeakMap<Element, boolean>} */\nlet uncontrolledNodes = new WeakMap();\n\n/** @type {Record<string, WeakMap<Element, number>>} */\nlet markerMap = {};\n\n/** @type {number} */\nlet lockCount = 0;\n\n/**\n * @param {?Node} node\n * @return {boolean}\n */\nconst isElement = node => node && node.nodeType === Node.ELEMENT_NODE;\n\n/**\n * @param  {...unknown} args\n */\nconst logError = function () {\n  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n    args[_key] = arguments[_key];\n  }\n  console.error(`Error: ${args.join(' ')}. Skip setting aria-hidden.`);\n};\n\n/**\n * @param {HTMLElement} parent\n * @param {Element[]} targets\n * @return {Element[]}\n */\nconst correctTargets = (parent, targets) => {\n  if (!isElement(parent)) {\n    logError(parent, 'is not a valid element');\n    return [];\n  }\n  return targets.map(target => {\n    if (!isElement(target)) {\n      logError(target, 'is not a valid element');\n      return null;\n    }\n    let node = target;\n    while (node && node !== parent) {\n      if (parent.contains(node)) {\n        return target;\n      }\n      node = node.getRootNode().host;\n    }\n    logError(target, 'is not contained inside', parent);\n    return null;\n  }).filter(x => Boolean(x));\n};\n\n/**\n * Marks everything except given node(or nodes) as aria-hidden\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param {HTMLElement} [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @param {String} [controlAttribute] - html Attribute to control\n * @return {Function}\n */\nconst applyAttributeToOthers = (originalTarget, parentNode, markerName, controlAttribute) => {\n  const targets = correctTargets(parentNode, Array.isArray(originalTarget) ? originalTarget : [originalTarget]);\n  if (!markerMap[markerName]) {\n    markerMap[markerName] = new WeakMap();\n  }\n  const markerCounter = markerMap[markerName];\n\n  /** @type {Element[]} */\n  const hiddenNodes = [];\n\n  /** @type {Set<Node>} */\n  const elementsToKeep = new Set();\n\n  /** @type {Set<Node>} */\n  const elementsToStop = new Set(targets);\n\n  /**\n   * @param {?Node} el\n   */\n  const keep = el => {\n    if (!el || elementsToKeep.has(el)) {\n      return;\n    }\n    elementsToKeep.add(el);\n    const slot = el.assignedSlot;\n    if (slot) {\n      keep(slot);\n    }\n    keep(el.parentNode || el.host);\n  };\n  targets.forEach(keep);\n\n  /**\n   * @param {?Node} el\n   */\n  const deep = parent => {\n    if (!parent || elementsToStop.has(parent)) {\n      return;\n    }\n    const root = parent.shadowRoot;\n    const children = root ? [...parent.children, ...root.children] : [...parent.children];\n    children.forEach(node => {\n      // Skip elements that don't need to be hidden\n      if (['template', 'script', 'style'].includes(node.localName)) {\n        return;\n      }\n      if (elementsToKeep.has(node)) {\n        deep(node);\n      } else {\n        const attr = node.getAttribute(controlAttribute);\n        const alreadyHidden = attr !== null && attr !== 'false';\n        const counterValue = (counterMap.get(node) || 0) + 1;\n        const markerValue = (markerCounter.get(node) || 0) + 1;\n        counterMap.set(node, counterValue);\n        markerCounter.set(node, markerValue);\n        hiddenNodes.push(node);\n        if (counterValue === 1 && alreadyHidden) {\n          uncontrolledNodes.set(node, true);\n        }\n        if (markerValue === 1) {\n          node.setAttribute(markerName, 'true');\n        }\n        if (!alreadyHidden) {\n          node.setAttribute(controlAttribute, 'true');\n        }\n      }\n    });\n  };\n  deep(parentNode);\n  elementsToKeep.clear();\n  lockCount += 1;\n  return () => {\n    hiddenNodes.forEach(node => {\n      const counterValue = counterMap.get(node) - 1;\n      const markerValue = markerCounter.get(node) - 1;\n      counterMap.set(node, counterValue);\n      markerCounter.set(node, markerValue);\n      if (!counterValue) {\n        if (uncontrolledNodes.has(node)) {\n          uncontrolledNodes.delete(node);\n        } else {\n          node.removeAttribute(controlAttribute);\n        }\n      }\n      if (!markerValue) {\n        node.removeAttribute(markerName);\n      }\n    });\n    lockCount -= 1;\n    if (!lockCount) {\n      // clear\n      counterMap = new WeakMap();\n      counterMap = new WeakMap();\n      uncontrolledNodes = new WeakMap();\n      markerMap = {};\n    }\n  };\n};\n\n/**\n * Marks everything except given node(or nodes) as aria-hidden\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param {HTMLElement} [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @return {Function} undo command\n */\nexport const hideOthers = function (originalTarget) {\n  let parentNode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : document.body;\n  let markerName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'data-aria-hidden';\n  const targets = Array.from(Array.isArray(originalTarget) ? originalTarget : [originalTarget]);\n  if (parentNode) {\n    // We should not hide ariaLive elements - https://github.com/theKashey/aria-hidden/issues/10\n    targets.push(...Array.from(parentNode.querySelectorAll('[aria-live]')));\n  }\n  return applyAttributeToOthers(targets, parentNode, markerName, 'aria-hidden');\n};\n\n/**\n * Marks everything except given node(or nodes) as inert\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param {HTMLElement} [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @return {Function} undo command\n */\nexport const inertOthers = function (originalTarget) {\n  let parentNode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : document.body;\n  let markerName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'data-inert-ed';\n  return applyAttributeToOthers(originalTarget, parentNode, markerName, 'inert');\n};\n\n/**\n * @return if current browser supports inert\n */\nexport const supportsInert = 'inert' in HTMLElement.prototype;\n\n/**\n * Automatic function to \"suppress\" DOM elements - _hide_ or _inert_ in the best possible way\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param {HTMLElement} [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @return {Function} undo command\n */\nexport const suppressOthers = (originalTarget, parentNode, markerName) => (supportsInert ? inertOthers : hideOthers)(originalTarget, parentNode, markerName);","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { hideOthers } from './aria-hidden.js';\n\n/**\n * A controller for handling modal state on the elements with `dialog` and `alertdialog` role.\n * See https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-modal\n *\n * Note, the actual `role` and `aria-modal` attributes are supposed to be handled by the\n * consumer web component. This is done in to ensure the controller only does one thing.\n */\nexport class AriaModalController {\n  /**\n   * @param {HTMLElement} host\n   */\n  constructor(host, callback) {\n    /**\n     * The controller host element.\n     *\n     * @type {HTMLElement}\n     */\n    this.host = host;\n\n    /**\n     * The callback used to detect which element\n     * to use as a target. Defaults to the host.\n     *\n     * @type {Function}\n     */\n    this.callback = typeof callback === 'function' ? callback : () => host;\n  }\n\n  /**\n   * Make the controller host modal by hiding other elements from screen readers\n   * using `aria-hidden` attribute (can be replaced with `inert` in the future).\n   *\n   * The method name is chosen to align with the one provided by native `<dialog>`:\n   * https://developer.mozilla.org/en-US/docs/Web/API/HTMLDialogElement/showModal\n   */\n  showModal() {\n    const targets = this.callback();\n    this.__showOthers = hideOthers(targets);\n  }\n\n  /**\n   * Remove `aria-hidden` from other elements unless there are any other\n   * controller hosts on the page activated by using `showModal()` call.\n   */\n  close() {\n    if (this.__showOthers) {\n      this.__showOthers();\n      this.__showOthers = null;\n    }\n  }\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { getDeepActiveElement } from './focus-utils.js';\n\n/**\n * A controller for saving a focused node and restoring focus to it later.\n */\nexport class FocusRestorationController {\n  /**\n   * Saves the given node as a target for restoring focus to\n   * when `restoreFocus()` is called. If no node is provided,\n   * the currently focused node in the DOM is saved as a target.\n   *\n   * @param {Node | null | undefined} focusNode\n   */\n  saveFocus(focusNode) {\n    this.focusNode = focusNode || getDeepActiveElement();\n  }\n\n  /**\n   * Restores focus to the target node that was saved previously with `saveFocus()`.\n   */\n  restoreFocus(options) {\n    const focusNode = this.focusNode;\n    if (!focusNode) {\n      return;\n    }\n    const preventScroll = options ? options.preventScroll : false;\n    if (getDeepActiveElement() === document.body) {\n      // In Firefox and Safari, focusing the node synchronously\n      // doesn't work as expected when the overlay is closing on outside click.\n      // These browsers force focus to move to the body element and retain it\n      // there until the next event loop iteration.\n      setTimeout(() => focusNode.focus({\n        preventScroll\n      }));\n    } else {\n      focusNode.focus({\n        preventScroll\n      });\n    }\n    this.focusNode = null;\n  }\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { getFocusableElements, isElementFocused } from './focus-utils.js';\nconst instances = [];\n\n/**\n * A controller for trapping focus within a DOM node.\n */\nexport class FocusTrapController {\n  /**\n   * @param {HTMLElement} host\n   */\n  constructor(host) {\n    /**\n     * The controller host element.\n     *\n     * @type {HTMLElement}\n     */\n    this.host = host;\n\n    /**\n     * A node for trapping focus in.\n     *\n     * @type {HTMLElement | null}\n     * @private\n     */\n    this.__trapNode = null;\n    this.__onKeyDown = this.__onKeyDown.bind(this);\n  }\n\n  /**\n   * An array of tab-ordered focusable elements inside the trap node.\n   *\n   * @return {HTMLElement[]}\n   * @private\n   */\n  get __focusableElements() {\n    return getFocusableElements(this.__trapNode);\n  }\n\n  /**\n   * The index of the element inside the trap node that currently has focus.\n   *\n   * @return {HTMLElement | undefined}\n   * @private\n   */\n  get __focusedElementIndex() {\n    const focusableElements = this.__focusableElements;\n    return focusableElements.indexOf(focusableElements.filter(isElementFocused).pop());\n  }\n  hostConnected() {\n    document.addEventListener('keydown', this.__onKeyDown);\n  }\n  hostDisconnected() {\n    document.removeEventListener('keydown', this.__onKeyDown);\n  }\n\n  /**\n   * Activates a focus trap for a DOM node that will prevent focus from escaping the node.\n   * The trap can be deactivated with the `.releaseFocus()` method.\n   *\n   * If focus is initially outside the trap, the method will move focus inside,\n   * on the first focusable element of the trap in the tab order.\n   * The first focusable element can be the trap node itself if it is focusable\n   * and comes first in the tab order.\n   *\n   * If there are no focusable elements, the method will throw an exception\n   * and the trap will not be set.\n   *\n   * @param {HTMLElement} trapNode\n   */\n  trapFocus(trapNode) {\n    this.__trapNode = trapNode;\n    if (this.__focusableElements.length === 0) {\n      this.__trapNode = null;\n      throw new Error('The trap node should have at least one focusable descendant or be focusable itself.');\n    }\n    instances.push(this);\n    if (this.__focusedElementIndex === -1) {\n      this.__focusableElements[0].focus();\n    }\n  }\n\n  /**\n   * Deactivates the focus trap set with the `.trapFocus()` method\n   * so that it becomes possible to tab outside the trap node.\n   */\n  releaseFocus() {\n    this.__trapNode = null;\n    instances.pop();\n  }\n\n  /**\n   * A `keydown` event handler that manages tabbing navigation when the trap is enabled.\n   *\n   * - Moves focus to the next focusable element of the trap on `Tab` press.\n   * When no next element to focus, the method moves focus to the first focusable element.\n   * - Moves focus to the prev focusable element of the trap on `Shift+Tab` press.\n   * When no prev element to focus, the method moves focus to the last focusable element.\n   *\n   * @param {KeyboardEvent} event\n   * @private\n   */\n  __onKeyDown(event) {\n    if (!this.__trapNode) {\n      return;\n    }\n\n    // Only handle events for the last instance\n    if (this !== Array.from(instances).pop()) {\n      return;\n    }\n    if (event.key === 'Tab') {\n      event.preventDefault();\n      const backward = event.shiftKey;\n      this.__focusNextElement(backward);\n    }\n  }\n\n  /**\n   * - Moves focus to the next focusable element if `backward === false`.\n   * When no next element to focus, the method moves focus to the first focusable element.\n   * - Moves focus to the prev focusable element if `backward === true`.\n   * When no prev element to focus the method moves focus to the last focusable element.\n   *\n   * If no focusable elements, the method returns immediately.\n   *\n   * @param {boolean} backward\n   * @private\n   */\n  __focusNextElement() {\n    let backward = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n    const focusableElements = this.__focusableElements;\n    const step = backward ? -1 : 1;\n    const currentIndex = this.__focusedElementIndex;\n    const nextIndex = (focusableElements.length + currentIndex + step) % focusableElements.length;\n    const element = focusableElements[nextIndex];\n    element.focus();\n    if (element.localName === 'input') {\n      element.select();\n    }\n  }\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';\n\n/**\n * @typedef ReactiveController\n * @type {import('lit').ReactiveController}\n */\n\n/**\n * A mixin for connecting controllers to the element.\n *\n * @polymerMixin\n */\nexport const ControllerMixin = dedupingMixin(superClass => {\n  // If the superclass extends from LitElement,\n  // use its own controllers implementation.\n  if (typeof superClass.prototype.addController === 'function') {\n    return superClass;\n  }\n  return class ControllerMixinClass extends superClass {\n    constructor() {\n      super();\n\n      /**\n       * @type {Set<ReactiveController>}\n       */\n      this.__controllers = new Set();\n    }\n\n    /** @protected */\n    connectedCallback() {\n      super.connectedCallback();\n      this.__controllers.forEach(c => {\n        if (c.hostConnected) {\n          c.hostConnected();\n        }\n      });\n    }\n\n    /** @protected */\n    disconnectedCallback() {\n      super.disconnectedCallback();\n      this.__controllers.forEach(c => {\n        if (c.hostDisconnected) {\n          c.hostDisconnected();\n        }\n      });\n    }\n\n    /**\n     * Registers a controller to participate in the element update cycle.\n     *\n     * @param {ReactiveController} controller\n     * @protected\n     */\n    addController(controller) {\n      this.__controllers.add(controller);\n      // Call hostConnected if a controller is added after the element is attached.\n      if (this.$ !== undefined && this.isConnected && controller.hostConnected) {\n        controller.hostConnected();\n      }\n    }\n\n    /**\n     * Removes a controller from the element.\n     *\n     * @param {ReactiveController} controller\n     * @protected\n     */\n    removeController(controller) {\n      this.__controllers.delete(controller);\n    }\n  };\n});","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { AriaModalController } from '@vaadin/a11y-base/src/aria-modal-controller.js';\nimport { FocusRestorationController } from '@vaadin/a11y-base/src/focus-restoration-controller.js';\nimport { FocusTrapController } from '@vaadin/a11y-base/src/focus-trap-controller.js';\nimport { getDeepActiveElement, isKeyboardActive } from '@vaadin/a11y-base/src/focus-utils.js';\nimport { ControllerMixin } from '@vaadin/component-base/src/controller-mixin.js';\n\n/**\n * @polymerMixin\n * @mixes ControllerMixin\n */\nexport const OverlayFocusMixin = superClass => class OverlayFocusMixin extends ControllerMixin(superClass) {\n  static get properties() {\n    return {\n      /**\n       * When true, opening the overlay moves focus to the first focusable child,\n       * or to the overlay part with tabindex if there are no focusable children.\n       * @attr {boolean} focus-trap\n       */\n      focusTrap: {\n        type: Boolean,\n        value: false\n      },\n      /**\n       * Set to true to enable restoring of focus when overlay is closed.\n       * @attr {boolean} restore-focus-on-close\n       */\n      restoreFocusOnClose: {\n        type: Boolean,\n        value: false\n      },\n      /**\n       * Set to specify the element which should be focused on overlay close,\n       * if `restoreFocusOnClose` is set to true.\n       * @type {HTMLElement}\n       */\n      restoreFocusNode: {\n        type: HTMLElement\n      }\n    };\n  }\n  constructor() {\n    super();\n    this.__ariaModalController = new AriaModalController(this);\n    this.__focusTrapController = new FocusTrapController(this);\n    this.__focusRestorationController = new FocusRestorationController();\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n    this.addController(this.__ariaModalController);\n    this.addController(this.__focusTrapController);\n    this.addController(this.__focusRestorationController);\n  }\n\n  /**\n   * Release focus and restore focus after the overlay is closed.\n   *\n   * @protected\n   */\n  _resetFocus() {\n    if (this.focusTrap) {\n      this.__ariaModalController.close();\n      this.__focusTrapController.releaseFocus();\n    }\n    if (this.restoreFocusOnClose && this._shouldRestoreFocus()) {\n      const preventScroll = !isKeyboardActive();\n      this.__focusRestorationController.restoreFocus({\n        preventScroll\n      });\n    }\n  }\n\n  /**\n   * Save the previously focused node when the overlay starts to open.\n   *\n   * @protected\n   */\n  _saveFocus() {\n    if (this.restoreFocusOnClose) {\n      this.__focusRestorationController.saveFocus(this.restoreFocusNode);\n    }\n  }\n\n  /**\n   * Trap focus within the overlay after opening has completed.\n   *\n   * @protected\n   */\n  _trapFocus() {\n    if (this.focusTrap) {\n      this.__ariaModalController.showModal();\n      this.__focusTrapController.trapFocus(this.$.overlay);\n    }\n  }\n\n  /**\n   * Returns true if focus is still inside the overlay or on the body element,\n   * otherwise false.\n   *\n   * Focus shouldn't be restored if it's been moved elsewhere by another\n   * component or as a result of a user interaction e.g. the user clicked\n   * on a button outside the overlay while the overlay was open.\n   *\n   * @protected\n   * @return {boolean}\n   */\n  _shouldRestoreFocus() {\n    const activeElement = getDeepActiveElement();\n    return activeElement === document.body || this._deepContains(activeElement);\n  }\n\n  /**\n   * Returns true if the overlay contains the given node,\n   * including those within shadow DOM trees.\n   *\n   * @param {Node} node\n   * @return {boolean}\n   * @protected\n   */\n  _deepContains(node) {\n    if (this.contains(node)) {\n      return true;\n    }\n    let n = node;\n    const doc = node.ownerDocument;\n    // Walk from node to `this` or `document`\n    while (n && n !== doc && n !== this) {\n      n = n.parentNode || n.host;\n    }\n    return n === this;\n  }\n};","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n/**\n * Returns all attached overlays in visual stacking order.\n * @private\n */\nconst getAttachedInstances = () => Array.from(document.body.children).filter(el => el instanceof HTMLElement && el._hasOverlayStackMixin && !el.hasAttribute('closing')).sort((a, b) => a.__zIndex - b.__zIndex || 0);\n\n/**\n * Returns true if the overlay is the last one in the opened overlays stack.\n * @param {HTMLElement} overlay\n * @return {boolean}\n * @protected\n */\nexport const isLastOverlay = overlay => overlay === getAttachedInstances().pop();\n\n/**\n * @polymerMixin\n */\nexport const OverlayStackMixin = superClass => class OverlayStackMixin extends superClass {\n  constructor() {\n    super();\n    this._hasOverlayStackMixin = true;\n  }\n\n  /**\n   * Returns true if this is the last one in the opened overlays stack.\n   *\n   * @return {boolean}\n   * @protected\n   */\n  get _last() {\n    return isLastOverlay(this);\n  }\n\n  /**\n   * Brings the overlay as visually the frontmost one.\n   */\n  bringToFront() {\n    let zIndex = '';\n    const frontmost = getAttachedInstances().filter(o => o !== this).pop();\n    if (frontmost) {\n      const frontmostZIndex = frontmost.__zIndex;\n      zIndex = frontmostZIndex + 1;\n    }\n    this.style.zIndex = zIndex;\n    this.__zIndex = zIndex || parseFloat(getComputedStyle(this).zIndex);\n  }\n\n  /** @protected */\n  _enterModalState() {\n    if (document.body.style.pointerEvents !== 'none') {\n      // Set body pointer-events to 'none' to disable mouse interactions with\n      // other document nodes.\n      this._previousDocumentPointerEvents = document.body.style.pointerEvents;\n      document.body.style.pointerEvents = 'none';\n    }\n\n    // Disable pointer events in other attached overlays\n    getAttachedInstances().forEach(el => {\n      if (el !== this) {\n        el.$.overlay.style.pointerEvents = 'none';\n      }\n    });\n  }\n\n  /** @protected */\n  _exitModalState() {\n    if (this._previousDocumentPointerEvents !== undefined) {\n      // Restore body pointer-events\n      document.body.style.pointerEvents = this._previousDocumentPointerEvents;\n      delete this._previousDocumentPointerEvents;\n    }\n\n    // Restore pointer events in the previous overlay(s)\n    const instances = getAttachedInstances();\n    let el;\n    // Use instances.pop() to ensure the reverse order\n    while (el = instances.pop()) {\n      if (el === this) {\n        // Skip the current instance\n        continue;\n      }\n      el.$.overlay.style.removeProperty('pointer-events');\n      if (!el.modeless) {\n        // Stop after the last modal\n        break;\n      }\n    }\n  }\n};","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { afterNextRender } from '@polymer/polymer/lib/utils/render-status.js';\nimport { isIOS } from '@vaadin/component-base/src/browser-utils.js';\nimport { OverlayFocusMixin } from './vaadin-overlay-focus-mixin.js';\nimport { OverlayStackMixin } from './vaadin-overlay-stack-mixin.js';\n\n/**\n * @polymerMixin\n * @mixes OverlayFocusMixin\n * @mixes OverlayStackMixin\n */\nexport const OverlayMixin = superClass => class OverlayMixin extends OverlayFocusMixin(OverlayStackMixin(superClass)) {\n  static get properties() {\n    return {\n      /**\n       * When true, the overlay is visible and attached to body.\n       */\n      opened: {\n        type: Boolean,\n        notify: true,\n        observer: '_openedChanged',\n        reflectToAttribute: true\n      },\n      /**\n       * Owner element passed with renderer function\n       * @type {HTMLElement}\n       */\n      owner: {\n        type: Object\n      },\n      /**\n       * Object with properties that is passed to `renderer` function\n       */\n      model: {\n        type: Object\n      },\n      /**\n       * Custom function for rendering the content of the overlay.\n       * Receives three arguments:\n       *\n       * - `root` The root container DOM element. Append your content to it.\n       * - `owner` The host element of the renderer function.\n       * - `model` The object with the properties related with rendering.\n       * @type {OverlayRenderer | null | undefined}\n       */\n      renderer: {\n        type: Object\n      },\n      /**\n       * When true the overlay won't disable the main content, showing\n       * it doesn't change the functionality of the user interface.\n       * @type {boolean}\n       */\n      modeless: {\n        type: Boolean,\n        value: false,\n        reflectToAttribute: true,\n        observer: '_modelessChanged'\n      },\n      /**\n       * When set to true, the overlay is hidden. This also closes the overlay\n       * immediately in case there is a closing animation in progress.\n       * @type {boolean}\n       */\n      hidden: {\n        type: Boolean,\n        reflectToAttribute: true,\n        observer: '_hiddenChanged'\n      },\n      /**\n       * When true the overlay has backdrop on top of content when opened.\n       * @type {boolean}\n       */\n      withBackdrop: {\n        type: Boolean,\n        value: false,\n        reflectToAttribute: true\n      }\n    };\n  }\n  static get observers() {\n    return ['_rendererOrDataChanged(renderer, owner, model, opened)'];\n  }\n  constructor() {\n    super();\n    this._boundMouseDownListener = this._mouseDownListener.bind(this);\n    this._boundMouseUpListener = this._mouseUpListener.bind(this);\n    this._boundOutsideClickListener = this._outsideClickListener.bind(this);\n    this._boundKeydownListener = this._keydownListener.bind(this);\n\n    /* c8 ignore next 3 */\n    if (isIOS) {\n      this._boundIosResizeListener = () => this._detectIosNavbar();\n    }\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n\n    // Need to add dummy click listeners to this and the backdrop or else\n    // the document click event listener (_outsideClickListener) may never\n    // get invoked on iOS Safari (reproducible in <vaadin-dialog>\n    // and <vaadin-context-menu>).\n    this.addEventListener('click', () => {});\n    this.$.backdrop.addEventListener('click', () => {});\n    this.addEventListener('mouseup', () => {\n      // In Chrome, focus moves to body on overlay content mousedown\n      // See https://github.com/vaadin/flow-components/issues/5507\n      if (document.activeElement === document.body && this.$.overlay.getAttribute('tabindex') === '0') {\n        this.$.overlay.focus();\n      }\n    });\n  }\n\n  /** @protected */\n  connectedCallback() {\n    super.connectedCallback();\n\n    /* c8 ignore next 3 */\n    if (this._boundIosResizeListener) {\n      this._detectIosNavbar();\n      window.addEventListener('resize', this._boundIosResizeListener);\n    }\n  }\n\n  /** @protected */\n  disconnectedCallback() {\n    super.disconnectedCallback();\n\n    /* c8 ignore next 3 */\n    if (this._boundIosResizeListener) {\n      window.removeEventListener('resize', this._boundIosResizeListener);\n    }\n  }\n\n  /**\n   * Requests an update for the content of the overlay.\n   * While performing the update, it invokes the renderer passed in the `renderer` property.\n   *\n   * It is not guaranteed that the update happens immediately (synchronously) after it is requested.\n   */\n  requestContentUpdate() {\n    if (this.renderer) {\n      this.renderer.call(this.owner, this, this.owner, this.model);\n    }\n  }\n\n  /**\n   * @param {Event=} sourceEvent\n   */\n  close(sourceEvent) {\n    const evt = new CustomEvent('vaadin-overlay-close', {\n      bubbles: true,\n      cancelable: true,\n      detail: {\n        sourceEvent\n      }\n    });\n    this.dispatchEvent(evt);\n    if (!evt.defaultPrevented) {\n      this.opened = false;\n    }\n  }\n\n  /** @private */\n  _detectIosNavbar() {\n    /* c8 ignore next 15 */\n    if (!this.opened) {\n      return;\n    }\n    const innerHeight = window.innerHeight;\n    const innerWidth = window.innerWidth;\n    const landscape = innerWidth > innerHeight;\n    const clientHeight = document.documentElement.clientHeight;\n    if (landscape && clientHeight > innerHeight) {\n      this.style.setProperty('--vaadin-overlay-viewport-bottom', `${clientHeight - innerHeight}px`);\n    } else {\n      this.style.setProperty('--vaadin-overlay-viewport-bottom', '0');\n    }\n  }\n\n  /** @private */\n  _addGlobalListeners() {\n    document.addEventListener('mousedown', this._boundMouseDownListener);\n    document.addEventListener('mouseup', this._boundMouseUpListener);\n    // Firefox leaks click to document on contextmenu even if prevented\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=990614\n    document.documentElement.addEventListener('click', this._boundOutsideClickListener, true);\n  }\n\n  /** @private */\n  _removeGlobalListeners() {\n    document.removeEventListener('mousedown', this._boundMouseDownListener);\n    document.removeEventListener('mouseup', this._boundMouseUpListener);\n    document.documentElement.removeEventListener('click', this._boundOutsideClickListener, true);\n  }\n\n  /** @private */\n  _rendererOrDataChanged(renderer, owner, model, opened) {\n    const ownerOrModelChanged = this._oldOwner !== owner || this._oldModel !== model;\n    this._oldModel = model;\n    this._oldOwner = owner;\n    const rendererChanged = this._oldRenderer !== renderer;\n    const hasOldRenderer = this._oldRenderer !== undefined;\n    this._oldRenderer = renderer;\n    const openedChanged = this._oldOpened !== opened;\n    this._oldOpened = opened;\n    if (rendererChanged && hasOldRenderer) {\n      this.innerHTML = '';\n      // Whenever a Lit-based renderer is used, it assigns a Lit part to the node it was rendered into.\n      // When clearing the rendered content, this part needs to be manually disposed of.\n      // Otherwise, using a Lit-based renderer on the same node will throw an exception or render nothing afterward.\n      delete this._$litPart$;\n    }\n    if (opened && renderer && (rendererChanged || openedChanged || ownerOrModelChanged)) {\n      this.requestContentUpdate();\n    }\n  }\n\n  /** @private */\n  _modelessChanged(modeless) {\n    if (!modeless) {\n      if (this.opened) {\n        this._addGlobalListeners();\n        this._enterModalState();\n      }\n    } else {\n      this._removeGlobalListeners();\n      this._exitModalState();\n    }\n  }\n\n  /** @private */\n  _openedChanged(opened, wasOpened) {\n    if (opened) {\n      this._saveFocus();\n      this._animatedOpening();\n      afterNextRender(this, () => {\n        this._trapFocus();\n        const evt = new CustomEvent('vaadin-overlay-open', {\n          bubbles: true\n        });\n        this.dispatchEvent(evt);\n      });\n      document.addEventListener('keydown', this._boundKeydownListener);\n      if (!this.modeless) {\n        this._addGlobalListeners();\n      }\n    } else if (wasOpened) {\n      this._resetFocus();\n      this._animatedClosing();\n      document.removeEventListener('keydown', this._boundKeydownListener);\n      if (!this.modeless) {\n        this._removeGlobalListeners();\n      }\n    }\n  }\n\n  /** @private */\n  _hiddenChanged(hidden) {\n    if (hidden && this.hasAttribute('closing')) {\n      this._flushAnimation('closing');\n    }\n  }\n\n  /**\n   * @return {boolean}\n   * @private\n   */\n  _shouldAnimate() {\n    const style = getComputedStyle(this);\n    const name = style.getPropertyValue('animation-name');\n    const hidden = style.getPropertyValue('display') === 'none';\n    return !hidden && name && name !== 'none';\n  }\n\n  /**\n   * @param {string} type\n   * @param {Function} callback\n   * @private\n   */\n  _enqueueAnimation(type, callback) {\n    const handler = `__${type}Handler`;\n    const listener = event => {\n      if (event && event.target !== this) {\n        return;\n      }\n      callback();\n      this.removeEventListener('animationend', listener);\n      delete this[handler];\n    };\n    this[handler] = listener;\n    this.addEventListener('animationend', listener);\n  }\n\n  /**\n   * @param {string} type\n   * @protected\n   */\n  _flushAnimation(type) {\n    const handler = `__${type}Handler`;\n    if (typeof this[handler] === 'function') {\n      this[handler]();\n    }\n  }\n\n  /** @private */\n  _animatedOpening() {\n    if (this.parentNode === document.body && this.hasAttribute('closing')) {\n      this._flushAnimation('closing');\n    }\n    this._attachOverlay();\n    if (!this.modeless) {\n      this._enterModalState();\n    }\n    this.setAttribute('opening', '');\n    if (this._shouldAnimate()) {\n      this._enqueueAnimation('opening', () => {\n        this._finishOpening();\n      });\n    } else {\n      this._finishOpening();\n    }\n  }\n\n  /** @private */\n  _attachOverlay() {\n    this._placeholder = document.createComment('vaadin-overlay-placeholder');\n    this.parentNode.insertBefore(this._placeholder, this);\n    document.body.appendChild(this);\n    this.bringToFront();\n  }\n\n  /** @private */\n  _finishOpening() {\n    this.removeAttribute('opening');\n  }\n\n  /** @private */\n  _finishClosing() {\n    this._detachOverlay();\n    this.$.overlay.style.removeProperty('pointer-events');\n    this.removeAttribute('closing');\n    this.dispatchEvent(new CustomEvent('vaadin-overlay-closed'));\n  }\n\n  /** @private */\n  _animatedClosing() {\n    if (this.hasAttribute('opening')) {\n      this._flushAnimation('opening');\n    }\n    if (this._placeholder) {\n      this._exitModalState();\n      this.setAttribute('closing', '');\n      this.dispatchEvent(new CustomEvent('vaadin-overlay-closing'));\n      if (this._shouldAnimate()) {\n        this._enqueueAnimation('closing', () => {\n          this._finishClosing();\n        });\n      } else {\n        this._finishClosing();\n      }\n    }\n  }\n\n  /** @private */\n  _detachOverlay() {\n    this._placeholder.parentNode.insertBefore(this, this._placeholder);\n    this._placeholder.parentNode.removeChild(this._placeholder);\n  }\n\n  /** @private */\n  _mouseDownListener(event) {\n    this._mouseDownInside = event.composedPath().indexOf(this.$.overlay) >= 0;\n  }\n\n  /** @private */\n  _mouseUpListener(event) {\n    this._mouseUpInside = event.composedPath().indexOf(this.$.overlay) >= 0;\n  }\n\n  /**\n   * Whether to close the overlay on outside click or not.\n   * Override this method to customize the closing logic.\n   *\n   * @param {Event} _event\n   * @return {boolean}\n   * @protected\n   */\n  _shouldCloseOnOutsideClick(_event) {\n    return this._last;\n  }\n\n  /**\n   * Outside click listener used in capture phase to close the overlay before\n   * propagating the event to the listener on the element that triggered it.\n   * Otherwise, calling `open()` would result in closing and re-opening.\n   *\n   * @private\n   */\n  _outsideClickListener(event) {\n    if (event.composedPath().includes(this.$.overlay) || this._mouseDownInside || this._mouseUpInside) {\n      this._mouseDownInside = false;\n      this._mouseUpInside = false;\n      return;\n    }\n    if (!this._shouldCloseOnOutsideClick(event)) {\n      return;\n    }\n    const evt = new CustomEvent('vaadin-overlay-outside-click', {\n      bubbles: true,\n      cancelable: true,\n      detail: {\n        sourceEvent: event\n      }\n    });\n    this.dispatchEvent(evt);\n    if (this.opened && !evt.defaultPrevented) {\n      this.close(event);\n    }\n  }\n\n  /**\n   * Listener used to close whe overlay on Escape press, if it is the last one.\n   * @private\n   */\n  _keydownListener(event) {\n    if (!this._last) {\n      return;\n    }\n\n    // Only close modeless overlay on Esc press when it contains focus\n    if (this.modeless && !event.composedPath().includes(this.$.overlay)) {\n      return;\n    }\n    if (event.key === 'Escape') {\n      const evt = new CustomEvent('vaadin-overlay-escape-press', {\n        bubbles: true,\n        cancelable: true,\n        detail: {\n          sourceEvent: event\n        }\n      });\n      this.dispatchEvent(evt);\n      if (this.opened && !evt.defaultPrevented) {\n        this.close(event);\n      }\n    }\n  }\n};","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { html, PolymerElement } from '@polymer/polymer/polymer-element.js';\nimport { ComboBoxOverlayMixin } from '@vaadin/combo-box/src/vaadin-combo-box-overlay-mixin.js';\nimport { defineCustomElement } from '@vaadin/component-base/src/define.js';\nimport { DirMixin } from '@vaadin/component-base/src/dir-mixin.js';\nimport { OverlayMixin } from '@vaadin/overlay/src/vaadin-overlay-mixin.js';\nimport { overlayStyles } from '@vaadin/overlay/src/vaadin-overlay-styles.js';\nimport { css, registerStyles, ThemableMixin } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nconst multiSelectComboBoxOverlayStyles = css`\n  #overlay {\n    width: var(\n      --vaadin-multi-select-combo-box-overlay-width,\n      var(--_vaadin-multi-select-combo-box-overlay-default-width, auto)\n    );\n  }\n\n  [part='content'] {\n    display: flex;\n    flex-direction: column;\n    height: 100%;\n  }\n`;\nregisterStyles('vaadin-multi-select-combo-box-overlay', [overlayStyles, multiSelectComboBoxOverlayStyles], {\n  moduleId: 'vaadin-multi-select-combo-box-overlay-styles'\n});\n\n/**\n * An element used internally by `<vaadin-multi-select-combo-box>`. Not intended to be used separately.\n *\n * @customElement\n * @extends HTMLElement\n * @mixes ComboBoxOverlayMixin\n * @mixes DirMixin\n * @mixes OverlayMixin\n * @mixes ThemableMixin\n * @private\n */\nclass MultiSelectComboBoxOverlay extends ComboBoxOverlayMixin(OverlayMixin(DirMixin(ThemableMixin(PolymerElement)))) {\n  static get is() {\n    return 'vaadin-multi-select-combo-box-overlay';\n  }\n  static get template() {\n    return html`\n      <div id=\"backdrop\" part=\"backdrop\" hidden></div>\n      <div part=\"overlay\" id=\"overlay\">\n        <div part=\"loader\"></div>\n        <div part=\"content\" id=\"content\"><slot></slot></div>\n      </div>\n    `;\n  }\n}\ndefineCustomElement(MultiSelectComboBoxOverlay);","/**\n * @license\n * Copyright (c) 2017 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { css } from 'lit';\nexport const overlayStyles = css`\n  :host {\n    z-index: 200;\n    position: fixed;\n\n    /* Despite of what the names say, <vaadin-overlay> is just a container\n          for position/sizing/alignment. The actual overlay is the overlay part. */\n\n    /* Default position constraints: the entire viewport. Note: themes can\n          override this to introduce gaps between the overlay and the viewport. */\n    inset: 0;\n    bottom: var(--vaadin-overlay-viewport-bottom);\n\n    /* Use flexbox alignment for the overlay part. */\n    display: flex;\n    flex-direction: column; /* makes dropdowns sizing easier */\n    /* Align to center by default. */\n    align-items: center;\n    justify-content: center;\n\n    /* Allow centering when max-width/max-height applies. */\n    margin: auto;\n\n    /* The host is not clickable, only the overlay part is. */\n    pointer-events: none;\n\n    /* Remove tap highlight on touch devices. */\n    -webkit-tap-highlight-color: transparent;\n\n    /* CSS API for host */\n    --vaadin-overlay-viewport-bottom: 0;\n  }\n\n  :host([hidden]),\n  :host(:not([opened]):not([closing])),\n  :host(:not([opened]):not([closing])) [part='overlay'] {\n    display: none !important;\n  }\n\n  [part='overlay'] {\n    -webkit-overflow-scrolling: touch;\n    overflow: auto;\n    pointer-events: auto;\n\n    /* Prevent overflowing the host */\n    max-width: 100%;\n    box-sizing: border-box;\n\n    -webkit-tap-highlight-color: initial; /* reenable tap highlight inside */\n  }\n\n  [part='backdrop'] {\n    z-index: -1;\n    content: '';\n    background: rgba(0, 0, 0, 0.5);\n    position: fixed;\n    inset: 0;\n    pointer-events: auto;\n  }\n`;","/**\n * @license\n * Copyright (c) 2015 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n/*\n * Placeholder object class representing items being loaded.\n *\n * @private\n */\nexport const ComboBoxPlaceholder = class ComboBoxPlaceholder {\n  toString() {\n    return '';\n  }\n};","/**\n * @license\n * Copyright (c) 2023 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n/**\n * Convenience method for reading a value from a path.\n *\n * @param {string} path\n * @param {object} object\n */\nexport function get(path, object) {\n  return path.split('.').reduce((obj, property) => obj ? obj[property] : undefined, object);\n}\n\n/**\n * Convenience method for setting a value to a path.\n *\n * @param {string} path\n * @param {unknown} value\n * @param {object} object\n */\nexport function set(path, value, object) {\n  const pathParts = path.split('.');\n  const lastPart = pathParts.pop();\n  const target = pathParts.reduce((target, part) => target[part], object);\n  target[lastPart] = value;\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\nlet uniqueId = 0;\n\n/**\n * Resets the unique id counter.\n *\n * @return {void}\n */\nexport function resetUniqueId() {\n  uniqueId = 0;\n}\n\n/**\n * Returns a unique integer id.\n *\n * @return {number}\n */\nexport function generateUniqueId() {\n  // eslint-disable-next-line no-plusplus\n  return uniqueId++;\n}","/**\n * @license\n * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * @fileoverview\n *\n * This module provides a number of strategies for enqueuing asynchronous\n * tasks. Each sub-module provides a standard `run(fn)` interface that returns a\n * handle, and a `cancel(handle)` interface for canceling async tasks before\n * they run.\n *\n * @summary Module that provides a number of strategies for enqueuing\n * asynchronous tasks.\n */\n\nlet microtaskCurrHandle = 0;\nlet microtaskLastHandle = 0;\nconst microtaskCallbacks = [];\nlet microtaskScheduled = false;\nfunction microtaskFlush() {\n  microtaskScheduled = false;\n  const len = microtaskCallbacks.length;\n  for (let i = 0; i < len; i++) {\n    const cb = microtaskCallbacks[i];\n    if (cb) {\n      try {\n        cb();\n      } catch (e) {\n        setTimeout(() => {\n          throw e;\n        });\n      }\n    }\n  }\n  microtaskCallbacks.splice(0, len);\n  microtaskLastHandle += len;\n}\n\n/**\n * Async interface wrapper around `setTimeout`.\n *\n * @namespace\n * @summary Async interface wrapper around `setTimeout`.\n */\nconst timeOut = {\n  /**\n   * Returns a sub-module with the async interface providing the provided\n   * delay.\n   *\n   * @memberof timeOut\n   * @param {number=} delay Time to wait before calling callbacks in ms\n   * @return {!AsyncInterface} An async timeout interface\n   */\n  after(delay) {\n    return {\n      run(fn) {\n        return window.setTimeout(fn, delay);\n      },\n      cancel(handle) {\n        window.clearTimeout(handle);\n      }\n    };\n  },\n  /**\n   * Enqueues a function called in the next task.\n   *\n   * @memberof timeOut\n   * @param {!Function} fn Callback to run\n   * @param {number=} delay Delay in milliseconds\n   * @return {number} Handle used for canceling task\n   */\n  run(fn, delay) {\n    return window.setTimeout(fn, delay);\n  },\n  /**\n   * Cancels a previously enqueued `timeOut` callback.\n   *\n   * @memberof timeOut\n   * @param {number} handle Handle returned from `run` of callback to cancel\n   * @return {void}\n   */\n  cancel(handle) {\n    window.clearTimeout(handle);\n  }\n};\nexport { timeOut };\n\n/**\n * Async interface wrapper around `requestAnimationFrame`.\n *\n * @namespace\n * @summary Async interface wrapper around `requestAnimationFrame`.\n */\nconst animationFrame = {\n  /**\n   * Enqueues a function called at `requestAnimationFrame` timing.\n   *\n   * @memberof animationFrame\n   * @param {function(number):void} fn Callback to run\n   * @return {number} Handle used for canceling task\n   */\n  run(fn) {\n    return window.requestAnimationFrame(fn);\n  },\n  /**\n   * Cancels a previously enqueued `animationFrame` callback.\n   *\n   * @memberof animationFrame\n   * @param {number} handle Handle returned from `run` of callback to cancel\n   * @return {void}\n   */\n  cancel(handle) {\n    window.cancelAnimationFrame(handle);\n  }\n};\nexport { animationFrame };\n\n/**\n * Async interface wrapper around `requestIdleCallback`.  Falls back to\n * `setTimeout` on browsers that do not support `requestIdleCallback`.\n *\n * @namespace\n * @summary Async interface wrapper around `requestIdleCallback`.\n */\nconst idlePeriod = {\n  /**\n   * Enqueues a function called at `requestIdleCallback` timing.\n   *\n   * @memberof idlePeriod\n   * @param {function(!IdleDeadline):void} fn Callback to run\n   * @return {number} Handle used for canceling task\n   */\n  run(fn) {\n    return window.requestIdleCallback ? window.requestIdleCallback(fn) : window.setTimeout(fn, 16);\n  },\n  /**\n   * Cancels a previously enqueued `idlePeriod` callback.\n   *\n   * @memberof idlePeriod\n   * @param {number} handle Handle returned from `run` of callback to cancel\n   * @return {void}\n   */\n  cancel(handle) {\n    if (window.cancelIdleCallback) {\n      window.cancelIdleCallback(handle);\n    } else {\n      window.clearTimeout(handle);\n    }\n  }\n};\nexport { idlePeriod };\n\n/**\n * Async interface for enqueuing callbacks that run at microtask timing.\n *\n * @namespace\n * @summary Async interface for enqueuing callbacks that run at microtask\n *   timing.\n */\nconst microTask = {\n  /**\n   * Enqueues a function called at microtask timing.\n   *\n   * @memberof microTask\n   * @param {!Function=} callback Callback to run\n   * @return {number} Handle used for canceling task\n   */\n  run(callback) {\n    if (!microtaskScheduled) {\n      microtaskScheduled = true;\n      queueMicrotask(() => microtaskFlush());\n    }\n    microtaskCallbacks.push(callback);\n    const result = microtaskCurrHandle;\n    microtaskCurrHandle += 1;\n    return result;\n  },\n  /**\n   * Cancels a previously enqueued `microTask` callback.\n   *\n   * @memberof microTask\n   * @param {number} handle Handle returned from `run` of callback to cancel\n   * @return {void}\n   */\n  cancel(handle) {\n    const idx = handle - microtaskLastHandle;\n    if (idx >= 0) {\n      if (!microtaskCallbacks[idx]) {\n        throw new Error(`invalid async handle: ${handle}`);\n      }\n      microtaskCallbacks[idx] = null;\n    }\n  }\n};\nexport { microTask };","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nconst debouncerQueue = new Set();\n\n/**\n * @summary Collapse multiple callbacks into one invocation after a timer.\n */\nexport class Debouncer {\n  /**\n   * Creates a debouncer if no debouncer is passed as a parameter\n   * or it cancels an active debouncer otherwise. The following\n   * example shows how a debouncer can be called multiple times within a\n   * microtask and \"debounced\" such that the provided callback function is\n   * called once. Add this method to a custom element:\n   *\n   * ```js\n   * import {microTask} from '@vaadin/component-base/src/async.js';\n   * import {Debouncer} from '@vaadin/component-base/src/debounce.js';\n   * // ...\n   *\n   * _debounceWork() {\n   *   this._debounceJob = Debouncer.debounce(this._debounceJob,\n   *       microTask, () => this._doWork());\n   * }\n   * ```\n   *\n   * If the `_debounceWork` method is called multiple times within the same\n   * microtask, the `_doWork` function will be called only once at the next\n   * microtask checkpoint.\n   *\n   * Note: In testing it is often convenient to avoid asynchrony. To accomplish\n   * this with a debouncer, you can use `enqueueDebouncer` and\n   * `flush`. For example, extend the above example by adding\n   * `enqueueDebouncer(this._debounceJob)` at the end of the\n   * `_debounceWork` method. Then in a test, call `flush` to ensure\n   * the debouncer has completed.\n   *\n   * @param {Debouncer?} debouncer Debouncer object.\n   * @param {!AsyncInterface} asyncModule Object with Async interface\n   * @param {function()} callback Callback to run.\n   * @return {!Debouncer} Returns a debouncer object.\n   */\n  static debounce(debouncer, asyncModule, callback) {\n    if (debouncer instanceof Debouncer) {\n      // Cancel the async callback, but leave in debouncerQueue if it was\n      // enqueued, to maintain 1.x flush order\n      debouncer._cancelAsync();\n    } else {\n      debouncer = new Debouncer();\n    }\n    debouncer.setConfig(asyncModule, callback);\n    return debouncer;\n  }\n  constructor() {\n    this._asyncModule = null;\n    this._callback = null;\n    this._timer = null;\n  }\n\n  /**\n   * Sets the scheduler; that is, a module with the Async interface,\n   * a callback and optional arguments to be passed to the run function\n   * from the async module.\n   *\n   * @param {!AsyncInterface} asyncModule Object with Async interface.\n   * @param {function()} callback Callback to run.\n   * @return {void}\n   */\n  setConfig(asyncModule, callback) {\n    this._asyncModule = asyncModule;\n    this._callback = callback;\n    this._timer = this._asyncModule.run(() => {\n      this._timer = null;\n      debouncerQueue.delete(this);\n      this._callback();\n    });\n  }\n\n  /**\n   * Cancels an active debouncer and returns a reference to itself.\n   *\n   * @return {void}\n   */\n  cancel() {\n    if (this.isActive()) {\n      this._cancelAsync();\n      // Canceling a debouncer removes its spot from the flush queue,\n      // so if a debouncer is manually canceled and re-debounced, it\n      // will reset its flush order (this is a very minor difference from 1.x)\n      // Re-debouncing via the `debounce` API retains the 1.x FIFO flush order\n      debouncerQueue.delete(this);\n    }\n  }\n\n  /**\n   * Cancels a debouncer's async callback.\n   *\n   * @return {void}\n   */\n  _cancelAsync() {\n    if (this.isActive()) {\n      this._asyncModule.cancel(/** @type {number} */this._timer);\n      this._timer = null;\n    }\n  }\n\n  /**\n   * Flushes an active debouncer and returns a reference to itself.\n   *\n   * @return {void}\n   */\n  flush() {\n    if (this.isActive()) {\n      this.cancel();\n      this._callback();\n    }\n  }\n\n  /**\n   * Returns true if the debouncer is active.\n   *\n   * @return {boolean} True if active.\n   */\n  isActive() {\n    return this._timer != null;\n  }\n}\n\n/**\n * Adds a `Debouncer` to a list of globally flushable tasks.\n *\n * @param {!Debouncer} debouncer Debouncer to enqueue\n * @return {void}\n */\nexport function enqueueDebouncer(debouncer) {\n  debouncerQueue.add(debouncer);\n}\n\n/**\n * Flushes any enqueued debouncers\n *\n * @return {boolean} Returns whether any debouncers were flushed\n */\nexport function flushDebouncers() {\n  const didFlush = Boolean(debouncerQueue.size);\n  // If new debouncers are added while flushing, Set.forEach will ensure\n  // newly added ones are also flushed\n  debouncerQueue.forEach(debouncer => {\n    try {\n      debouncer.flush();\n    } catch (e) {\n      setTimeout(() => {\n        throw e;\n      });\n    }\n  });\n  return didFlush;\n}\nexport const flush = () => {\n  let debouncers;\n  do {\n    debouncers = flushDebouncers();\n  } while (debouncers);\n};","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\nimport { animationFrame, idlePeriod, microTask } from './async.js';\nimport { Debouncer, enqueueDebouncer, flush } from './debounce.js';\nconst IOS = navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\\d+)/u);\nconst IOS_TOUCH_SCROLLING = IOS && IOS[1] >= 8;\nconst DEFAULT_PHYSICAL_COUNT = 3;\n\n/**\n * DO NOT EDIT THIS FILE!\n *\n * This file includes the iron-list scrolling engine copied from\n * https://github.com/PolymerElements/iron-list/blob/master/iron-list.js\n *\n * If something in the scrolling engine needs to be changed\n * for the virtualizer's purposes, override a function\n * in virtualizer-iron-list-adapter.js instead of changing it here.\n * If a function on this file is no longer needed, the code can be safely deleted.\n *\n * This will allow us to keep the iron-list code here as close to\n * the original as possible.\n */\nexport const ironList = {\n  /**\n   * The ratio of hidden tiles that should remain in the scroll direction.\n   * Recommended value ~0.5, so it will distribute tiles evenly in both\n   * directions.\n   */\n  _ratio: 0.5,\n  /**\n   * The padding-top value for the list.\n   */\n  _scrollerPaddingTop: 0,\n  /**\n   * This value is a cached value of `scrollTop` from the last `scroll` event.\n   */\n  _scrollPosition: 0,\n  /**\n   * The sum of the heights of all the tiles in the DOM.\n   */\n  _physicalSize: 0,\n  /**\n   * The average `offsetHeight` of the tiles observed till now.\n   */\n  _physicalAverage: 0,\n  /**\n   * The number of tiles which `offsetHeight` > 0 observed until now.\n   */\n  _physicalAverageCount: 0,\n  /**\n   * The Y position of the item rendered in the `_physicalStart`\n   * tile relative to the scrolling list.\n   */\n  _physicalTop: 0,\n  /**\n   * The number of items in the list.\n   */\n  _virtualCount: 0,\n  /**\n   * The estimated scroll height based on `_physicalAverage`\n   */\n  _estScrollHeight: 0,\n  /**\n   * The scroll height of the dom node\n   */\n  _scrollHeight: 0,\n  /**\n   * The height of the list. This is referred as the viewport in the context of\n   * list.\n   */\n  _viewportHeight: 0,\n  /**\n   * The width of the list. This is referred as the viewport in the context of\n   * list.\n   */\n  _viewportWidth: 0,\n  /**\n   * An array of DOM nodes that are currently in the tree\n   * @type {?Array<!HTMLElement>}\n   */\n  _physicalItems: null,\n  /**\n   * An array of heights for each item in `_physicalItems`\n   * @type {?Array<number>}\n   */\n  _physicalSizes: null,\n  /**\n   * A cached value for the first visible index.\n   * See `firstVisibleIndex`\n   * @type {?number}\n   */\n  _firstVisibleIndexVal: null,\n  /**\n   * A cached value for the last visible index.\n   * See `lastVisibleIndex`\n   * @type {?number}\n   */\n  _lastVisibleIndexVal: null,\n  /**\n   * The max number of pages to render. One page is equivalent to the height of\n   * the list.\n   */\n  _maxPages: 2,\n  /**\n   * The cost of stamping a template in ms.\n   */\n  _templateCost: 0,\n  /**\n   * The bottom of the physical content.\n   */\n  get _physicalBottom() {\n    return this._physicalTop + this._physicalSize;\n  },\n  /**\n   * The bottom of the scroll.\n   */\n  get _scrollBottom() {\n    return this._scrollPosition + this._viewportHeight;\n  },\n  /**\n   * The n-th item rendered in the last physical item.\n   */\n  get _virtualEnd() {\n    return this._virtualStart + this._physicalCount - 1;\n  },\n  /**\n   * The height of the physical content that isn't on the screen.\n   */\n  get _hiddenContentSize() {\n    return this._physicalSize - this._viewportHeight;\n  },\n  /**\n   * The maximum scroll top value.\n   */\n  get _maxScrollTop() {\n    return this._estScrollHeight - this._viewportHeight + this._scrollOffset;\n  },\n  /**\n   * The largest n-th value for an item such that it can be rendered in\n   * `_physicalStart`.\n   */\n  get _maxVirtualStart() {\n    const virtualCount = this._virtualCount;\n    return Math.max(0, virtualCount - this._physicalCount);\n  },\n  get _virtualStart() {\n    return this._virtualStartVal || 0;\n  },\n  set _virtualStart(val) {\n    val = this._clamp(val, 0, this._maxVirtualStart);\n    this._virtualStartVal = val;\n  },\n  get _physicalStart() {\n    return this._physicalStartVal || 0;\n  },\n  /**\n   * The k-th tile that is at the top of the scrolling list.\n   */\n  set _physicalStart(val) {\n    val %= this._physicalCount;\n    if (val < 0) {\n      val = this._physicalCount + val;\n    }\n    this._physicalStartVal = val;\n  },\n  /**\n   * The k-th tile that is at the bottom of the scrolling list.\n   */\n  get _physicalEnd() {\n    return (this._physicalStart + this._physicalCount - 1) % this._physicalCount;\n  },\n  get _physicalCount() {\n    return this._physicalCountVal || 0;\n  },\n  set _physicalCount(val) {\n    this._physicalCountVal = val;\n  },\n  /**\n   * An optimal physical size such that we will have enough physical items\n   * to fill up the viewport and recycle when the user scrolls.\n   *\n   * This default value assumes that we will at least have the equivalent\n   * to a viewport of physical items above and below the user's viewport.\n   */\n  get _optPhysicalSize() {\n    return this._viewportHeight === 0 ? Infinity : this._viewportHeight * this._maxPages;\n  },\n  /**\n   * True if the current list is visible.\n   */\n  get _isVisible() {\n    return Boolean(this.offsetWidth || this.offsetHeight);\n  },\n  /**\n   * Gets the index of the first visible item in the viewport.\n   *\n   * @type {number}\n   */\n  get firstVisibleIndex() {\n    let idx = this._firstVisibleIndexVal;\n    if (idx == null) {\n      let physicalOffset = this._physicalTop + this._scrollOffset;\n      idx = this._iterateItems((pidx, vidx) => {\n        physicalOffset += this._getPhysicalSizeIncrement(pidx);\n        if (physicalOffset > this._scrollPosition) {\n          return vidx;\n        }\n      }) || 0;\n      this._firstVisibleIndexVal = idx;\n    }\n    return idx;\n  },\n  /**\n   * Gets the index of the last visible item in the viewport.\n   *\n   * @type {number}\n   */\n  get lastVisibleIndex() {\n    let idx = this._lastVisibleIndexVal;\n    if (idx == null) {\n      let physicalOffset = this._physicalTop + this._scrollOffset;\n      this._iterateItems((pidx, vidx) => {\n        if (physicalOffset < this._scrollBottom) {\n          idx = vidx;\n        }\n        physicalOffset += this._getPhysicalSizeIncrement(pidx);\n      });\n      this._lastVisibleIndexVal = idx;\n    }\n    return idx;\n  },\n  get _scrollOffset() {\n    return this._scrollerPaddingTop + this.scrollOffset;\n  },\n  /**\n   * Recycles the physical items when needed.\n   */\n  _scrollHandler() {\n    const scrollTop = Math.max(0, Math.min(this._maxScrollTop, this._scrollTop));\n    let delta = scrollTop - this._scrollPosition;\n    const isScrollingDown = delta >= 0;\n    // Track the current scroll position.\n    this._scrollPosition = scrollTop;\n    // Clear indexes for first and last visible indexes.\n    this._firstVisibleIndexVal = null;\n    this._lastVisibleIndexVal = null;\n    // Random access.\n    if (Math.abs(delta) > this._physicalSize && this._physicalSize > 0) {\n      delta -= this._scrollOffset;\n      const idxAdjustment = Math.round(delta / this._physicalAverage);\n      this._virtualStart += idxAdjustment;\n      this._physicalStart += idxAdjustment;\n      // Estimate new physical offset based on the virtual start index.\n      // adjusts the physical start position to stay in sync with the clamped\n      // virtual start index. It's critical not to let this value be\n      // more than the scroll position however, since that would result in\n      // the physical items not covering the viewport, and leading to\n      // _increasePoolIfNeeded to run away creating items to try to fill it.\n      this._physicalTop = Math.min(Math.floor(this._virtualStart) * this._physicalAverage, this._scrollPosition);\n      this._update();\n    } else if (this._physicalCount > 0) {\n      const reusables = this._getReusables(isScrollingDown);\n      if (isScrollingDown) {\n        this._physicalTop = reusables.physicalTop;\n        this._virtualStart += reusables.indexes.length;\n        this._physicalStart += reusables.indexes.length;\n      } else {\n        this._virtualStart -= reusables.indexes.length;\n        this._physicalStart -= reusables.indexes.length;\n      }\n      this._update(reusables.indexes, isScrollingDown ? null : reusables.indexes);\n      this._debounce('_increasePoolIfNeeded', this._increasePoolIfNeeded.bind(this, 0), microTask);\n    }\n  },\n  /**\n   * Returns an object that contains the indexes of the physical items\n   * that might be reused and the physicalTop.\n   *\n   * @param {boolean} fromTop If the potential reusable items are above the scrolling region.\n   */\n  _getReusables(fromTop) {\n    let ith, offsetContent, physicalItemHeight;\n    const idxs = [];\n    const protectedOffsetContent = this._hiddenContentSize * this._ratio;\n    const virtualStart = this._virtualStart;\n    const virtualEnd = this._virtualEnd;\n    const physicalCount = this._physicalCount;\n    let top = this._physicalTop + this._scrollOffset;\n    const bottom = this._physicalBottom + this._scrollOffset;\n    // This may be called outside of a scrollHandler, so use last cached position\n    const scrollTop = this._scrollPosition;\n    const scrollBottom = this._scrollBottom;\n    if (fromTop) {\n      ith = this._physicalStart;\n      offsetContent = scrollTop - top;\n    } else {\n      ith = this._physicalEnd;\n      offsetContent = bottom - scrollBottom;\n    }\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n      physicalItemHeight = this._getPhysicalSizeIncrement(ith);\n      offsetContent -= physicalItemHeight;\n      if (idxs.length >= physicalCount || offsetContent <= protectedOffsetContent) {\n        break;\n      }\n      if (fromTop) {\n        // Check that index is within the valid range.\n        if (virtualEnd + idxs.length + 1 >= this._virtualCount) {\n          break;\n        }\n        // Check that the index is not visible.\n        if (top + physicalItemHeight >= scrollTop - this._scrollOffset) {\n          break;\n        }\n        idxs.push(ith);\n        top += physicalItemHeight;\n        ith = (ith + 1) % physicalCount;\n      } else {\n        // Check that index is within the valid range.\n        if (virtualStart - idxs.length <= 0) {\n          break;\n        }\n        // Check that the index is not visible.\n        if (top + this._physicalSize - physicalItemHeight <= scrollBottom) {\n          break;\n        }\n        idxs.push(ith);\n        top -= physicalItemHeight;\n        ith = ith === 0 ? physicalCount - 1 : ith - 1;\n      }\n    }\n    return {\n      indexes: idxs,\n      physicalTop: top - this._scrollOffset\n    };\n  },\n  /**\n   * Update the list of items, starting from the `_virtualStart` item.\n   * @param {!Array<number>=} itemSet\n   * @param {!Array<number>=} movingUp\n   */\n  _update(itemSet, movingUp) {\n    if (itemSet && itemSet.length === 0 || this._physicalCount === 0) {\n      return;\n    }\n    this._assignModels(itemSet);\n    this._updateMetrics(itemSet);\n    // Adjust offset after measuring.\n    if (movingUp) {\n      while (movingUp.length) {\n        const idx = movingUp.pop();\n        this._physicalTop -= this._getPhysicalSizeIncrement(idx);\n      }\n    }\n    this._positionItems();\n    this._updateScrollerSize();\n  },\n  _isClientFull() {\n    return this._scrollBottom !== 0 && this._physicalBottom - 1 >= this._scrollBottom && this._physicalTop <= this._scrollPosition;\n  },\n  /**\n   * Increases the pool size.\n   */\n  _increasePoolIfNeeded(count) {\n    const nextPhysicalCount = this._clamp(this._physicalCount + count, DEFAULT_PHYSICAL_COUNT, this._virtualCount - this._virtualStart);\n    const delta = nextPhysicalCount - this._physicalCount;\n    let nextIncrease = Math.round(this._physicalCount * 0.5);\n    if (delta < 0) {\n      return;\n    }\n    if (delta > 0) {\n      const ts = window.performance.now();\n      // Concat arrays in place.\n      [].push.apply(this._physicalItems, this._createPool(delta));\n      // Push 0s into physicalSizes. Can't use Array.fill because IE11 doesn't\n      // support it.\n      for (let i = 0; i < delta; i++) {\n        this._physicalSizes.push(0);\n      }\n      this._physicalCount += delta;\n      // Update the physical start if it needs to preserve the model of the\n      // focused item. In this situation, the focused item is currently rendered\n      // and its model would have changed after increasing the pool if the\n      // physical start remained unchanged.\n      if (this._physicalStart > this._physicalEnd && this._isIndexRendered(this._focusedVirtualIndex) && this._getPhysicalIndex(this._focusedVirtualIndex) < this._physicalEnd) {\n        this._physicalStart += delta;\n      }\n      this._update();\n      this._templateCost = (window.performance.now() - ts) / delta;\n      nextIncrease = Math.round(this._physicalCount * 0.5);\n    }\n    if (this._virtualEnd >= this._virtualCount - 1 || nextIncrease === 0) {\n      // Do nothing.\n    } else if (!this._isClientFull()) {\n      this._debounce('_increasePoolIfNeeded', this._increasePoolIfNeeded.bind(this, nextIncrease), microTask);\n    } else if (this._physicalSize < this._optPhysicalSize) {\n      // Yield and increase the pool during idle time until the physical size is\n      // optimal.\n      this._debounce('_increasePoolIfNeeded', this._increasePoolIfNeeded.bind(this, this._clamp(Math.round(50 / this._templateCost), 1, nextIncrease)), idlePeriod);\n    }\n  },\n  /**\n   * Renders the a new list.\n   */\n  _render() {\n    if (!this.isAttached || !this._isVisible) {\n      return;\n    }\n    if (this._physicalCount !== 0) {\n      const reusables = this._getReusables(true);\n      this._physicalTop = reusables.physicalTop;\n      this._virtualStart += reusables.indexes.length;\n      this._physicalStart += reusables.indexes.length;\n      this._update(reusables.indexes);\n      this._update();\n      this._increasePoolIfNeeded(0);\n    } else if (this._virtualCount > 0) {\n      // Initial render\n      this.updateViewportBoundaries();\n      this._increasePoolIfNeeded(DEFAULT_PHYSICAL_COUNT);\n    }\n  },\n  /**\n   * Called when the items have changed. That is, reassignments\n   * to `items`, splices or updates to a single item.\n   */\n  _itemsChanged(change) {\n    if (change.path === 'items') {\n      this._virtualStart = 0;\n      this._physicalTop = 0;\n      this._virtualCount = this.items ? this.items.length : 0;\n      this._physicalIndexForKey = {};\n      this._firstVisibleIndexVal = null;\n      this._lastVisibleIndexVal = null;\n      if (!this._physicalItems) {\n        this._physicalItems = [];\n      }\n      if (!this._physicalSizes) {\n        this._physicalSizes = [];\n      }\n      this._physicalStart = 0;\n      if (this._scrollTop > this._scrollOffset) {\n        this._resetScrollPosition(0);\n      }\n      this._debounce('_render', this._render, animationFrame);\n    }\n  },\n  /**\n   * Executes a provided function per every physical index in `itemSet`\n   * `itemSet` default value is equivalent to the entire set of physical\n   * indexes.\n   *\n   * @param {!function(number, number)} fn\n   * @param {!Array<number>=} itemSet\n   */\n  _iterateItems(fn, itemSet) {\n    let pidx, vidx, rtn, i;\n    if (arguments.length === 2 && itemSet) {\n      for (i = 0; i < itemSet.length; i++) {\n        pidx = itemSet[i];\n        vidx = this._computeVidx(pidx);\n        if ((rtn = fn.call(this, pidx, vidx)) != null) {\n          return rtn;\n        }\n      }\n    } else {\n      pidx = this._physicalStart;\n      vidx = this._virtualStart;\n      for (; pidx < this._physicalCount; pidx++, vidx++) {\n        if ((rtn = fn.call(this, pidx, vidx)) != null) {\n          return rtn;\n        }\n      }\n      for (pidx = 0; pidx < this._physicalStart; pidx++, vidx++) {\n        if ((rtn = fn.call(this, pidx, vidx)) != null) {\n          return rtn;\n        }\n      }\n    }\n  },\n  /**\n   * Returns the virtual index for a given physical index\n   *\n   * @param {number} pidx Physical index\n   * @return {number}\n   */\n  _computeVidx(pidx) {\n    if (pidx >= this._physicalStart) {\n      return this._virtualStart + (pidx - this._physicalStart);\n    }\n    return this._virtualStart + (this._physicalCount - this._physicalStart) + pidx;\n  },\n  /**\n   * Updates the position of the physical items.\n   */\n  _positionItems() {\n    this._adjustScrollPosition();\n    let y = this._physicalTop;\n    this._iterateItems(pidx => {\n      this.translate3d(0, `${y}px`, 0, this._physicalItems[pidx]);\n      y += this._physicalSizes[pidx];\n    });\n  },\n  _getPhysicalSizeIncrement(pidx) {\n    return this._physicalSizes[pidx];\n  },\n  /**\n   * Adjusts the scroll position when it was overestimated.\n   */\n  _adjustScrollPosition() {\n    const deltaHeight = this._virtualStart === 0 ? this._physicalTop : Math.min(this._scrollPosition + this._physicalTop, 0);\n    // Note: the delta can be positive or negative.\n    if (deltaHeight !== 0) {\n      this._physicalTop -= deltaHeight;\n      // This may be called outside of a scrollHandler, so use last cached position\n      const scrollTop = this._scrollPosition;\n      // Juking scroll position during interial scrolling on iOS is no bueno\n      if (!IOS_TOUCH_SCROLLING && scrollTop > 0) {\n        this._resetScrollPosition(scrollTop - deltaHeight);\n      }\n    }\n  },\n  /**\n   * Sets the position of the scroll.\n   */\n  _resetScrollPosition(pos) {\n    if (this.scrollTarget && pos >= 0) {\n      this._scrollTop = pos;\n      this._scrollPosition = this._scrollTop;\n    }\n  },\n  /**\n   * Sets the scroll height, that's the height of the content,\n   *\n   * @param {boolean=} forceUpdate If true, updates the height no matter what.\n   */\n  _updateScrollerSize(forceUpdate) {\n    const estScrollHeight = this._physicalBottom + Math.max(this._virtualCount - this._physicalCount - this._virtualStart, 0) * this._physicalAverage;\n    this._estScrollHeight = estScrollHeight;\n\n    // Amortize height adjustment, so it won't trigger large repaints too often.\n    if (forceUpdate || this._scrollHeight === 0 || this._scrollPosition >= estScrollHeight - this._physicalSize || Math.abs(estScrollHeight - this._scrollHeight) >= this._viewportHeight) {\n      this.$.items.style.height = `${estScrollHeight}px`;\n      this._scrollHeight = estScrollHeight;\n    }\n  },\n  /**\n   * Scroll to a specific index in the virtual list regardless\n   * of the physical items in the DOM tree.\n   *\n   * @method scrollToIndex\n   * @param {number} idx The index of the item\n   */\n  scrollToIndex(idx) {\n    if (typeof idx !== 'number' || idx < 0 || idx > this.items.length - 1) {\n      return;\n    }\n    flush();\n    // Items should have been rendered prior scrolling to an index.\n    if (this._physicalCount === 0) {\n      return;\n    }\n    idx = this._clamp(idx, 0, this._virtualCount - 1);\n    // Update the virtual start only when needed.\n    if (!this._isIndexRendered(idx) || idx >= this._maxVirtualStart) {\n      this._virtualStart = idx - 1;\n    }\n    this._assignModels();\n    this._updateMetrics();\n    // Estimate new physical offset.\n    this._physicalTop = this._virtualStart * this._physicalAverage;\n    let currentTopItem = this._physicalStart;\n    let currentVirtualItem = this._virtualStart;\n    let targetOffsetTop = 0;\n    const hiddenContentSize = this._hiddenContentSize;\n    // Scroll to the item as much as we can.\n    while (currentVirtualItem < idx && targetOffsetTop <= hiddenContentSize) {\n      targetOffsetTop += this._getPhysicalSizeIncrement(currentTopItem);\n      currentTopItem = (currentTopItem + 1) % this._physicalCount;\n      currentVirtualItem += 1;\n    }\n    this._updateScrollerSize(true);\n    this._positionItems();\n    this._resetScrollPosition(this._physicalTop + this._scrollOffset + targetOffsetTop);\n    this._increasePoolIfNeeded(0);\n    // Clear cached visible index.\n    this._firstVisibleIndexVal = null;\n    this._lastVisibleIndexVal = null;\n  },\n  /**\n   * Reset the physical average and the average count.\n   */\n  _resetAverage() {\n    this._physicalAverage = 0;\n    this._physicalAverageCount = 0;\n  },\n  /**\n   * A handler for the `iron-resize` event triggered by `IronResizableBehavior`\n   * when the element is resized.\n   */\n  _resizeHandler() {\n    this._debounce('_render', () => {\n      // Clear cached visible index.\n      this._firstVisibleIndexVal = null;\n      this._lastVisibleIndexVal = null;\n      if (this._isVisible) {\n        this.updateViewportBoundaries();\n        // Reinstall the scroll event listener.\n        this.toggleScrollListener(true);\n        this._resetAverage();\n        this._render();\n      } else {\n        // Uninstall the scroll event listener.\n        this.toggleScrollListener(false);\n      }\n    }, animationFrame);\n  },\n  _isIndexRendered(idx) {\n    return idx >= this._virtualStart && idx <= this._virtualEnd;\n  },\n  _getPhysicalIndex(vidx) {\n    return (this._physicalStart + (vidx - this._virtualStart)) % this._physicalCount;\n  },\n  _clamp(v, min, max) {\n    return Math.min(max, Math.max(min, v));\n  },\n  _debounce(name, cb, asyncModule) {\n    if (!this._debouncers) {\n      this._debouncers = {};\n    }\n    this._debouncers[name] = Debouncer.debounce(this._debouncers[name], asyncModule, cb.bind(this));\n    enqueueDebouncer(this._debouncers[name]);\n  }\n};","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n/* eslint-disable @typescript-eslint/member-ordering */\n// https://github.com/vaadin/eslint-config-vaadin/issues/33\nimport { animationFrame, microTask, timeOut } from './async.js';\nimport { isSafari } from './browser-utils.js';\nimport { Debouncer, flush } from './debounce.js';\nimport { ironList } from './iron-list-core.js';\n\n// Iron-list can by default handle sizes up to around 100000.\n// When the size is larger than MAX_VIRTUAL_COUNT _vidxOffset is used\nconst MAX_VIRTUAL_COUNT = 100000;\nconst OFFSET_ADJUST_MIN_THRESHOLD = 1000;\nexport class IronListAdapter {\n  constructor(_ref) {\n    let createElements = _ref.createElements,\n      updateElement = _ref.updateElement,\n      scrollTarget = _ref.scrollTarget,\n      scrollContainer = _ref.scrollContainer,\n      elementsContainer = _ref.elementsContainer,\n      reorderElements = _ref.reorderElements;\n    this.isAttached = true;\n    this._vidxOffset = 0;\n    this.createElements = createElements;\n    this.updateElement = updateElement;\n    this.scrollTarget = scrollTarget;\n    this.scrollContainer = scrollContainer;\n    this.elementsContainer = elementsContainer || scrollContainer;\n    this.reorderElements = reorderElements;\n    // Iron-list uses this value to determine how many pages of elements to render\n    this._maxPages = 1.3;\n\n    // Placeholder height (used for sizing elements that have intrinsic 0 height after update)\n    this.__placeholderHeight = 200;\n    // A queue of 10 previous element heights\n    this.__elementHeightQueue = Array(10);\n    this.timeouts = {\n      SCROLL_REORDER: 500,\n      IGNORE_WHEEL: 500,\n      FIX_INVALID_ITEM_POSITIONING: 100\n    };\n    this.__resizeObserver = new ResizeObserver(() => this._resizeHandler());\n    if (getComputedStyle(this.scrollTarget).overflow === 'visible') {\n      this.scrollTarget.style.overflow = 'auto';\n    }\n    if (getComputedStyle(this.scrollContainer).position === 'static') {\n      this.scrollContainer.style.position = 'relative';\n    }\n    this.__resizeObserver.observe(this.scrollTarget);\n    this.scrollTarget.addEventListener('scroll', () => this._scrollHandler());\n    this._scrollLineHeight = this._getScrollLineHeight();\n    this.scrollTarget.addEventListener('wheel', e => this.__onWheel(e));\n    this.scrollTarget.addEventListener('virtualizer-element-focused', e => this.__onElementFocused(e));\n    this.elementsContainer.addEventListener('focusin', () => {\n      this.scrollTarget.dispatchEvent(new CustomEvent('virtualizer-element-focused', {\n        detail: {\n          element: this.__getFocusedElement()\n        }\n      }));\n    });\n    if (this.reorderElements) {\n      // Reordering the physical elements cancels the user's grab of the scroll bar handle on Safari.\n      // Need to defer reordering until the user lets go of the scroll bar handle.\n      this.scrollTarget.addEventListener('mousedown', () => {\n        this.__mouseDown = true;\n      });\n      this.scrollTarget.addEventListener('mouseup', () => {\n        this.__mouseDown = false;\n        if (this.__pendingReorder) {\n          this.__reorderElements();\n        }\n      });\n    }\n  }\n  get scrollOffset() {\n    return 0;\n  }\n  get adjustedFirstVisibleIndex() {\n    return this.firstVisibleIndex + this._vidxOffset;\n  }\n  get adjustedLastVisibleIndex() {\n    return this.lastVisibleIndex + this._vidxOffset;\n  }\n  get _maxVirtualIndexOffset() {\n    return this.size - this._virtualCount;\n  }\n  __hasPlaceholders() {\n    return this.__getVisibleElements().some(el => el.__virtualizerPlaceholder);\n  }\n  scrollToIndex(index) {\n    if (typeof index !== 'number' || isNaN(index) || this.size === 0 || !this.scrollTarget.offsetHeight) {\n      return;\n    }\n    delete this.__pendingScrollToIndex;\n    if (this._physicalCount <= 3 /* iron-list-core.DEFAULT_PHYSICAL_COUNT */) {\n      // The condition here is a performance improvement to avoid an unnecessary\n      // re-render when the physical item pool is already covered.\n\n      // Finish rendering at the current scroll position before scrolling\n      this.flush();\n    }\n    index = this._clamp(index, 0, this.size - 1);\n    const visibleElementCount = this.__getVisibleElements().length;\n    let targetVirtualIndex = Math.floor(index / this.size * this._virtualCount);\n    if (this._virtualCount - targetVirtualIndex < visibleElementCount) {\n      targetVirtualIndex = this._virtualCount - (this.size - index);\n      this._vidxOffset = this._maxVirtualIndexOffset;\n    } else if (targetVirtualIndex < visibleElementCount) {\n      if (index < OFFSET_ADJUST_MIN_THRESHOLD) {\n        targetVirtualIndex = index;\n        this._vidxOffset = 0;\n      } else {\n        targetVirtualIndex = OFFSET_ADJUST_MIN_THRESHOLD;\n        this._vidxOffset = index - targetVirtualIndex;\n      }\n    } else {\n      this._vidxOffset = index - targetVirtualIndex;\n    }\n    this.__skipNextVirtualIndexAdjust = true;\n    super.scrollToIndex(targetVirtualIndex);\n    if (this.adjustedFirstVisibleIndex !== index && this._scrollTop < this._maxScrollTop && !this.grid) {\n      // Workaround an iron-list issue by manually adjusting the scroll position\n      this._scrollTop -= this.__getIndexScrollOffset(index) || 0;\n    }\n    this._scrollHandler();\n    if (this.__hasPlaceholders()) {\n      // After rendering synchronously, there are still placeholders in the DOM.\n      // Try again after the next elements update.\n      this.__pendingScrollToIndex = index;\n    }\n  }\n  flush() {\n    // The scroll target is hidden.\n    if (this.scrollTarget.offsetHeight === 0) {\n      return;\n    }\n    this._resizeHandler();\n    flush();\n    this._scrollHandler();\n    if (this.__fixInvalidItemPositioningDebouncer) {\n      this.__fixInvalidItemPositioningDebouncer.flush();\n    }\n    if (this.__scrollReorderDebouncer) {\n      this.__scrollReorderDebouncer.flush();\n    }\n    if (this.__debouncerWheelAnimationFrame) {\n      this.__debouncerWheelAnimationFrame.flush();\n    }\n  }\n  update() {\n    let startIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n    let endIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.size - 1;\n    const updatedElements = [];\n    this.__getVisibleElements().forEach(el => {\n      if (el.__virtualIndex >= startIndex && el.__virtualIndex <= endIndex) {\n        this.__updateElement(el, el.__virtualIndex, true);\n        updatedElements.push(el);\n      }\n    });\n    this.__afterElementsUpdated(updatedElements);\n  }\n\n  /**\n   * Updates the height for a given set of items.\n   *\n   * @param {!Array<number>=} itemSet\n   */\n  _updateMetrics(itemSet) {\n    // Make sure we distributed all the physical items\n    // so we can measure them.\n    flush();\n    let newPhysicalSize = 0;\n    let oldPhysicalSize = 0;\n    const prevAvgCount = this._physicalAverageCount;\n    const prevPhysicalAvg = this._physicalAverage;\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    this._iterateItems((pidx, vidx) => {\n      oldPhysicalSize += this._physicalSizes[pidx];\n      this._physicalSizes[pidx] = Math.ceil(this.__getBorderBoxHeight(this._physicalItems[pidx]));\n      newPhysicalSize += this._physicalSizes[pidx];\n      this._physicalAverageCount += this._physicalSizes[pidx] ? 1 : 0;\n    }, itemSet);\n    this._physicalSize = this._physicalSize + newPhysicalSize - oldPhysicalSize;\n\n    // Update the average if it measured something.\n    if (this._physicalAverageCount !== prevAvgCount) {\n      this._physicalAverage = Math.round((prevPhysicalAvg * prevAvgCount + newPhysicalSize) / this._physicalAverageCount);\n    }\n  }\n  __getBorderBoxHeight(el) {\n    const style = getComputedStyle(el);\n    const itemHeight = parseFloat(style.height) || 0;\n    if (style.boxSizing === 'border-box') {\n      return itemHeight;\n    }\n    const paddingBottom = parseFloat(style.paddingBottom) || 0;\n    const paddingTop = parseFloat(style.paddingTop) || 0;\n    const borderBottomWidth = parseFloat(style.borderBottomWidth) || 0;\n    const borderTopWidth = parseFloat(style.borderTopWidth) || 0;\n    return itemHeight + paddingBottom + paddingTop + borderBottomWidth + borderTopWidth;\n  }\n  __updateElement(el, index, forceSameIndexUpdates) {\n    // Clean up temporary placeholder sizing\n    if (el.__virtualizerPlaceholder) {\n      el.style.paddingTop = '';\n      el.style.opacity = '';\n      el.__virtualizerPlaceholder = false;\n    }\n    if (!this.__preventElementUpdates && (el.__lastUpdatedIndex !== index || forceSameIndexUpdates)) {\n      this.updateElement(el, index);\n      el.__lastUpdatedIndex = index;\n    }\n  }\n\n  /**\n   * Called synchronously right after elements have been updated.\n   * This is a good place to do any post-update work.\n   *\n   * @param {!Array<!HTMLElement>} updatedElements\n   */\n  __afterElementsUpdated(updatedElements) {\n    updatedElements.forEach(el => {\n      const elementHeight = el.offsetHeight;\n      if (elementHeight === 0) {\n        // If the elements have 0 height after update (for example due to lazy rendering),\n        // it results in iron-list requesting to create an unlimited count of elements.\n        // Assign a temporary placeholder sizing to elements that would otherwise end up having\n        // no height.\n        el.style.paddingTop = `${this.__placeholderHeight}px`;\n        el.style.opacity = '0';\n        el.__virtualizerPlaceholder = true;\n\n        // Manually schedule the resize handler to make sure the placeholder padding is\n        // cleared in case the resize observer never triggers.\n        this.__placeholderClearDebouncer = Debouncer.debounce(this.__placeholderClearDebouncer, animationFrame, () => this._resizeHandler());\n      } else {\n        // Add element height to the queue\n        this.__elementHeightQueue.push(elementHeight);\n        this.__elementHeightQueue.shift();\n\n        // Calculate new placeholder height based on the average of the defined values in the\n        // element height queue\n        const filteredHeights = this.__elementHeightQueue.filter(h => h !== undefined);\n        this.__placeholderHeight = Math.round(filteredHeights.reduce((a, b) => a + b, 0) / filteredHeights.length);\n      }\n    });\n    if (this.__pendingScrollToIndex !== undefined && !this.__hasPlaceholders()) {\n      this.scrollToIndex(this.__pendingScrollToIndex);\n    }\n  }\n  __getIndexScrollOffset(index) {\n    const element = this.__getVisibleElements().find(el => el.__virtualIndex === index);\n    return element ? this.scrollTarget.getBoundingClientRect().top - element.getBoundingClientRect().top : undefined;\n  }\n  get size() {\n    return this.__size;\n  }\n  set size(size) {\n    if (size === this.size) {\n      return;\n    }\n    // Cancel active debouncers\n    if (this.__fixInvalidItemPositioningDebouncer) {\n      this.__fixInvalidItemPositioningDebouncer.cancel();\n    }\n    if (this._debouncers && this._debouncers._increasePoolIfNeeded) {\n      // Avoid creating unnecessary elements on the following flush()\n      this._debouncers._increasePoolIfNeeded.cancel();\n    }\n\n    // Prevent element update while the scroll position is being restored\n    this.__preventElementUpdates = true;\n\n    // Record the scroll position before changing the size\n    let fvi; // First visible index\n    let fviOffsetBefore; // Scroll offset of the first visible index\n    if (size > 0) {\n      fvi = this.adjustedFirstVisibleIndex;\n      fviOffsetBefore = this.__getIndexScrollOffset(fvi);\n    }\n\n    // Change the size\n    this.__size = size;\n    this._itemsChanged({\n      path: 'items'\n    });\n    flush();\n\n    // Try to restore the scroll position if the new size is larger than 0\n    if (size > 0) {\n      fvi = Math.min(fvi, size - 1);\n      // Note, calling scrollToIndex also updates the virtual index offset,\n      // causing the virtualizer to add more items when size is increased,\n      // and remove exceeding items when size is decreased.\n      this.scrollToIndex(fvi);\n      const fviOffsetAfter = this.__getIndexScrollOffset(fvi);\n      if (fviOffsetBefore !== undefined && fviOffsetAfter !== undefined) {\n        this._scrollTop += fviOffsetBefore - fviOffsetAfter;\n      }\n    }\n    this.__preventElementUpdates = false;\n\n    // When reducing size while invisible, iron-list does not update items, so\n    // their hidden state is not updated and their __lastUpdatedIndex is not\n    // reset. In that case force an update here.\n    if (!this._isVisible) {\n      this._assignModels();\n    }\n    if (!this.elementsContainer.children.length) {\n      requestAnimationFrame(() => this._resizeHandler());\n    }\n\n    // Schedule and flush a resize handler\n    this._resizeHandler();\n    flush();\n    // Schedule an update to ensure item positions are correct after subsequent size changes\n    // Fix for https://github.com/vaadin/flow-components/issues/6269\n    this._debounce('_update', this._update, microTask);\n  }\n\n  /** @private */\n  get _scrollTop() {\n    return this.scrollTarget.scrollTop;\n  }\n\n  /** @private */\n  set _scrollTop(top) {\n    this.scrollTarget.scrollTop = top;\n  }\n\n  /** @private */\n  get items() {\n    return {\n      length: Math.min(this.size, MAX_VIRTUAL_COUNT)\n    };\n  }\n\n  /** @private */\n  get offsetHeight() {\n    return this.scrollTarget.offsetHeight;\n  }\n\n  /** @private */\n  get $() {\n    return {\n      items: this.scrollContainer\n    };\n  }\n\n  /** @private */\n  updateViewportBoundaries() {\n    const styles = window.getComputedStyle(this.scrollTarget);\n    this._scrollerPaddingTop = this.scrollTarget === this ? 0 : parseInt(styles['padding-top'], 10);\n    this._isRTL = Boolean(styles.direction === 'rtl');\n    this._viewportWidth = this.elementsContainer.offsetWidth;\n    this._viewportHeight = this.scrollTarget.offsetHeight;\n    this._scrollPageHeight = this._viewportHeight - this._scrollLineHeight;\n    if (this.grid) {\n      this._updateGridMetrics();\n    }\n  }\n\n  /** @private */\n  setAttribute() {}\n\n  /** @private */\n  _createPool(size) {\n    const physicalItems = this.createElements(size);\n    const fragment = document.createDocumentFragment();\n    physicalItems.forEach(el => {\n      el.style.position = 'absolute';\n      fragment.appendChild(el);\n      this.__resizeObserver.observe(el);\n    });\n    this.elementsContainer.appendChild(fragment);\n    return physicalItems;\n  }\n\n  /** @private */\n  _assignModels(itemSet) {\n    const updatedElements = [];\n    this._iterateItems((pidx, vidx) => {\n      const el = this._physicalItems[pidx];\n      el.hidden = vidx >= this.size;\n      if (!el.hidden) {\n        el.__virtualIndex = vidx + (this._vidxOffset || 0);\n        this.__updateElement(el, el.__virtualIndex);\n        updatedElements.push(el);\n      } else {\n        delete el.__lastUpdatedIndex;\n      }\n    }, itemSet);\n    this.__afterElementsUpdated(updatedElements);\n  }\n\n  /** @private */\n  _isClientFull() {\n    // Workaround an issue in iron-list that can cause it to freeze on fast scroll\n    setTimeout(() => {\n      this.__clientFull = true;\n    });\n    return this.__clientFull || super._isClientFull();\n  }\n\n  /** @private */\n  translate3d(_x, y, _z, el) {\n    el.style.transform = `translateY(${y})`;\n  }\n\n  /** @private */\n  toggleScrollListener() {}\n\n  /** @private */\n  __getFocusedElement() {\n    let visibleElements = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.__getVisibleElements();\n    return visibleElements.find(element => element.contains(this.elementsContainer.getRootNode().activeElement) || element.contains(this.scrollTarget.getRootNode().activeElement));\n  }\n\n  /** @private */\n  __nextFocusableSiblingMissing(focusedElement, visibleElements) {\n    return (\n      // Check if focused element is the last visible DOM element\n      visibleElements.indexOf(focusedElement) === visibleElements.length - 1 &&\n      // ...while there are more items available\n      this.size > focusedElement.__virtualIndex + 1\n    );\n  }\n\n  /** @private */\n  __previousFocusableSiblingMissing(focusedElement, visibleElements) {\n    return (\n      // Check if focused element is the first visible DOM element\n      visibleElements.indexOf(focusedElement) === 0 &&\n      // ...while there are preceding items available\n      focusedElement.__virtualIndex > 0\n    );\n  }\n\n  /** @private */\n  __onElementFocused(e) {\n    if (!this.reorderElements) {\n      return;\n    }\n    const focusedElement = e.detail.element;\n    if (!focusedElement) {\n      return;\n    }\n\n    // User has tabbed to or within a virtualizer element.\n    // Check if a next or previous focusable sibling is missing while it should be there (so the user can continue tabbing).\n    // The focusable sibling might be missing due to the elements not yet being in the correct DOM order.\n    // First try flushing (which also flushes any active __scrollReorderDebouncer).\n    const visibleElements = this.__getVisibleElements();\n    if (this.__previousFocusableSiblingMissing(focusedElement, visibleElements) || this.__nextFocusableSiblingMissing(focusedElement, visibleElements)) {\n      this.flush();\n    }\n\n    // If the focusable sibling is still missing (because the focused element is at the edge of the viewport and\n    // the virtual scrolling logic hasn't had the need to recycle elements), scroll the virtualizer just enough to\n    // have the focusable sibling inside the visible viewport to force the virtualizer to recycle.\n    const reorderedVisibleElements = this.__getVisibleElements();\n    if (this.__nextFocusableSiblingMissing(focusedElement, reorderedVisibleElements)) {\n      this._scrollTop += Math.ceil(focusedElement.getBoundingClientRect().bottom) - Math.floor(this.scrollTarget.getBoundingClientRect().bottom - 1);\n      this.flush();\n    } else if (this.__previousFocusableSiblingMissing(focusedElement, reorderedVisibleElements)) {\n      this._scrollTop -= Math.ceil(this.scrollTarget.getBoundingClientRect().top + 1) - Math.floor(focusedElement.getBoundingClientRect().top);\n      this.flush();\n    }\n  }\n  _scrollHandler() {\n    // The scroll target is hidden.\n    if (this.scrollTarget.offsetHeight === 0) {\n      return;\n    }\n    this._adjustVirtualIndexOffset(this._scrollTop - (this.__previousScrollTop || 0));\n    const delta = this.scrollTarget.scrollTop - this._scrollPosition;\n    super._scrollHandler();\n    if (this._physicalCount !== 0) {\n      const isScrollingDown = delta >= 0;\n      const reusables = this._getReusables(!isScrollingDown);\n      if (reusables.indexes.length) {\n        // After running super._scrollHandler, fix internal properties to workaround an iron-list issue.\n        // See https://github.com/vaadin/web-components/issues/1691\n        this._physicalTop = reusables.physicalTop;\n        if (isScrollingDown) {\n          this._virtualStart -= reusables.indexes.length;\n          this._physicalStart -= reusables.indexes.length;\n        } else {\n          this._virtualStart += reusables.indexes.length;\n          this._physicalStart += reusables.indexes.length;\n        }\n        this._resizeHandler();\n      }\n    }\n    if (delta) {\n      // There was a change in scroll top. Schedule a check for invalid item positioning.\n      this.__fixInvalidItemPositioningDebouncer = Debouncer.debounce(this.__fixInvalidItemPositioningDebouncer, timeOut.after(this.timeouts.FIX_INVALID_ITEM_POSITIONING), () => this.__fixInvalidItemPositioning());\n    }\n    if (this.reorderElements) {\n      this.__scrollReorderDebouncer = Debouncer.debounce(this.__scrollReorderDebouncer, timeOut.after(this.timeouts.SCROLL_REORDER), () => this.__reorderElements());\n    }\n    this.__previousScrollTop = this._scrollTop;\n\n    // If the first visible index is not 0 when scrolled to the top,\n    // scroll to index 0 to fix the issue.\n    if (this._scrollTop === 0 && this.firstVisibleIndex !== 0 && Math.abs(delta) > 0) {\n      this.scrollToIndex(0);\n    }\n  }\n\n  /**\n   * Work around an iron-list issue with invalid item positioning.\n   * See https://github.com/vaadin/flow-components/issues/4306\n   * @private\n   */\n  __fixInvalidItemPositioning() {\n    if (!this.scrollTarget.isConnected) {\n      return;\n    }\n\n    // Check if the first physical item element is below the top of the viewport\n    const physicalTopBelowTop = this._physicalTop > this._scrollTop;\n    // Check if the last physical item element is above the bottom of the viewport\n    const physicalBottomAboveBottom = this._physicalBottom < this._scrollBottom;\n\n    // Check if the first index is visible\n    const firstIndexVisible = this.adjustedFirstVisibleIndex === 0;\n    // Check if the last index is visible\n    const lastIndexVisible = this.adjustedLastVisibleIndex === this.size - 1;\n    if (physicalTopBelowTop && !firstIndexVisible || physicalBottomAboveBottom && !lastIndexVisible) {\n      // Invalid state! Try to recover.\n\n      const isScrollingDown = physicalBottomAboveBottom;\n      // Set the \"_ratio\" property temporarily to 0 to make iron-list's _getReusables\n      // place all the free physical items on one side of the viewport.\n      const originalRatio = this._ratio;\n      this._ratio = 0;\n      // Fake a scroll change to make _scrollHandler place the physical items\n      // on the desired side.\n      this._scrollPosition = this._scrollTop + (isScrollingDown ? -1 : 1);\n      this._scrollHandler();\n      // Restore the original \"_ratio\" value.\n      this._ratio = originalRatio;\n    }\n  }\n\n  /** @private */\n  __onWheel(e) {\n    if (e.ctrlKey || this._hasScrolledAncestor(e.target, e.deltaX, e.deltaY)) {\n      return;\n    }\n    let deltaY = e.deltaY;\n    if (e.deltaMode === WheelEvent.DOM_DELTA_LINE) {\n      // Scrolling by \"lines of text\" instead of pixels\n      deltaY *= this._scrollLineHeight;\n    } else if (e.deltaMode === WheelEvent.DOM_DELTA_PAGE) {\n      // Scrolling by \"pages\" instead of pixels\n      deltaY *= this._scrollPageHeight;\n    }\n    if (!this._deltaYAcc) {\n      this._deltaYAcc = 0;\n    }\n    if (this._wheelAnimationFrame) {\n      // Accumulate wheel delta while a frame is being processed\n      this._deltaYAcc += deltaY;\n      e.preventDefault();\n      return;\n    }\n    deltaY += this._deltaYAcc;\n    this._deltaYAcc = 0;\n    this._wheelAnimationFrame = true;\n    this.__debouncerWheelAnimationFrame = Debouncer.debounce(this.__debouncerWheelAnimationFrame, animationFrame, () => {\n      this._wheelAnimationFrame = false;\n    });\n    const momentum = Math.abs(e.deltaX) + Math.abs(deltaY);\n    if (this._canScroll(this.scrollTarget, e.deltaX, deltaY)) {\n      e.preventDefault();\n      this.scrollTarget.scrollTop += deltaY;\n      this.scrollTarget.scrollLeft += e.deltaX;\n      this._hasResidualMomentum = true;\n      this._ignoreNewWheel = true;\n      this._debouncerIgnoreNewWheel = Debouncer.debounce(this._debouncerIgnoreNewWheel, timeOut.after(this.timeouts.IGNORE_WHEEL), () => {\n        this._ignoreNewWheel = false;\n      });\n    } else if (this._hasResidualMomentum && momentum <= this._previousMomentum || this._ignoreNewWheel) {\n      e.preventDefault();\n    } else if (momentum > this._previousMomentum) {\n      this._hasResidualMomentum = false;\n    }\n    this._previousMomentum = momentum;\n  }\n\n  /**\n   * Determines if the element has an ancestor that handles the scroll delta prior to this\n   *\n   * @private\n   */\n  _hasScrolledAncestor(el, deltaX, deltaY) {\n    if (el === this.scrollTarget || el === this.scrollTarget.getRootNode().host) {\n      return false;\n    } else if (this._canScroll(el, deltaX, deltaY) && ['auto', 'scroll'].indexOf(getComputedStyle(el).overflow) !== -1) {\n      return true;\n    } else if (el !== this && el.parentElement) {\n      return this._hasScrolledAncestor(el.parentElement, deltaX, deltaY);\n    }\n  }\n  _canScroll(el, deltaX, deltaY) {\n    return deltaY > 0 && el.scrollTop < el.scrollHeight - el.offsetHeight || deltaY < 0 && el.scrollTop > 0 || deltaX > 0 && el.scrollLeft < el.scrollWidth - el.offsetWidth || deltaX < 0 && el.scrollLeft > 0;\n  }\n\n  /**\n   * Increases the pool size.\n   * @override\n   */\n  _increasePoolIfNeeded(count) {\n    if (this._physicalCount > 2 && count) {\n      // The iron-list logic has already created some physical items and\n      // has decided to create more. Since each item creation round is\n      // expensive, let's try to create the remaining items in one go.\n\n      // Calculate the total item count that would be needed to fill the viewport\n      // plus the buffer assuming rest of the items to be of the average size\n      // of the items already created.\n      const totalItemCount = Math.ceil(this._optPhysicalSize / this._physicalAverage);\n      const missingItemCount = totalItemCount - this._physicalCount;\n      // Create the remaining items in one go. Use a maximum of 100 items\n      // as a safety measure.\n      super._increasePoolIfNeeded(Math.max(count, Math.min(100, missingItemCount)));\n    } else {\n      super._increasePoolIfNeeded(count);\n    }\n  }\n\n  /**\n   * An optimal physical size such that we will have enough physical items\n   * to fill up the viewport and recycle when the user scrolls.\n   *\n   * This default value assumes that we will at least have the equivalent\n   * to a viewport of physical items above and below the user's viewport.\n   * @override\n   */\n  get _optPhysicalSize() {\n    const optPhysicalSize = super._optPhysicalSize;\n    // No need to adjust\n    if (optPhysicalSize <= 0 || this.__hasPlaceholders()) {\n      return optPhysicalSize;\n    }\n    // Item height buffer accounts for the cases where some items are much larger than the average.\n    // This can lead to some items not being rendered and leaving empty space in the viewport.\n    // https://github.com/vaadin/flow-components/issues/6651\n    return optPhysicalSize + this.__getItemHeightBuffer();\n  }\n\n  /**\n   * Extra item height buffer used when calculating optimal physical size.\n   *\n   * The iron list core uses the optimal physical size when determining whether to increase the item pool.\n   * For the cases where some items are much larger than the average, the iron list core might not increase item pool.\n   * This can lead to the large item not being rendered.\n   *\n   * @returns {Number} - Extra item height buffer\n   * @private\n   */\n  __getItemHeightBuffer() {\n    // No need for a buffer with no items\n    if (this._physicalCount === 0) {\n      return 0;\n    }\n    // The regular buffer zone height for either top or bottom\n    const bufferZoneHeight = Math.ceil(this._viewportHeight * (this._maxPages - 1) / 2);\n    // The maximum height of the currently rendered items\n    const maxItemHeight = Math.max(...this._physicalSizes);\n    // Only add buffer if the item is larger that the other items\n    if (maxItemHeight > Math.min(...this._physicalSizes)) {\n      // Add a buffer height since the large item can still be in the viewport and out of the original buffer\n      return Math.max(0, maxItemHeight - bufferZoneHeight);\n    }\n    return 0;\n  }\n\n  /**\n   * @returns {Number|undefined} - The browser's default font-size in pixels\n   * @private\n   */\n  _getScrollLineHeight() {\n    const el = document.createElement('div');\n    el.style.fontSize = 'initial';\n    el.style.display = 'none';\n    document.body.appendChild(el);\n    const fontSize = window.getComputedStyle(el).fontSize;\n    document.body.removeChild(el);\n    return fontSize ? window.parseInt(fontSize) : undefined;\n  }\n  __getVisibleElements() {\n    return Array.from(this.elementsContainer.children).filter(element => !element.hidden);\n  }\n\n  /** @private */\n  __reorderElements() {\n    if (this.__mouseDown) {\n      this.__pendingReorder = true;\n      return;\n    }\n    this.__pendingReorder = false;\n    const adjustedVirtualStart = this._virtualStart + (this._vidxOffset || 0);\n\n    // Which row to use as a target?\n    const visibleElements = this.__getVisibleElements();\n    const targetElement = this.__getFocusedElement(visibleElements) || visibleElements[0];\n    if (!targetElement) {\n      // All elements are hidden, don't reorder\n      return;\n    }\n\n    // Where the target row should be?\n    const targetPhysicalIndex = targetElement.__virtualIndex - adjustedVirtualStart;\n\n    // Reodrer the DOM elements to keep the target row at the target physical index\n    const delta = visibleElements.indexOf(targetElement) - targetPhysicalIndex;\n    if (delta > 0) {\n      for (let i = 0; i < delta; i++) {\n        this.elementsContainer.appendChild(visibleElements[i]);\n      }\n    } else if (delta < 0) {\n      for (let i = visibleElements.length + delta; i < visibleElements.length; i++) {\n        this.elementsContainer.insertBefore(visibleElements[i], visibleElements[0]);\n      }\n    }\n\n    // Due to a rendering bug, reordering the rows can make parts of the scroll target disappear\n    // on Safari when using sticky positioning in case the scroll target is inside a flexbox.\n    // This issue manifests with grid (the header can disappear if grid is used inside a flexbox)\n    if (isSafari) {\n      const transform = this.scrollTarget.style.transform;\n      this.scrollTarget.style.transform = 'translateZ(0)';\n      setTimeout(() => {\n        this.scrollTarget.style.transform = transform;\n      });\n    }\n  }\n\n  /** @private */\n  _adjustVirtualIndexOffset(delta) {\n    const maxOffset = this._maxVirtualIndexOffset;\n    if (this._virtualCount >= this.size) {\n      this._vidxOffset = 0;\n    } else if (this.__skipNextVirtualIndexAdjust) {\n      this.__skipNextVirtualIndexAdjust = false;\n    } else if (Math.abs(delta) > 10000) {\n      // Process a large scroll position change\n      const scale = this._scrollTop / (this.scrollTarget.scrollHeight - this.scrollTarget.clientHeight);\n      this._vidxOffset = Math.round(scale * maxOffset);\n    } else {\n      // Make sure user can always swipe/wheel scroll to the start and end\n      const oldOffset = this._vidxOffset;\n      const threshold = OFFSET_ADJUST_MIN_THRESHOLD;\n      const maxShift = 100;\n\n      // Near start\n      if (this._scrollTop === 0) {\n        this._vidxOffset = 0;\n        if (oldOffset !== this._vidxOffset) {\n          super.scrollToIndex(0);\n        }\n      } else if (this.firstVisibleIndex < threshold && this._vidxOffset > 0) {\n        this._vidxOffset -= Math.min(this._vidxOffset, maxShift);\n        super.scrollToIndex(this.firstVisibleIndex + (oldOffset - this._vidxOffset));\n      }\n\n      // Near end\n      if (this._scrollTop >= this._maxScrollTop && this._maxScrollTop > 0) {\n        this._vidxOffset = maxOffset;\n        if (oldOffset !== this._vidxOffset) {\n          super.scrollToIndex(this._virtualCount - 1);\n        }\n      } else if (this.firstVisibleIndex > this._virtualCount - threshold && this._vidxOffset < maxOffset) {\n        this._vidxOffset += Math.min(maxOffset - this._vidxOffset, maxShift);\n        super.scrollToIndex(this.firstVisibleIndex - (this._vidxOffset - oldOffset));\n      }\n    }\n  }\n}\nObject.setPrototypeOf(IronListAdapter.prototype, ironList);","import { IronListAdapter } from './virtualizer-iron-list-adapter.js';\nexport class Virtualizer {\n  /**\n   * @typedef {Object} VirtualizerConfig\n   * @property {Function} createElements Function that returns the given number of new elements\n   * @property {Function} updateElement Function that updates the element at a specific index\n   * @property {HTMLElement} scrollTarget Reference to the scrolling element\n   * @property {HTMLElement} scrollContainer Reference to a wrapper for the item elements (or a slot) inside the scrollTarget\n   * @property {HTMLElement | undefined} elementsContainer Reference to the container in which the item elements are placed, defaults to scrollContainer\n   * @property {boolean | undefined} reorderElements Determines whether the physical item elements should be kept in order in the DOM\n   * @param {VirtualizerConfig} config Configuration for the virtualizer\n   */\n  constructor(config) {\n    this.__adapter = new IronListAdapter(config);\n  }\n\n  /**\n   * Gets the index of the first visible item in the viewport.\n   *\n   * @return {number}\n   */\n  get firstVisibleIndex() {\n    return this.__adapter.adjustedFirstVisibleIndex;\n  }\n\n  /**\n   * Gets the index of the last visible item in the viewport.\n   *\n   * @return {number}\n   */\n  get lastVisibleIndex() {\n    return this.__adapter.adjustedLastVisibleIndex;\n  }\n\n  /**\n   * The size of the virtualizer\n   * @return {number | undefined} The size of the virtualizer\n   */\n  get size() {\n    return this.__adapter.size;\n  }\n\n  /**\n   * The size of the virtualizer\n   * @param {number} size The size of the virtualizer\n   */\n  set size(size) {\n    this.__adapter.size = size;\n  }\n\n  /**\n   * Scroll to a specific index in the virtual list\n   *\n   * @method scrollToIndex\n   * @param {number} index The index of the item\n   */\n  scrollToIndex(index) {\n    this.__adapter.scrollToIndex(index);\n  }\n\n  /**\n   * Requests the virtualizer to re-render the item elements on an index range, if currently in the DOM\n   *\n   * @method update\n   * @param {number | undefined} startIndex The start index of the range\n   * @param {number | undefined} endIndex The end index of the range\n   */\n  update() {\n    let startIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n    let endIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.size - 1;\n    this.__adapter.update(startIndex, endIndex);\n  }\n\n  /**\n   * Flushes active asynchronous tasks so that the component and the DOM end up in a stable state\n   *\n   * @method update\n   * @param {number | undefined} startIndex The start index of the range\n   * @param {number | undefined} endIndex The end index of the range\n   */\n  flush() {\n    this.__adapter.flush();\n  }\n}","/**\n * @license\n * Copyright (c) 2015 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { get } from '@vaadin/component-base/src/path-utils.js';\nimport { generateUniqueId } from '@vaadin/component-base/src/unique-id-utils.js';\nimport { Virtualizer } from '@vaadin/component-base/src/virtualizer.js';\nimport { ComboBoxPlaceholder } from './vaadin-combo-box-placeholder.js';\n\n/**\n * @polymerMixin\n */\nexport const ComboBoxScrollerMixin = superClass => class ComboBoxScrollerMixin extends superClass {\n  static get properties() {\n    return {\n      /**\n       * A full set of items to filter the visible options from.\n       * Set to an empty array when combo-box is not opened.\n       */\n      items: {\n        type: Array,\n        sync: true,\n        observer: '__itemsChanged'\n      },\n      /**\n       * Index of an item that has focus outline and is scrolled into view.\n       * The actual focus still remains in the input field.\n       */\n      focusedIndex: {\n        type: Number,\n        sync: true,\n        observer: '__focusedIndexChanged'\n      },\n      /**\n       * Set to true while combo-box fetches new page from the data provider.\n       */\n      loading: {\n        type: Boolean,\n        sync: true,\n        observer: '__loadingChanged'\n      },\n      /**\n       * Whether the combo-box is currently opened or not. If set to false,\n       * calling `scrollIntoView` does not have any effect.\n       */\n      opened: {\n        type: Boolean,\n        sync: true,\n        observer: '__openedChanged'\n      },\n      /**\n       * The selected item from the `items` array.\n       */\n      selectedItem: {\n        type: Object,\n        sync: true,\n        observer: '__selectedItemChanged'\n      },\n      /**\n       * A function used to generate CSS class names for dropdown\n       * items based on the item. The return value should be the\n       * generated class name as a string, or multiple class names\n       * separated by whitespace characters.\n       */\n      itemClassNameGenerator: {\n        type: Object,\n        observer: '__itemClassNameGeneratorChanged'\n      },\n      /**\n       * Path for the id of the item, used to detect whether the item is selected.\n       */\n      itemIdPath: {\n        type: String\n      },\n      /**\n       * Reference to the owner (combo-box owner), used by the item elements.\n       */\n      owner: {\n        type: Object\n      },\n      /**\n       * Function used to set a label for every combo-box item.\n       */\n      getItemLabel: {\n        type: Object\n      },\n      /**\n       * Function used to render the content of every combo-box item.\n       */\n      renderer: {\n        type: Object,\n        sync: true,\n        observer: '__rendererChanged'\n      },\n      /**\n       * Used to propagate the `theme` attribute from the host element.\n       */\n      theme: {\n        type: String\n      }\n    };\n  }\n  constructor() {\n    super();\n    this.__boundOnItemClick = this.__onItemClick.bind(this);\n  }\n\n  /** @private */\n  get _viewportTotalPaddingBottom() {\n    if (this._cachedViewportTotalPaddingBottom === undefined) {\n      const itemsStyle = window.getComputedStyle(this.$.selector);\n      this._cachedViewportTotalPaddingBottom = [itemsStyle.paddingBottom, itemsStyle.borderBottomWidth].map(v => {\n        return parseInt(v, 10);\n      }).reduce((sum, v) => {\n        return sum + v;\n      });\n    }\n    return this._cachedViewportTotalPaddingBottom;\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n    this.setAttribute('role', 'listbox');\n\n    // Ensure every instance has unique ID\n    this.id = `${this.localName}-${generateUniqueId()}`;\n\n    // Allow extensions to customize tag name for the items\n    this.__hostTagName = this.constructor.is.replace('-scroller', '');\n    this.addEventListener('click', e => e.stopPropagation());\n    this.__patchWheelOverScrolling();\n  }\n\n  /**\n   * Updates the virtualizer's size and items.\n   */\n  requestContentUpdate() {\n    if (!this.__virtualizer) {\n      return;\n    }\n    if (this.items) {\n      this.__virtualizer.size = this.items.length;\n    }\n    if (this.opened) {\n      this.__virtualizer.update();\n    }\n  }\n\n  /**\n   * Scrolls an item at given index into view and adjusts `scrollTop`\n   * so that the element gets fully visible on Arrow Down key press.\n   * @param {number} index\n   */\n  scrollIntoView(index) {\n    if (!this.__virtualizer || !(this.opened && index >= 0)) {\n      return;\n    }\n    const visibleItemsCount = this._visibleItemsCount();\n    let targetIndex = index;\n    if (index > this.__virtualizer.lastVisibleIndex - 1) {\n      // Index is below the bottom, scrolling down. Make the item appear at the bottom.\n      // First scroll to target (will be at the top of the scroller) to make sure it's rendered.\n      this.__virtualizer.scrollToIndex(index);\n      // Then calculate the index for the following scroll (to get the target to bottom of the scroller).\n      targetIndex = index - visibleItemsCount + 1;\n    } else if (index > this.__virtualizer.firstVisibleIndex) {\n      // The item is already visible, scrolling is unnecessary per se. But we need to trigger iron-list to set\n      // the correct scrollTop on the scrollTarget. Scrolling to firstVisibleIndex.\n      targetIndex = this.__virtualizer.firstVisibleIndex;\n    }\n    this.__virtualizer.scrollToIndex(Math.max(0, targetIndex));\n\n    // Sometimes the item is partly below the bottom edge, detect and adjust.\n    const lastPhysicalItem = [...this.children].find(el => !el.hidden && el.index === this.__virtualizer.lastVisibleIndex);\n    if (!lastPhysicalItem || index !== lastPhysicalItem.index) {\n      return;\n    }\n    const lastPhysicalItemRect = lastPhysicalItem.getBoundingClientRect();\n    const scrollerRect = this.getBoundingClientRect();\n    const scrollTopAdjust = lastPhysicalItemRect.bottom - scrollerRect.bottom + this._viewportTotalPaddingBottom;\n    if (scrollTopAdjust > 0) {\n      this.scrollTop += scrollTopAdjust;\n    }\n  }\n\n  /**\n   * @param {string | object} item\n   * @param {string | object} selectedItem\n   * @param {string} itemIdPath\n   * @protected\n   */\n  _isItemSelected(item, selectedItem, itemIdPath) {\n    if (item instanceof ComboBoxPlaceholder) {\n      return false;\n    } else if (itemIdPath && item !== undefined && selectedItem !== undefined) {\n      return get(itemIdPath, item) === get(itemIdPath, selectedItem);\n    }\n    return item === selectedItem;\n  }\n\n  /** @private */\n  __initVirtualizer() {\n    this.__virtualizer = new Virtualizer({\n      createElements: this.__createElements.bind(this),\n      updateElement: this._updateElement.bind(this),\n      elementsContainer: this,\n      scrollTarget: this,\n      scrollContainer: this.$.selector,\n      reorderElements: true\n    });\n  }\n\n  /** @private */\n  __itemsChanged(items) {\n    if (items && this.__virtualizer) {\n      this.requestContentUpdate();\n    }\n  }\n\n  /** @private */\n  __loadingChanged() {\n    this.requestContentUpdate();\n  }\n\n  /** @private */\n  __openedChanged(opened) {\n    if (opened) {\n      if (!this.__virtualizer) {\n        this.__initVirtualizer();\n      }\n      this.requestContentUpdate();\n    }\n  }\n\n  /** @private */\n  __selectedItemChanged() {\n    this.requestContentUpdate();\n  }\n\n  /** @private */\n  __itemClassNameGeneratorChanged(generator, oldGenerator) {\n    if (generator || oldGenerator) {\n      this.requestContentUpdate();\n    }\n  }\n\n  /** @private */\n  __focusedIndexChanged(index, oldIndex) {\n    if (index !== oldIndex) {\n      this.requestContentUpdate();\n    }\n\n    // Do not jump back to the previously focused item while loading\n    // when requesting next page from the data provider on scroll.\n    if (index >= 0 && !this.loading) {\n      this.scrollIntoView(index);\n    }\n  }\n\n  /** @private */\n  __rendererChanged(renderer, oldRenderer) {\n    if (renderer || oldRenderer) {\n      this.requestContentUpdate();\n    }\n  }\n\n  /** @private */\n  __createElements(count) {\n    return [...Array(count)].map(() => {\n      const item = document.createElement(`${this.__hostTagName}-item`);\n      item.addEventListener('click', this.__boundOnItemClick);\n      // Negative tabindex prevents the item content from being focused.\n      item.tabIndex = '-1';\n      item.style.width = '100%';\n      return item;\n    });\n  }\n\n  /**\n   * @param {HTMLElement} el\n   * @param {number} index\n   * @protected\n   */\n  _updateElement(el, index) {\n    const item = this.items[index];\n    const focusedIndex = this.focusedIndex;\n    const selected = this._isItemSelected(item, this.selectedItem, this.itemIdPath);\n    el.setProperties({\n      item,\n      index,\n      label: this.getItemLabel(item),\n      selected,\n      renderer: this.renderer,\n      focused: !this.loading && focusedIndex === index\n    });\n    if (typeof this.itemClassNameGenerator === 'function') {\n      el.className = this.itemClassNameGenerator(item);\n    } else if (el.className !== '') {\n      el.className = '';\n    }\n\n    // NOTE: in PolylitMixin, setProperties() waits for `hasUpdated` to be set.\n    // However, this causes issues with virtualizer. So we enforce sync update.\n    if (el.performUpdate && !el.hasUpdated) {\n      el.performUpdate();\n    }\n    el.id = `${this.__hostTagName}-item-${index}`;\n    el.setAttribute('role', index !== undefined ? 'option' : false);\n    el.setAttribute('aria-selected', selected.toString());\n    el.setAttribute('aria-posinset', index + 1);\n    el.setAttribute('aria-setsize', this.items.length);\n    if (this.theme) {\n      el.setAttribute('theme', this.theme);\n    } else {\n      el.removeAttribute('theme');\n    }\n    if (item instanceof ComboBoxPlaceholder) {\n      this.__requestItemByIndex(index);\n    }\n  }\n\n  /** @private */\n  __onItemClick(e) {\n    this.dispatchEvent(new CustomEvent('selection-changed', {\n      detail: {\n        item: e.currentTarget.item\n      }\n    }));\n  }\n\n  /**\n   * We want to prevent the kinetic scrolling energy from being transferred from the overlay contents over to the parent.\n   * Further improvement ideas: after the contents have been scrolled to the top or bottom and scrolling has stopped, it could allow\n   * scrolling the parent similarly to touch scrolling.\n   * @private\n   */\n  __patchWheelOverScrolling() {\n    this.$.selector.addEventListener('wheel', e => {\n      const scrolledToTop = this.scrollTop === 0;\n      const scrolledToBottom = this.scrollHeight - this.scrollTop - this.clientHeight <= 1;\n      if (scrolledToTop && e.deltaY < 0) {\n        e.preventDefault();\n      } else if (scrolledToBottom && e.deltaY > 0) {\n        e.preventDefault();\n      }\n    });\n  }\n\n  /**\n   * Dispatches an `index-requested` event for the given index to notify\n   * the data provider that it should start loading the page containing the requested index.\n   *\n   * The event is dispatched asynchronously to prevent an immediate page request and therefore\n   * a possible infinite recursion in case the data provider implements page request cancelation logic\n   * by invoking data provider page callbacks with an empty array.\n   * The infinite recursion may occur otherwise since invoking a data provider page callback with an empty array\n   * triggers a synchronous scroller update and, if the callback corresponds to the currently visible page,\n   * the scroller will synchronously request the page again which may lead to looping in the end.\n   * That was the case for the Flow counterpart:\n   * https://github.com/vaadin/flow-components/issues/3553#issuecomment-1239344828\n   * @private\n   */\n  __requestItemByIndex(index) {\n    requestAnimationFrame(() => {\n      this.dispatchEvent(new CustomEvent('index-requested', {\n        detail: {\n          index\n        }\n      }));\n    });\n  }\n\n  /** @private */\n  _visibleItemsCount() {\n    // Ensure items are positioned\n    this.__virtualizer.scrollToIndex(this.__virtualizer.firstVisibleIndex);\n    const hasItems = this.__virtualizer.size > 0;\n    return hasItems ? this.__virtualizer.lastVisibleIndex - this.__virtualizer.firstVisibleIndex + 1 : 0;\n  }\n};","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { html, PolymerElement } from '@polymer/polymer/polymer-element.js';\nimport { ComboBoxPlaceholder } from '@vaadin/combo-box/src/vaadin-combo-box-placeholder.js';\nimport { ComboBoxScrollerMixin } from '@vaadin/combo-box/src/vaadin-combo-box-scroller-mixin.js';\nimport { defineCustomElement } from '@vaadin/component-base/src/define.js';\n\n/**\n * An element used internally by `<vaadin-multi-select-combo-box>`. Not intended to be used separately.\n *\n * @customElement\n * @extends HTMLElement\n * @mixes ComboBoxScrollerMixin\n * @private\n */\nexport class MultiSelectComboBoxScroller extends ComboBoxScrollerMixin(PolymerElement) {\n  static get is() {\n    return 'vaadin-multi-select-combo-box-scroller';\n  }\n  static get template() {\n    return html`\n      <style>\n        :host {\n          display: block;\n          min-height: 1px;\n          overflow: auto;\n\n          /* Fixes item background from getting on top of scrollbars on Safari */\n          transform: translate3d(0, 0, 0);\n\n          /* Enable momentum scrolling on iOS */\n          -webkit-overflow-scrolling: touch;\n\n          /* Fixes scrollbar disappearing when 'Show scroll bars: Always' enabled in Safari */\n          box-shadow: 0 0 0 white;\n        }\n\n        #selector {\n          border-width: var(--_vaadin-multi-select-combo-box-items-container-border-width);\n          border-style: var(--_vaadin-multi-select-combo-box-items-container-border-style);\n          border-color: var(--_vaadin-multi-select-combo-box-items-container-border-color, transparent);\n          position: relative;\n        }\n      </style>\n      <div id=\"selector\">\n        <slot></slot>\n      </div>\n    `;\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n    this.setAttribute('aria-multiselectable', 'true');\n  }\n\n  /**\n   * @protected\n   * @override\n   */\n  _isItemSelected(item, _selectedItem, itemIdPath) {\n    if (item instanceof ComboBoxPlaceholder) {\n      return false;\n    }\n    if (this.owner.readonly) {\n      return false;\n    }\n    return this.owner._findIndex(item, this.owner.selectedItems, itemIdPath) > -1;\n  }\n\n  /**\n   * @param {HTMLElement} el\n   * @param {number} index\n   * @protected\n   * @override\n   */\n  _updateElement(el, index) {\n    super._updateElement(el, index);\n    el.toggleAttribute('readonly', this.owner.readonly);\n  }\n}\ndefineCustomElement(MultiSelectComboBoxScroller);","function _toArray(r) { return _arrayWithHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction _iterableToArray(r) { if (\"undefined\" != typeof Symbol && null != r[Symbol.iterator] || null != r[\"@@iterator\"]) return Array.from(r); }\nfunction _arrayWithHoles(r) { if (Array.isArray(r)) return r; }\n/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n/**\n * @typedef {import('./cache.js').Cache} Cache\n */\n\n/**\n * Returns context for the given flattened index, including:\n * - the corresponding cache\n * - the cache level\n * - the corresponding item (if loaded)\n * - the item's index in the cache's items array\n * - the page containing the item\n *\n * @param {Cache} cache\n * @param {number} flatIndex\n */\nexport function getFlatIndexContext(cache, flatIndex) {\n  let level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n  let levelIndex = flatIndex;\n  for (const subCache of cache.subCaches) {\n    const index = subCache.parentCacheIndex;\n    if (levelIndex <= index) {\n      break;\n    } else if (levelIndex <= index + subCache.flatSize) {\n      return getFlatIndexContext(subCache, levelIndex - index - 1, level + 1);\n    }\n    levelIndex -= subCache.flatSize;\n  }\n  return {\n    cache,\n    item: cache.items[levelIndex],\n    index: levelIndex,\n    page: Math.floor(levelIndex / cache.pageSize),\n    level\n  };\n}\n\n/**\n * Returns context for the given item, including:\n * - the cache containing the item\n * - the cache level\n * - the item\n * - the item's index in the cache's items array\n * - the item's flattened index\n * - the item's sub-cache (if exists)\n * - the page containing the item\n *\n * If the item isn't found, the method returns undefined.\n *\n * @param {Cache} cache\n * @param {{ getItemId: (item: unknown) => unknown}} context\n * @param {Cache} cache\n * @param {unknown} targetItem\n * @param {number} level\n * @param {number} levelFlatIndex\n */\nexport function getItemContext(_ref, cache, targetItem) {\n  let getItemId = _ref.getItemId;\n  let level = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n  let levelFlatIndex = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;\n  // Start looking in this cache\n  for (let index = 0; index < cache.items.length; index++) {\n    const item = cache.items[index];\n    if (!!item && getItemId(item) === getItemId(targetItem)) {\n      return {\n        cache,\n        level,\n        item,\n        index,\n        page: Math.floor(index / cache.pageSize),\n        subCache: cache.getSubCache(index),\n        flatIndex: levelFlatIndex + cache.getFlatIndex(index)\n      };\n    }\n  }\n\n  // Look through sub-caches\n  for (const subCache of cache.subCaches) {\n    const parentItemFlatIndex = levelFlatIndex + cache.getFlatIndex(subCache.parentCacheIndex);\n    const result = getItemContext({\n      getItemId\n    }, subCache, targetItem, level + 1, parentItemFlatIndex + 1);\n    if (result) {\n      return result;\n    }\n  }\n}\n\n/**\n * Recursively returns the globally flat index of the item the given indexes point to.\n * Each index in the array points to a sub-item of the previous index.\n * Using `Infinity` as an index will point to the last item on the level.\n *\n * @param {Cache} cache\n * @param {number[]} path\n * @param {number} flatIndex\n * @return {number}\n */\nexport function getFlatIndexByPath(cache, _ref2) {\n  let _ref3 = _toArray(_ref2),\n    levelIndex = _ref3[0],\n    subIndexes = _ref3.slice(1);\n  let flatIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n  if (levelIndex === Infinity) {\n    // Treat Infinity as the last index on the level\n    levelIndex = cache.size - 1;\n  }\n  const flatIndexOnLevel = cache.getFlatIndex(levelIndex);\n  const subCache = cache.getSubCache(levelIndex);\n  if (subCache && subCache.flatSize > 0 && subIndexes.length) {\n    return getFlatIndexByPath(subCache, subIndexes, flatIndex + flatIndexOnLevel + 1);\n  }\n  return flatIndex + flatIndexOnLevel;\n}","function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }\nfunction _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\nfunction _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\n/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { getFlatIndexContext } from './helpers.js';\n\n/**\n * A class that stores items with their associated sub-caches.\n */\nexport class Cache {\n  /**\n   * @param {Cache['context']} context\n   * @param {number} pageSize\n   * @param {number | undefined} size\n   * @param {Cache | undefined} parentCache\n   * @param {number | undefined} parentCacheIndex\n   */\n  constructor(context, pageSize, size, parentCache, parentCacheIndex) {\n    /**\n     * A context object.\n     *\n     * @type {{ isExpanded: (item: unknown) => boolean }}\n     */\n    _defineProperty(this, \"context\", void 0);\n    /**\n     * The number of items to display per page.\n     *\n     * @type {number}\n     */\n    _defineProperty(this, \"pageSize\", void 0);\n    /**\n     * An array of cached items.\n     *\n     * @type {object[]}\n     */\n    _defineProperty(this, \"items\", []);\n    /**\n     * A map where the key is a requested page and the value is a callback\n     * that will be called with data once the request is complete.\n     *\n     * @type {Record<number, Function>}\n     */\n    _defineProperty(this, \"pendingRequests\", {});\n    /**\n     * A map where the key is the index of an item in the `items` array\n     * and the value is a sub-cache associated with that item.\n     *\n     * Note, it's intentionally defined as an object instead of a Map\n     * to ensure that Object.entries() returns an array with keys sorted\n     * in alphabetical order, rather than the order they were added.\n     *\n     * @type {Record<number, Cache>}\n     * @private\n     */\n    _defineProperty(this, \"__subCacheByIndex\", {});\n    /**\n     * The number of items.\n     *\n     * @type {number}\n     * @private\n     */\n    _defineProperty(this, \"__size\", 0);\n    /**\n     * The total number of items, including items from expanded sub-caches.\n     *\n     * @type {number}\n     * @private\n     */\n    _defineProperty(this, \"__flatSize\", 0);\n    this.context = context;\n    this.pageSize = pageSize;\n    this.size = size;\n    this.parentCache = parentCache;\n    this.parentCacheIndex = parentCacheIndex;\n    this.__flatSize = size || 0;\n  }\n\n  /**\n   * An item in the parent cache that the current cache is associated with.\n   *\n   * @return {object | undefined}\n   */\n  get parentItem() {\n    return this.parentCache && this.parentCache.items[this.parentCacheIndex];\n  }\n\n  /**\n   * An array of sub-caches sorted in the same order as their associated items\n   * appear in the `items` array.\n   *\n   * @return {Cache[]}\n   */\n  get subCaches() {\n    return Object.values(this.__subCacheByIndex);\n  }\n\n  /**\n   * Whether the cache or any of its descendant caches have pending requests.\n   *\n   * @return {boolean}\n   */\n  get isLoading() {\n    if (Object.keys(this.pendingRequests).length > 0) {\n      return true;\n    }\n    return this.subCaches.some(subCache => subCache.isLoading);\n  }\n\n  /**\n   * The total number of items, including items from expanded sub-caches.\n   *\n   * @return {number}\n   */\n  get flatSize() {\n    return this.__flatSize;\n  }\n\n  /**\n   * The total number of items, including items from expanded sub-caches.\n   *\n   * @protected\n   * @deprecated since 24.3 and will be removed in Vaadin 25.\n   */\n  get effectiveSize() {\n    console.warn('<vaadin-grid> The `effectiveSize` property of ItemCache is deprecated and will be removed in Vaadin 25.');\n    return this.flatSize;\n  }\n\n  /**\n   * The number of items.\n   *\n   * @return {number}\n   */\n  get size() {\n    return this.__size;\n  }\n\n  /**\n   * Sets the number of items.\n   *\n   * @param {number} size\n   */\n  set size(size) {\n    const oldSize = this.__size;\n    if (oldSize === size) {\n      return;\n    }\n    this.__size = size;\n    if (this.context.placeholder !== undefined) {\n      this.items.length = size || 0;\n      for (let i = 0; i < size || 0; i++) {\n        var _this$items, _i;\n        (_this$items = this.items)[_i = i] || (_this$items[_i] = this.context.placeholder);\n      }\n    }\n    Object.keys(this.pendingRequests).forEach(page => {\n      const startIndex = parseInt(page) * this.pageSize;\n      if (startIndex >= this.size || 0) {\n        delete this.pendingRequests[page];\n      }\n    });\n  }\n\n  /**\n   * Recalculates the flattened size for the cache and its descendant caches recursively.\n   */\n  recalculateFlatSize() {\n    this.__flatSize = !this.parentItem || this.context.isExpanded(this.parentItem) ? this.size + this.subCaches.reduce((total, subCache) => {\n      subCache.recalculateFlatSize();\n      return total + subCache.flatSize;\n    }, 0) : 0;\n  }\n\n  /**\n   * Adds an array of items corresponding to the given page\n   * to the `items` array.\n   *\n   * @param {number} page\n   * @param {object[]} items\n   */\n  setPage(page, items) {\n    const startIndex = page * this.pageSize;\n    items.forEach((item, i) => {\n      const itemIndex = startIndex + i;\n      if (this.size === undefined || itemIndex < this.size) {\n        this.items[itemIndex] = item;\n      }\n    });\n  }\n\n  /**\n   * Retrieves the sub-cache associated with the item at the given index\n   * in the `items` array.\n   *\n   * @param {number} index\n   * @return {Cache | undefined}\n   */\n  getSubCache(index) {\n    return this.__subCacheByIndex[index];\n  }\n\n  /**\n   * Removes the sub-cache associated with the item at the given index\n   * in the `items` array.\n   *\n   * @param {number} index\n   */\n  removeSubCache(index) {\n    delete this.__subCacheByIndex[index];\n  }\n\n  /**\n   * Removes all sub-caches.\n   */\n  removeSubCaches() {\n    this.__subCacheByIndex = {};\n  }\n\n  /**\n   * Creates and associates a sub-cache for the item at the given index\n   * in the `items` array.\n   *\n   * @param {number} index\n   * @return {Cache}\n   */\n  createSubCache(index) {\n    const subCache = new Cache(this.context, this.pageSize, 0, this, index);\n    this.__subCacheByIndex[index] = subCache;\n    return subCache;\n  }\n\n  /**\n   * Retrieves the flattened index corresponding to the given index\n   * of an item in the `items` array.\n   *\n   * @param {number} index\n   * @return {number}\n   */\n  getFlatIndex(index) {\n    const clampedIndex = Math.max(0, Math.min(this.size - 1, index));\n    return this.subCaches.reduce((prev, subCache) => {\n      const index = subCache.parentCacheIndex;\n      return clampedIndex > index ? prev + subCache.flatSize : prev;\n    }, clampedIndex);\n  }\n\n  /**\n   * @deprecated since 24.3 and will be removed in Vaadin 25.\n   */\n  getItemForIndex(index) {\n    console.warn('<vaadin-grid> The `getItemForIndex` method of ItemCache is deprecated and will be removed in Vaadin 25.');\n    const _getFlatIndexContext = getFlatIndexContext(this, index),\n      item = _getFlatIndexContext.item;\n    return item;\n  }\n\n  /**\n   * @deprecated since 24.3 and will be removed in Vaadin 25.\n   */\n  getCacheAndIndex(index) {\n    console.warn('<vaadin-grid> The `getCacheAndIndex` method of ItemCache is deprecated and will be removed in Vaadin 25.');\n    const _getFlatIndexContext2 = getFlatIndexContext(this, index),\n      cache = _getFlatIndexContext2.cache,\n      scaledIndex = _getFlatIndexContext2.index;\n    return {\n      cache,\n      scaledIndex\n    };\n  }\n\n  /**\n   * @deprecated since 24.3 and will be removed in Vaadin 25.\n   */\n  updateSize() {\n    console.warn('<vaadin-grid> The `updateSize` method of ItemCache is deprecated and will be removed in Vaadin 25.');\n    this.recalculateFlatSize();\n  }\n\n  /**\n   * @deprecated since 24.3 and will be removed in Vaadin 25.\n   */\n  ensureSubCacheForScaledIndex(scaledIndex) {\n    console.warn('<vaadin-grid> The `ensureSubCacheForScaledIndex` method of ItemCache is deprecated and will be removed in Vaadin 25.');\n    if (!this.getSubCache(scaledIndex)) {\n      const subCache = this.createSubCache(scaledIndex);\n      this.context.__controller.__loadCachePage(subCache, 0);\n    }\n  }\n\n  /**\n   * @deprecated since 24.3 and will be removed in Vaadin 25.\n   */\n  get grid() {\n    console.warn('<vaadin-grid> The `grid` property of ItemCache is deprecated and will be removed in Vaadin 25.');\n    return this.context.__controller.host;\n  }\n\n  /**\n   * @deprecated since 24.3 and will be removed in Vaadin 25.\n   */\n  get itemCaches() {\n    console.warn('<vaadin-grid> The `itemCaches` property of ItemCache is deprecated and will be removed in Vaadin 25.');\n    return this.__subCacheByIndex;\n  }\n}","function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }\nfunction _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\nfunction _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\n/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { Cache } from './cache.js';\nimport { getFlatIndexByPath, getFlatIndexContext, getItemContext } from './helpers.js';\n\n/**\n * A controller that stores and manages items loaded with a data provider.\n */\nexport class DataProviderController extends EventTarget {\n  constructor(host, _ref) {\n    let size = _ref.size,\n      pageSize = _ref.pageSize,\n      isExpanded = _ref.isExpanded,\n      getItemId = _ref.getItemId,\n      isPlaceholder = _ref.isPlaceholder,\n      placeholder = _ref.placeholder,\n      dataProvider = _ref.dataProvider,\n      dataProviderParams = _ref.dataProviderParams;\n    super();\n    /**\n     * The controller host element.\n     *\n     * @param {HTMLElement}\n     */\n    _defineProperty(this, \"host\", void 0);\n    /**\n     * A callback that returns data based on the passed params such as\n     * `page`, `pageSize`, `parentItem`, etc.\n     */\n    _defineProperty(this, \"dataProvider\", void 0);\n    /**\n     * A callback that returns additional params that need to be passed\n     * to the data provider callback with every request.\n     */\n    _defineProperty(this, \"dataProviderParams\", void 0);\n    /**\n     * A number of items to display per page.\n     *\n     * @type {number}\n     */\n    _defineProperty(this, \"pageSize\", void 0);\n    /**\n     * A callback that returns whether the given item is expanded.\n     *\n     * @type {(item: unknown) => boolean}\n     */\n    _defineProperty(this, \"isExpanded\", void 0);\n    /**\n     * A callback that returns the id for the given item and that\n     * is used when checking object items for equality.\n     *\n     * @type { (item: unknown) => unknown}\n     */\n    _defineProperty(this, \"getItemId\", void 0);\n    /**\n     * A reference to the root cache instance.\n     *\n     * @param {Cache}\n     */\n    _defineProperty(this, \"rootCache\", void 0);\n    /**\n     * A placeholder item that is used to indicate that the item is not loaded yet.\n     *\n     * @type {unknown}\n     */\n    _defineProperty(this, \"placeholder\", void 0);\n    /**\n     * A callback that returns whether the given item is a placeholder.\n     *\n     * @type {(item: unknown) => boolean}\n     */\n    _defineProperty(this, \"isPlaceholder\", void 0);\n    this.host = host;\n    this.pageSize = pageSize;\n    this.getItemId = getItemId;\n    this.isExpanded = isExpanded;\n    this.placeholder = placeholder;\n    this.isPlaceholder = isPlaceholder;\n    this.dataProvider = dataProvider;\n    this.dataProviderParams = dataProviderParams;\n    this.rootCache = this.__createRootCache(size);\n  }\n\n  /**\n   * The total number of items, including items from expanded sub-caches.\n   */\n  get flatSize() {\n    return this.rootCache.flatSize;\n  }\n\n  /** @private */\n  get __cacheContext() {\n    return {\n      isExpanded: this.isExpanded,\n      placeholder: this.placeholder,\n      // The controller instance is needed to ensure deprecated cache methods work.\n      __controller: this\n    };\n  }\n\n  /**\n   * Whether the root cache or any of its decendant caches have pending requests.\n   *\n   * @return {boolean}\n   */\n  isLoading() {\n    return this.rootCache.isLoading;\n  }\n\n  /**\n   * Sets the page size and clears the cache.\n   *\n   * @param {number} pageSize\n   */\n  setPageSize(pageSize) {\n    this.pageSize = pageSize;\n    this.clearCache();\n  }\n\n  /**\n   * Sets the data provider callback and clears the cache.\n   *\n   * @type {Function}\n   */\n  setDataProvider(dataProvider) {\n    this.dataProvider = dataProvider;\n    this.clearCache();\n  }\n\n  /**\n   * Recalculates the flattened size.\n   */\n  recalculateFlatSize() {\n    this.rootCache.recalculateFlatSize();\n  }\n\n  /**\n   * Clears the cache.\n   */\n  clearCache() {\n    this.rootCache = this.__createRootCache(this.rootCache.size);\n  }\n\n  /**\n   * Returns context for the given flattened index, including:\n   * - the corresponding cache\n   * - the cache level\n   * - the corresponding item (if loaded)\n   * - the item's index in the cache's items array\n   * - the page containing the item\n   *\n   * @param {number} flatIndex\n   */\n  getFlatIndexContext(flatIndex) {\n    return getFlatIndexContext(this.rootCache, flatIndex);\n  }\n\n  /**\n   * Returns context for the given item, including:\n   * - the cache containing the item\n   * - the cache level\n   * - the item\n   * - the item's index in the cache's items array\n   * - the item's flattened index\n   * - the item's sub-cache (if exists)\n   * - the page containing the item\n   *\n   * If the item isn't found, the method returns undefined.\n   */\n  getItemContext(item) {\n    return getItemContext({\n      getItemId: this.getItemId\n    }, this.rootCache, item);\n  }\n\n  /**\n   * Returns the flattened index for the item that the given indexes point to.\n   * Each index in the path array points to a sub-item of the previous index.\n   * Using `Infinity` as an index will point to the last item on the level.\n   *\n   * @param {number[]} path\n   * @return {number}\n   */\n  getFlatIndexByPath(path) {\n    return getFlatIndexByPath(this.rootCache, path);\n  }\n\n  /**\n   * Requests the data provider to load the page with the item corresponding\n   * to the given flattened index. If the item is already loaded, the method\n   * returns immediatelly.\n   *\n   * @param {number} flatIndex\n   */\n  ensureFlatIndexLoaded(flatIndex) {\n    const _this$getFlatIndexCon = this.getFlatIndexContext(flatIndex),\n      cache = _this$getFlatIndexCon.cache,\n      page = _this$getFlatIndexCon.page,\n      item = _this$getFlatIndexCon.item;\n    if (!this.__isItemLoaded(item)) {\n      this.__loadCachePage(cache, page);\n    }\n  }\n\n  /**\n   * Creates a sub-cache for the item corresponding to the given flattened index and\n   * requests the data provider to load the first page into the created sub-cache.\n   * If the sub-cache already exists, the method returns immediatelly.\n   *\n   * @param {number} flatIndex\n   */\n  ensureFlatIndexHierarchy(flatIndex) {\n    const _this$getFlatIndexCon2 = this.getFlatIndexContext(flatIndex),\n      cache = _this$getFlatIndexCon2.cache,\n      item = _this$getFlatIndexCon2.item,\n      index = _this$getFlatIndexCon2.index;\n    if (this.__isItemLoaded(item) && this.isExpanded(item) && !cache.getSubCache(index)) {\n      const subCache = cache.createSubCache(index);\n      this.__loadCachePage(subCache, 0);\n    }\n  }\n\n  /**\n   * Loads the first page into the root cache.\n   */\n  loadFirstPage() {\n    this.__loadCachePage(this.rootCache, 0);\n  }\n\n  /** @private */\n  __createRootCache(size) {\n    return new Cache(this.__cacheContext, this.pageSize, size);\n  }\n\n  /** @private */\n  __loadCachePage(cache, page) {\n    if (!this.dataProvider || cache.pendingRequests[page]) {\n      return;\n    }\n    let params = {\n      page,\n      pageSize: this.pageSize,\n      parentItem: cache.parentItem\n    };\n    if (this.dataProviderParams) {\n      params = _objectSpread(_objectSpread({}, params), this.dataProviderParams());\n    }\n    const callback = (items, size) => {\n      if (cache.pendingRequests[page] !== callback) {\n        return;\n      }\n      if (size !== undefined) {\n        cache.size = size;\n      } else if (params.parentItem) {\n        cache.size = items.length;\n      }\n      cache.setPage(page, items);\n      this.recalculateFlatSize();\n      this.dispatchEvent(new CustomEvent('page-received'));\n      delete cache.pendingRequests[page];\n      this.dispatchEvent(new CustomEvent('page-loaded'));\n    };\n    cache.pendingRequests[page] = callback;\n    this.dispatchEvent(new CustomEvent('page-requested'));\n    this.dataProvider(params, callback);\n  }\n\n  /** @private */\n  __isItemLoaded(item) {\n    if (this.isPlaceholder) {\n      return !this.isPlaceholder(item);\n    } else if (this.placeholder) {\n      return item !== this.placeholder;\n    }\n    return !!item;\n  }\n}","/**\n * @license\n * Copyright (c) 2015 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { DataProviderController } from '@vaadin/component-base/src/data-provider-controller/data-provider-controller.js';\nimport { ComboBoxPlaceholder } from './vaadin-combo-box-placeholder.js';\n\n/**\n * @polymerMixin\n */\nexport const ComboBoxDataProviderMixin = superClass => class DataProviderMixin extends superClass {\n  static get properties() {\n    return {\n      /**\n       * Number of items fetched at a time from the dataprovider.\n       * @attr {number} page-size\n       * @type {number}\n       */\n      pageSize: {\n        type: Number,\n        value: 50,\n        observer: '_pageSizeChanged',\n        sync: true\n      },\n      /**\n       * Total number of items.\n       * @type {number | undefined}\n       */\n      size: {\n        type: Number,\n        observer: '_sizeChanged',\n        sync: true\n      },\n      /**\n       * Function that provides items lazily. Receives arguments `params`, `callback`\n       *\n       * `params.page` Requested page index\n       *\n       * `params.pageSize` Current page size\n       *\n       * `params.filter` Currently applied filter\n       *\n       * `callback(items, size)` Callback function with arguments:\n       *   - `items` Current page of items\n       *   - `size` Total number of items.\n       * @type {ComboBoxDataProvider | undefined}\n       */\n      dataProvider: {\n        type: Object,\n        observer: '_dataProviderChanged',\n        sync: true\n      },\n      /** @private */\n      __dataProviderInitialized: {\n        type: Boolean,\n        value: false\n      },\n      /** @private */\n      __previousDataProviderFilter: {\n        type: String\n      }\n    };\n  }\n  static get observers() {\n    return ['_dataProviderFilterChanged(filter)', '_warnDataProviderValue(dataProvider, value)', '_ensureFirstPage(opened)'];\n  }\n  constructor() {\n    super();\n\n    /**\n     * @type {DataProviderController}\n     * @private\n     */\n    this.__dataProviderController = new DataProviderController(this, {\n      placeholder: new ComboBoxPlaceholder(),\n      isPlaceholder: item => item instanceof ComboBoxPlaceholder,\n      dataProviderParams: () => ({\n        filter: this.filter\n      })\n    });\n    this.__dataProviderController.addEventListener('page-requested', this.__onDataProviderPageRequested.bind(this));\n    this.__dataProviderController.addEventListener('page-loaded', this.__onDataProviderPageLoaded.bind(this));\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n    this._scroller.addEventListener('index-requested', e => {\n      if (!this._shouldFetchData()) {\n        return;\n      }\n      const index = e.detail.index;\n      if (index !== undefined) {\n        this.__dataProviderController.ensureFlatIndexLoaded(index);\n      }\n    });\n    this.__dataProviderInitialized = true;\n    if (this.dataProvider) {\n      this.requestContentUpdate();\n    }\n  }\n\n  /** @private */\n  _dataProviderFilterChanged(filter) {\n    if (this.__previousDataProviderFilter === undefined && filter === '') {\n      this.__previousDataProviderFilter = filter;\n      return;\n    }\n    if (this.__previousDataProviderFilter !== filter) {\n      this.__previousDataProviderFilter = filter;\n      this.__keepOverlayOpened = true;\n      this.size = undefined;\n      this.clearCache();\n      this.__keepOverlayOpened = false;\n    }\n  }\n\n  /** @protected */\n  _shouldFetchData() {\n    if (!this.dataProvider) {\n      return false;\n    }\n    return this.opened || this.filter && this.filter.length;\n  }\n\n  /** @private */\n  _ensureFirstPage(opened) {\n    if (!this._shouldFetchData() || !opened) {\n      return;\n    }\n    if (this._forceNextRequest || this.size === undefined) {\n      this._forceNextRequest = false;\n      this.__dataProviderController.loadFirstPage();\n    } else if (this.size > 0) {\n      this.__dataProviderController.ensureFlatIndexLoaded(0);\n    }\n  }\n\n  /** @private */\n  __onDataProviderPageRequested() {\n    this.loading = true;\n  }\n\n  /** @private */\n  __onDataProviderPageLoaded() {\n    // The controller adds new items to the cache through mutation,\n    // so we need to create a new array to trigger filteredItems observers.\n    const rootCache = this.__dataProviderController.rootCache;\n    rootCache.items = [...rootCache.items];\n    this.requestContentUpdate();\n    if (!this.opened && !this._isInputFocused()) {\n      this._commitValue();\n    }\n  }\n\n  /**\n   * Clears the cached pages and reloads data from dataprovider when needed.\n   */\n  clearCache() {\n    if (!this.dataProvider) {\n      return;\n    }\n    this.__dataProviderController.clearCache();\n    this.requestContentUpdate();\n    if (this._shouldFetchData()) {\n      this._forceNextRequest = false;\n      this.__dataProviderController.loadFirstPage();\n    } else {\n      this._forceNextRequest = true;\n    }\n  }\n\n  /**\n   * When the size change originates externally, synchronizes the new size with\n   * the controller and request a content update to re-render the scroller.\n   *\n   * @private\n   */\n  _sizeChanged(size) {\n    const rootCache = this.__dataProviderController.rootCache;\n    if (rootCache.size !== size) {\n      rootCache.size = size;\n      // The controller adds new placeholders to the cache through mutation,\n      // so we need to create a new array to trigger filteredItems observers.\n      rootCache.items = [...rootCache.items];\n      this.requestContentUpdate();\n    }\n  }\n\n  /**\n   * When the items change originates externally, synchronizes the new items with\n   * the controller and requests a content update to re-render the scroller.\n   *\n   * @private\n   * @override\n   */\n  _filteredItemsChanged(items) {\n    super._filteredItemsChanged(items);\n    if (this.dataProvider && items) {\n      const rootCache = this.__dataProviderController.rootCache;\n      if (rootCache.items !== items) {\n        rootCache.items = items;\n        this.requestContentUpdate();\n      }\n    }\n  }\n\n  /**\n   * Synchronizes the controller's state with the component, which can be\n   * out of sync after the controller receives new data from the data provider\n   * or if the state in the controller is directly manupulated.\n   *\n   * @override\n   */\n  requestContentUpdate() {\n    // When the data provider isn't initialized, it means the content update was requested\n    // by an observer before the `ready()` callback. In such cases, some properties\n    // in the data provider controller might still be uninitialized, so it's not safe\n    // to use them to update the component's properties yet. Another content update\n    // will be requested in the `ready()` callback.\n    if (this.__dataProviderInitialized && this.dataProvider) {\n      const rootCache = this.__dataProviderController.rootCache;\n      this.size = rootCache.size;\n      this.filteredItems = rootCache.items;\n      this.loading = this.__dataProviderController.isLoading();\n    }\n    super.requestContentUpdate();\n  }\n\n  /** @private */\n  _pageSizeChanged(pageSize, oldPageSize) {\n    if (Math.floor(pageSize) !== pageSize || pageSize < 1) {\n      this.pageSize = oldPageSize;\n      throw new Error('`pageSize` value must be an integer > 0');\n    }\n    this.__dataProviderController.setPageSize(pageSize);\n    this.clearCache();\n  }\n\n  /** @private */\n  _dataProviderChanged(dataProvider, oldDataProvider) {\n    this._ensureItemsOrDataProvider(() => {\n      this.dataProvider = oldDataProvider;\n    });\n    this.__dataProviderController.setDataProvider(dataProvider);\n    this.clearCache();\n  }\n\n  /** @private */\n  _ensureItemsOrDataProvider(restoreOldValueCallback) {\n    if (this.items !== undefined && this.dataProvider !== undefined) {\n      restoreOldValueCallback();\n      throw new Error('Using `items` and `dataProvider` together is not supported');\n    }\n  }\n\n  /** @private */\n  _warnDataProviderValue(dataProvider, value) {\n    if (dataProvider && value !== '' && (this.selectedItem === undefined || this.selectedItem === null)) {\n      const valueIndex = this.__getItemIndexByValue(this.filteredItems, value);\n      if (valueIndex < 0 || !this._getItemLabel(this.filteredItems[valueIndex])) {\n        console.warn('Warning: unable to determine the label for the provided `value`. ' + 'Nothing to display in the text field. This usually happens when ' + 'setting an initial `value` before any items are returned from ' + 'the `dataProvider` callback. Consider setting `selectedItem` ' + 'instead of `value`');\n      }\n    }\n  }\n};","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';\n\n/**\n * A mixin to provide disabled property for field components.\n *\n * @polymerMixin\n */\nexport const DisabledMixin = dedupingMixin(superclass => class DisabledMixinClass extends superclass {\n  static get properties() {\n    return {\n      /**\n       * If true, the user cannot interact with this element.\n       */\n      disabled: {\n        type: Boolean,\n        value: false,\n        observer: '_disabledChanged',\n        reflectToAttribute: true\n      }\n    };\n  }\n\n  /**\n   * @param {boolean} disabled\n   * @protected\n   */\n  _disabledChanged(disabled) {\n    this._setAriaDisabled(disabled);\n  }\n\n  /**\n   * @param {boolean} disabled\n   * @protected\n   */\n  _setAriaDisabled(disabled) {\n    if (disabled) {\n      this.setAttribute('aria-disabled', 'true');\n    } else {\n      this.removeAttribute('aria-disabled');\n    }\n  }\n\n  /**\n   * Overrides the default element `click` method in order to prevent\n   * firing the `click` event when the element is disabled.\n   * @protected\n   * @override\n   */\n  click() {\n    if (!this.disabled) {\n      super.click();\n    }\n  }\n});","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';\nimport { isKeyboardActive } from './focus-utils.js';\n\n/**\n * A mixin to handle `focused` and `focus-ring` attributes based on focus.\n *\n * @polymerMixin\n */\nexport const FocusMixin = dedupingMixin(superclass => class FocusMixinClass extends superclass {\n  /**\n   * @protected\n   * @return {boolean}\n   */\n  get _keyboardActive() {\n    return isKeyboardActive();\n  }\n\n  /** @protected */\n  ready() {\n    this.addEventListener('focusin', e => {\n      if (this._shouldSetFocus(e)) {\n        this._setFocused(true);\n      }\n    });\n    this.addEventListener('focusout', e => {\n      if (this._shouldRemoveFocus(e)) {\n        this._setFocused(false);\n      }\n    });\n\n    // In super.ready() other 'focusin' and 'focusout' listeners might be\n    // added, so we call it after our own ones to ensure they execute first.\n    // Issue to watch out: when incorrect, <vaadin-combo-box> refocuses the\n    // input field on iOS after \"Done\" is pressed.\n    super.ready();\n  }\n\n  /** @protected */\n  disconnectedCallback() {\n    super.disconnectedCallback();\n\n    // In non-Chrome browsers, blur does not fire on the element when it is disconnected.\n    // reproducible in `<vaadin-date-picker>` when closing on `Cancel` or `Today` click.\n    if (this.hasAttribute('focused')) {\n      this._setFocused(false);\n    }\n  }\n\n  /**\n   * Override to change how focused and focus-ring attributes are set.\n   *\n   * @param {boolean} focused\n   * @protected\n   */\n  _setFocused(focused) {\n    this.toggleAttribute('focused', focused);\n\n    // Focus-ring is true when the element was focused from the keyboard.\n    // Focus Ring [A11ycasts]: https://youtu.be/ilj2P5-5CjI\n    this.toggleAttribute('focus-ring', focused && this._keyboardActive);\n  }\n\n  /**\n   * Override to define if the field receives focus based on the event.\n   *\n   * @param {FocusEvent} _event\n   * @return {boolean}\n   * @protected\n   */\n  _shouldSetFocus(_event) {\n    return true;\n  }\n\n  /**\n   * Override to define if the field loses focus based on the event.\n   *\n   * @param {FocusEvent} _event\n   * @return {boolean}\n   * @protected\n   */\n  _shouldRemoveFocus(_event) {\n    return true;\n  }\n});","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';\n\n/**\n * A mixin that manages keyboard handling.\n * The mixin subscribes to the keyboard events while an actual implementation\n * for the event handlers is left to the client (a component or another mixin).\n *\n * @polymerMixin\n */\nexport const KeyboardMixin = dedupingMixin(superclass => class KeyboardMixinClass extends superclass {\n  /** @protected */\n  ready() {\n    super.ready();\n    this.addEventListener('keydown', event => {\n      this._onKeyDown(event);\n    });\n    this.addEventListener('keyup', event => {\n      this._onKeyUp(event);\n    });\n  }\n\n  /**\n   * A handler for the `keydown` event. By default, it calls\n   * separate methods for handling \"Enter\" and \"Escape\" keys.\n   * Override the method to implement your own behavior.\n   *\n   * @param {KeyboardEvent} event\n   * @protected\n   */\n  _onKeyDown(event) {\n    switch (event.key) {\n      case 'Enter':\n        this._onEnter(event);\n        break;\n      case 'Escape':\n        this._onEscape(event);\n        break;\n      default:\n        break;\n    }\n  }\n\n  /**\n   * A handler for the `keyup` event. By default, it does nothing.\n   * Override the method to implement your own behavior.\n   *\n   * @param {KeyboardEvent} _event\n   * @protected\n   */\n  _onKeyUp(_event) {\n    // To be implemented.\n  }\n\n  /**\n   * A handler for the \"Enter\" key. By default, it does nothing.\n   * Override the method to implement your own behavior.\n   *\n   * @param {KeyboardEvent} _event\n   * @protected\n   */\n  _onEnter(_event) {\n    // To be implemented.\n  }\n\n  /**\n   * A handler for the \"Escape\" key. By default, it does nothing.\n   * Override the method to implement your own behavior.\n   *\n   * @param {KeyboardEvent} _event\n   * @protected\n   */\n  _onEscape(_event) {\n    // To be implemented.\n  }\n});","/**\n * @license\n * Copyright (c) 2023 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n/**\n * A mixin that forwards CSS class names to the internal overlay element\n * by setting the `overlayClass` property or `overlay-class` attribute.\n *\n * @polymerMixin\n */\nexport const OverlayClassMixin = superclass => class OverlayClassMixinClass extends superclass {\n  static get properties() {\n    return {\n      /**\n       * A space-delimited list of CSS class names to set on the overlay element.\n       * This property does not affect other CSS class names set manually via JS.\n       *\n       * Note, if the CSS class name was set with this property, clearing it will\n       * remove it from the overlay, even if the same class name was also added\n       * manually, e.g. by using `classList.add()` in the `renderer` function.\n       *\n       * @attr {string} overlay-class\n       */\n      overlayClass: {\n        type: String\n      },\n      /**\n       * An overlay element on which CSS class names are set.\n       *\n       * @protected\n       */\n      _overlayElement: {\n        type: Object\n      }\n    };\n  }\n  static get observers() {\n    return ['__updateOverlayClassNames(overlayClass, _overlayElement)'];\n  }\n\n  /** @private */\n  __updateOverlayClassNames(overlayClass, overlayElement) {\n    if (!overlayElement) {\n      return;\n    }\n\n    // Overlay is set but overlayClass is not set\n    if (overlayClass === undefined) {\n      return;\n    }\n    const classList = overlayElement.classList;\n    if (!this.__initialClasses) {\n      this.__initialClasses = new Set(classList);\n    }\n    if (Array.isArray(this.__previousClasses)) {\n      // Remove old classes that no longer apply\n      const classesToRemove = this.__previousClasses.filter(name => !this.__initialClasses.has(name));\n      if (classesToRemove.length > 0) {\n        classList.remove(...classesToRemove);\n      }\n    }\n\n    // Add new classes based on the overlayClass\n    const classesToAdd = typeof overlayClass === 'string' ? overlayClass.split(' ').filter(Boolean) : [];\n    if (classesToAdd.length > 0) {\n      classList.add(...classesToAdd);\n    }\n    this.__previousClasses = classesToAdd;\n  }\n};","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n/**\n * Passes the component to the template renderer callback if the template renderer is imported.\n * Otherwise, if there is a template, it warns that the template renderer needs to be imported.\n *\n * @param {HTMLElement} component\n */\nexport function processTemplates(component) {\n  if (window.Vaadin && window.Vaadin.templateRendererCallback) {\n    window.Vaadin.templateRendererCallback(component);\n    return;\n  }\n  if (component.querySelector('template')) {\n    console.warn(`WARNING: <template> inside <${component.localName}> is no longer supported. Import @vaadin/polymer-legacy-adapter/template-renderer.js to enable compatibility.`);\n  }\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';\n\n/**\n * A mixin to store the reference to an input element\n * and add input and change event listeners to it.\n *\n * @polymerMixin\n */\nexport const InputMixin = dedupingMixin(superclass => class InputMixinClass extends superclass {\n  static get properties() {\n    return {\n      /**\n       * A reference to the input element controlled by the mixin.\n       * Any component implementing this mixin is expected to provide it\n       * by using `this._setInputElement(input)` Polymer API.\n       *\n       * A typical case is using `InputController` that does this automatically.\n       * However, the input element does not have to always be native <input>:\n       * as an example, <vaadin-combo-box-light> accepts other components.\n       *\n       * @protected\n       * @type {!HTMLElement}\n       */\n      inputElement: {\n        type: Object,\n        readOnly: true,\n        observer: '_inputElementChanged'\n      },\n      /**\n       * String used to define input type.\n       * @protected\n       */\n      type: {\n        type: String,\n        readOnly: true\n      },\n      /**\n       * The value of the field.\n       */\n      value: {\n        type: String,\n        value: '',\n        observer: '_valueChanged',\n        notify: true,\n        sync: true\n      },\n      /**\n       * Whether the input element has a non-empty value.\n       *\n       * @protected\n       */\n      _hasInputValue: {\n        type: Boolean,\n        value: false,\n        observer: '_hasInputValueChanged'\n      }\n    };\n  }\n  constructor() {\n    super();\n    this._boundOnInput = this.__onInput.bind(this);\n    this._boundOnChange = this._onChange.bind(this);\n  }\n\n  /**\n   * Indicates whether the value is different from the default one.\n   * Override if the `value` property has a type other than `string`.\n   *\n   * @protected\n   */\n  get _hasValue() {\n    return this.value != null && this.value !== '';\n  }\n\n  /**\n   * A property for accessing the input element's value.\n   *\n   * Override this getter if the property is different from the default `value` one.\n   *\n   * @protected\n   * @return {string}\n   */\n  get _inputElementValueProperty() {\n    return 'value';\n  }\n\n  /**\n   * The input element's value.\n   *\n   * @protected\n   * @return {string}\n   */\n  get _inputElementValue() {\n    return this.inputElement ? this.inputElement[this._inputElementValueProperty] : undefined;\n  }\n\n  /**\n   * The input element's value.\n   *\n   * @protected\n   */\n  set _inputElementValue(value) {\n    if (this.inputElement) {\n      this.inputElement[this._inputElementValueProperty] = value;\n    }\n  }\n\n  /**\n   * Clear the value of the field.\n   */\n  clear() {\n    this._hasInputValue = false;\n    this.value = '';\n\n    // Clear the input immediately without waiting for the observer.\n    // Otherwise, when using Lit, the old value would be restored.\n    this._inputElementValue = '';\n  }\n\n  /**\n   * Add event listeners to the input element instance.\n   * Override this method to add custom listeners.\n   * @param {!HTMLElement} input\n   * @protected\n   */\n  _addInputListeners(input) {\n    input.addEventListener('input', this._boundOnInput);\n    input.addEventListener('change', this._boundOnChange);\n  }\n\n  /**\n   * Remove event listeners from the input element instance.\n   * @param {!HTMLElement} input\n   * @protected\n   */\n  _removeInputListeners(input) {\n    input.removeEventListener('input', this._boundOnInput);\n    input.removeEventListener('change', this._boundOnChange);\n  }\n\n  /**\n   * A method to forward the value property set on the field\n   * programmatically back to the input element value.\n   * Override this method to perform additional checks,\n   * for example to skip this in certain conditions.\n   * @param {string} value\n   * @protected\n   */\n  _forwardInputValue(value) {\n    // Value might be set before an input element is initialized.\n    // This case should be handled separately by a component that\n    // implements this mixin, for example in `connectedCallback`.\n    if (!this.inputElement) {\n      return;\n    }\n    this._inputElementValue = value != null ? value : '';\n  }\n\n  /**\n   * @param {HTMLElement | undefined} input\n   * @param {HTMLElement | undefined} oldInput\n   * @protected\n   */\n  _inputElementChanged(input, oldInput) {\n    if (input) {\n      this._addInputListeners(input);\n    } else if (oldInput) {\n      this._removeInputListeners(oldInput);\n    }\n  }\n\n  /**\n   * Observer to notify about the change of private property.\n   *\n   * @private\n   */\n  _hasInputValueChanged(hasValue, oldHasValue) {\n    if (hasValue || oldHasValue) {\n      this.dispatchEvent(new CustomEvent('has-input-value-changed'));\n    }\n  }\n\n  /**\n   * An input event listener used to update `_hasInputValue` property.\n   * Do not override this method.\n   *\n   * @param {Event} event\n   * @private\n   */\n  __onInput(event) {\n    this._setHasInputValue(event);\n    this._onInput(event);\n  }\n\n  /**\n   * An input event listener used to update the field value.\n   *\n   * @param {Event} event\n   * @protected\n   */\n  _onInput(event) {\n    // In the case a custom web component is passed as `inputElement`,\n    // the actual native input element, on which the event occurred,\n    // can be inside shadow trees.\n    const target = event.composedPath()[0];\n    // Ignore fake input events e.g. used by clear button.\n    this.__userInput = event.isTrusted;\n    this.value = target.value;\n    this.__userInput = false;\n  }\n\n  /**\n   * A change event listener.\n   * Override this method with an actual implementation.\n   * @param {Event} _event\n   * @protected\n   */\n  _onChange(_event) {}\n\n  /**\n   * Toggle the has-value attribute based on the value property.\n   *\n   * @param {boolean} hasValue\n   * @protected\n   */\n  _toggleHasValue(hasValue) {\n    this.toggleAttribute('has-value', hasValue);\n  }\n\n  /**\n   * Observer called when a value property changes.\n   * @param {string | undefined} newVal\n   * @param {string | undefined} oldVal\n   * @protected\n   */\n  _valueChanged(newVal, oldVal) {\n    this._toggleHasValue(this._hasValue);\n\n    // Setting initial value to empty string, do nothing.\n    if (newVal === '' && oldVal === undefined) {\n      return;\n    }\n\n    // Value is set by the user, no need to sync it back to input.\n    if (this.__userInput) {\n      return;\n    }\n\n    // Setting a value programmatically, sync it to input element.\n    this._forwardInputValue(newVal);\n  }\n\n  /**\n   * Sets the `_hasInputValue` property based on the `input` event.\n   *\n   * @param {InputEvent} event\n   * @protected\n   */\n  _setHasInputValue(event) {\n    // In the case a custom web component is passed as `inputElement`,\n    // the actual native input element, on which the event occurred,\n    // can be inside shadow trees.\n    const target = event.composedPath()[0];\n    this._hasInputValue = target.value.length > 0;\n  }\n});","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';\n\n/**\n * A mixin to provide required state and validation logic.\n *\n * @polymerMixin\n */\nexport const ValidateMixin = dedupingMixin(superclass => class ValidateMixinClass extends superclass {\n  static get properties() {\n    return {\n      /**\n       * Set to true when the field is invalid.\n       */\n      invalid: {\n        type: Boolean,\n        reflectToAttribute: true,\n        notify: true,\n        value: false\n      },\n      /**\n       * Specifies that the user must fill in a value.\n       */\n      required: {\n        type: Boolean,\n        reflectToAttribute: true\n      }\n    };\n  }\n\n  /**\n   * Validates the field and sets the `invalid` property based on the result.\n   *\n   * The method fires a `validated` event with the result of the validation.\n   *\n   * @return {boolean} True if the value is valid.\n   */\n  validate() {\n    const isValid = this.checkValidity();\n    this._setInvalid(!isValid);\n    this.dispatchEvent(new CustomEvent('validated', {\n      detail: {\n        valid: isValid\n      }\n    }));\n    return isValid;\n  }\n\n  /**\n   * Returns true if the field value satisfies all constraints (if any).\n   *\n   * @return {boolean}\n   */\n  checkValidity() {\n    return !this.required || !!this.value;\n  }\n\n  /**\n   * @param {boolean} invalid\n   * @protected\n   */\n  _setInvalid(invalid) {\n    if (this._shouldSetInvalid(invalid)) {\n      this.invalid = invalid;\n    }\n  }\n\n  /**\n   * Override this method to define whether the given `invalid` state should be set.\n   *\n   * @param {boolean} _invalid\n   * @return {boolean}\n   * @protected\n   */\n  _shouldSetInvalid(_invalid) {\n    return true;\n  }\n\n  /**\n   * Fired whenever the field is validated.\n   *\n   * @event validated\n   * @param {Object} detail\n   * @param {boolean} detail.valid the result of the validation.\n   */\n});","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n/**\n * A controller which prevents the virtual keyboard from showing up on mobile devices\n * when the field's overlay is closed.\n */\nexport class VirtualKeyboardController {\n  /**\n   * @param {{ inputElement?: HTMLElement; opened: boolean } & HTMLElement} host\n   */\n  constructor(host) {\n    this.host = host;\n    host.addEventListener('opened-changed', () => {\n      if (!host.opened) {\n        // Prevent opening the virtual keyboard when the input gets re-focused on dropdown close\n        this.__setVirtualKeyboardEnabled(false);\n      }\n    });\n\n    // Re-enable virtual keyboard on blur, so it gets opened when the field is focused again\n    host.addEventListener('blur', () => this.__setVirtualKeyboardEnabled(true));\n\n    // Re-enable the virtual keyboard whenever the field is touched\n    host.addEventListener('touchstart', () => this.__setVirtualKeyboardEnabled(true));\n  }\n\n  /** @private */\n  __setVirtualKeyboardEnabled(value) {\n    if (this.host.inputElement) {\n      this.host.inputElement.inputMode = value ? '' : 'none';\n    }\n  }\n}","/**\n * @license\n * Copyright (c) 2015 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { DisabledMixin } from '@vaadin/a11y-base/src/disabled-mixin.js';\nimport { FocusMixin } from '@vaadin/a11y-base/src/focus-mixin.js';\nimport { isElementFocused, isKeyboardActive } from '@vaadin/a11y-base/src/focus-utils.js';\nimport { KeyboardMixin } from '@vaadin/a11y-base/src/keyboard-mixin.js';\nimport { isTouch } from '@vaadin/component-base/src/browser-utils.js';\nimport { ControllerMixin } from '@vaadin/component-base/src/controller-mixin.js';\nimport { OverlayClassMixin } from '@vaadin/component-base/src/overlay-class-mixin.js';\nimport { get } from '@vaadin/component-base/src/path-utils.js';\nimport { processTemplates } from '@vaadin/component-base/src/templates.js';\nimport { InputMixin } from '@vaadin/field-base/src/input-mixin.js';\nimport { ValidateMixin } from '@vaadin/field-base/src/validate-mixin.js';\nimport { VirtualKeyboardController } from '@vaadin/field-base/src/virtual-keyboard-controller.js';\nimport { ComboBoxPlaceholder } from './vaadin-combo-box-placeholder.js';\n\n/**\n * Checks if the value is supported as an item value in this control.\n *\n * @param {unknown} value\n * @return {boolean}\n */\nfunction isValidValue(value) {\n  return value !== undefined && value !== null;\n}\n\n/**\n * Returns the index of the first item that satisfies the provided testing function\n * ignoring placeholder items.\n *\n * @param {Array<ComboBoxItem | string>} items\n * @param {Function} callback\n * @return {number}\n */\nfunction findItemIndex(items, callback) {\n  return items.findIndex(item => {\n    if (item instanceof ComboBoxPlaceholder) {\n      return false;\n    }\n    return callback(item);\n  });\n}\n\n/**\n * @polymerMixin\n * @mixes ControllerMixin\n * @mixes ValidateMixin\n * @mixes DisabledMixin\n * @mixes InputMixin\n * @mixes KeyboardMixin\n * @mixes FocusMixin\n * @mixes OverlayClassMixin\n * @param {function(new:HTMLElement)} subclass\n */\nexport const ComboBoxMixin = subclass => class ComboBoxMixinClass extends OverlayClassMixin(ControllerMixin(ValidateMixin(FocusMixin(KeyboardMixin(InputMixin(DisabledMixin(subclass))))))) {\n  static get properties() {\n    return {\n      /**\n       * True if the dropdown is open, false otherwise.\n       * @type {boolean}\n       */\n      opened: {\n        type: Boolean,\n        notify: true,\n        value: false,\n        reflectToAttribute: true,\n        sync: true,\n        observer: '_openedChanged'\n      },\n      /**\n       * Set true to prevent the overlay from opening automatically.\n       * @attr {boolean} auto-open-disabled\n       */\n      autoOpenDisabled: {\n        type: Boolean,\n        sync: true\n      },\n      /**\n       * When present, it specifies that the field is read-only.\n       * @type {boolean}\n       */\n      readonly: {\n        type: Boolean,\n        value: false,\n        reflectToAttribute: true\n      },\n      /**\n       * Custom function for rendering the content of every item.\n       * Receives three arguments:\n       *\n       * - `root` The `<vaadin-combo-box-item>` internal container DOM element.\n       * - `comboBox` The reference to the `<vaadin-combo-box>` element.\n       * - `model` The object with the properties related with the rendered\n       *   item, contains:\n       *   - `model.index` The index of the rendered item.\n       *   - `model.item` The item.\n       * @type {ComboBoxRenderer | undefined}\n       */\n      renderer: {\n        type: Object,\n        sync: true\n      },\n      /**\n       * A full set of items to filter the visible options from.\n       * The items can be of either `String` or `Object` type.\n       * @type {!Array<!ComboBoxItem | string> | undefined}\n       */\n      items: {\n        type: Array,\n        sync: true,\n        observer: '_itemsChanged'\n      },\n      /**\n       * If `true`, the user can input a value that is not present in the items list.\n       * `value` property will be set to the input value in this case.\n       * Also, when `value` is set programmatically, the input value will be set\n       * to reflect that value.\n       * @attr {boolean} allow-custom-value\n       * @type {boolean}\n       */\n      allowCustomValue: {\n        type: Boolean,\n        value: false\n      },\n      /**\n       * A subset of items, filtered based on the user input. Filtered items\n       * can be assigned directly to omit the internal filtering functionality.\n       * The items can be of either `String` or `Object` type.\n       * @type {!Array<!ComboBoxItem | string> | undefined}\n       */\n      filteredItems: {\n        type: Array,\n        observer: '_filteredItemsChanged',\n        sync: true\n      },\n      /**\n       * Used to detect user value changes and fire `change` events.\n       * @private\n       */\n      _lastCommittedValue: String,\n      /**\n       * When set to `true`, \"loading\" attribute is added to host and the overlay element.\n       * @type {boolean}\n       */\n      loading: {\n        type: Boolean,\n        value: false,\n        reflectToAttribute: true,\n        sync: true\n      },\n      /**\n       * @type {number}\n       * @protected\n       */\n      _focusedIndex: {\n        type: Number,\n        observer: '_focusedIndexChanged',\n        value: -1,\n        sync: true\n      },\n      /**\n       * Filtering string the user has typed into the input field.\n       * @type {string}\n       */\n      filter: {\n        type: String,\n        value: '',\n        notify: true,\n        sync: true\n      },\n      /**\n       * The selected item from the `items` array.\n       * @type {ComboBoxItem | string | undefined}\n       */\n      selectedItem: {\n        type: Object,\n        notify: true,\n        sync: true\n      },\n      /**\n       * A function used to generate CSS class names for dropdown\n       * items based on the item. The return value should be the\n       * generated class name as a string, or multiple class names\n       * separated by whitespace characters.\n       */\n      itemClassNameGenerator: {\n        type: Object\n      },\n      /**\n       * Path for label of the item. If `items` is an array of objects, the\n       * `itemLabelPath` is used to fetch the displayed string label for each\n       * item.\n       *\n       * The item label is also used for matching items when processing user\n       * input, i.e., for filtering and selecting items.\n       * @attr {string} item-label-path\n       * @type {string}\n       */\n      itemLabelPath: {\n        type: String,\n        value: 'label',\n        observer: '_itemLabelPathChanged',\n        sync: true\n      },\n      /**\n       * Path for the value of the item. If `items` is an array of objects, the\n       * `itemValuePath:` is used to fetch the string value for the selected\n       * item.\n       *\n       * The item value is used in the `value` property of the combo box,\n       * to provide the form value.\n       * @attr {string} item-value-path\n       * @type {string}\n       */\n      itemValuePath: {\n        type: String,\n        value: 'value',\n        sync: true\n      },\n      /**\n       * Path for the id of the item. If `items` is an array of objects,\n       * the `itemIdPath` is used to compare and identify the same item\n       * in `selectedItem` and `filteredItems` (items given by the\n       * `dataProvider` callback).\n       * @attr {string} item-id-path\n       */\n      itemIdPath: {\n        type: String,\n        sync: true\n      },\n      /**\n       * @type {!HTMLElement | undefined}\n       * @protected\n       */\n      _toggleElement: {\n        type: Object,\n        observer: '_toggleElementChanged'\n      },\n      /**\n       * Set of items to be rendered in the dropdown.\n       * @protected\n       */\n      _dropdownItems: {\n        type: Array,\n        sync: true\n      },\n      /** @private */\n      _closeOnBlurIsPrevented: Boolean,\n      /** @private */\n      _scroller: {\n        type: Object,\n        sync: true\n      },\n      /** @private */\n      _overlayOpened: {\n        type: Boolean,\n        sync: true,\n        observer: '_overlayOpenedChanged'\n      },\n      /** @private */\n      __keepOverlayOpened: {\n        type: Boolean,\n        sync: true\n      }\n    };\n  }\n  static get observers() {\n    return ['_selectedItemChanged(selectedItem, itemValuePath, itemLabelPath)', '_openedOrItemsChanged(opened, _dropdownItems, loading, __keepOverlayOpened)', '_updateScroller(_scroller, _dropdownItems, opened, loading, selectedItem, itemIdPath, _focusedIndex, renderer, _theme, itemClassNameGenerator)'];\n  }\n  constructor() {\n    super();\n    this._boundOverlaySelectedItemChanged = this._overlaySelectedItemChanged.bind(this);\n    this._boundOnClearButtonMouseDown = this.__onClearButtonMouseDown.bind(this);\n    this._boundOnClick = this._onClick.bind(this);\n    this._boundOnOverlayTouchAction = this._onOverlayTouchAction.bind(this);\n    this._boundOnTouchend = this._onTouchend.bind(this);\n  }\n\n  /**\n   * Tag name prefix used by scroller and items.\n   * @protected\n   * @return {string}\n   */\n  get _tagNamePrefix() {\n    return 'vaadin-combo-box';\n  }\n\n  /**\n   * Get a reference to the native `<input>` element.\n   * Override to provide a custom input.\n   * @protected\n   * @return {HTMLInputElement | undefined}\n   */\n  get _nativeInput() {\n    return this.inputElement;\n  }\n\n  /**\n   * Override method inherited from `InputMixin`\n   * to customize the input element.\n   * @protected\n   * @override\n   */\n  _inputElementChanged(inputElement) {\n    super._inputElementChanged(inputElement);\n    const input = this._nativeInput;\n    if (input) {\n      input.autocomplete = 'off';\n      input.autocapitalize = 'off';\n      input.setAttribute('role', 'combobox');\n      input.setAttribute('aria-autocomplete', 'list');\n      input.setAttribute('aria-expanded', !!this.opened);\n\n      // Disable the macOS Safari spell check auto corrections.\n      input.setAttribute('spellcheck', 'false');\n\n      // Disable iOS autocorrect suggestions.\n      input.setAttribute('autocorrect', 'off');\n      this._revertInputValueToValue();\n      if (this.clearElement) {\n        this.clearElement.addEventListener('mousedown', this._boundOnClearButtonMouseDown);\n      }\n    }\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n    this._initOverlay();\n    this._initScroller();\n    this._lastCommittedValue = this.value;\n    this.addEventListener('click', this._boundOnClick);\n    this.addEventListener('touchend', this._boundOnTouchend);\n    const bringToFrontListener = () => {\n      requestAnimationFrame(() => {\n        this._overlayElement.bringToFront();\n      });\n    };\n    this.addEventListener('mousedown', bringToFrontListener);\n    this.addEventListener('touchstart', bringToFrontListener);\n    processTemplates(this);\n    this.addController(new VirtualKeyboardController(this));\n  }\n\n  /** @protected */\n  disconnectedCallback() {\n    super.disconnectedCallback();\n\n    // Close the overlay on detach\n    this.close();\n  }\n\n  /**\n   * Requests an update for the content of items.\n   * While performing the update, it invokes the renderer (passed in the `renderer` property) once an item.\n   *\n   * It is not guaranteed that the update happens immediately (synchronously) after it is requested.\n   */\n  requestContentUpdate() {\n    if (!this._scroller) {\n      return;\n    }\n    this._scroller.requestContentUpdate();\n    this._getItemElements().forEach(item => {\n      item.requestContentUpdate();\n    });\n  }\n\n  /**\n   * Opens the dropdown list.\n   */\n  open() {\n    // Prevent _open() being called when input is disabled or read-only\n    if (!this.disabled && !this.readonly) {\n      this.opened = true;\n    }\n  }\n\n  /**\n   * Closes the dropdown list.\n   */\n  close() {\n    this.opened = false;\n  }\n\n  /**\n   * Override Polymer lifecycle callback to handle `filter` property change after\n   * the observer for `opened` property is triggered. This is needed when opening\n   * combo-box on user input to ensure the focused index is set correctly.\n   *\n   * @param {!Object} currentProps Current accessor values\n   * @param {?Object} changedProps Properties changed since the last call\n   * @param {?Object} oldProps Previous values for each changed property\n   * @protected\n   * @override\n   */\n  _propertiesChanged(currentProps, changedProps, oldProps) {\n    super._propertiesChanged(currentProps, changedProps, oldProps);\n    if (changedProps.filter !== undefined) {\n      this._filterChanged(changedProps.filter);\n    }\n  }\n\n  /**\n   * Override LitElement lifecycle callback to handle filter property change.\n   * @param {Object} props\n   */\n  updated(props) {\n    super.updated(props);\n    if (props.has('filter')) {\n      this._filterChanged(this.filter);\n    }\n  }\n\n  /** @private */\n  _initOverlay() {\n    const overlay = this.$.overlay;\n\n    // Store instance for detecting \"dir\" attribute on opening\n    overlay._comboBox = this;\n    overlay.addEventListener('touchend', this._boundOnOverlayTouchAction);\n    overlay.addEventListener('touchmove', this._boundOnOverlayTouchAction);\n\n    // Prevent blurring the input when clicking inside the overlay\n    overlay.addEventListener('mousedown', e => e.preventDefault());\n\n    // Manual two-way binding for the overlay \"opened\" property\n    overlay.addEventListener('opened-changed', e => {\n      this._overlayOpened = e.detail.value;\n    });\n    this._overlayElement = overlay;\n  }\n\n  /**\n   * Create and initialize the scroller element.\n   * Override to provide custom host reference.\n   *\n   * @protected\n   */\n  _initScroller(host) {\n    const scroller = document.createElement(`${this._tagNamePrefix}-scroller`);\n    scroller.owner = host || this;\n    scroller.getItemLabel = this._getItemLabel.bind(this);\n    scroller.addEventListener('selection-changed', this._boundOverlaySelectedItemChanged);\n    const overlay = this._overlayElement;\n    overlay.renderer = root => {\n      if (!root.innerHTML) {\n        root.appendChild(scroller);\n      }\n    };\n\n    // Ensure the scroller is rendered\n    overlay.requestContentUpdate();\n\n    // Trigger the observer to set properties\n    this._scroller = scroller;\n  }\n\n  /** @private */\n  // eslint-disable-next-line @typescript-eslint/max-params\n  _updateScroller(scroller, items, opened, loading, selectedItem, itemIdPath, focusedIndex, renderer, theme, itemClassNameGenerator) {\n    if (scroller) {\n      if (opened) {\n        scroller.style.maxHeight = getComputedStyle(this).getPropertyValue(`--${this._tagNamePrefix}-overlay-max-height`) || '65vh';\n      }\n      scroller.setProperties({\n        items: opened ? items : [],\n        opened,\n        loading,\n        selectedItem,\n        itemIdPath,\n        focusedIndex,\n        renderer,\n        theme,\n        itemClassNameGenerator\n      });\n\n      // NOTE: in PolylitMixin, setProperties() waits for `hasUpdated` to be set.\n      // This means for the first opening, properties won't be set synchronously.\n      // Call `performUpdate()` in this case to mimic the Polymer version logic.\n      if (scroller.performUpdate && !scroller.hasUpdated) {\n        try {\n          scroller.performUpdate();\n        } catch (_) {\n          // Suppress errors in synchronous tests for pre-opened combo-box.\n        }\n      }\n    }\n  }\n\n  /** @private */\n  _openedOrItemsChanged(opened, items, loading, keepOverlayOpened) {\n    // Close the overlay if there are no items to display.\n    // See https://github.com/vaadin/vaadin-combo-box/pull/964\n    this._overlayOpened = opened && (keepOverlayOpened || loading || !!(items && items.length));\n  }\n\n  /** @private */\n  _overlayOpenedChanged(opened, wasOpened) {\n    if (opened) {\n      this.dispatchEvent(new CustomEvent('vaadin-combo-box-dropdown-opened', {\n        bubbles: true,\n        composed: true\n      }));\n      this._onOpened();\n    } else if (wasOpened && this._dropdownItems && this._dropdownItems.length) {\n      this.close();\n      this.dispatchEvent(new CustomEvent('vaadin-combo-box-dropdown-closed', {\n        bubbles: true,\n        composed: true\n      }));\n    }\n  }\n\n  /** @private */\n  _focusedIndexChanged(index, oldIndex) {\n    if (oldIndex === undefined) {\n      return;\n    }\n    this._updateActiveDescendant(index);\n  }\n\n  /** @protected */\n  _isInputFocused() {\n    return this.inputElement && isElementFocused(this.inputElement);\n  }\n\n  /** @private */\n  _updateActiveDescendant(index) {\n    const input = this._nativeInput;\n    if (!input) {\n      return;\n    }\n    const item = this._getItemElements().find(el => el.index === index);\n    if (item) {\n      input.setAttribute('aria-activedescendant', item.id);\n    } else {\n      input.removeAttribute('aria-activedescendant');\n    }\n  }\n\n  /** @private */\n  _openedChanged(opened, wasOpened) {\n    // Prevent _close() being called when opened is set to its default value (false).\n    if (wasOpened === undefined) {\n      return;\n    }\n    if (opened) {\n      // For touch devices, we don't want to popup virtual keyboard\n      // unless input element is explicitly focused by the user.\n      if (!this._isInputFocused() && !isTouch) {\n        if (this.inputElement) {\n          this.inputElement.focus();\n        }\n      }\n    } else {\n      this._onClosed();\n    }\n    const input = this._nativeInput;\n    if (input) {\n      input.setAttribute('aria-expanded', !!opened);\n      if (opened) {\n        input.setAttribute('aria-controls', this._scroller.id);\n      } else {\n        input.removeAttribute('aria-controls');\n      }\n    }\n  }\n\n  /** @private */\n  _onOverlayTouchAction() {\n    // On touch devices, blur the input on touch start inside the overlay, in order to hide\n    // the virtual keyboard. But don't close the overlay on this blur.\n    this._closeOnBlurIsPrevented = true;\n    this.inputElement.blur();\n    this._closeOnBlurIsPrevented = false;\n  }\n\n  /** @protected */\n  _isClearButton(event) {\n    return event.composedPath()[0] === this.clearElement;\n  }\n\n  /** @private */\n  __onClearButtonMouseDown(event) {\n    event.preventDefault(); // Prevent native focusout event\n    this.inputElement.focus();\n  }\n\n  /**\n   * @param {Event} event\n   * @protected\n   */\n  _onClearButtonClick(event) {\n    event.preventDefault();\n    this._onClearAction();\n\n    // De-select dropdown item\n    if (this.opened) {\n      this.requestContentUpdate();\n    }\n  }\n\n  /**\n   * @param {Event} event\n   * @private\n   */\n  _onToggleButtonClick(event) {\n    // Prevent parent components such as `vaadin-grid`\n    // from handling the click event after it bubbles.\n    event.preventDefault();\n    if (this.opened) {\n      this.close();\n    } else {\n      this.open();\n    }\n  }\n\n  /**\n   * @param {Event} event\n   * @protected\n   */\n  _onHostClick(event) {\n    if (!this.autoOpenDisabled) {\n      event.preventDefault();\n      this.open();\n    }\n  }\n\n  /** @private */\n  _onClick(event) {\n    if (this._isClearButton(event)) {\n      this._onClearButtonClick(event);\n    } else if (event.composedPath().includes(this._toggleElement)) {\n      this._onToggleButtonClick(event);\n    } else {\n      this._onHostClick(event);\n    }\n  }\n\n  /**\n   * Override an event listener from `KeyboardMixin`.\n   *\n   * @param {KeyboardEvent} e\n   * @protected\n   * @override\n   */\n  _onKeyDown(e) {\n    super._onKeyDown(e);\n    if (e.key === 'ArrowDown') {\n      this._onArrowDown();\n\n      // Prevent caret from moving\n      e.preventDefault();\n    } else if (e.key === 'ArrowUp') {\n      this._onArrowUp();\n\n      // Prevent caret from moving\n      e.preventDefault();\n    }\n  }\n\n  /** @private */\n  _getItemLabel(item) {\n    let label = item && this.itemLabelPath ? get(this.itemLabelPath, item) : undefined;\n    if (label === undefined || label === null) {\n      label = item ? item.toString() : '';\n    }\n    return label;\n  }\n\n  /** @private */\n  _getItemValue(item) {\n    let value = item && this.itemValuePath ? get(this.itemValuePath, item) : undefined;\n    if (value === undefined) {\n      value = item ? item.toString() : '';\n    }\n    return value;\n  }\n\n  /** @private */\n  _onArrowDown() {\n    if (this.opened) {\n      const items = this._dropdownItems;\n      if (items) {\n        this._focusedIndex = Math.min(items.length - 1, this._focusedIndex + 1);\n        this._prefillFocusedItemLabel();\n      }\n    } else {\n      this.open();\n    }\n  }\n\n  /** @private */\n  _onArrowUp() {\n    if (this.opened) {\n      if (this._focusedIndex > -1) {\n        this._focusedIndex = Math.max(0, this._focusedIndex - 1);\n      } else {\n        const items = this._dropdownItems;\n        if (items) {\n          this._focusedIndex = items.length - 1;\n        }\n      }\n      this._prefillFocusedItemLabel();\n    } else {\n      this.open();\n    }\n  }\n\n  /** @private */\n  _prefillFocusedItemLabel() {\n    if (this._focusedIndex > -1) {\n      const focusedItem = this._dropdownItems[this._focusedIndex];\n      this._inputElementValue = this._getItemLabel(focusedItem);\n      this._markAllSelectionRange();\n    }\n  }\n\n  /** @private */\n  _setSelectionRange(start, end) {\n    // Setting selection range focuses and/or moves the caret in some browsers,\n    // and there's no need to modify the selection range if the input isn't focused anyway.\n    // This affects Safari. When the overlay is open, and then hitting tab, browser should focus\n    // the next focusable element instead of the combo-box itself.\n    if (this._isInputFocused() && this.inputElement.setSelectionRange) {\n      this.inputElement.setSelectionRange(start, end);\n    }\n  }\n\n  /** @private */\n  _markAllSelectionRange() {\n    if (this._inputElementValue !== undefined) {\n      this._setSelectionRange(0, this._inputElementValue.length);\n    }\n  }\n\n  /** @private */\n  _clearSelectionRange() {\n    if (this._inputElementValue !== undefined) {\n      const pos = this._inputElementValue ? this._inputElementValue.length : 0;\n      this._setSelectionRange(pos, pos);\n    }\n  }\n\n  /** @private */\n  _closeOrCommit() {\n    if (!this.opened && !this.loading) {\n      this._commitValue();\n    } else {\n      this.close();\n    }\n  }\n\n  /**\n   * Override an event listener from `KeyboardMixin`.\n   *\n   * @param {KeyboardEvent} e\n   * @protected\n   * @override\n   */\n  _onEnter(e) {\n    // Do not commit value when custom values are disallowed and input value is not a valid option\n    // also stop propagation of the event, otherwise the user could submit a form while the input\n    // still contains an invalid value\n    if (!this._hasValidInputValue()) {\n      // Do not submit the surrounding form.\n      e.preventDefault();\n      // Do not trigger global listeners\n      e.stopPropagation();\n      return;\n    }\n\n    // Stop propagation of the enter event only if the dropdown is opened, this\n    // \"consumes\" the enter event for the action of closing the dropdown\n    if (this.opened) {\n      // Do not submit the surrounding form.\n      e.preventDefault();\n      // Do not trigger global listeners\n      e.stopPropagation();\n    }\n    this._closeOrCommit();\n  }\n\n  /**\n   * @protected\n   */\n  _hasValidInputValue() {\n    const hasInvalidOption = this._focusedIndex < 0 && this._inputElementValue !== '' && this._getItemLabel(this.selectedItem) !== this._inputElementValue;\n    return this.allowCustomValue || !hasInvalidOption;\n  }\n\n  /**\n   * Override an event listener from `KeyboardMixin`.\n   * Do not call `super` in order to override clear\n   * button logic defined in `InputControlMixin`.\n   *\n   * @param {!KeyboardEvent} e\n   * @protected\n   * @override\n   */\n  _onEscape(e) {\n    if (this.autoOpenDisabled) {\n      // Auto-open is disabled\n      if (this.opened || this.value !== this._inputElementValue && this._inputElementValue.length > 0) {\n        // The overlay is open or\n        // The input value has changed but the change hasn't been committed, so cancel it.\n        e.stopPropagation();\n        this._focusedIndex = -1;\n        this.cancel();\n      } else if (this.clearButtonVisible && !this.opened && !!this.value) {\n        e.stopPropagation();\n        // The clear button is visible and the overlay is closed, so clear the value.\n        this._onClearAction();\n      }\n    } else if (this.opened) {\n      // Auto-open is enabled\n      // The overlay is open\n      e.stopPropagation();\n      if (this._focusedIndex > -1) {\n        // An item is focused, revert the input to the filtered value\n        this._focusedIndex = -1;\n        this._revertInputValue();\n      } else {\n        // No item is focused, cancel the change and close the overlay\n        this.cancel();\n      }\n    } else if (this.clearButtonVisible && !!this.value) {\n      e.stopPropagation();\n      // The clear button is visible and the overlay is closed, so clear the value.\n      this._onClearAction();\n    }\n  }\n\n  /** @private */\n  _toggleElementChanged(toggleElement) {\n    if (toggleElement) {\n      // Don't blur the input on toggle mousedown\n      toggleElement.addEventListener('mousedown', e => e.preventDefault());\n      // Unfocus previously focused element if focus is not inside combo box (on touch devices)\n      toggleElement.addEventListener('click', () => {\n        if (isTouch && !this._isInputFocused()) {\n          document.activeElement.blur();\n        }\n      });\n    }\n  }\n\n  /**\n   * Clears the current value.\n   * @protected\n   */\n  _onClearAction() {\n    this.selectedItem = null;\n    if (this.allowCustomValue) {\n      this.value = '';\n    }\n    this._detectAndDispatchChange();\n  }\n\n  /**\n   * Clears the current filter. Should be used instead of setting the property\n   * directly in order to allow overriding this in multi-select combo box.\n   * @protected\n   */\n  _clearFilter() {\n    this.filter = '';\n  }\n\n  /**\n   * Reverts back to original value.\n   */\n  cancel() {\n    this._revertInputValueToValue();\n    // In the next _detectAndDispatchChange() call, the change detection should not pass\n    this._lastCommittedValue = this.value;\n    this._closeOrCommit();\n  }\n\n  /** @private */\n  _onOpened() {\n    // _detectAndDispatchChange() should not consider value changes done before opening\n    this._lastCommittedValue = this.value;\n  }\n\n  /** @private */\n  _onClosed() {\n    if (!this.loading || this.allowCustomValue) {\n      this._commitValue();\n    }\n  }\n\n  /** @private */\n  _commitValue() {\n    if (this._focusedIndex > -1) {\n      const focusedItem = this._dropdownItems[this._focusedIndex];\n      if (this.selectedItem !== focusedItem) {\n        this.selectedItem = focusedItem;\n      }\n      // Make sure input field is updated in case value doesn't change (i.e. FOO -> foo)\n      this._inputElementValue = this._getItemLabel(this.selectedItem);\n      this._focusedIndex = -1;\n    } else if (this._inputElementValue === '' || this._inputElementValue === undefined) {\n      this.selectedItem = null;\n      if (this.allowCustomValue) {\n        this.value = '';\n      }\n    } else {\n      // Try to find an item which label matches the input value.\n      const items = [this.selectedItem, ...(this._dropdownItems || [])];\n      const itemMatchingInputValue = items[this.__getItemIndexByLabel(items, this._inputElementValue)];\n      if (this.allowCustomValue &&\n      // To prevent a repetitive input value being saved after pressing ESC and Tab.\n      !itemMatchingInputValue) {\n        const customValue = this._inputElementValue;\n\n        // Store reference to the last custom value for checking it on focusout.\n        this._lastCustomValue = customValue;\n\n        // An item matching by label was not found, but custom values are allowed.\n        // Dispatch a custom-value-set event with the input value.\n        const e = new CustomEvent('custom-value-set', {\n          detail: customValue,\n          composed: true,\n          cancelable: true,\n          bubbles: true\n        });\n        this.dispatchEvent(e);\n        if (!e.defaultPrevented) {\n          this.value = customValue;\n        }\n      } else if (!this.allowCustomValue && !this.opened && itemMatchingInputValue) {\n        // An item matching by label was found, select it.\n        this.value = this._getItemValue(itemMatchingInputValue);\n      } else {\n        // Revert the input value\n        this._revertInputValueToValue();\n      }\n    }\n    this._detectAndDispatchChange();\n    this._clearSelectionRange();\n    this._clearFilter();\n  }\n\n  /**\n   * Override an event listener from `InputMixin`.\n   * @param {!Event} event\n   * @protected\n   * @override\n   */\n  _onInput(event) {\n    const filter = this._inputElementValue;\n\n    // When opening dropdown on user input, both `opened` and `filter` properties are set.\n    // Perform a batched property update instead of relying on sync property observers.\n    // This is necessary to avoid an extra data-provider request for loading first page.\n    const props = {};\n    if (this.filter === filter) {\n      // Filter and input value might get out of sync, while keyboard navigating for example.\n      // Afterwards, input value might be changed to the same value as used in filtering.\n      // In situation like these, we need to make sure all the filter changes handlers are run.\n      this._filterChanged(this.filter);\n    } else {\n      props.filter = filter;\n    }\n    if (!this.opened && !this._isClearButton(event) && !this.autoOpenDisabled) {\n      props.opened = true;\n    }\n    this.setProperties(props);\n  }\n\n  /**\n   * Override an event listener from `InputMixin`.\n   * @param {!Event} event\n   * @protected\n   * @override\n   */\n  _onChange(event) {\n    // Suppress the native change event fired on the native input.\n    // We use `_detectAndDispatchChange` to fire a custom event.\n    event.stopPropagation();\n  }\n\n  /** @private */\n  _itemLabelPathChanged(itemLabelPath) {\n    if (typeof itemLabelPath !== 'string') {\n      console.error('You should set itemLabelPath to a valid string');\n    }\n  }\n\n  /** @private */\n  _filterChanged(filter) {\n    // Scroll to the top of the list whenever the filter changes.\n    this._scrollIntoView(0);\n    this._focusedIndex = -1;\n    if (this.items) {\n      this.filteredItems = this._filterItems(this.items, filter);\n    } else {\n      // With certain use cases (e. g., external filtering), `items` are\n      // undefined. Filtering is unnecessary per se, but the filteredItems\n      // observer should still be invoked to update focused item.\n      this._filteredItemsChanged(this.filteredItems);\n    }\n  }\n\n  /** @protected */\n  _revertInputValue() {\n    if (this.filter !== '') {\n      this._inputElementValue = this.filter;\n    } else {\n      this._revertInputValueToValue();\n    }\n    this._clearSelectionRange();\n  }\n\n  /** @private */\n  _revertInputValueToValue() {\n    if (this.allowCustomValue && !this.selectedItem) {\n      this._inputElementValue = this.value;\n    } else {\n      this._inputElementValue = this._getItemLabel(this.selectedItem);\n    }\n  }\n\n  /** @private */\n  _selectedItemChanged(selectedItem) {\n    if (selectedItem === null || selectedItem === undefined) {\n      if (this.filteredItems) {\n        if (!this.allowCustomValue) {\n          this.value = '';\n        }\n        this._toggleHasValue(this._hasValue);\n        this._inputElementValue = this.value;\n      }\n    } else {\n      const value = this._getItemValue(selectedItem);\n      if (this.value !== value) {\n        this.value = value;\n        if (this.value !== value) {\n          // The value was changed to something else in value-changed listener,\n          // so prevent from resetting it to the previous value.\n          return;\n        }\n      }\n      this._toggleHasValue(true);\n      this._inputElementValue = this._getItemLabel(selectedItem);\n    }\n  }\n\n  /**\n   * Override an observer from `InputMixin`.\n   * @protected\n   * @override\n   */\n  _valueChanged(value, oldVal) {\n    if (value === '' && oldVal === undefined) {\n      // Initializing, no need to do anything\n      // See https://github.com/vaadin/vaadin-combo-box/issues/554\n      return;\n    }\n    if (isValidValue(value)) {\n      if (this._getItemValue(this.selectedItem) !== value) {\n        this._selectItemForValue(value);\n      }\n      if (!this.selectedItem && this.allowCustomValue) {\n        this._inputElementValue = value;\n      }\n      this._toggleHasValue(this._hasValue);\n    } else {\n      this.selectedItem = null;\n    }\n    this._clearFilter();\n\n    // In the next _detectAndDispatchChange() call, the change detection should pass\n    this._lastCommittedValue = undefined;\n  }\n\n  /** @private */\n  _detectAndDispatchChange() {\n    // Do not validate when focusout is caused by document\n    // losing focus, which happens on browser tab switch.\n    if (document.hasFocus()) {\n      this.validate();\n    }\n    if (this.value !== this._lastCommittedValue) {\n      this.dispatchEvent(new CustomEvent('change', {\n        bubbles: true\n      }));\n      this._lastCommittedValue = this.value;\n    }\n  }\n\n  /** @private */\n  _itemsChanged(items, oldItems) {\n    this._ensureItemsOrDataProvider(() => {\n      this.items = oldItems;\n    });\n    if (items) {\n      this.filteredItems = items.slice(0);\n    } else if (oldItems) {\n      // Only clear filteredItems if the component had items previously but got cleared\n      this.filteredItems = null;\n    }\n  }\n\n  /** @private */\n  _filteredItemsChanged(filteredItems) {\n    this._setDropdownItems(filteredItems);\n  }\n\n  /** @private */\n  _filterItems(arr, filter) {\n    if (!arr) {\n      return arr;\n    }\n    const filteredItems = arr.filter(item => {\n      filter = filter ? filter.toString().toLowerCase() : '';\n      // Check if item contains input value.\n      return this._getItemLabel(item).toString().toLowerCase().indexOf(filter) > -1;\n    });\n    return filteredItems;\n  }\n\n  /** @private */\n  _selectItemForValue(value) {\n    const valueIndex = this.__getItemIndexByValue(this.filteredItems, value);\n    const previouslySelectedItem = this.selectedItem;\n    if (valueIndex >= 0) {\n      this.selectedItem = this.filteredItems[valueIndex];\n    } else if (this.dataProvider && this.selectedItem === undefined) {\n      this.selectedItem = undefined;\n    } else {\n      this.selectedItem = null;\n    }\n    if (this.selectedItem === null && previouslySelectedItem === null) {\n      this._selectedItemChanged(this.selectedItem);\n    }\n  }\n\n  /**\n   * Provide items to be rendered in the dropdown.\n   * Override this method to show custom items.\n   *\n   * @protected\n   */\n  _setDropdownItems(newItems) {\n    const oldItems = this._dropdownItems;\n    this._dropdownItems = newItems;\n\n    // Store the currently focused item if any. The focused index preserves\n    // in the case when more filtered items are loading but it is reset\n    // when the user types in a filter query.\n    const focusedItem = oldItems ? oldItems[this._focusedIndex] : null;\n\n    // Try to sync `selectedItem` based on `value` once a new set of `filteredItems` is available\n    // (as a result of external filtering or when they have been loaded by the data provider).\n    // When `value` is specified but `selectedItem` is not, it means that there was no item\n    // matching `value` at the moment `value` was set, so `selectedItem` has remained unsynced.\n    const valueIndex = this.__getItemIndexByValue(newItems, this.value);\n    if ((this.selectedItem === null || this.selectedItem === undefined) && valueIndex >= 0) {\n      this.selectedItem = newItems[valueIndex];\n    }\n\n    // Try to first set focus on the item that had been focused before `newItems` were updated\n    // if it is still present in the `newItems` array. Otherwise, set the focused index\n    // depending on the selected item or the filter query.\n    const focusedItemIndex = this.__getItemIndexByValue(newItems, this._getItemValue(focusedItem));\n    if (focusedItemIndex > -1) {\n      this._focusedIndex = focusedItemIndex;\n    } else {\n      // When the user filled in something that is different from the current value = filtering is enabled,\n      // set the focused index to the item that matches the filter query.\n      this._focusedIndex = this.__getItemIndexByLabel(newItems, this.filter);\n    }\n  }\n\n  /** @private */\n  _getItemElements() {\n    return Array.from(this._scroller.querySelectorAll(`${this._tagNamePrefix}-item`));\n  }\n\n  /** @private */\n  _scrollIntoView(index) {\n    if (!this._scroller) {\n      return;\n    }\n    this._scroller.scrollIntoView(index);\n  }\n\n  /**\n   * Returns the first item that matches the provided value.\n   *\n   * @private\n   */\n  __getItemIndexByValue(items, value) {\n    if (!items || !isValidValue(value)) {\n      return -1;\n    }\n    return findItemIndex(items, item => {\n      return this._getItemValue(item) === value;\n    });\n  }\n\n  /**\n   * Returns the first item that matches the provided label.\n   * Labels are matched against each other case insensitively.\n   *\n   * @private\n   */\n  __getItemIndexByLabel(items, label) {\n    if (!items || !label) {\n      return -1;\n    }\n    return findItemIndex(items, item => {\n      return this._getItemLabel(item).toString().toLowerCase() === label.toString().toLowerCase();\n    });\n  }\n\n  /** @private */\n  _overlaySelectedItemChanged(e) {\n    // Stop this private event from leaking outside.\n    e.stopPropagation();\n    if (e.detail.item instanceof ComboBoxPlaceholder) {\n      // Placeholder items should not be selectable.\n      return;\n    }\n    if (this.opened) {\n      this._focusedIndex = this.filteredItems.indexOf(e.detail.item);\n      this.close();\n    }\n  }\n\n  /**\n   * Override method inherited from `FocusMixin`\n   * to close the overlay on blur and commit the value.\n   *\n   * @param {boolean} focused\n   * @protected\n   * @override\n   */\n  _setFocused(focused) {\n    super._setFocused(focused);\n    if (!focused && !this.readonly && !this._closeOnBlurIsPrevented) {\n      // User's logic in `custom-value-set` event listener might cause input to blur,\n      // which will result in attempting to commit the same custom value once again.\n      if (!this.opened && this.allowCustomValue && this._inputElementValue === this._lastCustomValue) {\n        delete this._lastCustomValue;\n        return;\n      }\n      if (isKeyboardActive()) {\n        // Close on Tab key causing blur. With mouse, close on outside click instead.\n        this._closeOrCommit();\n        return;\n      }\n      if (!this.opened) {\n        this._commitValue();\n      } else if (!this._overlayOpened) {\n        // Combo-box is opened, but overlay is not visible -> custom value was entered.\n        // Make sure we close here as there won't be an \"outside click\" in this case.\n        this.close();\n      }\n    }\n  }\n\n  /**\n   * Override method inherited from `FocusMixin` to not remove focused\n   * state when focus moves to the overlay.\n   *\n   * @param {FocusEvent} event\n   * @return {boolean}\n   * @protected\n   * @override\n   */\n  _shouldRemoveFocus(event) {\n    // VoiceOver on iOS fires `focusout` event when moving focus to the item in the dropdown.\n    // Do not focus the input in this case, because it would break announcement for the item.\n    if (event.relatedTarget && event.relatedTarget.localName === `${this._tagNamePrefix}-item`) {\n      return false;\n    }\n\n    // Do not blur when focus moves to the overlay\n    // Also, fixes the problem with `focusout` happening when clicking on the scroll bar on Edge\n    if (event.relatedTarget === this._overlayElement) {\n      event.composedPath()[0].focus();\n      return false;\n    }\n    return true;\n  }\n\n  /** @private */\n  _onTouchend(event) {\n    if (!this.clearElement || event.composedPath()[0] !== this.clearElement) {\n      return;\n    }\n    event.preventDefault();\n    this._onClearAction();\n  }\n\n  /**\n   * Fired when the value changes.\n   *\n   * @event value-changed\n   * @param {Object} detail\n   * @param {String} detail.value the combobox value\n   */\n\n  /**\n   * Fired when selected item changes.\n   *\n   * @event selected-item-changed\n   * @param {Object} detail\n   * @param {Object|String} detail.value the selected item. Type is the same as the type of `items`.\n   */\n\n  /**\n   * Fired when the user sets a custom value.\n   * @event custom-value-set\n   * @param {String} detail the custom value\n   */\n\n  /**\n   * Fired when value changes.\n   * To comply with https://developer.mozilla.org/en-US/docs/Web/Events/change\n   * @event change\n   */\n\n  /**\n   * Fired after the `vaadin-combo-box-overlay` opens.\n   *\n   * @event vaadin-combo-box-dropdown-opened\n   */\n\n  /**\n   * Fired after the `vaadin-combo-box-overlay` closes.\n   *\n   * @event vaadin-combo-box-dropdown-closed\n   */\n};","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport './vaadin-multi-select-combo-box-item.js';\nimport './vaadin-multi-select-combo-box-overlay.js';\nimport './vaadin-multi-select-combo-box-scroller.js';\nimport { html, PolymerElement } from '@polymer/polymer/polymer-element.js';\nimport { ComboBoxDataProviderMixin } from '@vaadin/combo-box/src/vaadin-combo-box-data-provider-mixin.js';\nimport { ComboBoxMixin } from '@vaadin/combo-box/src/vaadin-combo-box-mixin.js';\nimport { ComboBoxPlaceholder } from '@vaadin/combo-box/src/vaadin-combo-box-placeholder.js';\nimport { defineCustomElement } from '@vaadin/component-base/src/define.js';\nimport { ThemableMixin } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\n\n/**\n * An element used internally by `<vaadin-multi-select-combo-box>`. Not intended to be used separately.\n *\n * @customElement\n * @extends HTMLElement\n * @mixes ComboBoxDataProviderMixin\n * @mixes ComboBoxMixin\n * @mixes ThemableMixin\n * @private\n */\nclass MultiSelectComboBoxInternal extends ComboBoxDataProviderMixin(ComboBoxMixin(ThemableMixin(PolymerElement))) {\n  static get is() {\n    return 'vaadin-multi-select-combo-box-internal';\n  }\n  static get template() {\n    return html`\n      <style>\n        :host([opened]) {\n          pointer-events: auto;\n        }\n      </style>\n\n      <slot></slot>\n\n      <vaadin-multi-select-combo-box-overlay\n        id=\"overlay\"\n        opened=\"[[_overlayOpened]]\"\n        loading$=\"[[loading]]\"\n        theme$=\"[[_theme]]\"\n        position-target=\"[[_target]]\"\n        no-vertical-overlap\n        restore-focus-node=\"[[inputElement]]\"\n      ></vaadin-multi-select-combo-box-overlay>\n    `;\n  }\n  static get properties() {\n    return {\n      /**\n       * A subset of items, filtered based on the user input.\n       */\n      filteredItems: {\n        type: Array,\n        notify: true\n      },\n      /**\n       * When true, filter string isn't cleared after selecting an item.\n       */\n      keepFilter: {\n        type: Boolean,\n        value: false\n      },\n      /**\n       * When set to `true`, \"loading\" attribute is set\n       * on the host and the overlay element.\n       * @type {boolean}\n       */\n      loading: {\n        type: Boolean,\n        notify: true\n      },\n      /**\n       * Total number of items.\n       * @type {number | undefined}\n       */\n      size: {\n        type: Number,\n        notify: true\n      },\n      /**\n       * Selected items to render in the dropdown\n       * when the component is read-only.\n       */\n      selectedItems: {\n        type: Array,\n        value: () => []\n      },\n      /**\n       * Set to true to group selected items at the top of the overlay.\n       * @attr {boolean} selected-items-on-top\n       */\n      selectedItemsOnTop: {\n        type: Boolean,\n        value: false\n      },\n      /**\n       * Last input value entered by the user before value is updated.\n       * Used to store `filter` property value before clearing it.\n       */\n      lastFilter: {\n        type: String,\n        notify: true\n      },\n      /**\n       * A subset of items to be shown at the top of the overlay.\n       */\n      topGroup: {\n        type: Array,\n        observer: '_topGroupChanged'\n      },\n      _target: {\n        type: Object\n      }\n    };\n  }\n  static get observers() {\n    return ['_readonlyChanged(readonly)'];\n  }\n\n  /**\n   * Reference to the clear button element.\n   * @protected\n   * @return {!HTMLElement}\n   */\n  get clearElement() {\n    return this.querySelector('[part=\"clear-button\"]');\n  }\n\n  /**\n   * Tag name prefix used by scroller and items.\n   * @protected\n   * @return {string}\n   */\n  get _tagNamePrefix() {\n    return 'vaadin-multi-select-combo-box';\n  }\n\n  /**\n   * Override method inherited from the combo-box\n   * to allow opening dropdown when readonly.\n   * @override\n   */\n  open() {\n    if (!this.disabled && !(this.readonly && this.selectedItems.length === 0)) {\n      this.opened = true;\n    }\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n    this._target = this;\n    this._toggleElement = this.querySelector('.toggle-button');\n  }\n\n  /** @private */\n  _readonlyChanged() {\n    this._setDropdownItems(this.filteredItems);\n  }\n\n  /**\n   * Override combo-box method to group selected\n   * items at the top of the overlay.\n   *\n   * @protected\n   * @override\n   */\n  _setDropdownItems(items) {\n    if (this.readonly) {\n      super._setDropdownItems(this.selectedItems);\n      return;\n    }\n    if (this.filter || !this.selectedItemsOnTop) {\n      super._setDropdownItems(items);\n      return;\n    }\n    if (items && items.length && this.topGroup && this.topGroup.length) {\n      // Filter out items included to the top group.\n      const filteredItems = items.filter(item => this._comboBox._findIndex(item, this.topGroup, this.itemIdPath) === -1);\n      super._setDropdownItems(this.topGroup.concat(filteredItems));\n      return;\n    }\n    super._setDropdownItems(items);\n  }\n\n  /** @private */\n  _topGroupChanged(topGroup) {\n    if (topGroup) {\n      this._setDropdownItems(this.filteredItems);\n    }\n  }\n\n  /**\n   * Override combo-box method to set correct owner for using by item renderers.\n   * This needs to be done before the scroller gets added to the DOM to ensure\n   * Lit directive works in case when combo-box is opened using attribute.\n   *\n   * @protected\n   * @override\n   */\n  _initScroller() {\n    const comboBox = this.getRootNode().host;\n    this._comboBox = comboBox;\n    super._initScroller(comboBox);\n  }\n\n  /**\n   * Override Enter handler to keep overlay open\n   * when item is selected or unselected.\n   * @param {!Event} event\n   * @protected\n   * @override\n   */\n  _onEnter(event) {\n    if (this.opened) {\n      // Do not submit the surrounding form.\n      event.preventDefault();\n      // Do not trigger global listeners.\n      event.stopPropagation();\n      if (this.readonly) {\n        this.close();\n      } else if (this._hasValidInputValue()) {\n        // Keep selected item focused after committing on Enter.\n        const focusedItem = this._dropdownItems[this._focusedIndex];\n        this._commitValue();\n        this._focusedIndex = this._dropdownItems.indexOf(focusedItem);\n      }\n      return;\n    }\n    super._onEnter(event);\n  }\n\n  /**\n   * Override Escape handler to not clear\n   * selected items when readonly.\n   * @param {!Event} event\n   * @protected\n   * @override\n   */\n  _onEscape(event) {\n    if (this.readonly) {\n      event.stopPropagation();\n      if (this.opened) {\n        this.close();\n      }\n      return;\n    }\n    super._onEscape(event);\n  }\n\n  /**\n   * Override from combo-box to ignore requests to clear the filter if the\n   * keepFilter option is enabled. Exceptions are when the dropdown is closed,\n   * so the filter is still cleared on cancel and focus out.\n   * @protected\n   * @override\n   */\n  _clearFilter() {\n    if (!this.keepFilter || !this.opened) {\n      super._clearFilter();\n    }\n  }\n\n  /**\n   * Override method from combo-box to always clear the filter when reverting\n   * the input value, regardless of the keepFilter option.\n   * @override\n   * @protected\n   */\n  _revertInputValueToValue() {\n    super._revertInputValueToValue();\n    this.filter = '';\n  }\n\n  /**\n   * @protected\n   * @override\n   */\n  _commitValue() {\n    // Store filter value for checking if user input is matching\n    // an item which is already selected, to not un-select it.\n    this.lastFilter = this.filter;\n    super._commitValue();\n  }\n\n  /**\n   * Override method inherited from the combo-box\n   * to not update focused item when readonly.\n   * @protected\n   * @override\n   */\n  _onArrowDown() {\n    if (!this.readonly) {\n      super._onArrowDown();\n    } else if (!this.opened) {\n      this.open();\n    }\n  }\n\n  /**\n   * Override method inherited from the combo-box\n   * to not update focused item when readonly.\n   * @protected\n   * @override\n   */\n  _onArrowUp() {\n    if (!this.readonly) {\n      super._onArrowUp();\n    } else if (!this.opened) {\n      this.open();\n    }\n  }\n\n  /**\n   * Override method inherited from the combo-box\n   * to close dropdown on blur when readonly.\n   * @param {boolean} focused\n   * @protected\n   * @override\n   */\n  _setFocused(focused) {\n    // Disable combo-box logic that updates selectedItem\n    // based on the overlay focused index on input blur\n    if (!focused) {\n      this._ignoreCommitValue = true;\n    }\n    super._setFocused(focused);\n    if (!focused && this.readonly && !this._closeOnBlurIsPrevented) {\n      this.close();\n    }\n  }\n\n  /**\n   * Override method inherited from the combo-box\n   * to not commit an already selected item again\n   * on blur, which would result in un-selecting.\n   * @protected\n   * @override\n   */\n  _detectAndDispatchChange() {\n    if (this._ignoreCommitValue) {\n      this._ignoreCommitValue = false;\n\n      // Reset internal combo-box state\n      this.selectedItem = null;\n      this._inputElementValue = '';\n      return;\n    }\n    super._detectAndDispatchChange();\n  }\n\n  /**\n   * @param {CustomEvent} event\n   * @protected\n   * @override\n   */\n  _overlaySelectedItemChanged(event) {\n    event.stopPropagation();\n\n    // Do not un-select on click when readonly\n    if (this.readonly) {\n      return;\n    }\n    if (event.detail.item instanceof ComboBoxPlaceholder) {\n      return;\n    }\n    if (this.opened) {\n      // Store filter value for checking if user input is matching\n      // an item which is already selected, to not un-select it.\n      this.lastFilter = this.filter;\n      this.dispatchEvent(new CustomEvent('combo-box-item-selected', {\n        detail: {\n          item: event.detail.item\n        }\n      }));\n    }\n  }\n\n  /**\n   * Override method inherited from the combo-box\n   * to not request data provider when read-only.\n   *\n   * @protected\n   * @override\n   */\n  _shouldFetchData() {\n    if (this.readonly) {\n      return false;\n    }\n    return super._shouldFetchData();\n  }\n\n  /**\n   * Override method inherited from the combo-box\n   * to not clear the data provider cache when read-only.\n   *\n   * @protected\n   * @override\n   */\n  clearCache() {\n    if (this.readonly) {\n      return;\n    }\n    super.clearCache();\n  }\n}\ndefineCustomElement(MultiSelectComboBoxInternal);","/**\n * @license\n * Copyright (c) 2022 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { animationFrame } from '@vaadin/component-base/src/async.js';\nimport { Debouncer } from '@vaadin/component-base/src/debounce.js';\nconst region = document.createElement('div');\nregion.style.position = 'fixed';\nregion.style.clip = 'rect(0px, 0px, 0px, 0px)';\nregion.setAttribute('aria-live', 'polite');\ndocument.body.appendChild(region);\nlet alertDebouncer;\n/**\n * Cause a text string to be announced by screen readers.\n *\n * @param {string} text The text that should be announced by the screen reader.\n * @param {{mode?: string, timeout?: number}} options Additional options.\n */\nexport function announce(text) {\n  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  const mode = options.mode || 'polite';\n  const timeout = options.timeout === undefined ? 150 : options.timeout;\n  if (mode === 'alert') {\n    region.removeAttribute('aria-live');\n    region.removeAttribute('role');\n    alertDebouncer = Debouncer.debounce(alertDebouncer, animationFrame, () => {\n      region.setAttribute('role', 'alert');\n    });\n  } else {\n    if (alertDebouncer) {\n      alertDebouncer.cancel();\n    }\n    region.removeAttribute('role');\n    region.setAttribute('aria-live', mode);\n  }\n  region.textContent = '';\n  setTimeout(() => {\n    region.textContent = text;\n  }, timeout);\n}","const DEV_MODE_CODE_REGEXP = /\\/\\*[\\*!]\\s+vaadin-dev-mode:start([\\s\\S]*)vaadin-dev-mode:end\\s+\\*\\*\\//i;\nconst FlowClients = window.Vaadin && window.Vaadin.Flow && window.Vaadin.Flow.clients;\nfunction isMinified() {\n  function test() {\n    /** vaadin-dev-mode:start\n    return false;\n    vaadin-dev-mode:end **/\n    return true;\n  }\n  return uncommentAndRun(test);\n}\nfunction isDevelopmentMode() {\n  try {\n    if (isForcedDevelopmentMode()) {\n      return true;\n    }\n    if (!isLocalhost()) {\n      return false;\n    }\n    if (FlowClients) {\n      return !isFlowProductionMode();\n    }\n    return !isMinified();\n  } catch (e) {\n    // Some error in this code, assume production so no further actions will be taken\n    return false;\n  }\n}\nfunction isForcedDevelopmentMode() {\n  return localStorage.getItem(\"vaadin.developmentmode.force\");\n}\nfunction isLocalhost() {\n  return [\"localhost\", \"127.0.0.1\"].indexOf(window.location.hostname) >= 0;\n}\nfunction isFlowProductionMode() {\n  if (FlowClients) {\n    const productionModeApps = Object.keys(FlowClients).map(key => FlowClients[key]).filter(client => client.productionMode);\n    if (productionModeApps.length > 0) {\n      return true;\n    }\n  }\n  return false;\n}\nfunction uncommentAndRun(callback, args) {\n  if (typeof callback !== 'function') {\n    return;\n  }\n  const match = DEV_MODE_CODE_REGEXP.exec(callback.toString());\n  if (match) {\n    try {\n      // requires CSP: script-src 'unsafe-eval'\n      callback = new Function(match[1]);\n    } catch (e) {\n      // eat the exception\n      console.log('vaadin-development-mode-detector: uncommentAndRun() failed', e);\n    }\n  }\n  return callback(args);\n}\n\n// A guard against polymer-modulizer removing the window.Vaadin\n// initialization above.\nwindow['Vaadin'] = window['Vaadin'] || {};\n\n/**\n * Inspects the source code of the given `callback` function for\n * specially-marked _commented_ code. If such commented code is found in the\n * callback source, uncomments and runs that code instead of the callback\n * itself. Otherwise runs the callback as is.\n *\n * The optional arguments are passed into the callback / uncommented code,\n * the result is returned.\n *\n * See the `isMinified()` function source code in this file for an example.\n *\n */\nexport const runIfDevelopmentMode = function (callback, args) {\n  if (window.Vaadin.developmentMode) {\n    return uncommentAndRun(callback, args);\n  }\n};\nif (window.Vaadin.developmentMode === undefined) {\n  window.Vaadin.developmentMode = isDevelopmentMode();\n}","/* This file is autogenerated from src/vaadin-usage-statistics.tpl.html */\n/*\n\nThis script gathers usage statistics from the application running in development mode.\n\nStatistics gathering is automatically disabled and excluded from production builds.\n\nFor details and to opt-out, see https://github.com/vaadin/vaadin-usage-statistics.\n\n*/\n/*\n  FIXME(polymer-modulizer): the above comments were extracted\n  from HTML and may be out of place here. Review them and\n  then delete this comment!\n*/\nimport { runIfDevelopmentMode } from '@vaadin/vaadin-development-mode-detector/vaadin-development-mode-detector.js';\nfunction maybeGatherAndSendStats() {\n  /*! vaadin-dev-mode:start\n  (function () {\n  'use strict';\n  var _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n  } : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  };\n  var classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n  };\n  var createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n   return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n  }();\n  var getPolymerVersion = function getPolymerVersion() {\n  return window.Polymer && window.Polymer.version;\n  };\n  var StatisticsGatherer = function () {\n  function StatisticsGatherer(logger) {\n    classCallCheck(this, StatisticsGatherer);\n     this.now = new Date().getTime();\n    this.logger = logger;\n  }\n   createClass(StatisticsGatherer, [{\n    key: 'frameworkVersionDetectors',\n    value: function frameworkVersionDetectors() {\n      return {\n        'Flow': function Flow() {\n          if (window.Vaadin && window.Vaadin.Flow && window.Vaadin.Flow.clients) {\n            var flowVersions = Object.keys(window.Vaadin.Flow.clients).map(function (key) {\n              return window.Vaadin.Flow.clients[key];\n            }).filter(function (client) {\n              return client.getVersionInfo;\n            }).map(function (client) {\n              return client.getVersionInfo().flow;\n            });\n            if (flowVersions.length > 0) {\n              return flowVersions[0];\n            }\n          }\n        },\n        'Vaadin Framework': function VaadinFramework() {\n          if (window.vaadin && window.vaadin.clients) {\n            var frameworkVersions = Object.values(window.vaadin.clients).filter(function (client) {\n              return client.getVersionInfo;\n            }).map(function (client) {\n              return client.getVersionInfo().vaadinVersion;\n            });\n            if (frameworkVersions.length > 0) {\n              return frameworkVersions[0];\n            }\n          }\n        },\n        'AngularJs': function AngularJs() {\n          if (window.angular && window.angular.version && window.angular.version) {\n            return window.angular.version.full;\n          }\n        },\n        'Angular': function Angular() {\n          if (window.ng) {\n            var tags = document.querySelectorAll(\"[ng-version]\");\n            if (tags.length > 0) {\n              return tags[0].getAttribute(\"ng-version\");\n            }\n            return \"Unknown\";\n          }\n        },\n        'Backbone.js': function BackboneJs() {\n          if (window.Backbone) {\n            return window.Backbone.VERSION;\n          }\n        },\n        'React': function React() {\n          var reactSelector = '[data-reactroot], [data-reactid]';\n          if (!!document.querySelector(reactSelector)) {\n            // React does not publish the version by default\n            return \"unknown\";\n          }\n        },\n        'Ember': function Ember() {\n          if (window.Em && window.Em.VERSION) {\n            return window.Em.VERSION;\n          } else if (window.Ember && window.Ember.VERSION) {\n            return window.Ember.VERSION;\n          }\n        },\n        'jQuery': function (_jQuery) {\n          function jQuery() {\n            return _jQuery.apply(this, arguments);\n          }\n           jQuery.toString = function () {\n            return _jQuery.toString();\n          };\n           return jQuery;\n        }(function () {\n          if (typeof jQuery === 'function' && jQuery.prototype.jquery !== undefined) {\n            return jQuery.prototype.jquery;\n          }\n        }),\n        'Polymer': function Polymer() {\n          var version = getPolymerVersion();\n          if (version) {\n            return version;\n          }\n        },\n        'LitElement': function LitElement() {\n          var version = window.litElementVersions && window.litElementVersions[0];\n          if (version) {\n            return version;\n          }\n        },\n        'LitHtml': function LitHtml() {\n          var version = window.litHtmlVersions && window.litHtmlVersions[0];\n          if (version) {\n            return version;\n          }\n        },\n        'Vue.js': function VueJs() {\n          if (window.Vue) {\n            return window.Vue.version;\n          }\n        }\n      };\n    }\n  }, {\n    key: 'getUsedVaadinElements',\n    value: function getUsedVaadinElements(elements) {\n      var version = getPolymerVersion();\n      var elementClasses = void 0;\n      // NOTE: In case you edit the code here, YOU MUST UPDATE any statistics reporting code in Flow.\n      // Check all locations calling the method getEntries() in\n      // https://github.com/vaadin/flow/blob/master/flow-server/src/main/java/com/vaadin/flow/internal/UsageStatistics.java#L106\n      // Currently it is only used by BootstrapHandler.\n      if (version && version.indexOf('2') === 0) {\n        // Polymer 2: components classes are stored in window.Vaadin\n        elementClasses = Object.keys(window.Vaadin).map(function (c) {\n          return window.Vaadin[c];\n        }).filter(function (c) {\n          return c.is;\n        });\n      } else {\n        // Polymer 3: components classes are stored in window.Vaadin.registrations\n        elementClasses = window.Vaadin.registrations || [];\n      }\n      elementClasses.forEach(function (klass) {\n        var version = klass.version ? klass.version : \"0.0.0\";\n        elements[klass.is] = { version: version };\n      });\n    }\n  }, {\n    key: 'getUsedVaadinThemes',\n    value: function getUsedVaadinThemes(themes) {\n      ['Lumo', 'Material'].forEach(function (themeName) {\n        var theme;\n        var version = getPolymerVersion();\n        if (version && version.indexOf('2') === 0) {\n          // Polymer 2: themes are stored in window.Vaadin\n          theme = window.Vaadin[themeName];\n        } else {\n          // Polymer 3: themes are stored in custom element registry\n          theme = customElements.get('vaadin-' + themeName.toLowerCase() + '-styles');\n        }\n        if (theme && theme.version) {\n          themes[themeName] = { version: theme.version };\n        }\n      });\n    }\n  }, {\n    key: 'getFrameworks',\n    value: function getFrameworks(frameworks) {\n      var detectors = this.frameworkVersionDetectors();\n      Object.keys(detectors).forEach(function (framework) {\n        var detector = detectors[framework];\n        try {\n          var version = detector();\n          if (version) {\n            frameworks[framework] = { version: version };\n          }\n        } catch (e) {}\n      });\n    }\n  }, {\n    key: 'gather',\n    value: function gather(storage) {\n      var storedStats = storage.read();\n      var gatheredStats = {};\n      var types = [\"elements\", \"frameworks\", \"themes\"];\n       types.forEach(function (type) {\n        gatheredStats[type] = {};\n        if (!storedStats[type]) {\n          storedStats[type] = {};\n        }\n      });\n       var previousStats = JSON.stringify(storedStats);\n       this.getUsedVaadinElements(gatheredStats.elements);\n      this.getFrameworks(gatheredStats.frameworks);\n      this.getUsedVaadinThemes(gatheredStats.themes);\n       var now = this.now;\n      types.forEach(function (type) {\n        var keys = Object.keys(gatheredStats[type]);\n        keys.forEach(function (key) {\n          if (!storedStats[type][key] || _typeof(storedStats[type][key]) != _typeof({})) {\n            storedStats[type][key] = { firstUsed: now };\n          }\n          // Discards any previously logged version number\n          storedStats[type][key].version = gatheredStats[type][key].version;\n          storedStats[type][key].lastUsed = now;\n        });\n      });\n       var newStats = JSON.stringify(storedStats);\n      storage.write(newStats);\n      if (newStats != previousStats && Object.keys(storedStats).length > 0) {\n        this.logger.debug(\"New stats: \" + newStats);\n      }\n    }\n  }]);\n  return StatisticsGatherer;\n  }();\n  var StatisticsStorage = function () {\n  function StatisticsStorage(key) {\n    classCallCheck(this, StatisticsStorage);\n     this.key = key;\n  }\n   createClass(StatisticsStorage, [{\n    key: 'read',\n    value: function read() {\n      var localStorageStatsString = localStorage.getItem(this.key);\n      try {\n        return JSON.parse(localStorageStatsString ? localStorageStatsString : '{}');\n      } catch (e) {\n        return {};\n      }\n    }\n  }, {\n    key: 'write',\n    value: function write(data) {\n      localStorage.setItem(this.key, data);\n    }\n  }, {\n    key: 'clear',\n    value: function clear() {\n      localStorage.removeItem(this.key);\n    }\n  }, {\n    key: 'isEmpty',\n    value: function isEmpty() {\n      var storedStats = this.read();\n      var empty = true;\n      Object.keys(storedStats).forEach(function (key) {\n        if (Object.keys(storedStats[key]).length > 0) {\n          empty = false;\n        }\n      });\n       return empty;\n    }\n  }]);\n  return StatisticsStorage;\n  }();\n  var StatisticsSender = function () {\n  function StatisticsSender(url, logger) {\n    classCallCheck(this, StatisticsSender);\n     this.url = url;\n    this.logger = logger;\n  }\n   createClass(StatisticsSender, [{\n    key: 'send',\n    value: function send(data, errorHandler) {\n      var logger = this.logger;\n       if (navigator.onLine === false) {\n        logger.debug(\"Offline, can't send\");\n        errorHandler();\n        return;\n      }\n      logger.debug(\"Sending data to \" + this.url);\n       var req = new XMLHttpRequest();\n      req.withCredentials = true;\n      req.addEventListener(\"load\", function () {\n        // Stats sent, nothing more to do\n        logger.debug(\"Response: \" + req.responseText);\n      });\n      req.addEventListener(\"error\", function () {\n        logger.debug(\"Send failed\");\n        errorHandler();\n      });\n      req.addEventListener(\"abort\", function () {\n        logger.debug(\"Send aborted\");\n        errorHandler();\n      });\n      req.open(\"POST\", this.url);\n      req.setRequestHeader(\"Content-Type\", \"application/json\");\n      req.send(data);\n    }\n  }]);\n  return StatisticsSender;\n  }();\n  var StatisticsLogger = function () {\n  function StatisticsLogger(id) {\n    classCallCheck(this, StatisticsLogger);\n     this.id = id;\n  }\n   createClass(StatisticsLogger, [{\n    key: '_isDebug',\n    value: function _isDebug() {\n      return localStorage.getItem(\"vaadin.\" + this.id + \".debug\");\n    }\n  }, {\n    key: 'debug',\n    value: function debug(msg) {\n      if (this._isDebug()) {\n        console.info(this.id + \": \" + msg);\n      }\n    }\n  }]);\n  return StatisticsLogger;\n  }();\n  var UsageStatistics = function () {\n  function UsageStatistics() {\n    classCallCheck(this, UsageStatistics);\n     this.now = new Date();\n    this.timeNow = this.now.getTime();\n    this.gatherDelay = 10; // Delay between loading this file and gathering stats\n    this.initialDelay = 24 * 60 * 60;\n     this.logger = new StatisticsLogger(\"statistics\");\n    this.storage = new StatisticsStorage(\"vaadin.statistics.basket\");\n    this.gatherer = new StatisticsGatherer(this.logger);\n    this.sender = new StatisticsSender(\"https://tools.vaadin.com/usage-stats/submit\", this.logger);\n  }\n   createClass(UsageStatistics, [{\n    key: 'maybeGatherAndSend',\n    value: function maybeGatherAndSend() {\n      var _this = this;\n       if (localStorage.getItem(UsageStatistics.optOutKey)) {\n        return;\n      }\n      this.gatherer.gather(this.storage);\n      setTimeout(function () {\n        _this.maybeSend();\n      }, this.gatherDelay * 1000);\n    }\n  }, {\n    key: 'lottery',\n    value: function lottery() {\n      return true;\n    }\n  }, {\n    key: 'currentMonth',\n    value: function currentMonth() {\n      return this.now.getYear() * 12 + this.now.getMonth();\n    }\n  }, {\n    key: 'maybeSend',\n    value: function maybeSend() {\n      var firstUse = Number(localStorage.getItem(UsageStatistics.firstUseKey));\n      var monthProcessed = Number(localStorage.getItem(UsageStatistics.monthProcessedKey));\n       if (!firstUse) {\n        // Use a grace period to avoid interfering with tests, incognito mode etc\n        firstUse = this.timeNow;\n        localStorage.setItem(UsageStatistics.firstUseKey, firstUse);\n      }\n       if (this.timeNow < firstUse + this.initialDelay * 1000) {\n        this.logger.debug(\"No statistics will be sent until the initial delay of \" + this.initialDelay + \"s has passed\");\n        return;\n      }\n      if (this.currentMonth() <= monthProcessed) {\n        this.logger.debug(\"This month has already been processed\");\n        return;\n      }\n      localStorage.setItem(UsageStatistics.monthProcessedKey, this.currentMonth());\n      // Use random sampling\n      if (this.lottery()) {\n        this.logger.debug(\"Congratulations, we have a winner!\");\n      } else {\n        this.logger.debug(\"Sorry, no stats from you this time\");\n        return;\n      }\n       this.send();\n    }\n  }, {\n    key: 'send',\n    value: function send() {\n      // Ensure we have the latest data\n      this.gatherer.gather(this.storage);\n       // Read, send and clean up\n      var data = this.storage.read();\n      data[\"firstUse\"] = Number(localStorage.getItem(UsageStatistics.firstUseKey));\n      data[\"usageStatisticsVersion\"] = UsageStatistics.version;\n      var info = 'This request contains usage statistics gathered from the application running in development mode. \\n\\nStatistics gathering is automatically disabled and excluded from production builds.\\n\\nFor details and to opt-out, see https://github.com/vaadin/vaadin-usage-statistics.\\n\\n\\n\\n';\n      var self = this;\n      this.sender.send(info + JSON.stringify(data), function () {\n        // Revert the 'month processed' flag\n        localStorage.setItem(UsageStatistics.monthProcessedKey, self.currentMonth() - 1);\n      });\n    }\n  }], [{\n    key: 'version',\n    get: function get$1() {\n      return '2.1.2';\n    }\n  }, {\n    key: 'firstUseKey',\n    get: function get$1() {\n      return 'vaadin.statistics.firstuse';\n    }\n  }, {\n    key: 'monthProcessedKey',\n    get: function get$1() {\n      return 'vaadin.statistics.monthProcessed';\n    }\n  }, {\n    key: 'optOutKey',\n    get: function get$1() {\n      return 'vaadin.statistics.optout';\n    }\n  }]);\n  return UsageStatistics;\n  }();\n  try {\n  window.Vaadin = window.Vaadin || {};\n  window.Vaadin.usageStatsChecker = window.Vaadin.usageStatsChecker || new UsageStatistics();\n  window.Vaadin.usageStatsChecker.maybeGatherAndSend();\n  } catch (e) {\n  // Intentionally ignored as this is not a problem in the app being developed\n  }\n  }());\n   vaadin-dev-mode:end **/\n}\nexport const usageStatistics = function () {\n  if (typeof runIfDevelopmentMode === 'function') {\n    return runIfDevelopmentMode(maybeGatherAndSendStats);\n  }\n};","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { setCancelSyntheticClickEvents } from '@polymer/polymer/lib/utils/settings.js';\nimport { usageStatistics } from '@vaadin/vaadin-usage-statistics/vaadin-usage-statistics.js';\nimport { idlePeriod } from './async.js';\nimport { Debouncer, enqueueDebouncer } from './debounce.js';\nimport { DirMixin } from './dir-mixin.js';\n\n// This setting affects the legacy Polymer gestures which get activated\n// once you import any iron component e.g iron-icon.\n// It has to be explicitly disabled to prevent click issues in iOS + VoiceOver\n// for buttons that are based on `[role=button]` e.g vaadin-button.\nsetCancelSyntheticClickEvents(false);\nif (!window.Vaadin) {\n  window.Vaadin = {};\n}\n\n/**\n * Array of Vaadin custom element classes that have been finalized.\n */\nif (!window.Vaadin.registrations) {\n  window.Vaadin.registrations = [];\n}\nif (!window.Vaadin.developmentModeCallback) {\n  window.Vaadin.developmentModeCallback = {};\n}\nwindow.Vaadin.developmentModeCallback['vaadin-usage-statistics'] = function () {\n  usageStatistics();\n};\nlet statsJob;\nconst registered = new Set();\n\n/**\n * @polymerMixin\n * @mixes DirMixin\n */\nexport const ElementMixin = superClass => class VaadinElementMixin extends DirMixin(superClass) {\n  /** @protected */\n  static finalize() {\n    super.finalize();\n    const is = this.is;\n\n    // Registers a class prototype for telemetry purposes.\n    if (is && !registered.has(is)) {\n      window.Vaadin.registrations.push(this);\n      registered.add(is);\n      if (window.Vaadin.developmentModeCallback) {\n        statsJob = Debouncer.debounce(statsJob, idlePeriod, () => {\n          window.Vaadin.developmentModeCallback['vaadin-usage-statistics']();\n        });\n        enqueueDebouncer(statsJob);\n      }\n    }\n  }\n  constructor() {\n    super();\n    if (document.doctype === null) {\n      console.warn('Vaadin components require the \"standards mode\" declaration. Please add <!DOCTYPE html> to the HTML document.');\n    }\n  }\n};","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';\nconst observer = new ResizeObserver(entries => {\n  setTimeout(() => {\n    entries.forEach(entry => {\n      // Notify child resizables, if any\n      if (entry.target.resizables) {\n        entry.target.resizables.forEach(resizable => {\n          resizable._onResize(entry.contentRect);\n        });\n      } else {\n        entry.target._onResize(entry.contentRect);\n      }\n    });\n  });\n});\n\n/**\n * A mixin that uses a ResizeObserver to listen to host size changes.\n *\n * @polymerMixin\n */\nexport const ResizeMixin = dedupingMixin(superclass => class ResizeMixinClass extends superclass {\n  /**\n   * When true, the parent element resize will be also observed.\n   * Override this getter and return `true` to enable this.\n   *\n   * @protected\n   */\n  get _observeParent() {\n    return false;\n  }\n\n  /** @protected */\n  connectedCallback() {\n    super.connectedCallback();\n    observer.observe(this);\n    if (this._observeParent) {\n      const parent = this.parentNode instanceof ShadowRoot ? this.parentNode.host : this.parentNode;\n      if (!parent.resizables) {\n        parent.resizables = new Set();\n        observer.observe(parent);\n      }\n      parent.resizables.add(this);\n      this.__parent = parent;\n    }\n  }\n\n  /** @protected */\n  disconnectedCallback() {\n    super.disconnectedCallback();\n    observer.unobserve(this);\n    const parent = this.__parent;\n    if (this._observeParent && parent) {\n      const resizables = parent.resizables;\n      if (resizables) {\n        resizables.delete(this);\n        if (resizables.size === 0) {\n          observer.unobserve(parent);\n        }\n      }\n      this.__parent = null;\n    }\n  }\n\n  /**\n   * A handler invoked on host resize. By default, it does nothing.\n   * Override the method to implement your own behavior.\n   *\n   * @protected\n   */\n  _onResize(_contentRect) {\n    // To be implemented.\n  }\n});","/**\n * @license\n * Copyright (c) 2023 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n/**\n * A helper for observing slot changes.\n */\nexport class SlotObserver {\n  constructor(slot, callback) {\n    /** @type HTMLSlotElement */\n    this.slot = slot;\n\n    /** @type Function */\n    this.callback = callback;\n\n    /** @type {Node[]} */\n    this._storedNodes = [];\n    this._connected = false;\n    this._scheduled = false;\n    this._boundSchedule = () => {\n      this._schedule();\n    };\n    this.connect();\n    this._schedule();\n  }\n\n  /**\n   * Activates an observer. This method is automatically called when\n   * a `SlotObserver` is created. It should only be called to  re-activate\n   * an observer that has been deactivated via the `disconnect` method.\n   */\n  connect() {\n    this.slot.addEventListener('slotchange', this._boundSchedule);\n    this._connected = true;\n  }\n\n  /**\n   * Deactivates the observer. After calling this method the observer callback\n   * will not be called when changes to slotted nodes occur. The `connect` method\n   * may be subsequently called to reactivate the observer.\n   */\n  disconnect() {\n    this.slot.removeEventListener('slotchange', this._boundSchedule);\n    this._connected = false;\n  }\n\n  /** @private */\n  _schedule() {\n    if (!this._scheduled) {\n      this._scheduled = true;\n      queueMicrotask(() => {\n        this.flush();\n      });\n    }\n  }\n\n  /**\n   * Run the observer callback synchronously.\n   */\n  flush() {\n    if (!this._connected) {\n      return;\n    }\n    this._scheduled = false;\n    this._processNodes();\n  }\n\n  /** @private */\n  _processNodes() {\n    const currentNodes = this.slot.assignedNodes({\n      flatten: true\n    });\n    let addedNodes = [];\n    const removedNodes = [];\n    const movedNodes = [];\n    if (currentNodes.length) {\n      addedNodes = currentNodes.filter(node => !this._storedNodes.includes(node));\n    }\n    if (this._storedNodes.length) {\n      this._storedNodes.forEach((node, index) => {\n        const idx = currentNodes.indexOf(node);\n        if (idx === -1) {\n          removedNodes.push(node);\n        } else if (idx !== index) {\n          movedNodes.push(node);\n        }\n      });\n    }\n    if (addedNodes.length || removedNodes.length || movedNodes.length) {\n      this.callback({\n        addedNodes,\n        currentNodes,\n        movedNodes,\n        removedNodes\n      });\n    }\n    this._storedNodes = currentNodes;\n  }\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { isEmptyTextNode } from './dom-utils.js';\nimport { SlotObserver } from './slot-observer.js';\nimport { generateUniqueId } from './unique-id-utils.js';\n\n/**\n * A controller for providing content to slot element and observing changes.\n */\nexport class SlotController extends EventTarget {\n  /**\n   * Ensure that every instance has unique ID.\n   *\n   * @param {HTMLElement} host\n   * @param {string} slotName\n   * @return {string}\n   * @protected\n   */\n  static generateId(host) {\n    let prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'default';\n    return `${prefix}-${host.localName}-${generateUniqueId()}`;\n  }\n  constructor(host, slotName, tagName) {\n    let config = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n    super();\n    const initializer = config.initializer,\n      multiple = config.multiple,\n      observe = config.observe,\n      useUniqueId = config.useUniqueId,\n      uniqueIdPrefix = config.uniqueIdPrefix;\n    this.host = host;\n    this.slotName = slotName;\n    this.tagName = tagName;\n    this.observe = typeof observe === 'boolean' ? observe : true;\n    this.multiple = typeof multiple === 'boolean' ? multiple : false;\n    this.slotInitializer = initializer;\n    if (multiple) {\n      this.nodes = [];\n    }\n\n    // Only generate the default ID if requested by the controller.\n    if (useUniqueId) {\n      this.defaultId = this.constructor.generateId(host, uniqueIdPrefix || slotName);\n    }\n  }\n  hostConnected() {\n    if (!this.initialized) {\n      if (this.multiple) {\n        this.initMultiple();\n      } else {\n        this.initSingle();\n      }\n      if (this.observe) {\n        this.observeSlot();\n      }\n      this.initialized = true;\n    }\n  }\n\n  /** @protected */\n  initSingle() {\n    let node = this.getSlotChild();\n    if (!node) {\n      node = this.attachDefaultNode();\n      this.initNode(node);\n    } else {\n      this.node = node;\n      this.initAddedNode(node);\n    }\n  }\n\n  /** @protected */\n  initMultiple() {\n    const children = this.getSlotChildren();\n    if (children.length === 0) {\n      const defaultNode = this.attachDefaultNode();\n      if (defaultNode) {\n        this.nodes = [defaultNode];\n        this.initNode(defaultNode);\n      }\n    } else {\n      this.nodes = children;\n      children.forEach(node => {\n        this.initAddedNode(node);\n      });\n    }\n  }\n\n  /**\n   * Create and attach default node using the provided tag name, if any.\n   * @return {Node | undefined}\n   * @protected\n   */\n  attachDefaultNode() {\n    const host = this.host,\n      slotName = this.slotName,\n      tagName = this.tagName;\n\n    // Check if the node was created previously and if so, reuse it.\n    let node = this.defaultNode;\n\n    // Tag name is optional, sometimes we don't init default content.\n    if (!node && tagName) {\n      node = document.createElement(tagName);\n      if (node instanceof Element) {\n        if (slotName !== '') {\n          node.setAttribute('slot', slotName);\n        }\n        this.defaultNode = node;\n      }\n    }\n    if (node) {\n      this.node = node;\n      host.appendChild(node);\n    }\n    return node;\n  }\n\n  /**\n   * Return the list of nodes matching the slot managed by the controller.\n   * @return {Node}\n   */\n  getSlotChildren() {\n    const slotName = this.slotName;\n    return Array.from(this.host.childNodes).filter(node => {\n      // Either an element (any slot) or a text node (only un-named slot).\n      return node.nodeType === Node.ELEMENT_NODE && node.slot === slotName || node.nodeType === Node.TEXT_NODE && node.textContent.trim() && slotName === '';\n    });\n  }\n\n  /**\n   * Return a reference to the node managed by the controller.\n   * @return {Node}\n   */\n  getSlotChild() {\n    return this.getSlotChildren()[0];\n  }\n\n  /**\n   * Run `slotInitializer` for the node managed by the controller.\n   *\n   * @param {Node} node\n   * @protected\n   */\n  initNode(node) {\n    const slotInitializer = this.slotInitializer;\n    // Don't try to bind `this` to initializer (normally it's arrow function).\n    // Instead, pass the host as a first argument to access component's state.\n    if (slotInitializer) {\n      slotInitializer(node, this.host);\n    }\n  }\n\n  /**\n   * Override to initialize the newly added custom node.\n   *\n   * @param {Node} _node\n   * @protected\n   */\n  initCustomNode(_node) {}\n\n  /**\n   * Override to teardown slotted node when it's removed.\n   *\n   * @param {Node} _node\n   * @protected\n   */\n  teardownNode(_node) {}\n\n  /**\n   * Run both `initCustomNode` and `initNode` for a custom slotted node.\n   *\n   * @param {Node} node\n   * @protected\n   */\n  initAddedNode(node) {\n    if (node !== this.defaultNode) {\n      this.initCustomNode(node);\n      this.initNode(node);\n    }\n  }\n\n  /**\n   * Setup the observer to manage slot content changes.\n   * @protected\n   */\n  observeSlot() {\n    const slotName = this.slotName;\n    const selector = slotName === '' ? 'slot:not([name])' : `slot[name=${slotName}]`;\n    const slot = this.host.shadowRoot.querySelector(selector);\n    this.__slotObserver = new SlotObserver(slot, _ref => {\n      let addedNodes = _ref.addedNodes,\n        removedNodes = _ref.removedNodes;\n      const current = this.multiple ? this.nodes : [this.node];\n\n      // Calling `slot.assignedNodes()` includes whitespace text nodes in case of default slot:\n      // unlike comment nodes, they are not filtered out. So we need to manually ignore them.\n      const newNodes = addedNodes.filter(node => !isEmptyTextNode(node) && !current.includes(node));\n      if (removedNodes.length) {\n        this.nodes = current.filter(node => !removedNodes.includes(node));\n        removedNodes.forEach(node => {\n          this.teardownNode(node);\n        });\n      }\n      if (newNodes && newNodes.length > 0) {\n        if (this.multiple) {\n          // Remove default node if exists\n          if (this.defaultNode) {\n            this.defaultNode.remove();\n          }\n          this.nodes = [...current, ...newNodes].filter(node => node !== this.defaultNode);\n          newNodes.forEach(node => {\n            this.initAddedNode(node);\n          });\n        } else {\n          // Remove previous node if exists\n          if (this.node) {\n            this.node.remove();\n          }\n          this.node = newNodes[0];\n          this.initAddedNode(this.node);\n        }\n      }\n    });\n  }\n}","/**\n * @license\n * Copyright (c) 2022 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { SlotController } from './slot-controller.js';\n\n/**\n * A controller that manages the slotted tooltip element.\n */\nexport class TooltipController extends SlotController {\n  constructor(host) {\n    // Do not provide slot factory to create tooltip lazily.\n    super(host, 'tooltip');\n    this.setTarget(host);\n  }\n\n  /**\n   * Override to initialize the newly added custom tooltip.\n   *\n   * @param {Node} tooltipNode\n   * @protected\n   * @override\n   */\n  initCustomNode(tooltipNode) {\n    tooltipNode.target = this.target;\n    if (this.ariaTarget !== undefined) {\n      tooltipNode.ariaTarget = this.ariaTarget;\n    }\n    if (this.context !== undefined) {\n      tooltipNode.context = this.context;\n    }\n    if (this.manual !== undefined) {\n      tooltipNode.manual = this.manual;\n    }\n    if (this.opened !== undefined) {\n      tooltipNode.opened = this.opened;\n    }\n    if (this.position !== undefined) {\n      tooltipNode._position = this.position;\n    }\n    if (this.shouldShow !== undefined) {\n      tooltipNode.shouldShow = this.shouldShow;\n    }\n    this.__notifyChange();\n  }\n\n  /**\n   * Override to notify the host when the tooltip is removed.\n   *\n   * @param {Node} tooltipNode\n   * @protected\n   * @override\n   */\n  teardownNode() {\n    this.__notifyChange();\n  }\n\n  /**\n   * Set an HTML element for linking with the tooltip overlay\n   * via `aria-describedby` attribute used by screen readers.\n   * @param {HTMLElement} ariaTarget\n   */\n  setAriaTarget(ariaTarget) {\n    this.ariaTarget = ariaTarget;\n    const tooltipNode = this.node;\n    if (tooltipNode) {\n      tooltipNode.ariaTarget = ariaTarget;\n    }\n  }\n\n  /**\n   * Set a context object to be used by generator.\n   * @param {object} context\n   */\n  setContext(context) {\n    this.context = context;\n    const tooltipNode = this.node;\n    if (tooltipNode) {\n      tooltipNode.context = context;\n    }\n  }\n\n  /**\n   * Toggle manual state on the slotted tooltip.\n   * @param {boolean} manual\n   */\n  setManual(manual) {\n    this.manual = manual;\n    const tooltipNode = this.node;\n    if (tooltipNode) {\n      tooltipNode.manual = manual;\n    }\n  }\n\n  /**\n   * Toggle opened state on the slotted tooltip.\n   * @param {boolean} opened\n   */\n  setOpened(opened) {\n    this.opened = opened;\n    const tooltipNode = this.node;\n    if (tooltipNode) {\n      tooltipNode.opened = opened;\n    }\n  }\n\n  /**\n   * Set default position for the slotted tooltip.\n   * This can be overridden by setting the position\n   * using corresponding property or attribute.\n   * @param {string} position\n   */\n  setPosition(position) {\n    this.position = position;\n    const tooltipNode = this.node;\n    if (tooltipNode) {\n      tooltipNode._position = position;\n    }\n  }\n\n  /**\n   * Set function used to detect whether to show\n   * the tooltip based on a condition.\n   * @param {Function} shouldShow\n   */\n  setShouldShow(shouldShow) {\n    this.shouldShow = shouldShow;\n    const tooltipNode = this.node;\n    if (tooltipNode) {\n      tooltipNode.shouldShow = shouldShow;\n    }\n  }\n\n  /**\n   * Set an HTML element to attach the tooltip to.\n   * @param {HTMLElement} target\n   */\n  setTarget(target) {\n    this.target = target;\n    const tooltipNode = this.node;\n    if (tooltipNode) {\n      tooltipNode.target = target;\n    }\n  }\n\n  /** @private */\n  __notifyChange() {\n    this.dispatchEvent(new CustomEvent('tooltip-changed', {\n      detail: {\n        node: this.node\n      }\n    }));\n  }\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { DisabledMixin } from './disabled-mixin.js';\n\n/**\n * A mixin to toggle the `tabindex` attribute.\n *\n * The attribute is set to -1 whenever the user disables the element\n * and restored with the last known value once the element is enabled.\n *\n * @polymerMixin\n * @mixes DisabledMixin\n */\nexport const TabindexMixin = superclass => class TabindexMixinClass extends DisabledMixin(superclass) {\n  static get properties() {\n    return {\n      /**\n       * Indicates whether the element can be focused and where it participates in sequential keyboard navigation.\n       *\n       * @protected\n       */\n      tabindex: {\n        type: Number,\n        reflectToAttribute: true,\n        observer: '_tabindexChanged'\n      },\n      /**\n       * Stores the last known tabindex since the element has been disabled.\n       *\n       * @protected\n       */\n      _lastTabIndex: {\n        type: Number\n      }\n    };\n  }\n\n  /**\n   * When the element gets disabled, the observer saves the last known tabindex\n   * and makes the element not focusable by setting tabindex to -1.\n   * As soon as the element gets enabled, the observer restores the last known tabindex\n   * so that the element can be focusable again.\n   *\n   * @protected\n   * @override\n   */\n  _disabledChanged(disabled, oldDisabled) {\n    super._disabledChanged(disabled, oldDisabled);\n    if (disabled) {\n      if (this.tabindex !== undefined) {\n        this._lastTabIndex = this.tabindex;\n      }\n      this.tabindex = -1;\n    } else if (oldDisabled) {\n      this.tabindex = this._lastTabIndex;\n    }\n  }\n\n  /**\n   * When the user has changed tabindex while the element is disabled,\n   * the observer reverts tabindex to -1 and rather saves the new tabindex value to apply it later.\n   * The new value will be applied as soon as the element becomes enabled.\n   *\n   * @protected\n   */\n  _tabindexChanged(tabindex) {\n    if (this.disabled && tabindex !== -1) {\n      this._lastTabIndex = tabindex;\n      this.tabindex = -1;\n    }\n  }\n};","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';\nimport { FocusMixin } from './focus-mixin.js';\nimport { TabindexMixin } from './tabindex-mixin.js';\n\n/**\n * A mixin to forward focus to an element in the light DOM.\n *\n * @polymerMixin\n * @mixes FocusMixin\n * @mixes TabindexMixin\n */\nexport const DelegateFocusMixin = dedupingMixin(superclass => class DelegateFocusMixinClass extends FocusMixin(TabindexMixin(superclass)) {\n  static get properties() {\n    return {\n      /**\n       * Specify that this control should have input focus when the page loads.\n       */\n      autofocus: {\n        type: Boolean\n      },\n      /**\n       * A reference to the focusable element controlled by the mixin.\n       * It can be an input, textarea, button or any element with tabindex > -1.\n       *\n       * Any component implementing this mixin is expected to provide it\n       * by using `this._setFocusElement(input)` Polymer API.\n       *\n       * Toggling `tabindex` attribute on the host element propagates its value to `focusElement`.\n       *\n       * @protected\n       * @type {!HTMLElement}\n       */\n      focusElement: {\n        type: Object,\n        readOnly: true,\n        observer: '_focusElementChanged'\n      },\n      /**\n       * Override the property from `TabIndexMixin`\n       * to ensure the `tabindex` attribute of the focus element\n       * will be restored to `0` after re-enabling the element.\n       *\n       * @protected\n       * @override\n       */\n      _lastTabIndex: {\n        value: 0\n      }\n    };\n  }\n  constructor() {\n    super();\n    this._boundOnBlur = this._onBlur.bind(this);\n    this._boundOnFocus = this._onFocus.bind(this);\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n    if (this.autofocus && !this.disabled) {\n      requestAnimationFrame(() => {\n        this.focus();\n        this.setAttribute('focus-ring', '');\n      });\n    }\n  }\n\n  /**\n   * @protected\n   * @override\n   */\n  focus() {\n    if (this.focusElement && !this.disabled) {\n      this.focusElement.focus();\n    }\n  }\n\n  /**\n   * @protected\n   * @override\n   */\n  blur() {\n    if (this.focusElement) {\n      this.focusElement.blur();\n    }\n  }\n\n  /**\n   * @protected\n   * @override\n   */\n  click() {\n    if (this.focusElement && !this.disabled) {\n      this.focusElement.click();\n    }\n  }\n\n  /** @protected */\n  _focusElementChanged(element, oldElement) {\n    if (element) {\n      element.disabled = this.disabled;\n      this._addFocusListeners(element);\n      this.__forwardTabIndex(this.tabindex);\n    } else if (oldElement) {\n      this._removeFocusListeners(oldElement);\n    }\n  }\n\n  /**\n   * @param {HTMLElement} element\n   * @protected\n   */\n  _addFocusListeners(element) {\n    element.addEventListener('blur', this._boundOnBlur);\n    element.addEventListener('focus', this._boundOnFocus);\n  }\n\n  /**\n   * @param {HTMLElement} element\n   * @protected\n   */\n  _removeFocusListeners(element) {\n    element.removeEventListener('blur', this._boundOnBlur);\n    element.removeEventListener('focus', this._boundOnFocus);\n  }\n\n  /**\n   * Focus event does not bubble, so we dispatch it manually\n   * on the host element to support adding focus listeners\n   * when the focusable element is placed in light DOM.\n   * @param {FocusEvent} event\n   * @protected\n   */\n  _onFocus(event) {\n    event.stopPropagation();\n    this.dispatchEvent(new Event('focus'));\n  }\n\n  /**\n   * Blur event does not bubble, so we dispatch it manually\n   * on the host element to support adding blur listeners\n   * when the focusable element is placed in light DOM.\n   * @param {FocusEvent} event\n   * @protected\n   */\n  _onBlur(event) {\n    event.stopPropagation();\n    this.dispatchEvent(new Event('blur'));\n  }\n\n  /**\n   * @param {FocusEvent} event\n   * @return {boolean}\n   * @protected\n   * @override\n   */\n  _shouldSetFocus(event) {\n    return event.target === this.focusElement;\n  }\n\n  /**\n   * @param {FocusEvent} event\n   * @return {boolean}\n   * @protected\n   * @override\n   */\n  _shouldRemoveFocus(event) {\n    return event.target === this.focusElement;\n  }\n\n  /**\n   * @param {boolean} disabled\n   * @param {boolean} oldDisabled\n   * @protected\n   * @override\n   */\n  _disabledChanged(disabled, oldDisabled) {\n    super._disabledChanged(disabled, oldDisabled);\n    if (this.focusElement) {\n      this.focusElement.disabled = disabled;\n    }\n    if (disabled) {\n      this.blur();\n    }\n  }\n\n  /**\n   * Override an observer from `TabindexMixin`.\n   * Do not call super to remove tabindex attribute\n   * from the host after it has been forwarded.\n   * @param {string} tabindex\n   * @protected\n   * @override\n   */\n  _tabindexChanged(tabindex) {\n    this.__forwardTabIndex(tabindex);\n  }\n\n  /** @private */\n  __forwardTabIndex(tabindex) {\n    if (tabindex !== undefined && this.focusElement) {\n      this.focusElement.tabIndex = tabindex;\n\n      // Preserve tabindex=\"-1\" on the host element\n      if (tabindex !== -1) {\n        this.tabindex = undefined;\n      }\n    }\n    if (this.disabled && tabindex) {\n      // If tabindex attribute was changed while component was disabled\n      if (tabindex !== -1) {\n        this._lastTabIndex = tabindex;\n      }\n      this.tabindex = undefined;\n    }\n  }\n});","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';\nconst stylesMap = new WeakMap();\n\n/**\n * Get all the styles inserted into root.\n * @param {DocumentOrShadowRoot} root\n * @return {Set<string>}\n */\nfunction getRootStyles(root) {\n  if (!stylesMap.has(root)) {\n    stylesMap.set(root, new Set());\n  }\n  return stylesMap.get(root);\n}\n\n/**\n * Insert styles into the root.\n * @param {string} styles\n * @param {DocumentOrShadowRoot} root\n */\nfunction insertStyles(styles, root) {\n  const style = document.createElement('style');\n  style.textContent = styles;\n  if (root === document) {\n    document.head.appendChild(style);\n  } else {\n    root.insertBefore(style, root.firstChild);\n  }\n}\n\n/**\n * Mixin to insert styles into the outer scope to handle slotted components.\n * This is useful e.g. to hide native `<input type=\"number\">` controls.\n *\n * @polymerMixin\n */\nexport const SlotStylesMixin = dedupingMixin(superclass => class SlotStylesMixinClass extends superclass {\n  /**\n   * List of styles to insert into root.\n   * @protected\n   */\n  get slotStyles() {\n    return {};\n  }\n\n  /** @protected */\n  connectedCallback() {\n    super.connectedCallback();\n    this.__applySlotStyles();\n  }\n\n  /** @private */\n  __applySlotStyles() {\n    const root = this.getRootNode();\n    const rootStyles = getRootStyles(root);\n    this.slotStyles.forEach(styles => {\n      if (!rootStyles.has(styles)) {\n        insertStyles(styles, root);\n        rootStyles.add(styles);\n      }\n    });\n  }\n});","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { KeyboardMixin } from '@vaadin/a11y-base/src/keyboard-mixin.js';\nimport { isTouch } from '@vaadin/component-base/src/browser-utils.js';\nimport { InputMixin } from './input-mixin.js';\n\n/**\n * A mixin that manages the clear button.\n *\n * @polymerMixin\n * @mixes InputMixin\n * @mixes KeyboardMixin\n */\nexport const ClearButtonMixin = superclass => class ClearButtonMixinClass extends InputMixin(KeyboardMixin(superclass)) {\n  static get properties() {\n    return {\n      /**\n       * Set to true to display the clear icon which clears the input.\n       *\n       * It is up to the component to choose where to place the clear icon:\n       * in the Shadow DOM or in the light DOM. In any way, a reference to\n       * the clear icon element should be provided via the `clearElement` getter.\n       *\n       * @attr {boolean} clear-button-visible\n       */\n      clearButtonVisible: {\n        type: Boolean,\n        reflectToAttribute: true,\n        value: false\n      }\n    };\n  }\n\n  /**\n   * Any element extending this mixin is required to implement this getter.\n   * It returns the reference to the clear button element.\n   *\n   * @protected\n   * @return {Element | null | undefined}\n   */\n  get clearElement() {\n    console.warn(`Please implement the 'clearElement' property in <${this.localName}>`);\n    return null;\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n    if (this.clearElement) {\n      this.clearElement.addEventListener('mousedown', event => this._onClearButtonMouseDown(event));\n      this.clearElement.addEventListener('click', event => this._onClearButtonClick(event));\n    }\n  }\n\n  /**\n   * @param {Event} event\n   * @protected\n   */\n  _onClearButtonClick(event) {\n    event.preventDefault();\n    this._onClearAction();\n  }\n\n  /**\n   * @param {MouseEvent} event\n   * @protected\n   */\n  _onClearButtonMouseDown(event) {\n    event.preventDefault();\n    if (!isTouch) {\n      this.inputElement.focus();\n    }\n  }\n\n  /**\n   * Override an event listener inherited from `KeydownMixin` to clear on Esc.\n   * Components that extend this mixin can prevent this behavior by overriding\n   * this method without calling `super._onEscape` to provide custom logic.\n   *\n   * @param {KeyboardEvent} event\n   * @protected\n   * @override\n   */\n  _onEscape(event) {\n    super._onEscape(event);\n    if (this.clearButtonVisible && !!this.value) {\n      event.stopPropagation();\n      this._onClearAction();\n    }\n  }\n\n  /**\n   * Clears the value and dispatches `input` and `change` events\n   * on the input element. This method should be called\n   * when the clear action originates from the user.\n   *\n   * @protected\n   */\n  _onClearAction() {\n    this._inputElementValue = '';\n    // Note, according to the HTML spec, the native change event isn't composed\n    // while the input event is composed.\n    this.inputElement.dispatchEvent(new Event('input', {\n      bubbles: true,\n      composed: true\n    }));\n    this.inputElement.dispatchEvent(new Event('change', {\n      bubbles: true\n    }));\n  }\n};","/**\n * @license\n * Copyright (c) 2023 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { addValueToAttribute, deserializeAttributeValue, removeValueFromAttribute, serializeAttributeValue } from '@vaadin/component-base/src/dom-utils.js';\nconst attributeToTargets = new Map();\n\n/**\n * Gets or creates a Set with the stored values for each element controlled by this helper\n *\n * @param {string} attr the attribute name used as key in the map\n *\n * @returns {WeakMap<HTMLElement, Set<string>} a weak map with the stored values for the elements being controlled by the helper\n */\nfunction getAttrMap(attr) {\n  if (!attributeToTargets.has(attr)) {\n    attributeToTargets.set(attr, new WeakMap());\n  }\n  return attributeToTargets.get(attr);\n}\n\n/**\n * Cleans the values set on the attribute to the given element.\n * It also stores the current values in the map, if `storeValue` is `true`.\n *\n * @param {HTMLElement} target\n * @param {string} attr the attribute to be cleared\n * @param {boolean} storeValue whether or not the current value of the attribute should be stored on the map\n * @returns\n */\nfunction cleanAriaIDReference(target, attr) {\n  if (!target) {\n    return;\n  }\n  target.removeAttribute(attr);\n}\n\n/**\n * Storing values of the accessible attributes in a Set inside of the WeakMap.\n *\n * @param {HTMLElement} target\n * @param {string} attr the attribute to be stored\n */\nfunction storeAriaIDReference(target, attr) {\n  if (!target || !attr) {\n    return;\n  }\n  const attributeMap = getAttrMap(attr);\n  if (attributeMap.has(target)) {\n    return;\n  }\n  const values = deserializeAttributeValue(target.getAttribute(attr));\n  attributeMap.set(target, new Set(values));\n}\n\n/**\n * Restores the generated values of the attribute to the given element.\n *\n * @param {HTMLElement} target\n * @param {string} attr\n */\nexport function restoreGeneratedAriaIDReference(target, attr) {\n  if (!target || !attr) {\n    return;\n  }\n  const attributeMap = getAttrMap(attr);\n  const values = attributeMap.get(target);\n  if (!values || values.size === 0) {\n    target.removeAttribute(attr);\n  } else {\n    addValueToAttribute(target, attr, serializeAttributeValue(values));\n  }\n  attributeMap.delete(target);\n}\n\n/**\n * Sets a new ID reference for a target element and an ARIA attribute.\n *\n * @typedef {Object} AriaIdReferenceConfig\n * @property {string | null | undefined} newId\n * @property {string | null | undefined} oldId\n * @property {boolean | null | undefined} fromUser\n * @param {HTMLElement} target\n * @param {string} attr\n * @param {AriaIdReferenceConfig | null | undefined} config\n * @param config.newId The new ARIA ID reference to set. If `null`, the attribute is removed,\n * and `config.fromUser` is true, any stored values are restored. If there are stored values\n * and `config.fromUser` is `false`, then `config.newId` is added to the stored values set.\n * @param config.oldId The ARIA ID reference to be removed from the attribute. If there are\n * stored values and `config.fromUser` is `false`, then `config.oldId` is removed from the\n * stored values set.\n * @param config.fromUser Indicates whether the function is called by the user or internally.\n * When `config.fromUser` is called with `true` for the first time, the function will clear\n * and store the attribute value for the given element.\n */\nexport function setAriaIDReference(target, attr) {\n  let config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {\n    newId: null,\n    oldId: null,\n    fromUser: false\n  };\n  if (!target || !attr) {\n    return;\n  }\n  const newId = config.newId,\n    oldId = config.oldId,\n    fromUser = config.fromUser;\n  const attributeMap = getAttrMap(attr);\n  const storedValues = attributeMap.get(target);\n  if (!fromUser && !!storedValues) {\n    // If there's any stored values, it means the attribute is being handled by the user\n    // Replace the \"oldId\" with \"newId\" on the stored values set and leave\n    oldId && storedValues.delete(oldId);\n    newId && storedValues.add(newId);\n    return;\n  }\n  if (fromUser) {\n    if (!storedValues) {\n      // If it's called from user and there's no stored values for the attribute,\n      // then store the current value\n      storeAriaIDReference(target, attr);\n    } else if (!newId) {\n      // If called from user with newId == null, it means the attribute will no longer\n      // be in control of the user and the stored values should be restored\n      // Removing the entry on the map for this target\n      attributeMap.delete(target);\n    }\n\n    // If it's from user, then clear the attribute value before setting newId\n    cleanAriaIDReference(target, attr);\n  }\n  removeValueFromAttribute(target, attr, oldId);\n  const attributeValue = !newId ? serializeAttributeValue(storedValues) : newId;\n  if (attributeValue) {\n    addValueToAttribute(target, attr, attributeValue);\n  }\n}\n\n/**\n * Removes the {@link attr | attribute} value of the given {@link target} element.\n * It also stores the current value, if no stored values are present.\n *\n * @param {HTMLElement} target\n * @param {string} attr\n */\nexport function removeAriaIDReference(target, attr) {\n  storeAriaIDReference(target, attr);\n  cleanAriaIDReference(target, attr);\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { removeAriaIDReference, restoreGeneratedAriaIDReference, setAriaIDReference } from './aria-id-reference.js';\n\n/**\n * A controller for managing ARIA attributes for a field element:\n * either the component itself or slotted `<input>` element.\n */\nexport class FieldAriaController {\n  constructor(host) {\n    this.host = host;\n    this.__required = false;\n  }\n\n  /**\n   * Sets a target element to which ARIA attributes are added.\n   *\n   * @param {HTMLElement} target\n   */\n  setTarget(target) {\n    this.__target = target;\n    this.__setAriaRequiredAttribute(this.__required);\n    // We need to make sure that value in __labelId is stored\n    this.__setLabelIdToAriaAttribute(this.__labelId, this.__labelId);\n    if (this.__labelIdFromUser != null) {\n      this.__setLabelIdToAriaAttribute(this.__labelIdFromUser, this.__labelIdFromUser, true);\n    }\n    this.__setErrorIdToAriaAttribute(this.__errorId);\n    this.__setHelperIdToAriaAttribute(this.__helperId);\n    this.setAriaLabel(this.__label);\n  }\n\n  /**\n   * Toggles the `aria-required` attribute on the target element\n   * if the target is the host component (e.g. a field group).\n   * Otherwise, it does nothing.\n   *\n   * @param {boolean} required\n   */\n  setRequired(required) {\n    this.__setAriaRequiredAttribute(required);\n    this.__required = required;\n  }\n\n  /**\n   * Defines the `aria-label` attribute of the target element.\n   *\n   * To remove the attribute, pass `null` as `label`.\n   *\n   * @param {string | null | undefined} label\n   */\n  setAriaLabel(label) {\n    this.__setAriaLabelToAttribute(label);\n    this.__label = label;\n  }\n\n  /**\n   * Links the target element with a slotted label element\n   * via the target's attribute `aria-labelledby`.\n   *\n   * To unlink the previous slotted label element, pass `null` as `labelId`.\n   *\n   * @param {string | null} labelId\n   */\n  setLabelId(labelId) {\n    let fromUser = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n    const oldLabelId = fromUser ? this.__labelIdFromUser : this.__labelId;\n    this.__setLabelIdToAriaAttribute(labelId, oldLabelId, fromUser);\n    if (fromUser) {\n      this.__labelIdFromUser = labelId;\n    } else {\n      this.__labelId = labelId;\n    }\n  }\n\n  /**\n   * Links the target element with a slotted error element via the target's attribute:\n   * - `aria-labelledby` if the target is the host component (e.g a field group).\n   * - `aria-describedby` otherwise.\n   *\n   * To unlink the previous slotted error element, pass `null` as `errorId`.\n   *\n   * @param {string | null} errorId\n   */\n  setErrorId(errorId) {\n    this.__setErrorIdToAriaAttribute(errorId, this.__errorId);\n    this.__errorId = errorId;\n  }\n\n  /**\n   * Links the target element with a slotted helper element via the target's attribute:\n   * - `aria-labelledby` if the target is the host component (e.g a field group).\n   * - `aria-describedby` otherwise.\n   *\n   * To unlink the previous slotted helper element, pass `null` as `helperId`.\n   *\n   * @param {string | null} helperId\n   */\n  setHelperId(helperId) {\n    this.__setHelperIdToAriaAttribute(helperId, this.__helperId);\n    this.__helperId = helperId;\n  }\n\n  /**\n   * @param {string | null | undefined} label\n   * @private\n   * */\n  __setAriaLabelToAttribute(label) {\n    if (!this.__target) {\n      return;\n    }\n    if (label) {\n      removeAriaIDReference(this.__target, 'aria-labelledby');\n      this.__target.setAttribute('aria-label', label);\n    } else if (this.__label) {\n      restoreGeneratedAriaIDReference(this.__target, 'aria-labelledby');\n      this.__target.removeAttribute('aria-label');\n    }\n  }\n\n  /**\n   * @param {string | null | undefined} labelId\n   * @param {string | null | undefined} oldLabelId\n   * @param {boolean | null | undefined} fromUser\n   * @private\n   */\n  __setLabelIdToAriaAttribute(labelId, oldLabelId, fromUser) {\n    setAriaIDReference(this.__target, 'aria-labelledby', {\n      newId: labelId,\n      oldId: oldLabelId,\n      fromUser\n    });\n  }\n\n  /**\n   * @param {string | null | undefined} errorId\n   * @param {string | null | undefined} oldErrorId\n   * @private\n   */\n  __setErrorIdToAriaAttribute(errorId, oldErrorId) {\n    setAriaIDReference(this.__target, 'aria-describedby', {\n      newId: errorId,\n      oldId: oldErrorId,\n      fromUser: false\n    });\n  }\n\n  /**\n   * @param {string | null | undefined} helperId\n   * @param {string | null | undefined} oldHelperId\n   * @private\n   */\n  __setHelperIdToAriaAttribute(helperId, oldHelperId) {\n    setAriaIDReference(this.__target, 'aria-describedby', {\n      newId: helperId,\n      oldId: oldHelperId,\n      fromUser: false\n    });\n  }\n\n  /**\n   * @param {boolean} required\n   * @private\n   */\n  __setAriaRequiredAttribute(required) {\n    if (!this.__target) {\n      return;\n    }\n    if (['input', 'textarea'].includes(this.__target.localName)) {\n      // Native <input> or <textarea>, required is enough\n      return;\n    }\n    if (required) {\n      this.__target.setAttribute('aria-required', 'true');\n    } else {\n      this.__target.removeAttribute('aria-required');\n    }\n  }\n}","function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }\nfunction _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\nfunction _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\n/**\n * @license\n * Copyright (c) 2022 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { SlotController } from './slot-controller.js';\n\n/**\n * A controller that observes slotted element mutations, especially ID attribute\n * and the text content, and fires an event to notify host element about those.\n */\nexport class SlotChildObserveController extends SlotController {\n  constructor(host, slot, tagName) {\n    let config = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n    super(host, slot, tagName, _objectSpread(_objectSpread({}, config), {}, {\n      useUniqueId: true\n    }));\n  }\n\n  /**\n   * Override to initialize the newly added custom node.\n   *\n   * @param {Node} node\n   * @protected\n   * @override\n   */\n  initCustomNode(node) {\n    this.__updateNodeId(node);\n    this.__notifyChange(node);\n  }\n\n  /**\n   * Override to notify the controller host about removal of\n   * the custom node, and to apply the default one if needed.\n   *\n   * @param {Node} _node\n   * @protected\n   * @override\n   */\n  teardownNode(_node) {\n    const node = this.getSlotChild();\n\n    // Custom node is added to the slot\n    if (node && node !== this.defaultNode) {\n      this.__notifyChange(node);\n    } else {\n      this.restoreDefaultNode();\n      this.updateDefaultNode(this.node);\n    }\n  }\n\n  /**\n   * Override method inherited from `SlotMixin`\n   * to set ID attribute on the default node.\n   *\n   * @return {Node}\n   * @protected\n   * @override\n   */\n  attachDefaultNode() {\n    const node = super.attachDefaultNode();\n    if (node) {\n      this.__updateNodeId(node);\n    }\n    return node;\n  }\n\n  /**\n   * Override to restore default node when a custom one is removed.\n   *\n   * @protected\n   */\n  restoreDefaultNode() {\n    // To be implemented\n  }\n\n  /**\n   * Override to update default node text on property change.\n   *\n   * @param {Node} node\n   * @protected\n   */\n  updateDefaultNode(node) {\n    this.__notifyChange(node);\n  }\n\n  /**\n   * Setup the mutation observer on the node to update ID and notify host.\n   * Node doesn't get observed automatically until this method is called.\n   *\n   * @param {Node} node\n   * @protected\n   */\n  observeNode(node) {\n    // Stop observing the previous node, if any.\n    if (this.__nodeObserver) {\n      this.__nodeObserver.disconnect();\n    }\n    this.__nodeObserver = new MutationObserver(mutations => {\n      mutations.forEach(mutation => {\n        const target = mutation.target;\n\n        // Ensure the mutation target is the currently connected node\n        // to ignore async mutations dispatched for removed element.\n        const isCurrentNodeMutation = target === this.node;\n        if (mutation.type === 'attributes') {\n          // We use attributeFilter to only observe ID mutation,\n          // no need to check for attribute name separately.\n          if (isCurrentNodeMutation) {\n            this.__updateNodeId(target);\n          }\n        } else if (isCurrentNodeMutation || target.parentElement === this.node) {\n          // Node text content has changed.\n          this.__notifyChange(this.node);\n        }\n      });\n    });\n\n    // Observe changes to node ID attribute, text content and children.\n    this.__nodeObserver.observe(node, {\n      attributes: true,\n      attributeFilter: ['id'],\n      childList: true,\n      subtree: true,\n      characterData: true\n    });\n  }\n\n  /**\n   * Returns true if a node is an HTML element with children,\n   * or is a defined custom element, or has non-empty text.\n   *\n   * @param {Node} node\n   * @return {boolean}\n   * @private\n   */\n  __hasContent(node) {\n    if (!node) {\n      return false;\n    }\n    return node.nodeType === Node.ELEMENT_NODE && (customElements.get(node.localName) || node.children.length > 0) || node.textContent && node.textContent.trim() !== '';\n  }\n\n  /**\n   * Fire an event to notify the controller host about node changes.\n   *\n   * @param {Node} node\n   * @private\n   */\n  __notifyChange(node) {\n    this.dispatchEvent(new CustomEvent('slot-content-changed', {\n      detail: {\n        hasContent: this.__hasContent(node),\n        node\n      }\n    }));\n  }\n\n  /**\n   * Set default ID on the node in case it is an HTML element.\n   *\n   * @param {Node} node\n   * @private\n   */\n  __updateNodeId(node) {\n    // When in multiple mode, only set ID attribute on the element in default slot.\n    const isFirstNode = !this.nodes || node === this.nodes[0];\n    if (node.nodeType === Node.ELEMENT_NODE && (!this.multiple || isFirstNode) && !node.id) {\n      node.id = this.defaultId;\n    }\n  }\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { SlotChildObserveController } from '@vaadin/component-base/src/slot-child-observe-controller.js';\n\n/**\n * A controller that manages the error message node content.\n */\nexport class ErrorController extends SlotChildObserveController {\n  constructor(host) {\n    super(host, 'error-message', 'div');\n  }\n\n  /**\n   * Set the error message element text content.\n   *\n   * @param {string} errorMessage\n   */\n  setErrorMessage(errorMessage) {\n    this.errorMessage = errorMessage;\n    this.updateDefaultNode(this.node);\n  }\n\n  /**\n   * Set invalid state for detecting whether to show error message.\n   *\n   * @param {boolean} invalid\n   */\n  setInvalid(invalid) {\n    this.invalid = invalid;\n    this.updateDefaultNode(this.node);\n  }\n\n  /**\n   * Override method inherited from `SlotController` to not run\n   * initializer on the custom slotted node unnecessarily.\n   *\n   * @param {Node} node\n   * @protected\n   * @override\n   */\n  initAddedNode(node) {\n    if (node !== this.defaultNode) {\n      // There is no need to run `initNode`.\n      this.initCustomNode(node);\n    }\n  }\n\n  /**\n   * Override to initialize the newly added default error message.\n   *\n   * @param {Node} errorNode\n   * @protected\n   * @override\n   */\n  initNode(errorNode) {\n    this.updateDefaultNode(errorNode);\n  }\n\n  /**\n   * Override to initialize the newly added custom error message.\n   *\n   * @param {Node} errorNode\n   * @protected\n   * @override\n   */\n  initCustomNode(errorNode) {\n    // Save the custom error message content on the host.\n    if (errorNode.textContent && !this.errorMessage) {\n      this.errorMessage = errorNode.textContent.trim();\n    }\n\n    // Notify the host about custom node.\n    super.initCustomNode(errorNode);\n  }\n\n  /**\n   * Override method inherited from `SlotChildObserveController`\n   * to restore the default error message element.\n   *\n   * @protected\n   * @override\n   */\n  restoreDefaultNode() {\n    this.attachDefaultNode();\n  }\n\n  /**\n   * Override method inherited from `SlotChildObserveController`\n   * to update the error message text and hidden state.\n   *\n   * Note: unlike with other controllers, this method is\n   * called for both default and custom error message.\n   *\n   * @param {Node | undefined} node\n   * @protected\n   * @override\n   */\n  updateDefaultNode(errorNode) {\n    const errorMessage = this.errorMessage,\n      invalid = this.invalid;\n    const hasError = Boolean(invalid && errorMessage && errorMessage.trim() !== '');\n    if (errorNode) {\n      errorNode.textContent = hasError ? errorMessage : '';\n      errorNode.hidden = !hasError;\n\n      // Role alert will make the error message announce immediately\n      // as the field becomes invalid\n      if (hasError) {\n        errorNode.setAttribute('role', 'alert');\n      } else {\n        errorNode.removeAttribute('role');\n      }\n    }\n\n    // Notify the host after update.\n    super.updateDefaultNode(errorNode);\n  }\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { SlotChildObserveController } from '@vaadin/component-base/src/slot-child-observe-controller.js';\n\n/**\n * A controller that manages the helper node content.\n */\nexport class HelperController extends SlotChildObserveController {\n  constructor(host) {\n    // Do not provide tag name, as we create helper lazily.\n    super(host, 'helper', null);\n  }\n\n  /**\n   * Set helper text based on corresponding host property.\n   *\n   * @param {string} helperText\n   */\n  setHelperText(helperText) {\n    this.helperText = helperText;\n\n    // Restore the default helper, if needed.\n    const helperNode = this.getSlotChild();\n    if (!helperNode) {\n      this.restoreDefaultNode();\n    }\n\n    // When default helper is used, update it.\n    if (this.node === this.defaultNode) {\n      this.updateDefaultNode(this.node);\n    }\n  }\n\n  /**\n   * Override method inherited from `SlotChildObserveController`\n   * to create the default helper element lazily as needed.\n   *\n   * @param {Node | undefined} node\n   * @protected\n   * @override\n   */\n  restoreDefaultNode() {\n    const helperText = this.helperText;\n\n    // No helper yet, create one.\n    if (helperText && helperText.trim() !== '') {\n      this.tagName = 'div';\n      const helperNode = this.attachDefaultNode();\n\n      // Observe the default node.\n      this.observeNode(helperNode);\n    }\n  }\n\n  /**\n   * Override method inherited from `SlotChildObserveController`\n   * to update the default helper element text content.\n   *\n   * @param {Node | undefined} node\n   * @protected\n   * @override\n   */\n  updateDefaultNode(node) {\n    if (node) {\n      node.textContent = this.helperText;\n    }\n\n    // Notify the host after update.\n    super.updateDefaultNode(node);\n  }\n\n  /**\n   * Override to observe the newly added custom node.\n   *\n   * @param {Node} node\n   * @protected\n   * @override\n   */\n  initCustomNode(node) {\n    // Notify the host about a custom slotted helper.\n    super.initCustomNode(node);\n    this.observeNode(node);\n  }\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { SlotChildObserveController } from '@vaadin/component-base/src/slot-child-observe-controller.js';\n\n/**\n * A controller to manage the label element.\n */\nexport class LabelController extends SlotChildObserveController {\n  constructor(host) {\n    super(host, 'label', 'label');\n  }\n\n  /**\n   * Set label based on corresponding host property.\n   *\n   * @param {string} label\n   */\n  setLabel(label) {\n    this.label = label;\n\n    // Restore the default label, if needed.\n    const labelNode = this.getSlotChild();\n    if (!labelNode) {\n      this.restoreDefaultNode();\n    }\n\n    // When default label is used, update it.\n    if (this.node === this.defaultNode) {\n      this.updateDefaultNode(this.node);\n    }\n  }\n\n  /**\n   * Override method inherited from `SlotChildObserveController`\n   * to restore and observe the default label element.\n   *\n   * @protected\n   * @override\n   */\n  restoreDefaultNode() {\n    const label = this.label;\n\n    // Restore the default label.\n    if (label && label.trim() !== '') {\n      const labelNode = this.attachDefaultNode();\n\n      // Observe the default label.\n      this.observeNode(labelNode);\n    }\n  }\n\n  /**\n   * Override method inherited from `SlotChildObserveController`\n   * to update the default label element text content.\n   *\n   * @param {Node | undefined} node\n   * @protected\n   * @override\n   */\n  updateDefaultNode(node) {\n    if (node) {\n      node.textContent = this.label;\n    }\n\n    // Notify the host after update.\n    super.updateDefaultNode(node);\n  }\n\n  /**\n   * Override to observe the newly added custom node.\n   *\n   * @param {Node} node\n   * @protected\n   * @override\n   */\n  initCustomNode(node) {\n    // Notify the host about adding a custom node.\n    super.initCustomNode(node);\n    this.observeNode(node);\n  }\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';\nimport { ControllerMixin } from '@vaadin/component-base/src/controller-mixin.js';\nimport { LabelController } from './label-controller.js';\n\n/**\n * A mixin to provide label via corresponding property or named slot.\n *\n * @polymerMixin\n * @mixes ControllerMixin\n */\nexport const LabelMixin = dedupingMixin(superclass => class LabelMixinClass extends ControllerMixin(superclass) {\n  static get properties() {\n    return {\n      /**\n       * The label text for the input node.\n       * When no light dom defined via [slot=label], this value will be used.\n       */\n      label: {\n        type: String,\n        observer: '_labelChanged'\n      }\n    };\n  }\n  constructor() {\n    super();\n    this._labelController = new LabelController(this);\n    this._labelController.addEventListener('slot-content-changed', event => {\n      this.toggleAttribute('has-label', event.detail.hasContent);\n    });\n  }\n\n  /** @protected */\n  get _labelId() {\n    const node = this._labelNode;\n    return node && node.id;\n  }\n\n  /** @protected */\n  get _labelNode() {\n    return this._labelController.node;\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n    this.addController(this._labelController);\n  }\n\n  /** @protected */\n  _labelChanged(label) {\n    this._labelController.setLabel(label);\n  }\n});","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { FieldAriaController } from '@vaadin/a11y-base/src/field-aria-controller.js';\nimport { ControllerMixin } from '@vaadin/component-base/src/controller-mixin.js';\nimport { ErrorController } from './error-controller.js';\nimport { HelperController } from './helper-controller.js';\nimport { LabelMixin } from './label-mixin.js';\nimport { ValidateMixin } from './validate-mixin.js';\n\n/**\n * A mixin to provide common field logic: label, error message and helper text.\n *\n * @polymerMixin\n * @mixes ControllerMixin\n * @mixes LabelMixin\n * @mixes ValidateMixin\n */\nexport const FieldMixin = superclass => class FieldMixinClass extends ValidateMixin(LabelMixin(ControllerMixin(superclass))) {\n  static get properties() {\n    return {\n      /**\n       * A target element to which ARIA attributes are set.\n       * @protected\n       */\n      ariaTarget: {\n        type: Object,\n        observer: '_ariaTargetChanged'\n      },\n      /**\n       * Error to show when the field is invalid.\n       *\n       * @attr {string} error-message\n       */\n      errorMessage: {\n        type: String,\n        observer: '_errorMessageChanged'\n      },\n      /**\n       * String used for the helper text.\n       * @attr {string} helper-text\n       */\n      helperText: {\n        type: String,\n        observer: '_helperTextChanged'\n      },\n      /**\n       * String used to label the component to screen reader users.\n       * @attr {string} accessible-name\n       */\n      accessibleName: {\n        type: String,\n        observer: '_accessibleNameChanged'\n      },\n      /**\n       * Id of the element used as label of the component to screen reader users.\n       * @attr {string} accessible-name-ref\n       */\n      accessibleNameRef: {\n        type: String,\n        observer: '_accessibleNameRefChanged'\n      }\n    };\n  }\n  static get observers() {\n    return ['_invalidChanged(invalid)', '_requiredChanged(required)'];\n  }\n  constructor() {\n    super();\n    this._fieldAriaController = new FieldAriaController(this);\n    this._helperController = new HelperController(this);\n    this._errorController = new ErrorController(this);\n    this._errorController.addEventListener('slot-content-changed', event => {\n      this.toggleAttribute('has-error-message', event.detail.hasContent);\n    });\n    this._labelController.addEventListener('slot-content-changed', event => {\n      const _event$detail = event.detail,\n        hasContent = _event$detail.hasContent,\n        node = _event$detail.node;\n      this.__labelChanged(hasContent, node);\n    });\n    this._helperController.addEventListener('slot-content-changed', event => {\n      const _event$detail2 = event.detail,\n        hasContent = _event$detail2.hasContent,\n        node = _event$detail2.node;\n      this.toggleAttribute('has-helper', hasContent);\n      this.__helperChanged(hasContent, node);\n    });\n  }\n\n  /**\n   * @protected\n   * @return {HTMLElement}\n   */\n  get _errorNode() {\n    return this._errorController.node;\n  }\n\n  /**\n   * @protected\n   * @return {HTMLElement}\n   */\n  get _helperNode() {\n    return this._helperController.node;\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n    this.addController(this._fieldAriaController);\n    this.addController(this._helperController);\n    this.addController(this._errorController);\n  }\n\n  /** @private */\n  __helperChanged(hasHelper, helperNode) {\n    if (hasHelper) {\n      this._fieldAriaController.setHelperId(helperNode.id);\n    } else {\n      this._fieldAriaController.setHelperId(null);\n    }\n  }\n\n  /** @protected */\n  _accessibleNameChanged(accessibleName) {\n    this._fieldAriaController.setAriaLabel(accessibleName);\n  }\n\n  /** @protected */\n  _accessibleNameRefChanged(accessibleNameRef) {\n    this._fieldAriaController.setLabelId(accessibleNameRef, true);\n  }\n\n  /** @private */\n  __labelChanged(hasLabel, labelNode) {\n    // Label ID should be only added when the label content is present.\n    // Otherwise, it may conflict with an `aria-label` attribute possibly added by the user.\n    if (hasLabel) {\n      this._fieldAriaController.setLabelId(labelNode.id);\n    } else {\n      this._fieldAriaController.setLabelId(null);\n    }\n  }\n\n  /**\n   * @param {string | null | undefined} errorMessage\n   * @protected\n   */\n  _errorMessageChanged(errorMessage) {\n    this._errorController.setErrorMessage(errorMessage);\n  }\n\n  /**\n   * @param {string} helperText\n   * @protected\n   */\n  _helperTextChanged(helperText) {\n    this._helperController.setHelperText(helperText);\n  }\n\n  /**\n   * @param {HTMLElement | null | undefined} target\n   * @protected\n   */\n  _ariaTargetChanged(target) {\n    if (target) {\n      this._fieldAriaController.setTarget(target);\n    }\n  }\n\n  /**\n   * @param {boolean} required\n   * @protected\n   */\n  _requiredChanged(required) {\n    this._fieldAriaController.setRequired(required);\n  }\n\n  /**\n   * @param {boolean} invalid\n   * @protected\n   */\n  _invalidChanged(invalid) {\n    this._errorController.setInvalid(invalid);\n\n    // This timeout is needed to prevent NVDA from announcing the error message twice:\n    // 1. Once adding the `[role=alert]` attribute when updating `has-error-message` (OK).\n    // 2. Once linking the error ID with the ARIA target here (unwanted).\n    // Related issue: https://github.com/vaadin/web-components/issues/3061.\n    setTimeout(() => {\n      // Error message ID needs to be dynamically added / removed based on the validity\n      // Otherwise assistive technologies would announce the error, even if we hide it.\n      if (invalid) {\n        const node = this._errorNode;\n        this._fieldAriaController.setErrorId(node && node.id);\n      } else {\n        this._fieldAriaController.setErrorId(null);\n      }\n    });\n  }\n};","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';\n\n/**\n * A mixin to delegate properties and attributes to a target element.\n *\n * @polymerMixin\n */\nexport const DelegateStateMixin = dedupingMixin(superclass => class DelegateStateMixinClass extends superclass {\n  static get properties() {\n    return {\n      /**\n       * A target element to which attributes and properties are delegated.\n       * @protected\n       */\n      stateTarget: {\n        type: Object,\n        observer: '_stateTargetChanged'\n      }\n    };\n  }\n\n  /**\n   * An array of the host attributes to delegate to the target element.\n   */\n  static get delegateAttrs() {\n    return [];\n  }\n\n  /**\n   * An array of the host properties to delegate to the target element.\n   */\n  static get delegateProps() {\n    return [];\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n    this._createDelegateAttrsObserver();\n    this._createDelegatePropsObserver();\n  }\n\n  /** @protected */\n  _stateTargetChanged(target) {\n    if (target) {\n      this._ensureAttrsDelegated();\n      this._ensurePropsDelegated();\n    }\n  }\n\n  /** @protected */\n  _createDelegateAttrsObserver() {\n    this._createMethodObserver(`_delegateAttrsChanged(${this.constructor.delegateAttrs.join(', ')})`);\n  }\n\n  /** @protected */\n  _createDelegatePropsObserver() {\n    this._createMethodObserver(`_delegatePropsChanged(${this.constructor.delegateProps.join(', ')})`);\n  }\n\n  /** @protected */\n  _ensureAttrsDelegated() {\n    this.constructor.delegateAttrs.forEach(name => {\n      this._delegateAttribute(name, this[name]);\n    });\n  }\n\n  /** @protected */\n  _ensurePropsDelegated() {\n    this.constructor.delegateProps.forEach(name => {\n      this._delegateProperty(name, this[name]);\n    });\n  }\n\n  /** @protected */\n  _delegateAttrsChanged() {\n    for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {\n      values[_key] = arguments[_key];\n    }\n    this.constructor.delegateAttrs.forEach((name, index) => {\n      this._delegateAttribute(name, values[index]);\n    });\n  }\n\n  /** @protected */\n  _delegatePropsChanged() {\n    for (var _len2 = arguments.length, values = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      values[_key2] = arguments[_key2];\n    }\n    this.constructor.delegateProps.forEach((name, index) => {\n      this._delegateProperty(name, values[index]);\n    });\n  }\n\n  /** @protected */\n  _delegateAttribute(name, value) {\n    if (!this.stateTarget) {\n      return;\n    }\n    if (name === 'invalid') {\n      this._delegateAttribute('aria-invalid', value ? 'true' : false);\n    }\n    if (typeof value === 'boolean') {\n      this.stateTarget.toggleAttribute(name, value);\n    } else if (value) {\n      this.stateTarget.setAttribute(name, value);\n    } else {\n      this.stateTarget.removeAttribute(name);\n    }\n  }\n\n  /** @protected */\n  _delegateProperty(name, value) {\n    if (!this.stateTarget) {\n      return;\n    }\n    this.stateTarget[name] = value;\n  }\n});","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';\nimport { DelegateStateMixin } from '@vaadin/component-base/src/delegate-state-mixin.js';\nimport { InputMixin } from './input-mixin.js';\nimport { ValidateMixin } from './validate-mixin.js';\n\n/**\n * A mixin to combine multiple input validation constraints.\n *\n * @polymerMixin\n * @mixes DelegateStateMixin\n * @mixes InputMixin\n * @mixes ValidateMixin\n */\nexport const InputConstraintsMixin = dedupingMixin(superclass => class InputConstraintsMixinClass extends DelegateStateMixin(ValidateMixin(InputMixin(superclass))) {\n  /**\n   * An array of attributes which participate in the input validation.\n   * Changing these attributes will cause the input to re-validate.\n   *\n   * IMPORTANT: The attributes should be properly delegated to the input element\n   * from the host using `delegateAttrs` getter (see `DelegateStateMixin`).\n   * The `required` attribute is already delegated.\n   */\n  static get constraints() {\n    return ['required'];\n  }\n  static get delegateAttrs() {\n    return [...super.delegateAttrs, 'required'];\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n    this._createConstraintsObserver();\n  }\n\n  /**\n   * Returns true if the current input value satisfies all constraints (if any).\n   * @return {boolean}\n   */\n  checkValidity() {\n    if (this.inputElement && this._hasValidConstraints(this.constructor.constraints.map(c => this[c]))) {\n      return this.inputElement.checkValidity();\n    }\n    return !this.invalid;\n  }\n\n  /**\n   * Returns true if some of the provided set of constraints are valid.\n   * @param {Array} constraints\n   * @return {boolean}\n   * @protected\n   */\n  _hasValidConstraints(constraints) {\n    return constraints.some(c => this.__isValidConstraint(c));\n  }\n\n  /**\n   * Override this method to customize setting up constraints observer.\n   * @protected\n   */\n  _createConstraintsObserver() {\n    // This complex observer needs to be added dynamically instead of using `static get observers()`\n    // to make it possible to tweak this behavior in classes that apply this mixin.\n    this._createMethodObserver(`_constraintsChanged(stateTarget, ${this.constructor.constraints.join(', ')})`);\n  }\n\n  /**\n   * Override this method to implement custom validation constraints.\n   * @param {HTMLElement | undefined} stateTarget\n   * @param {unknown[]} constraints\n   * @protected\n   */\n  _constraintsChanged(stateTarget) {\n    // The input element's validity cannot be determined until\n    // all the necessary constraint attributes aren't set on it.\n    if (!stateTarget) {\n      return;\n    }\n    for (var _len = arguments.length, constraints = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      constraints[_key - 1] = arguments[_key];\n    }\n    const hasConstraints = this._hasValidConstraints(constraints);\n    const isLastConstraintRemoved = this.__previousHasConstraints && !hasConstraints;\n    if ((this._hasValue || this.invalid) && hasConstraints) {\n      this.validate();\n    } else if (isLastConstraintRemoved) {\n      this._setInvalid(false);\n    }\n    this.__previousHasConstraints = hasConstraints;\n  }\n\n  /**\n   * Override an event listener inherited from `InputMixin`\n   * to capture native `change` event and make sure that\n   * a new one is dispatched after validation runs.\n   * @param {Event} event\n   * @protected\n   * @override\n   */\n  _onChange(event) {\n    event.stopPropagation();\n    this.validate();\n    this.dispatchEvent(new CustomEvent('change', {\n      detail: {\n        sourceEvent: event\n      },\n      bubbles: event.bubbles,\n      cancelable: event.cancelable\n    }));\n  }\n\n  /** @private */\n  __isValidConstraint(constraint) {\n    // 0 is valid for `minlength` and `maxlength`\n    return Boolean(constraint) || constraint === 0;\n  }\n});","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { DelegateFocusMixin } from '@vaadin/a11y-base/src/delegate-focus-mixin.js';\nimport { KeyboardMixin } from '@vaadin/a11y-base/src/keyboard-mixin.js';\nimport { timeOut } from '@vaadin/component-base/src/async.js';\nimport { Debouncer } from '@vaadin/component-base/src/debounce.js';\nimport { SlotStylesMixin } from '@vaadin/component-base/src/slot-styles-mixin.js';\nimport { ClearButtonMixin } from './clear-button-mixin.js';\nimport { FieldMixin } from './field-mixin.js';\nimport { InputConstraintsMixin } from './input-constraints-mixin.js';\n\n/**\n * A mixin to provide shared logic for the editable form input controls.\n *\n * @polymerMixin\n * @mixes DelegateFocusMixin\n * @mixes FieldMixin\n * @mixes InputConstraintsMixin\n * @mixes KeyboardMixin\n * @mixes ClearButtonMixin\n * @mixes SlotStylesMixin\n */\nexport const InputControlMixin = superclass => class InputControlMixinClass extends SlotStylesMixin(DelegateFocusMixin(InputConstraintsMixin(FieldMixin(ClearButtonMixin(KeyboardMixin(superclass)))))) {\n  static get properties() {\n    return {\n      /**\n       * A pattern matched against individual characters the user inputs.\n       *\n       * When set, the field will prevent:\n       * - `keydown` events if the entered key doesn't match `/^allowedCharPattern$/`\n       * - `paste` events if the pasted text doesn't match `/^allowedCharPattern*$/`\n       * - `drop` events if the dropped text doesn't match `/^allowedCharPattern*$/`\n       *\n       * For example, to allow entering only numbers and minus signs, use:\n       * `allowedCharPattern = \"[\\\\d-]\"`\n       * @attr {string} allowed-char-pattern\n       */\n      allowedCharPattern: {\n        type: String,\n        observer: '_allowedCharPatternChanged'\n      },\n      /**\n       * If true, the input text gets fully selected when the field is focused using click or touch / tap.\n       */\n      autoselect: {\n        type: Boolean,\n        value: false\n      },\n      /**\n       * The name of this field.\n       */\n      name: {\n        type: String,\n        reflectToAttribute: true\n      },\n      /**\n       * A hint to the user of what can be entered in the field.\n       */\n      placeholder: {\n        type: String,\n        reflectToAttribute: true\n      },\n      /**\n       * When present, it specifies that the field is read-only.\n       */\n      readonly: {\n        type: Boolean,\n        value: false,\n        reflectToAttribute: true\n      },\n      /**\n       * The text usually displayed in a tooltip popup when the mouse is over the field.\n       */\n      title: {\n        type: String,\n        reflectToAttribute: true\n      }\n    };\n  }\n  static get delegateAttrs() {\n    return [...super.delegateAttrs, 'name', 'type', 'placeholder', 'readonly', 'invalid', 'title'];\n  }\n  constructor() {\n    super();\n    this._boundOnPaste = this._onPaste.bind(this);\n    this._boundOnDrop = this._onDrop.bind(this);\n    this._boundOnBeforeInput = this._onBeforeInput.bind(this);\n  }\n\n  /** @protected */\n  get slotStyles() {\n    // Needed for Safari, where ::slotted(...)::placeholder does not work\n    return [`\n          :is(input[slot='input'], textarea[slot='textarea'])::placeholder {\n            font: inherit;\n            color: inherit;\n          }\n        `];\n  }\n\n  /**\n   * Override an event listener from `DelegateFocusMixin`.\n   * @param {FocusEvent} event\n   * @protected\n   * @override\n   */\n  _onFocus(event) {\n    super._onFocus(event);\n    if (this.autoselect && this.inputElement) {\n      this.inputElement.select();\n    }\n  }\n\n  /**\n   * Override an event listener inherited from `InputMixin`\n   * to capture native `change` event and make sure that\n   * a new one is dispatched after validation runs.\n   * @param {Event} event\n   * @protected\n   * @override\n   */\n  _onChange(event) {\n    event.stopPropagation();\n    this.validate();\n    this.dispatchEvent(new CustomEvent('change', {\n      detail: {\n        sourceEvent: event\n      },\n      bubbles: event.bubbles,\n      cancelable: event.cancelable\n    }));\n  }\n\n  /**\n   * Override a method from `InputMixin`.\n   * @param {!HTMLElement} input\n   * @protected\n   * @override\n   */\n  _addInputListeners(input) {\n    super._addInputListeners(input);\n    input.addEventListener('paste', this._boundOnPaste);\n    input.addEventListener('drop', this._boundOnDrop);\n    input.addEventListener('beforeinput', this._boundOnBeforeInput);\n  }\n\n  /**\n   * Override a method from `InputMixin`.\n   * @param {!HTMLElement} input\n   * @protected\n   * @override\n   */\n  _removeInputListeners(input) {\n    super._removeInputListeners(input);\n    input.removeEventListener('paste', this._boundOnPaste);\n    input.removeEventListener('drop', this._boundOnDrop);\n    input.removeEventListener('beforeinput', this._boundOnBeforeInput);\n  }\n\n  /**\n   * Override an event listener from `KeyboardMixin`.\n   * @param {!KeyboardEvent} event\n   * @protected\n   * @override\n   */\n  _onKeyDown(event) {\n    super._onKeyDown(event);\n    if (this.allowedCharPattern && !this.__shouldAcceptKey(event) && event.target === this.inputElement) {\n      event.preventDefault();\n      this._markInputPrevented();\n    }\n  }\n\n  /** @protected */\n  _markInputPrevented() {\n    // Add input-prevented attribute for 200ms\n    this.setAttribute('input-prevented', '');\n    this._preventInputDebouncer = Debouncer.debounce(this._preventInputDebouncer, timeOut.after(200), () => {\n      this.removeAttribute('input-prevented');\n    });\n  }\n\n  /** @private */\n  __shouldAcceptKey(event) {\n    return event.metaKey || event.ctrlKey || !event.key ||\n    // Allow typing anything if event.key is not supported\n    event.key.length !== 1 ||\n    // Allow \"Backspace\", \"ArrowLeft\" etc.\n    this.__allowedCharRegExp.test(event.key);\n  }\n\n  /** @private */\n  _onPaste(e) {\n    if (this.allowedCharPattern) {\n      const pastedText = e.clipboardData.getData('text');\n      if (!this.__allowedTextRegExp.test(pastedText)) {\n        e.preventDefault();\n        this._markInputPrevented();\n      }\n    }\n  }\n\n  /** @private */\n  _onDrop(e) {\n    if (this.allowedCharPattern) {\n      const draggedText = e.dataTransfer.getData('text');\n      if (!this.__allowedTextRegExp.test(draggedText)) {\n        e.preventDefault();\n        this._markInputPrevented();\n      }\n    }\n  }\n\n  /** @private */\n  _onBeforeInput(e) {\n    // The `beforeinput` event covers all the cases for `allowedCharPattern`: keyboard, pasting and dropping,\n    // but it is still experimental technology so we can't rely on it. It's used here just as an additional check,\n    // because it seems to be the only way to detect and prevent specific keys on mobile devices.\n    // See https://github.com/vaadin/vaadin-text-field/issues/429\n    if (this.allowedCharPattern && e.data && !this.__allowedTextRegExp.test(e.data)) {\n      e.preventDefault();\n      this._markInputPrevented();\n    }\n  }\n\n  /** @private */\n  _allowedCharPatternChanged(charPattern) {\n    if (charPattern) {\n      try {\n        this.__allowedCharRegExp = new RegExp(`^${charPattern}$`, 'u');\n        this.__allowedTextRegExp = new RegExp(`^${charPattern}*$`, 'u');\n      } catch (e) {\n        console.error(e);\n      }\n    }\n  }\n\n  /**\n   * Fired when the user commits a value change.\n   *\n   * @event change\n   */\n\n  /**\n   * Fired when the value is changed by the user: on every typing keystroke,\n   * and the value is cleared using the clear button.\n   *\n   * @event input\n   */\n};","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { SlotController } from '@vaadin/component-base/src/slot-controller.js';\n\n/**\n * A controller to create and initialize slotted `<input>` element.\n */\nexport class InputController extends SlotController {\n  constructor(host, callback) {\n    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    const uniqueIdPrefix = options.uniqueIdPrefix;\n    super(host, 'input', 'input', {\n      initializer: (node, host) => {\n        if (host.value) {\n          node.value = host.value;\n        }\n        if (host.type) {\n          node.setAttribute('type', host.type);\n        }\n\n        // Ensure every instance has unique ID\n        node.id = this.defaultId;\n        if (typeof callback === 'function') {\n          callback(node);\n        }\n      },\n      useUniqueId: true,\n      uniqueIdPrefix\n    });\n  }\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\n\n/**\n * A controller for linking a `<label>` element with an `<input>` element.\n */\nexport class LabelledInputController {\n  constructor(input, labelController) {\n    this.input = input;\n    this.__preventDuplicateLabelClick = this.__preventDuplicateLabelClick.bind(this);\n    labelController.addEventListener('slot-content-changed', event => {\n      this.__initLabel(event.detail.node);\n    });\n\n    // Initialize the default label element\n    this.__initLabel(labelController.node);\n  }\n\n  /**\n   * @param {HTMLElement} label\n   * @private\n   */\n  __initLabel(label) {\n    if (label) {\n      label.addEventListener('click', this.__preventDuplicateLabelClick);\n      if (this.input) {\n        label.setAttribute('for', this.input.id);\n      }\n    }\n  }\n\n  /**\n   * The native platform fires an event for both the click on the label, and also\n   * the subsequent click on the native input element caused by label click.\n   * This results in two click events arriving at the host, but we only want one.\n   * This method prevents the duplicate click and ensures the correct isTrusted event\n   * with the correct event.target arrives at the host.\n   * @private\n   */\n  __preventDuplicateLabelClick() {\n    const inputClickHandler = e => {\n      e.stopImmediatePropagation();\n      this.input.removeEventListener('click', inputClickHandler);\n    };\n    this.input.addEventListener('click', inputClickHandler);\n  }\n}","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd.\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport './vaadin-multi-select-combo-box-chip.js';\nimport './vaadin-multi-select-combo-box-container.js';\nimport './vaadin-multi-select-combo-box-internal.js';\nimport { html, PolymerElement } from '@polymer/polymer/polymer-element.js';\nimport { announce } from '@vaadin/a11y-base/src/announce.js';\nimport { defineCustomElement } from '@vaadin/component-base/src/define.js';\nimport { ElementMixin } from '@vaadin/component-base/src/element-mixin.js';\nimport { ResizeMixin } from '@vaadin/component-base/src/resize-mixin.js';\nimport { SlotController } from '@vaadin/component-base/src/slot-controller.js';\nimport { processTemplates } from '@vaadin/component-base/src/templates.js';\nimport { TooltipController } from '@vaadin/component-base/src/tooltip-controller.js';\nimport { InputControlMixin } from '@vaadin/field-base/src/input-control-mixin.js';\nimport { InputController } from '@vaadin/field-base/src/input-controller.js';\nimport { LabelledInputController } from '@vaadin/field-base/src/labelled-input-controller.js';\nimport { inputFieldShared } from '@vaadin/field-base/src/styles/input-field-shared-styles.js';\nimport { css, registerStyles, ThemableMixin } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';\nconst multiSelectComboBox = css`\n  :host {\n    --input-min-width: var(--vaadin-multi-select-combo-box-input-min-width, 4em);\n    --_chip-min-width: var(--vaadin-multi-select-combo-box-chip-min-width, 50px);\n  }\n\n  #chips {\n    display: flex;\n    align-items: center;\n  }\n\n  ::slotted(input) {\n    box-sizing: border-box;\n    flex: 1 0 var(--input-min-width);\n  }\n\n  ::slotted([slot='chip']),\n  ::slotted([slot='overflow']) {\n    flex: 0 1 auto;\n  }\n\n  ::slotted([slot='chip']) {\n    overflow: hidden;\n  }\n\n  :host(:is([readonly], [disabled])) ::slotted(input) {\n    flex-grow: 0;\n    flex-basis: 0;\n    padding: 0;\n  }\n\n  :host([auto-expand-vertically]) #chips {\n    display: contents;\n  }\n\n  :host([auto-expand-horizontally]) [class$='container'] {\n    width: auto;\n  }\n`;\nregisterStyles('vaadin-multi-select-combo-box', [inputFieldShared, multiSelectComboBox], {\n  moduleId: 'vaadin-multi-select-combo-box-styles'\n});\n\n/**\n * `<vaadin-multi-select-combo-box>` is a web component that wraps `<vaadin-combo-box>` and extends\n * its functionality to allow selecting multiple items, in addition to basic features.\n *\n * ```html\n * <vaadin-multi-select-combo-box id=\"comboBox\"></vaadin-multi-select-combo-box>\n * ```\n *\n * ```js\n * const comboBox = document.querySelector('#comboBox');\n * comboBox.items = ['apple', 'banana', 'lemon', 'orange'];\n * comboBox.selectedItems = ['lemon', 'orange'];\n * ```\n *\n * ### Styling\n *\n * The following shadow DOM parts are available for styling:\n *\n * Part name              | Description\n * -----------------------|----------------\n * `chips`                | The element that wraps slotted chips for selected items\n * `label`                | The label element\n * `input-field`          | The element that wraps prefix, value and suffix\n * `clear-button`         | The clear button\n * `error-message`        | The error message element\n * `helper-text`          | The helper text element wrapper\n * `required-indicator`   | The `required` state indicator element\n * `toggle-button`        | The toggle button\n *\n * The following state attributes are available for styling:\n *\n * Attribute              | Description\n * -----------------------|-----------------\n * `disabled`             | Set to a disabled element\n * `has-value`            | Set when the element has a value\n * `has-label`            | Set when the element has a label\n * `has-helper`           | Set when the element has helper text or slot\n * `has-error-message`    | Set when the element has an error message\n * `invalid`              | Set when the element is invalid\n * `focused`              | Set when the element is focused\n * `focus-ring`           | Set when the element is keyboard focused\n * `loading`              | Set when loading items from the data provider\n * `opened`               | Set when the dropdown is open\n * `readonly`             | Set to a readonly element\n *\n * The following custom CSS properties are available for styling:\n *\n * Custom property                                      | Description                | Default\n * -----------------------------------------------------|----------------------------|--------\n * `--vaadin-field-default-width`                       | Default width of the field | `12em`\n * `--vaadin-multi-select-combo-box-overlay-width`      | Width of the overlay       | `auto`\n * `--vaadin-multi-select-combo-box-overlay-max-height` | Max height of the overlay  | `65vh`\n * `--vaadin-multi-select-combo-box-chip-min-width`     | Min width of the chip      | `50px`\n * `--vaadin-multi-select-combo-box-input-min-width`    | Min width of the input     | `4em`\n *\n * ### Internal components\n *\n * In addition to `<vaadin-multi-select-combo-box>` itself, the following internal\n * components are themable:\n *\n * - `<vaadin-multi-select-combo-box-overlay>` - has the same API as `<vaadin-overlay>`.\n * - `<vaadin-multi-select-combo-box-item>` - has the same API as `<vaadin-item>`.\n * - `<vaadin-multi-select-combo-box-container>` - has the same API as `<vaadin-input-container>`.\n *\n * Note: the `theme` attribute value set on `<vaadin-multi-select-combo-box>` is\n * propagated to these components.\n *\n * See [Styling Components](https://vaadin.com/docs/latest/styling/styling-components) documentation.\n *\n * @fires {Event} change - Fired when the user commits a value change.\n * @fires {CustomEvent} custom-value-set - Fired when the user sets a custom value.\n * @fires {CustomEvent} filter-changed - Fired when the `filter` property changes.\n * @fires {CustomEvent} invalid-changed - Fired when the `invalid` property changes.\n * @fires {CustomEvent} opened-changed - Fired when the `opened` property changes.\n * @fires {CustomEvent} selected-items-changed - Fired when the `selectedItems` property changes.\n * @fires {CustomEvent} validated - Fired whenever the field is validated.\n *\n * @customElement\n * @extends HTMLElement\n * @mixes ElementMixin\n * @mixes ThemableMixin\n * @mixes InputControlMixin\n * @mixes ResizeMixin\n */\nclass MultiSelectComboBox extends ResizeMixin(InputControlMixin(ThemableMixin(ElementMixin(PolymerElement)))) {\n  static get is() {\n    return 'vaadin-multi-select-combo-box';\n  }\n  static get template() {\n    return html`\n      <div class=\"vaadin-multi-select-combo-box-container\">\n        <div part=\"label\">\n          <slot name=\"label\"></slot>\n          <span part=\"required-indicator\" aria-hidden=\"true\" on-click=\"focus\"></span>\n        </div>\n\n        <vaadin-multi-select-combo-box-internal\n          id=\"comboBox\"\n          items=\"[[items]]\"\n          item-id-path=\"[[itemIdPath]]\"\n          item-label-path=\"[[itemLabelPath]]\"\n          item-value-path=\"[[itemValuePath]]\"\n          disabled=\"[[disabled]]\"\n          readonly=\"[[readonly]]\"\n          auto-open-disabled=\"[[autoOpenDisabled]]\"\n          allow-custom-value=\"[[allowCustomValue]]\"\n          overlay-class=\"[[overlayClass]]\"\n          data-provider=\"[[dataProvider]]\"\n          filter=\"{{filter}}\"\n          last-filter=\"{{_lastFilter}}\"\n          loading=\"{{loading}}\"\n          size=\"{{size}}\"\n          filtered-items=\"[[filteredItems]]\"\n          selected-items=\"[[selectedItems]]\"\n          selected-items-on-top=\"[[selectedItemsOnTop]]\"\n          item-class-name-generator=\"[[itemClassNameGenerator]]\"\n          top-group=\"[[_topGroup]]\"\n          opened=\"{{opened}}\"\n          renderer=\"[[renderer]]\"\n          keep-filter=\"[[keepFilter]]\"\n          theme$=\"[[_theme]]\"\n          on-combo-box-item-selected=\"_onComboBoxItemSelected\"\n          on-change=\"_onComboBoxChange\"\n          on-custom-value-set=\"_onCustomValueSet\"\n          on-filtered-items-changed=\"_onFilteredItemsChanged\"\n        >\n          <vaadin-multi-select-combo-box-container\n            part=\"input-field\"\n            auto-expand-vertically=\"[[autoExpandVertically]]\"\n            readonly=\"[[readonly]]\"\n            disabled=\"[[disabled]]\"\n            invalid=\"[[invalid]]\"\n            theme$=\"[[_theme]]\"\n          >\n            <slot name=\"overflow\" slot=\"prefix\"></slot>\n            <div id=\"chips\" part=\"chips\" slot=\"prefix\">\n              <slot name=\"chip\"></slot>\n            </div>\n            <slot name=\"input\"></slot>\n            <div\n              id=\"clearButton\"\n              part=\"clear-button\"\n              slot=\"suffix\"\n              on-touchend=\"_onClearButtonTouchend\"\n              aria-hidden=\"true\"\n            ></div>\n            <div id=\"toggleButton\" class=\"toggle-button\" part=\"toggle-button\" slot=\"suffix\" aria-hidden=\"true\"></div>\n          </vaadin-multi-select-combo-box-container>\n        </vaadin-multi-select-combo-box-internal>\n\n        <div part=\"helper-text\">\n          <slot name=\"helper\"></slot>\n        </div>\n\n        <div part=\"error-message\">\n          <slot name=\"error-message\"></slot>\n        </div>\n      </div>\n\n      <slot name=\"tooltip\"></slot>\n    `;\n  }\n  static get properties() {\n    return {\n      /**\n       * Set to true to auto expand horizontally, causing input field to\n       * grow until max width is reached.\n       * @attr {boolean} auto-expand-horizontally\n       */\n      autoExpandHorizontally: {\n        type: Boolean,\n        value: false,\n        reflectToAttribute: true,\n        observer: '_autoExpandHorizontallyChanged'\n      },\n      /**\n       * Set to true to not collapse selected items chips into the overflow\n       * chip and instead always expand vertically, causing input field to\n       * wrap into multiple lines when width is limited.\n       * @attr {boolean} auto-expand-vertically\n       */\n      autoExpandVertically: {\n        type: Boolean,\n        value: false,\n        reflectToAttribute: true,\n        observer: '_autoExpandVerticallyChanged'\n      },\n      /**\n       * Set true to prevent the overlay from opening automatically.\n       * @attr {boolean} auto-open-disabled\n       */\n      autoOpenDisabled: Boolean,\n      /**\n       * Set to true to display the clear icon which clears the input.\n       * @attr {boolean} clear-button-visible\n       */\n      clearButtonVisible: {\n        type: Boolean,\n        reflectToAttribute: true,\n        observer: '_clearButtonVisibleChanged',\n        value: false\n      },\n      /**\n       * A full set of items to filter the visible options from.\n       * The items can be of either `String` or `Object` type.\n       */\n      items: {\n        type: Array\n      },\n      /**\n       * A function used to generate CSS class names for dropdown\n       * items and selected chips based on the item. The return\n       * value should be the generated class name as a string, or\n       * multiple class names separated by whitespace characters.\n       */\n      itemClassNameGenerator: {\n        type: Object,\n        observer: '__itemClassNameGeneratorChanged'\n      },\n      /**\n       * The item property used for a visual representation of the item.\n       * @attr {string} item-label-path\n       */\n      itemLabelPath: {\n        type: String,\n        value: 'label'\n      },\n      /**\n       * Path for the value of the item. If `items` is an array of objects,\n       * this property is used as a string value for the selected item.\n       * @attr {string} item-value-path\n       */\n      itemValuePath: {\n        type: String,\n        value: 'value'\n      },\n      /**\n       * Path for the id of the item, used to detect whether the item is selected.\n       * @attr {string} item-id-path\n       */\n      itemIdPath: {\n        type: String\n      },\n      /**\n       * The object used to localize this component.\n       * To change the default localization, replace the entire\n       * _i18n_ object or just the property you want to modify.\n       *\n       * The object has the following JSON structure and default values:\n       * ```\n       * {\n       *   // Screen reader announcement on clear button click.\n       *   cleared: 'Selection cleared',\n       *   // Screen reader announcement when a chip is focused.\n       *   focused: ' focused. Press Backspace to remove',\n       *   // Screen reader announcement when item is selected.\n       *   selected: 'added to selection',\n       *   // Screen reader announcement when item is deselected.\n       *   deselected: 'removed from selection',\n       *   // Screen reader announcement of the selected items count.\n       *   // {count} is replaced with the actual count of items.\n       *   total: '{count} items selected',\n       * }\n       * ```\n       * @type {!MultiSelectComboBoxI18n}\n       * @default {English/US}\n       */\n      i18n: {\n        type: Object,\n        value: () => {\n          return {\n            cleared: 'Selection cleared',\n            focused: 'focused. Press Backspace to remove',\n            selected: 'added to selection',\n            deselected: 'removed from selection',\n            total: '{count} items selected'\n          };\n        }\n      },\n      /**\n       * When true, filter string isn't cleared after selecting an item.\n       */\n      keepFilter: {\n        type: Boolean,\n        value: false\n      },\n      /**\n       * True when loading items from the data provider, false otherwise.\n       */\n      loading: {\n        type: Boolean,\n        value: false,\n        reflectToAttribute: true\n      },\n      /**\n       * A space-delimited list of CSS class names to set on the overlay element.\n       *\n       * @attr {string} overlay-class\n       */\n      overlayClass: {\n        type: String\n      },\n      /**\n       * When present, it specifies that the field is read-only.\n       */\n      readonly: {\n        type: Boolean,\n        value: false,\n        observer: '_readonlyChanged',\n        reflectToAttribute: true\n      },\n      /**\n       * The list of selected items.\n       * Note: modifying the selected items creates a new array each time.\n       */\n      selectedItems: {\n        type: Array,\n        value: () => [],\n        notify: true\n      },\n      /**\n       * True if the dropdown is open, false otherwise.\n       */\n      opened: {\n        type: Boolean,\n        notify: true,\n        value: false,\n        reflectToAttribute: true\n      },\n      /**\n       * Total number of items.\n       */\n      size: {\n        type: Number\n      },\n      /**\n       * Number of items fetched at a time from the data provider.\n       * @attr {number} page-size\n       */\n      pageSize: {\n        type: Number,\n        value: 50,\n        observer: '_pageSizeChanged'\n      },\n      /**\n       * Function that provides items lazily. Receives two arguments:\n       *\n       * - `params` - Object with the following properties:\n       *   - `params.page` Requested page index\n       *   - `params.pageSize` Current page size\n       *   - `params.filter` Currently applied filter\n       *\n       * - `callback(items, size)` - Callback function with arguments:\n       *   - `items` Current page of items\n       *   - `size` Total number of items.\n       */\n      dataProvider: {\n        type: Object\n      },\n      /**\n       * When true, the user can input a value that is not present in the items list.\n       * @attr {boolean} allow-custom-value\n       */\n      allowCustomValue: {\n        type: Boolean,\n        value: false\n      },\n      /**\n       * A hint to the user of what can be entered in the control.\n       * The placeholder will be only displayed in the case when\n       * there is no item selected.\n       */\n      placeholder: {\n        type: String,\n        observer: '_placeholderChanged'\n      },\n      /**\n       * Custom function for rendering the content of every item.\n       * Receives three arguments:\n       *\n       * - `root` The `<vaadin-multi-select-combo-box-item>` internal container DOM element.\n       * - `comboBox` The reference to the `<vaadin-multi-select-combo-box>` element.\n       * - `model` The object with the properties related with the rendered\n       *   item, contains:\n       *   - `model.index` The index of the rendered item.\n       *   - `model.item` The item.\n       */\n      renderer: Function,\n      /**\n       * Filtering string the user has typed into the input field.\n       */\n      filter: {\n        type: String,\n        value: '',\n        notify: true\n      },\n      /**\n       * A subset of items, filtered based on the user input. Filtered items\n       * can be assigned directly to omit the internal filtering functionality.\n       * The items can be of either `String` or `Object` type.\n       */\n      filteredItems: Array,\n      /**\n       * Set to true to group selected items at the top of the overlay.\n       * @attr {boolean} selected-items-on-top\n       */\n      selectedItemsOnTop: {\n        type: Boolean,\n        value: false\n      },\n      /** @private */\n      value: {\n        type: String\n      },\n      /** @private */\n      _overflowItems: {\n        type: Array,\n        value: () => []\n      },\n      /** @private */\n      _focusedChipIndex: {\n        type: Number,\n        value: -1,\n        observer: '_focusedChipIndexChanged'\n      },\n      /** @private */\n      _lastFilter: {\n        type: String\n      },\n      /** @private */\n      _topGroup: {\n        type: Array\n      }\n    };\n  }\n  static get observers() {\n    return ['_selectedItemsChanged(selectedItems, selectedItems.*)', '__updateOverflowChip(_overflow, _overflowItems, disabled, readonly)', '__updateTopGroup(selectedItemsOnTop, selectedItems, opened)'];\n  }\n\n  /** @protected */\n  get slotStyles() {\n    const tag = this.localName;\n    return [...super.slotStyles, `\n        ${tag}[has-value] input::placeholder {\n          color: transparent !important;\n          forced-color-adjust: none;\n        }\n      `];\n  }\n\n  /**\n   * Used by `InputControlMixin` as a reference to the clear button element.\n   * @protected\n   * @return {!HTMLElement}\n   */\n  get clearElement() {\n    return this.$.clearButton;\n  }\n\n  /** @protected */\n  get _chips() {\n    return [...this.querySelectorAll('[slot=\"chip\"]')];\n  }\n\n  /**\n   * Override a getter from `InputMixin` to compute\n   * the presence of value based on `selectedItems`.\n   *\n   * @protected\n   * @override\n   */\n  get _hasValue() {\n    return this.selectedItems && this.selectedItems.length > 0;\n  }\n\n  /** @protected */\n  ready() {\n    super.ready();\n    this.addController(new InputController(this, input => {\n      this._setInputElement(input);\n      this._setFocusElement(input);\n      this.stateTarget = input;\n      this.ariaTarget = input;\n    }));\n    this.addController(new LabelledInputController(this.inputElement, this._labelController));\n    this._tooltipController = new TooltipController(this);\n    this.addController(this._tooltipController);\n    this._tooltipController.setPosition('top');\n    this._tooltipController.setAriaTarget(this.inputElement);\n    this._tooltipController.setShouldShow(target => !target.opened);\n    this._inputField = this.shadowRoot.querySelector('[part=\"input-field\"]');\n    this._overflowController = new SlotController(this, 'overflow', 'vaadin-multi-select-combo-box-chip', {\n      initializer: chip => {\n        chip.addEventListener('mousedown', e => this._preventBlur(e));\n        this._overflow = chip;\n      }\n    });\n    this.addController(this._overflowController);\n    this.__updateChips();\n    processTemplates(this);\n  }\n\n  /**\n   * Returns true if the current input value satisfies all constraints (if any).\n   * @return {boolean}\n   */\n  checkValidity() {\n    return this.required && !this.readonly ? this._hasValue : true;\n  }\n\n  /**\n   * Clears the selected items.\n   */\n  clear() {\n    this.__updateSelection([]);\n    announce(this.i18n.cleared);\n  }\n\n  /**\n   * Clears the cached pages and reloads data from data provider when needed.\n   */\n  clearCache() {\n    if (this.$ && this.$.comboBox) {\n      this.$.comboBox.clearCache();\n    }\n  }\n\n  /**\n   * Requests an update for the content of items.\n   * While performing the update, it invokes the renderer (passed in the `renderer` property) once an item.\n   *\n   * It is not guaranteed that the update happens immediately (synchronously) after it is requested.\n   */\n  requestContentUpdate() {\n    if (this.$ && this.$.comboBox) {\n      this.$.comboBox.requestContentUpdate();\n    }\n  }\n\n  /**\n   * Override method inherited from `DisabledMixin` to forward disabled to chips.\n   * @protected\n   * @override\n   */\n  _disabledChanged(disabled, oldDisabled) {\n    super._disabledChanged(disabled, oldDisabled);\n    if (disabled || oldDisabled) {\n      this.__updateChips();\n    }\n  }\n\n  /**\n   * Override method inherited from `InputMixin` to forward the input to combo-box.\n   * @protected\n   * @override\n   */\n  _inputElementChanged(input) {\n    super._inputElementChanged(input);\n    if (input) {\n      this.$.comboBox._setInputElement(input);\n    }\n  }\n\n  /**\n   * Override method inherited from `FocusMixin` to validate on blur.\n   * @param {boolean} focused\n   * @protected\n   */\n  _setFocused(focused) {\n    super._setFocused(focused);\n\n    // Do not validate when focusout is caused by document\n    // losing focus, which happens on browser tab switch.\n    if (!focused && document.hasFocus()) {\n      this._focusedChipIndex = -1;\n      this.validate();\n    }\n  }\n\n  /**\n   * Implement callback from `ResizeMixin` to update chips.\n   * @protected\n   * @override\n   */\n  _onResize() {\n    this.__updateChips();\n  }\n\n  /**\n   * Override method from `DelegateStateMixin` to set required state\n   * using `aria-required` attribute instead of `required`, in order\n   * to prevent screen readers from announcing \"invalid entry\".\n   * @protected\n   * @override\n   */\n  _delegateAttribute(name, value) {\n    if (!this.stateTarget) {\n      return;\n    }\n    if (name === 'required') {\n      this._delegateAttribute('aria-required', value ? 'true' : false);\n      return;\n    }\n    super._delegateAttribute(name, value);\n  }\n\n  /** @private */\n  _autoExpandHorizontallyChanged(autoExpand, oldAutoExpand) {\n    if (autoExpand || oldAutoExpand) {\n      this.__updateChips();\n    }\n  }\n\n  /** @private */\n  _autoExpandVerticallyChanged(autoExpand, oldAutoExpand) {\n    if (autoExpand || oldAutoExpand) {\n      this.__updateChips();\n    }\n  }\n\n  /**\n   * Setting clear button visible reduces total space available\n   * for rendering chips, and making it hidden increases it.\n   * @private\n   */\n  _clearButtonVisibleChanged(visible, oldVisible) {\n    if (visible || oldVisible) {\n      this.__updateChips();\n    }\n  }\n\n  /**\n   * Implement two-way binding for the `filteredItems` property\n   * that can be set on the internal combo-box element.\n   *\n   * @param {CustomEvent} event\n   * @private\n   */\n  _onFilteredItemsChanged(event) {\n    const value = event.detail.value;\n    if (Array.isArray(value) || value == null) {\n      this.filteredItems = value;\n    }\n  }\n\n  /** @private */\n  _readonlyChanged(readonly, oldReadonly) {\n    if (readonly || oldReadonly) {\n      this.__updateChips();\n    }\n    if (this.dataProvider) {\n      this.clearCache();\n    }\n  }\n\n  /** @private */\n  __itemClassNameGeneratorChanged(generator, oldGenerator) {\n    if (generator || oldGenerator) {\n      this.__updateChips();\n    }\n  }\n\n  /** @private */\n  _pageSizeChanged(pageSize, oldPageSize) {\n    if (Math.floor(pageSize) !== pageSize || pageSize <= 0) {\n      this.pageSize = oldPageSize;\n      console.error('\"pageSize\" value must be an integer > 0');\n    }\n    this.$.comboBox.pageSize = this.pageSize;\n  }\n\n  /** @private */\n  _placeholderChanged(placeholder) {\n    const tmpPlaceholder = this.__tmpA11yPlaceholder;\n    // Do not store temporary placeholder\n    if (tmpPlaceholder !== placeholder) {\n      this.__savedPlaceholder = placeholder;\n      if (tmpPlaceholder) {\n        this.placeholder = tmpPlaceholder;\n      }\n    }\n  }\n\n  /** @private */\n  _selectedItemsChanged(selectedItems) {\n    this._toggleHasValue(this._hasValue);\n\n    // Use placeholder for announcing items\n    if (this._hasValue) {\n      const tmpPlaceholder = this._mergeItemLabels(selectedItems);\n      if (this.__tmpA11yPlaceholder === undefined) {\n        this.__savedPlaceholder = this.placeholder;\n      }\n      this.__tmpA11yPlaceholder = tmpPlaceholder;\n      this.placeholder = tmpPlaceholder;\n    } else if (this.__tmpA11yPlaceholder !== undefined) {\n      delete this.__tmpA11yPlaceholder;\n      this.placeholder = this.__savedPlaceholder;\n    }\n\n    // Re-render chips\n    this.__updateChips();\n\n    // Update selected for dropdown items\n    this.requestContentUpdate();\n    if (this.opened) {\n      this.$.comboBox.$.overlay._updateOverlayWidth();\n    }\n  }\n\n  /** @private */\n  _getItemLabel(item) {\n    return this.$.comboBox._getItemLabel(item);\n  }\n\n  /** @private */\n  _mergeItemLabels(items) {\n    return items.map(item => this._getItemLabel(item)).join(', ');\n  }\n\n  /** @private */\n  _findIndex(item, selectedItems, itemIdPath) {\n    if (itemIdPath && item) {\n      for (let index = 0; index < selectedItems.length; index++) {\n        if (selectedItems[index] && selectedItems[index][itemIdPath] === item[itemIdPath]) {\n          return index;\n        }\n      }\n      return -1;\n    }\n    return selectedItems.indexOf(item);\n  }\n\n  /**\n   * Clear the internal combo box value and filter. Filter will not be cleared\n   * when the `keepFilter` option is enabled. Using `force` can enforce clearing\n   * the filter.\n   * @param {boolean} force overrides the keepFilter option\n   * @private\n   */\n  __clearInternalValue() {\n    let force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n    if (!this.keepFilter || force) {\n      // Clear both combo box value and filter.\n      this.filter = '';\n      this.$.comboBox.clear();\n    } else {\n      // Only clear combo box value. This effectively resets _lastCommittedValue\n      // which allows toggling the same item multiple times via keyboard.\n      this.$.comboBox.clear();\n      // Restore input to the filter value. Needed when items are\n      // navigated with keyboard, which overrides the input value\n      // with the item label.\n      this._inputElementValue = this.filter;\n    }\n  }\n\n  /** @private */\n  __announceItem(itemLabel, isSelected, itemCount) {\n    const state = isSelected ? 'selected' : 'deselected';\n    const total = this.i18n.total.replace('{count}', itemCount || 0);\n    announce(`${itemLabel} ${this.i18n[state]} ${total}`);\n  }\n\n  /** @private */\n  __removeItem(item) {\n    const itemsCopy = [...this.selectedItems];\n    itemsCopy.splice(itemsCopy.indexOf(item), 1);\n    this.__updateSelection(itemsCopy);\n    const itemLabel = this._getItemLabel(item);\n    this.__announceItem(itemLabel, false, itemsCopy.length);\n  }\n\n  /** @private */\n  __selectItem(item) {\n    const itemsCopy = [...this.selectedItems];\n    const index = this._findIndex(item, itemsCopy, this.itemIdPath);\n    const itemLabel = this._getItemLabel(item);\n    let isSelected = false;\n    if (index !== -1) {\n      const lastFilter = this._lastFilter;\n      // Do not unselect when manually typing and committing an already selected item.\n      if (lastFilter && lastFilter.toLowerCase() === itemLabel.toLowerCase()) {\n        this.__clearInternalValue();\n        return;\n      }\n      itemsCopy.splice(index, 1);\n    } else {\n      itemsCopy.push(item);\n      isSelected = true;\n    }\n    this.__updateSelection(itemsCopy);\n\n    // Suppress `value-changed` event.\n    this.__clearInternalValue();\n    this.__announceItem(itemLabel, isSelected, itemsCopy.length);\n  }\n\n  /** @private */\n  __updateSelection(selectedItems) {\n    this.selectedItems = selectedItems;\n    this.validate();\n    this.dispatchEvent(new CustomEvent('change', {\n      bubbles: true\n    }));\n  }\n\n  /** @private */\n  __updateTopGroup(selectedItemsOnTop, selectedItems, opened) {\n    if (!selectedItemsOnTop) {\n      this._topGroup = [];\n    } else if (!opened) {\n      this._topGroup = [...selectedItems];\n    }\n  }\n\n  /** @private */\n  __createChip(item) {\n    const chip = document.createElement('vaadin-multi-select-combo-box-chip');\n    chip.setAttribute('slot', 'chip');\n    chip.item = item;\n    chip.disabled = this.disabled;\n    chip.readonly = this.readonly;\n    const label = this._getItemLabel(item);\n    chip.label = label;\n    chip.setAttribute('title', label);\n    if (typeof this.itemClassNameGenerator === 'function') {\n      chip.className = this.itemClassNameGenerator(item);\n    }\n    chip.addEventListener('item-removed', e => this._onItemRemoved(e));\n    chip.addEventListener('mousedown', e => this._preventBlur(e));\n    return chip;\n  }\n\n  /** @private */\n  __getOverflowWidth() {\n    const chip = this._overflow;\n    chip.style.visibility = 'hidden';\n    chip.removeAttribute('hidden');\n    const count = chip.getAttribute('count');\n\n    // Detect max possible width of the overflow chip\n    // by measuring it with widest number (2 digits)\n    chip.setAttribute('count', '99');\n    const overflowStyle = getComputedStyle(chip);\n    const overflowWidth = chip.clientWidth + parseInt(overflowStyle.marginInlineStart);\n    chip.setAttribute('count', count);\n    chip.setAttribute('hidden', '');\n    chip.style.visibility = '';\n    return overflowWidth;\n  }\n\n  /** @private */\n  __updateChips() {\n    if (!this._inputField || !this.inputElement) {\n      return;\n    }\n\n    // Clear all chips except the overflow\n    this._chips.forEach(chip => {\n      chip.remove();\n    });\n    const items = [...this.selectedItems];\n\n    // Detect available remaining width for chips\n    const totalWidth = this._inputField.$.wrapper.clientWidth;\n    const inputWidth = parseInt(getComputedStyle(this.inputElement).flexBasis);\n    let remainingWidth = totalWidth - inputWidth;\n    if (items.length > 1) {\n      remainingWidth -= this.__getOverflowWidth();\n    }\n    const chipMinWidth = parseInt(getComputedStyle(this).getPropertyValue('--_chip-min-width'));\n    if (this.autoExpandHorizontally) {\n      const chips = [];\n\n      // First, add all chips to make the field fully expand\n      for (let i = items.length - 1, refNode = null; i >= 0; i--) {\n        const chip = this.__createChip(items[i]);\n        this.insertBefore(chip, refNode);\n        refNode = chip;\n        chips.unshift(chip);\n      }\n      const overflowItems = [];\n      const availableWidth = this._inputField.$.wrapper.clientWidth - this.$.chips.clientWidth;\n\n      // When auto expanding vertically, no need to measure width\n      if (!this.autoExpandVertically && availableWidth < inputWidth) {\n        // Always show at least last item as a chip\n        while (chips.length > 1) {\n          const lastChip = chips.pop();\n          lastChip.remove();\n          overflowItems.unshift(items.pop());\n\n          // Remove chips until there is enough width for the input element to fit\n          const neededWidth = overflowItems.length > 0 ? inputWidth + this.__getOverflowWidth() : inputWidth;\n          if (this._inputField.$.wrapper.clientWidth - this.$.chips.clientWidth >= neededWidth) {\n            break;\n          }\n        }\n        if (chips.length === 1) {\n          chips[0].style.maxWidth = `${Math.max(chipMinWidth, remainingWidth)}px`;\n        }\n      }\n      this._overflowItems = overflowItems;\n      return;\n    }\n\n    // Add chips until remaining width is exceeded\n    for (let i = items.length - 1, refNode = null; i >= 0; i--) {\n      const chip = this.__createChip(items[i]);\n      this.insertBefore(chip, refNode);\n\n      // When auto expanding vertically, no need to measure remaining width\n      if (!this.autoExpandVertically && this.$.chips.clientWidth > remainingWidth) {\n        // Always show at least last selected item as a chip\n        if (refNode === null) {\n          chip.style.maxWidth = `${Math.max(chipMinWidth, remainingWidth)}px`;\n        } else {\n          chip.remove();\n          break;\n        }\n      }\n      items.pop();\n      refNode = chip;\n    }\n    this._overflowItems = items;\n  }\n\n  /** @private */\n  __updateOverflowChip(overflow, items, disabled, readonly) {\n    if (overflow) {\n      const count = items.length;\n      overflow.label = `${count}`;\n      overflow.setAttribute('count', `${count}`);\n      overflow.setAttribute('title', this._mergeItemLabels(items));\n      overflow.toggleAttribute('hidden', count === 0);\n      overflow.disabled = disabled;\n      overflow.readonly = readonly;\n    }\n  }\n\n  /** @private */\n  _onClearButtonTouchend(event) {\n    // Cancel the following click and focus events\n    event.preventDefault();\n    // Prevent default combo box behavior which can otherwise unnecessarily\n    // clear the input and filter\n    event.stopPropagation();\n    this.clear();\n  }\n\n  /**\n   * Override method inherited from `InputControlMixin` and clear items.\n   * @protected\n   * @override\n   */\n  _onClearButtonClick(event) {\n    event.stopPropagation();\n    this.clear();\n  }\n\n  /**\n   * Override an event listener from `InputControlMixin` to\n   * stop the change event re-targeted from the input.\n   *\n   * @param {!Event} event\n   * @protected\n   * @override\n   */\n  _onChange(event) {\n    event.stopPropagation();\n  }\n\n  /**\n   * Override an event listener from `KeyboardMixin`.\n   * Do not call `super` in order to override clear\n   * button logic defined in `InputControlMixin`.\n   *\n   * @param {!KeyboardEvent} event\n   * @protected\n   * @override\n   */\n  _onEscape(event) {\n    if (this.clearButtonVisible && this.selectedItems && this.selectedItems.length) {\n      event.stopPropagation();\n      this.selectedItems = [];\n    }\n  }\n\n  /**\n   * Override an event listener from `KeyboardMixin`.\n   * @param {KeyboardEvent} event\n   * @protected\n   * @override\n   */\n  _onKeyDown(event) {\n    super._onKeyDown(event);\n    const chips = this._chips;\n    if (!this.readonly && chips.length > 0) {\n      switch (event.key) {\n        case 'Backspace':\n          this._onBackSpace(chips);\n          break;\n        case 'ArrowLeft':\n          this._onArrowLeft(chips, event);\n          break;\n        case 'ArrowRight':\n          this._onArrowRight(chips, event);\n          break;\n        default:\n          this._focusedChipIndex = -1;\n          break;\n      }\n    }\n  }\n\n  /** @private */\n  _onArrowLeft(chips, event) {\n    if (this.inputElement.selectionStart !== 0) {\n      return;\n    }\n    const idx = this._focusedChipIndex;\n    if (idx !== -1) {\n      event.preventDefault();\n    }\n    let newIdx;\n    if (!this.__isRTL) {\n      if (idx === -1) {\n        // Focus last chip\n        newIdx = chips.length - 1;\n      } else if (idx > 0) {\n        // Focus prev chip\n        newIdx = idx - 1;\n      }\n    } else if (idx === chips.length - 1) {\n      // Blur last chip\n      newIdx = -1;\n    } else if (idx > -1) {\n      // Focus next chip\n      newIdx = idx + 1;\n    }\n    if (newIdx !== undefined) {\n      this._focusedChipIndex = newIdx;\n    }\n  }\n\n  /** @private */\n  _onArrowRight(chips, event) {\n    if (this.inputElement.selectionStart !== 0) {\n      return;\n    }\n    const idx = this._focusedChipIndex;\n    if (idx !== -1) {\n      event.preventDefault();\n    }\n    let newIdx;\n    if (this.__isRTL) {\n      if (idx === -1) {\n        // Focus last chip\n        newIdx = chips.length - 1;\n      } else if (idx > 0) {\n        // Focus prev chip\n        newIdx = idx - 1;\n      }\n    } else if (idx === chips.length - 1) {\n      // Blur last chip\n      newIdx = -1;\n    } else if (idx > -1) {\n      // Focus next chip\n      newIdx = idx + 1;\n    }\n    if (newIdx !== undefined) {\n      this._focusedChipIndex = newIdx;\n    }\n  }\n\n  /** @private */\n  _onBackSpace(chips) {\n    if (this.inputElement.selectionStart !== 0) {\n      return;\n    }\n    const idx = this._focusedChipIndex;\n    if (idx === -1) {\n      this._focusedChipIndex = chips.length - 1;\n    } else {\n      this.__removeItem(chips[idx].item);\n      this._focusedChipIndex = -1;\n    }\n  }\n\n  /** @private */\n  _focusedChipIndexChanged(focusedIndex, oldFocusedIndex) {\n    if (focusedIndex > -1 || oldFocusedIndex > -1) {\n      const chips = this._chips;\n      chips.forEach((chip, index) => {\n        chip.toggleAttribute('focused', index === focusedIndex);\n      });\n\n      // Announce focused chip\n      if (focusedIndex > -1) {\n        const item = chips[focusedIndex].item;\n        const itemLabel = this._getItemLabel(item);\n        announce(`${itemLabel} ${this.i18n.focused}`);\n      }\n    }\n  }\n\n  /** @private */\n  _onComboBoxChange() {\n    const item = this.$.comboBox.selectedItem;\n    if (item) {\n      this.__selectItem(item);\n    }\n  }\n\n  /** @private */\n  _onComboBoxItemSelected(event) {\n    this.__selectItem(event.detail.item);\n  }\n\n  /** @private */\n  _onCustomValueSet(event) {\n    // Do not set combo-box value\n    event.preventDefault();\n\n    // Stop the original event\n    event.stopPropagation();\n    this.__clearInternalValue(true);\n    this.dispatchEvent(new CustomEvent('custom-value-set', {\n      detail: event.detail,\n      composed: true,\n      bubbles: true\n    }));\n  }\n\n  /** @private */\n  _onItemRemoved(event) {\n    this.__removeItem(event.detail.item);\n  }\n\n  /** @private */\n  _preventBlur(event) {\n    // Prevent mousedown event to keep the input focused\n    // and keep the overlay opened when clicking a chip.\n    event.preventDefault();\n  }\n\n  /**\n   * Fired when the user sets a custom value.\n   * @event custom-value-set\n   * @param {string} detail the custom value\n   */\n}\ndefineCustomElement(MultiSelectComboBox);\nexport { MultiSelectComboBox };","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd..\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { clearButton } from './clear-button-styles.js';\nimport { fieldShared } from './field-shared-styles.js';\nimport { inputFieldContainer } from './input-field-container-styles.js';\nexport const inputFieldShared = [fieldShared, inputFieldContainer, clearButton];","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd..\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { css } from 'lit';\nexport const fieldShared = css`\n  :host {\n    display: inline-flex;\n    outline: none;\n  }\n\n  :host::before {\n    content: '\\\\2003';\n    width: 0;\n    display: inline-block;\n    /* Size and position this element on the same vertical position as the input-field element\n          to make vertical align for the host element work as expected */\n  }\n\n  :host([hidden]) {\n    display: none !important;\n  }\n\n  :host(:not([has-label])) [part='label'] {\n    display: none;\n  }\n\n  @media (forced-colors: active) {\n    :host(:not([readonly])) [part='input-field'] {\n      outline: 1px solid;\n      outline-offset: -1px;\n    }\n    :host([focused]) [part='input-field'] {\n      outline-width: 2px;\n    }\n    :host([disabled]) [part='input-field'] {\n      outline-color: GrayText;\n    }\n  }\n`;","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd..\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { css } from 'lit';\nexport const inputFieldContainer = css`\n  [class$='container'] {\n    display: flex;\n    flex-direction: column;\n    min-width: 100%;\n    max-width: 100%;\n    width: var(--vaadin-field-default-width, 12em);\n  }\n`;","/**\n * @license\n * Copyright (c) 2021 - 2024 Vaadin Ltd..\n * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/\n */\nimport { css } from 'lit';\nexport const clearButton = css`\n  [part='clear-button'] {\n    display: none;\n    cursor: default;\n  }\n\n  [part='clear-button']::before {\n    content: '\\\\2715';\n  }\n\n  :host([clear-button-visible][has-value]:not([disabled]):not([readonly])) [part='clear-button'] {\n    display: block;\n  }\n`;"],"sourceRoot":""}