{"version":3,"sources":["node_modules/@webcomponents/webcomponents-platform/webcomponents-platform.js"," [synthetic:util/global] "," [synthetic:util/defineproperty] "," [synthetic:es6/symbol] "," [synthetic:es6/util/makeiterator] "," [synthetic:es6/util/arrayfromiterator] ","node_modules/@webcomponents/template/template.js","node_modules/promise-polyfill/src/index.js","node_modules/promise-polyfill/src/finally.js","src/promise.js","node_modules/@webcomponents/html-imports/src/html-imports.js","src/pre-polyfill.js","node_modules/@webcomponents/shadydom/src/shady-data.js","node_modules/@webcomponents/shadydom/src/utils.js","node_modules/@webcomponents/shadydom/src/flush.js","node_modules/@webcomponents/shadydom/src/observe-changes.js","node_modules/@webcomponents/shadydom/src/innerHTML.js","node_modules/@webcomponents/shadydom/src/patch-native.js","node_modules/@webcomponents/shadydom/src/patch-instances.js","node_modules/@webcomponents/shadydom/src/patch-events.js","node_modules/@webcomponents/shadydom/src/array-splice.js","node_modules/@webcomponents/shadydom/src/link-nodes.js","node_modules/@webcomponents/shadydom/src/style-scoping.js","node_modules/@webcomponents/shadydom/src/patches/Node.js","node_modules/@webcomponents/shadydom/src/attach-shadow.js"," [synthetic:es6/util/arrayfromiterable] ","node_modules/@webcomponents/shadydom/src/patches/ParentNode.js","node_modules/@webcomponents/shadydom/src/patches/DocumentOrFragment.js","node_modules/@webcomponents/shadydom/src/patches/DocumentOrShadowRoot.js","node_modules/@webcomponents/shadydom/src/patches/ElementOrShadowRoot.js","node_modules/@webcomponents/shadydom/src/patches/ShadowRoot.js","node_modules/@webcomponents/shadydom/src/patch-shadyRoot.js","node_modules/@webcomponents/shadydom/src/wrapper.js","node_modules/@webcomponents/shadydom/src/patches/EventTarget.js","node_modules/@webcomponents/shadydom/src/patches/Slotable.js","node_modules/@webcomponents/shadydom/src/patches/Element.js","node_modules/@webcomponents/shadydom/src/patches/HTMLElement.js","node_modules/@webcomponents/shadydom/src/patches/Slot.js","node_modules/@webcomponents/shadydom/src/patches/Document.js","node_modules/@webcomponents/shadydom/src/patches/Window.js","node_modules/@webcomponents/shadydom/src/patch-prototypes.js","node_modules/@webcomponents/shadydom/src/shadydom.js","node_modules/@webcomponents/custom-elements/src/Utilities.js","node_modules/@webcomponents/custom-elements/src/CustomElementInternals.js","node_modules/@webcomponents/custom-elements/src/CustomElementState.js","node_modules/@webcomponents/custom-elements/src/DocumentConstructionObserver.js","node_modules/@webcomponents/custom-elements/src/CustomElementRegistry.js","node_modules/@webcomponents/custom-elements/src/Deferred.js","node_modules/@webcomponents/custom-elements/src/Patch/Native.js","node_modules/@webcomponents/custom-elements/src/AlreadyConstructedMarker.js","node_modules/@webcomponents/custom-elements/src/Patch/HTMLElement.js","node_modules/@webcomponents/custom-elements/src/custom-elements.js","node_modules/@webcomponents/custom-elements/src/Patch/Interface/ParentNode.js","node_modules/@webcomponents/custom-elements/src/Patch/Document.js","node_modules/@webcomponents/custom-elements/src/Patch/Node.js","node_modules/@webcomponents/custom-elements/src/Patch/Interface/ChildNode.js","node_modules/@webcomponents/custom-elements/src/Patch/Element.js","node_modules/@webcomponents/custom-elements/src/Patch/DocumentFragment.js","node_modules/@webcomponents/shadycss/src/css-parse.js","node_modules/@webcomponents/shadycss/src/style-settings.js","node_modules/@webcomponents/shadycss/src/common-regex.js","node_modules/@webcomponents/shadycss/src/unscoped-style-handler.js","node_modules/@webcomponents/shadycss/src/style-util.js","node_modules/@webcomponents/shadycss/src/style-transformer.js","node_modules/@webcomponents/shadycss/src/scoping-shim.js","node_modules/@webcomponents/shadycss/src/document-watcher.js","node_modules/@webcomponents/shadycss/src/style-properties.js","node_modules/@webcomponents/shadycss/src/style-info.js","node_modules/@webcomponents/shadycss/src/style-placeholder.js","node_modules/@webcomponents/shadycss/src/style-cache.js","node_modules/@webcomponents/shadycss/src/template-map.js","node_modules/@webcomponents/shadycss/src/apply-shim-utils.js","node_modules/@webcomponents/shadycss/src/common-utils.js","node_modules/@webcomponents/shadycss/entrypoints/scoping-shim.js","src/post-polyfill.js","src/unresolved.js"],"names":["$jscomp.global","$jscomp.defineProperty","$jscomp.initSymbol","$jscomp.Symbol","$jscomp.SYMBOL_PREFIX","$jscomp.arrayIterator","$jscomp.initSymbolIterator","$jscomp.iteratorPrototype","e","document","createEvent","initEvent","preventDefault","defaultPrevented","workingDefaultPrevented","origPreventDefault","Event","prototype","Event.prototype.preventDefault","cancelable","call","Object","defineProperty","get","configurable","isIE","test","navigator","userAgent","window","CustomEvent","window.CustomEvent","inType","params","initCustomEvent","bubbles","detail","origEvent","window.Event","i","MouseEvent","origMouseEvent","window.MouseEvent","initMouseEvent","view","screenX","screenY","clientX","clientY","ctrlKey","altKey","shiftKey","metaKey","button","relatedTarget","Array","from","Array.from","object","slice","assign","Object.assign","target","sources","args","arguments","s","length","n$","getOwnPropertyNames","source","p","WebComponents","PolyfilledHTMLTemplateElement","QSA","node","selector","childNodes","nodeType","Node","DOCUMENT_NODE","docQuerySelectorAll","DOCUMENT_FRAGMENT_NODE","fragQuerySelectorAll","elementQuerySelectorAll","needsTemplate","HTMLTemplateElement","brokenDocFragment","createDocumentFragment","cloneNode","DocumentFragment","needsDocFrag","insertBefore","newNode","refNode","child","firstChild","origInsertBefore","origCloneNode","Node.prototype.cloneNode","deep","newDom","__proto__","querySelectorAll","HTMLElement","querySelector","defineProperties","origAppendChild","appendChild","Node.prototype.appendChild","origRemoveChild","removeChild","origReplaceChild","replaceChild","Node.prototype.replaceChild","newChild","oldChild","Document","Document.prototype.createDocumentFragment","frag","createElement","origImportNode","importNode","Document.prototype.importNode","impNode","capturedCloneNode","capturedCreateElement","capturedImportNode","capturedRemoveChild","capturedAppendChild","capturedReplaceChild","capturedParseFromString","DOMParser","parseFromString","capturedHTMLElementInnerHTML","getOwnPropertyDescriptor","innerHTML","set","text","capturedChildNodes","Element","needsCloning","t","t2","content","clone","contentDoc","implementation","createHTMLDocument","canDecorate","templateStyle","textContent","head","firstElementChild","create","canProtoPatch","hasOwnProperty","decorate","PolyfilledHTMLTemplateElement.decorate","template","namespaceURI","documentElement","template.cloneNode","_cloneNode","defineInnerHTML","defineOuterHTML","err","bootstrap","topLevelWrappingMap","obj","getInnerHTML","wrap","exec","toLowerCase","body","j","lastChild","parentNode","docFrag","ownerDocument","Error","PolyfilledHTMLTemplateElement.bootstrap","doc","templates","TEMPLATE_TAG","l","addEventListener","Document.prototype.createElement","el","apply","localName","DOMParser.prototype.parseFromString","enumerable","escapeAttrRegExp","escapeDataRegExp","escapeReplace","c","makeSet","arr","voidElements","plaintextParents","callback","c$","ELEMENT_NODE","tagName","attrs","attributes","attr","name","value","replace","TEXT_NODE","data","COMMENT_NODE","console","error","PolyfilledHTMLTemplateElement._cloneNode","fixClonedDom","s$","t$","dom","element","scripts","scriptSelector","ns","ai","a","setAttribute","setTimeoutFunc","setTimeout","noop","bind","fn","thisArg","Promise","TypeError","_state","_handled","_value","undefined","_deferreds","doResolve","handle","self","deferred","push","Promise$$module$node_modules$promise_polyfill$src$index._immediateFn","cb","onFulfilled","onRejected","resolve","reject","promise","ret","newValue","then","finale","warn","len","Handler","done","reason","ex","Promise.prototype.then","prom","constructor","finallyConstructor","Promise.all","res","val","remaining","Promise.resolve","Promise.reject","Promise.race","values","setImmediate","Promise$$module$node_modules$promise_polyfill$src$index.all","Promise$$module$node_modules$promise_polyfill$src$index.race","Promise$$module$node_modules$promise_polyfill$src$index.resolve","Promise$$module$node_modules$promise_polyfill$src$index.reject","createTextNode","callbacks","observe","MutationObserver","splice","characterData","PromisePolyfill._immediateFn","scope","newCustomEvent","type","event","importForElement","useNative","closest","importSelector","isImportLink","whenImportsReady","imports","rootImportSelector","pending","forEach","imp","whenElementLoaded","whenDocumentReady","stateChanged","readyState","removeEventListener","whenReady","src","onLoadingDone","rel","Importer","documents","inflight","dynamicImportsMO","m","handleMutations","childList","subtree","loadImports","replaceScripts","fragment","scriptsSelector","script","emptyNodeList","list","inverseOrder","increment","link","currentScript","CSS_URL_REGEXP","CSS_IMPORT_REGEXP","STYLESHEET_REGEXP","Path","fixUrls","base","href","resolveUrl","getAttribute","r","replaceUrls","linkUrl","regexp","pre","url","post","urlPath","__workingURL","u","URL","pathname","__tempDoc","__base","__anchor","Xhr","async","load","success","fail","match","pieces","split","resource","header","indexOf","atob","decodeURIComponent","request","XMLHttpRequest","open","onload","request.onload","redirectedUrl","responseURL","getResponseHeader","location","origin","protocol","host","response","responseText","status","send","links","loadImport","fireEventIfNeeded","makeDocument","processImportsIfLoadingDone","p1","p2","baseEl","removeAttribute","importDependenciesSelector","inlineScriptIndex","n","importDependencyAttr","encodeURIComponent","disconnect","flatten","scriptsOk","stylesOk","fireEvents","waitForStyles","runScripts","cloneScript","pendingScriptsSelector","pendingStylesSelector","needsMove","disabledLinkSelector","placeholder","nextSibling","newSibling","import","dispatchEvent","mutations","addedNodes","elem","importer","imps","native_baseURI","klass","ownerDoc","HTMLLinkElement","HTMLImports","flagMatcher","flags","search","option","parts","f","forceShady","forceCE","ShadyData","publicRoot","root","dirty","flattenedNodes","_prevAssignedSlot","_previouslyAssignedNodes","assignedSlot","assignedNodes","observer","previousSibling","ownerShadyRoot","__insideAccessors","__outsideAccessors","__onCallbackListeners","toJSON","ensureShadyDataForNode","__shady","shadyDataForNode","settings","hasNativeShadowDOM","attachShadow","getRootNode","desc","hasDescriptors","inUse","noPatch","preferPerformance","isTrackingLogicalChildNodes","nodeData","isShadyRoot","_localName","hasShadowRootWithSlot","_hasInsertionPoint","matches","matchesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector","webkitMatchesSelector","twiddle","queue","shift","microtask","hasDocumentContains","contains","container","createPolyfilledHTMLCollection","nodes","isNaN","item","nodes.item","index","namedItem","nodes.namedItem","$jscomp.makeIterator","patchProperties","proto","descriptors","prefix","disallowedPatches","newDescriptor","getOwnPropertyDescriptors","flushList","scheduled","enqueue","flush","didFlush","AsyncObserver","_scheduled","removedNodes","Set","schedule","takeRecords","observeChildren","sd","add","_callback","_observer","_node","unobserveChildren","delete","size","filterMutations","targetRootNode","map","mutation","mutationInScope","filter","nativeMethods","nativeTree","installNativeAccessor","NATIVE_PREFIX","defineNativeAccessors","prop","copyProperties","descriptor","nodeWalker","createTreeWalker","NodeFilter","SHOW_ALL","elementWalker","SHOW_ELEMENT","inertDoc","clearNode","ParentNodeAccessors","ParentNodeMethods","addNativePrefixedProperties","eventProps","EventTarget","Window","currentNode","parentElement","textWalker","SHOW_TEXT","nextNode","nodeValue","ParentNodeWalkerDescriptors","lastElementChild","children","childElementCount","previousElementSibling","nextElementSibling","containerName","htmlContainer","createElementNS","newContent","InsideDescriptors","shadowRoot","OutsideDescriptors","className","noInstancePatching","patchOutsideElementAccessors","patchInsideElementAccessors","eventWrappersName","Date","now","composedGetter","composedProp","ev","alwaysComposed","unpatchedEvents","getRootNodeWithFallback","eventTarget","pathComposer","startNode","composed","composedPath","current","startRoot","__composedPath","retarget","path","refNodePath","ancestor","lastRoot","rootIdx","mixinComposedFlag","Base","klazz","options","__composed","nonBubblingEventsToRetarget","hasRetargeted","__relatedTarget","fireHandlers","phase","hs","__handlers","__immediatePropagationStopped","retargetNonBubblingEvent","__propagationStopped","AT_TARGET","lastFiredRoot","findListener","wrappers","capture","once","passive","savedType","savedListener","savedCapture","savedOnce","savedPassive","savedNode","fnOrObj","optionsOrCapture","handlerType","handleEvent","__shadyTarget","wrapperFn","patchEvent","lastCurrentTargetDesc","eventPhase","BUBBLING_PHASE","stopImmediatePropagation","CAPTURING_PHASE","idx","activateFocusEventOverrides","EventPatchesDescriptors","EventPatches","isTrusted","currentTarget","__relatedTargetComposedPath","stopPropagation","getPrototypeOf","SHADY_PROTO","patchedProto","PatchedEvent","PatchedCustomEvent","PatchedMouseEvent","patchClick","composedClickFn","click","eventPropertyNames","substring","newSplice","addedCount","removed","calcSplices","currentEnd","old","oldEnd","currentStart","oldStart","prefixCount","suffixCount","minLength","Math","min","currentValue","previousValue","index1","index2","count","equals","rowCount","columnCount","distances","north","west","edits","EDIT_ADD","EDIT_DELETE","northWest","EDIT_LEAVE","EDIT_UPDATE","reverse","splices","oldIndex","linkNode","ref_node","containerData","ref_nodeData","psd","nsd","recordInsertBefore","resetTo","recordRemoveChild","recordChildNodes","first","previous","scopingShim","getScopingShim","removeShadyScoping","currentScopeName","currentScopeIsCorrect","newScopeName","correctScope","currentScope","currentScopeForNode","treeVisitor","visitorFn","nativeIsConnectedAccessors","nativeIsConnected","removeOwnerShadyRoot","firstComposedNode","flattened","scheduleObserver","addedNode","removedNode","NodePatches","childNodes.item","isConnected","tc","cn","join","refData","slotsAdded","ownerRoot","ownerShadyRootForNode","oldScopeName","allowNativeInsert","needsScoping","needsSlotFinding","_pendingSlots","_addSlots","_ensureSlotData","_slotList","_slotMap","$jscomp.arrayFromIterator","_asyncRender","parentData","adoptNode","skipUnscoping","removingInsertionPoint","_removeContainedSlots","preventNativeRemove","changeSlotContent","ATTRIBUTE_NODE","nc","parent","query","matcher","halter","queryElements","elements","result","ParentNodePatches","QueryPatches","o","ParentNodeDocumentOrFragmentPatches","DocumentOrFragmentPatches","getElementById","id","DocumentOrShadowRootPatches","activeElement","active","activeRoot","ElementOrShadowRootPatches","ShadowRootPatches","patchShadyAccessors","ShadyRootConstructionToken","isRendering","rootRendered","ancestorList","ancestors","unshift","ShadyRoot","token","SHADYROOT_NAME","mode","hostData","MODE_CLOSED","rootData","_hasRendered","_renderPending","_render","_getPendingDistributionRoot","renderRoot","_getDistributionParent","__childSlotCount","_renderSelf","wasRendering","_validateSlots","_distribute","slot","_clearSlotAssignedNodes","slotData","_distributeNodeToSlot","slotParentRoot","slotParentData","_addAssignedToFlattenedNodes","prevAssignedNodes","_fireSlotChange","slots","composeList","_compose","_composeNode","_isInsertionPoint","_updateChildNodes","d","next","forcedSlot","oldSlot","CATCHALL_NAME","assigned","nestedAssigned","_mapSlots","slotNamesToSort","slotParent","_nameForSlot","_sortSlots","__slotName","sort","b","listA","listB","nA","nB","x","_removeFlattenedNodes","didRemove","patchShadyRoot","SHADY_PREFIX","nodeName","connectMap","Map","v","k","clear","__shadydom_connectedCallback","__shadydom_disconnectedCallback","ManageConnect","connected","disconnected","counter","connectFlag","connectedCallback","base.prototype.__shadydom_connectedCallback","disconnectedCallback","base.prototype.__shadydom_disconnectedCallback","define","Wrapper","addEventListener.prototype","removeEventListener.prototype","appendChild.prototype","insertBefore.prototype","removeChild.prototype","replaceChild.prototype","cloneNode.prototype","getRootNode.prototype","contains.prototype","dispatchEvent.prototype","setAttribute.prototype","getAttribute.prototype","hasAttribute.prototype","hasAttribute","removeAttribute.prototype","attachShadow.prototype","focus.prototype","focus","blur.prototype","blur","importNode.prototype","getElementById.prototype","querySelector.prototype","querySelectorAll.prototype","assignedNodes.prototype","$jscomp.global.Object.defineProperties","_activeElement","wrapperMap","WeakMap","wrapper","EventTargetPatches","SlotablePatches","distributeAttributeChange","_updateSlotName","oldName","ElementPatches","HTMLElementPatches","shadowActive","property","shadyData","eventName","SlotPatches","DocumentPatches","WindowPatches","NonStandardHTMLElement","patchMap","Text","HTMLSlotElement","disallowedNativePatches","applyPatches","disallowed","patch","ShadyDOM","flushInitial","_flushInitial","ShadowRoot","reservedTagList","isValidCustomElementName","reserved","has","validForm","nativeValue","__CE_isImportDocument","nextSiblingOrAncestorSibling","start","walkDeepDescendantElements","visitedImports","__CE_shadowRoot","setPropertyUnchecked","destination","CustomElementInternals","_localNameToDefinition","_constructorToDefinition","_patches","_hasPatches","setDefinition","definition","constructorFunction","addPatch","listener","patchTree","__CE_patched","connectTree","custom","__CE_state","upgradeElement","disconnectTree","patchAndUpgradeTree","upgrade","gatherElements","__CE_hasRegistry","__CE_documentLoadHandled","clonedVisitedImports","defaultView","localNameToDefinition","constructionStack","pop","failed","__CE_definition","attributeChangedCallback","observedAttributes","oldValue","namespace","DocumentConstructionObserver","internals","_internals","_document","_handleMutations","Deferred","_resolve","_promise","CustomElementRegistry","_elementDefinitionIsRunning","_whenDefinedDeferred","_flushCallback","this._flushCallback","_flushPending","_pendingDefinitions","_documentConstructionObserver","define.prototype","CustomElementRegistry$$module$node_modules$$webcomponents$custom_elements$src$CustomElementRegistry_prototype$define","Function","SyntaxError","getCallback","callbackValue","adoptedCallback","_flush","upgrade.prototype","pendingDefinitions","elementsWithStableDefinitions","elementsWithPendingDefinitions","pendingElements","pendingUpgradableElements","get.prototype","whenDefined.prototype","CustomElementRegistry$$module$node_modules$$webcomponents$custom_elements$src$CustomElementRegistry_prototype$whenDefined","whenDefined","prior","some","polyfillWrapFlushCallback.prototype","polyfillWrapFlushCallback","outer","inner","Document_createElement","Document_createElementNS","Document_importNode","Document_prepend","Document_append","DocumentFragment_prepend","DocumentFragment_append","Node_cloneNode","Node_appendChild","Node_insertBefore","Node_removeChild","Node_replaceChild","Node_textContent","Element_attachShadow","Element_innerHTML","Element_getAttribute","Element_setAttribute","Element_removeAttribute","Element_getAttributeNS","getAttributeNS","Element_setAttributeNS","setAttributeNS","Element_removeAttributeNS","removeAttributeNS","Element_insertAdjacentElement","Element_insertAdjacentHTML","Element_prepend","Element_append","Element_before","Element_after","Element_replaceWith","Element_remove","HTMLElement_innerHTML","HTMLElement_insertAdjacentElement","HTMLElement_insertAdjacentHTML","$jscompDefaultExport","AlreadyConstructedMarker","constructorToDefinition","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Document_createElement.call","setPrototypeOf","lastIndex","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.HTMLElement","writable","builtIn","appendPrependPatch","builtInMethod","connectedElements","prepend","append","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Document_importNode.call","NS_HTML","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Document_createElementNS.call","PatchParentNode","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Document_prepend","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Document_append","patch_textContent","baseDescriptor","assignedValue","childNodesLength","insertedNodes","nativeResult","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Node_insertBefore.call","nodeWasConnected","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Node_appendChild.call","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Node_cloneNode.call","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Node_removeChild.call","nodeToInsert","nodeToRemove","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Node_replaceChild.call","nodeToInsertWasConnected","thisIsConnected","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Node_textContent","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Node_textContent.get","beforeAfterPatch","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_before","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_after","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_replaceWith","wasConnected","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_remove","patch_innerHTML","htmlString","removedElements","patch_insertAdjacentElement","baseMethod","position","insertedElement","patch_insertAdjacentHTML","upgradeNodesInRange","end","marker","String","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_attachShadow","init","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_attachShadow.call","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_innerHTML","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_innerHTML.get","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.HTMLElement_innerHTML","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.HTMLElement_innerHTML.get","isTemplate","rawElement","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_setAttribute.call","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_getAttribute.call","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_setAttributeNS.call","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_getAttributeNS.call","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_removeAttribute.call","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_removeAttributeNS.call","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.HTMLElement_insertAdjacentElement","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_insertAdjacentElement","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.HTMLElement_insertAdjacentHTML","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_insertAdjacentHTML","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_prepend","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Element_append","PatchChildNode","priorCustomElements","PatchHTMLElement","PatchDocument","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.DocumentFragment_prepend","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.DocumentFragment_append","PatchNode","PatchElement","customElements","StyleNode","parse","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.comments","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.port","parseCss","OPEN_BRACE","CLOSE_BRACE","trim","ss","_expandUnicodeEscapes","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.multipleSpaces","lastIndexOf","AT_START","MEDIA_START","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.MEDIA_RULE","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.keyframesRule","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.KEYFRAMES_RULE","VAR_START","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.MIXIN_RULE","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.STYLE_RULE","r$","code","repeat","stringify","preserveProperties","cssText","rules","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.customProp","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.mixinProp","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.mixinApply","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.varApply","STYLE_RULE","KEYFRAMES_RULE","MEDIA_RULE","MIXIN_RULE","comments","port","customProp","mixinProp","mixinApply","varApply","keyframesRule","multipleSpaces","nativeShadow","nativeCssVariables_","calcCssVariables","CSS","supports","cssBuild","ShadyCSS","disableRuntime","nativeCss","nativeCssVariables","module$node_modules$$webcomponents$shadycss$src$style_settings.cssBuild","VAR_ASSIGN","MIXIN_MATCH","VAR_CONSUMED","ANIMATION_MATCH","MEDIA_MATCH","BRACKETED","styleTextSet","toCssText","forEachRule","rulesForStyle","style","isKeyframesSelector","rule","styleRuleCallback","keyframesRuleCallback","onlyActiveRules","skipRules","matchMedia","applyCss","moniker","contextNode","applyStyle","lastHeadApplyNode","applyStylePlaceHolder","placeHolder","createComment","after","compareDocumentPosition","DOCUMENT_POSITION_PRECEDING","findMatchingParen","level","processVariableAndFallback","str","suffix","comma","fallback","setElementClassRaw","getIsExtends","typeExtension","is","extends","splitSelectorList","part","getCssBuild","__cssBuild","attrValue","CSS_BUILD_ATTR","buildComment","Comment","commentParts","isOptimalCssBuild","StyleTransformer","domAddScope","_transformDom","transformer","_content","shouldRemoveScope","classList","remove","SCOPE_NAME","CLASS","domReplaceScope","oldScope","newScope","domRemoveScope","elementStyles","styleRules","css","ext","hostScope","_calcHostScope","_calcElementScope","CSS_CLASS_PREFIX","isScoped","_transformRule","transformedSelector","_transformRuleCss","_transformComplexSelector","p$","COMPLEX_SELECTOR_SEP","_twiddleNthPlus","NTH","inside","_preserveMatchesPseudo","MATCHES","input","MATCHES_REPLACEMENT","_replaceMatchesPseudo","reduce","acc","cur","stop","isNth","isMatches","SLOTTED_START","SIMPLE_SELECTOR_SEP","info","_transformCompoundSelector","combinator","slottedIndex","SLOTTED","HOST","_transformHostSelector","_transformSimpleSelector","slotted","SLOTTED_PAREN","paren","DIR_PAREN","before","dir","output","PSEUDO_PREFIX","HOST_PAREN","SIMPLE_SELECTOR_PREFIX","SELECTOR_NO_MATCH","normalizeRootSelector","ROOT","_transformDocumentSelector","SCOPE_DOC_SELECTOR","StyleInfo","ast","ownStylePropertyNames","overrideStyleProperties","customStyle","scopeSelector","styleProperties","styleInfo","_getStyleRules","method","IS_IE","StyleProperties","decorateStyles","props","keyframes","ruleIndex","decorateRule","propertyInfo","collectPropertiesInCssText","onKeyframesRule","_keyframes","names","properties","collectProperties","collectCssText","collectConsumingCssText","any","valueForProperty","valueForProperties","propertyValue","colon","pp","propertyDataFromStyles","selectorToMatch","parseInt","key","whenHostOrRootRule","parsedSelector","isRoot","isHost","hostAndRootPropertiesForScope","hostProps","rootProps","_element","transformStyles","hostSelector","hostRx","RegExp","StyleInfo$$module$node_modules$$webcomponents$shadycss$src$style_info.get","keyframeTransforms","_elementKeyframeTransforms","applyProperties","applyKeyframeTransforms","hasAnimations","keyframeNamesToTransform","keyframe","transform","_scopeSelector","keyframesRules","keyframesNameRx","_scopeKeyframes","transformedKeyframesName","scopeId","_keyframesRuleTransformer","applyCustomStyle","XSCOPE_NAME","placeholderMap","ce","origDefine","wrappedDefine","clazz","StyleCache","cache","store","tagname","styleElement","typeMax","scopeRegExp","getCurrentScope","getOwnerScope","handler","mxns","mxn","unscopedNodes","unscopedNode","scopeForPreviouslyUnscopedNode","delayedStart","requestAnimationFrame","module$node_modules$$webcomponents$shadycss$src$document_watcher.flush","templateMap","invalidate","elementName","templateIsValid","startValidatingTemplate","_validating","adoptedCssTextMap","styleCache","ScopingShim","_scopeCounter","_documentOwner","_documentOwnerStyleInfo","StyleInfo$$module$node_modules$$webcomponents$shadycss$src$style_info.set","_elementsHaveApplied","_customStyleInterface","_applyShim","flush.prototype","getStyleAst.prototype","getStyleAst","styleAstToString.prototype","styleAstToString","prepareTemplate.prototype","prepareTemplate","prepareTemplateDom","prepareTemplateStyles","prepareTemplateStyles.prototype","_prepared","optimalBuild","styleTextParts","styles","scopingAttribute","newStyle","_gatherStyles","_ensure","hasMixins","ownPropertyNames","_generateStaticStyle","shadowroot","_style","_ownPropertyNames","prepareAdoptedCssText.prototype","prepareAdoptedCssText","cssTextArray","prepareTemplateDom.prototype","_domPrepared","_prepareHost","_ensureCustomStyleInterface","CustomStyleInterface","transformCustomStyleForDocument","flushCustomStyles","_ensureApplyShim","ApplyShim","flushCustomStyles.prototype","customStyles","_revalidateCustomStyleApplyShim","_revalidateApplyShim","_updateProperties","_applyCustomStyles","styleDocument","styleElement.prototype","overrideProps","_mixOverrideStyleProps","styleElementNativeVariables","styleElementShimVariables","_applyStyleProperties","cacheEntry","fetch","entry","_validate","pn","cachedStyle","oldScopeSelector","_generateScopeSelector","applyElementStyle","applyElementScopeSelector","removeProperty","setProperty","_styleOwnerForNode","owner","ownerStyleInfo","ownerProperties","hostAndRootProps","propertiesMatchingHost","_mixinOverrideStyles","overrides","reify","styleDocument.prototype","styleSubtree","styleSubtree.prototype","wrappedHost","shadowChildren","transformCustomStyleForDocument.prototype","documentRule","getComputedStyleValue.prototype","getComputedStyleValue","getComputedStyle","getPropertyValue","setElementClass.prototype","setElementClass","classString","classes","scopeName","classAttr","k$","_styleInfoForNode.prototype","_styleInfoForNode","scopeNode.prototype","scopeNode","unscopeNode.prototype","unscopeNode","scopeForNode.prototype","scopeForNode","currentScopeForNode.prototype","elementExtends","Template","flushCallback","runAndClearCallback","origWhenReady","ready"],"mappings":"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","file":"webcomponents-lite.js","sourcesContent":["/**\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 */\n\n(function(scope) {\n\n  'use strict';\n\n  // defaultPrevented is broken in IE.\n  // https://connect.microsoft.com/IE/feedback/details/790389/event-defaultprevented-returns-false-after-preventdefault-was-called\n  var workingDefaultPrevented = (function() {\n    var e = document.createEvent('Event');\n    e.initEvent('foo', true, true);\n    e.preventDefault();\n    return e.defaultPrevented;\n  })();\n\n  if (!workingDefaultPrevented) {\n    var origPreventDefault = Event.prototype.preventDefault;\n    Event.prototype.preventDefault = function() {\n      if (!this.cancelable) {\n        return;\n      }\n\n      origPreventDefault.call(this);\n\n      Object.defineProperty(this, 'defaultPrevented', {\n        get: function() {\n          return true;\n        },\n        configurable: true\n      });\n    };\n  }\n\n  var isIE = /Trident/.test(navigator.userAgent);\n\n  // CustomEvent constructor shim\n  if (!window.CustomEvent || isIE && (typeof window.CustomEvent !== 'function')) {\n    window.CustomEvent = function(inType, params) {\n      params = params || {};\n      var e = document.createEvent('CustomEvent');\n      e.initCustomEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable), params.detail);\n      return e;\n    };\n    window.CustomEvent.prototype = window.Event.prototype;\n  }\n\n  // Event constructor shim\n  if (!window.Event || isIE && (typeof window.Event !== 'function')) {\n    var origEvent = window.Event;\n    window.Event = function(inType, params) {\n      params = params || {};\n      var e = document.createEvent('Event');\n      e.initEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable));\n      return e;\n    };\n    if (origEvent) {\n      for (var i in origEvent) {\n        window.Event[i] = origEvent[i];\n      }\n    }\n    window.Event.prototype = origEvent.prototype;\n  }\n\n  if (!window.MouseEvent || isIE && (typeof window.MouseEvent !== 'function')) {\n    var origMouseEvent = window.MouseEvent;\n    window.MouseEvent = function(inType, params) {\n      params = params || {};\n      var e = document.createEvent('MouseEvent');\n      e.initMouseEvent(inType,\n        Boolean(params.bubbles), Boolean(params.cancelable),\n        params.view || window, params.detail,\n        params.screenX, params.screenY, params.clientX, params.clientY,\n        params.ctrlKey, params.altKey, params.shiftKey, params.metaKey,\n        params.button, params.relatedTarget);\n      return e;\n    };\n    if (origMouseEvent) {\n      for (var i in origMouseEvent) {\n        window.MouseEvent[i] = origMouseEvent[i];\n      }\n    }\n    window.MouseEvent.prototype = origMouseEvent.prototype;\n  }\n\n  // ES6 stuff\n  if (!Array.from) {\n    Array.from = function (object) {\n      return [].slice.call(object);\n    };\n  }\n\n  if (!Object.assign) {\n    var assign = function(target, source) {\n      var n$ = Object.getOwnPropertyNames(source);\n      for (var i=0, p; i < n$.length; i++) {\n        p = n$[i];\n        target[p] = source[p];\n      }\n    }\n\n    Object.assign = function(target, sources) {\n      var args = [].slice.call(arguments, 1);\n      for (var i=0, s; i < args.length; i++) {\n        s = args[i];\n        if (s) {\n          assign(target, s);\n        }\n      }\n      return target;\n    }\n  }\n\n})(window.WebComponents);\n",null,null,null,null,null,"/**\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 */\n\n// minimal template polyfill\n(function() {\n  'use strict';\n\n  var needsTemplate = (typeof HTMLTemplateElement === 'undefined');\n  var brokenDocFragment = !(document.createDocumentFragment().cloneNode() instanceof DocumentFragment);\n  var needsDocFrag = false;\n\n  // NOTE: Replace DocumentFragment to work around IE11 bug that\n  // causes children of a document fragment modified while\n  // there is a mutation observer to not have a parentNode, or\n  // have a broken parentNode (!?!)\n  if (/Trident/.test(navigator.userAgent)) {\n    (function() {\n\n      needsDocFrag = true;\n\n      var origCloneNode = Node.prototype.cloneNode;\n      Node.prototype.cloneNode = function cloneNode(deep) {\n        var newDom = origCloneNode.call(this, deep);\n        if (this instanceof DocumentFragment) {\n          newDom.__proto__ = DocumentFragment.prototype;\n        }\n        return newDom;\n      };\n\n      // IE's DocumentFragment querySelector code doesn't work when\n      // called on an element instance\n      DocumentFragment.prototype.querySelectorAll = HTMLElement.prototype.querySelectorAll;\n      DocumentFragment.prototype.querySelector = HTMLElement.prototype.querySelector;\n\n      Object.defineProperties(DocumentFragment.prototype, {\n        'nodeType': {\n          get: function () {\n            return Node.DOCUMENT_FRAGMENT_NODE;\n          },\n          configurable: true\n        },\n\n        'localName': {\n          get: function () {\n            return undefined;\n          },\n          configurable: true\n        },\n\n        'nodeName': {\n          get: function () {\n            return '#document-fragment';\n          },\n          configurable: true\n        }\n      });\n\n      var origInsertBefore = Node.prototype.insertBefore;\n      function insertBefore(newNode, refNode) {\n        if (newNode instanceof DocumentFragment) {\n          var child;\n          while ((child = newNode.firstChild)) {\n            origInsertBefore.call(this, child, refNode);\n          }\n        } else {\n          origInsertBefore.call(this, newNode, refNode);\n        }\n        return newNode;\n      }\n      Node.prototype.insertBefore = insertBefore;\n\n      var origAppendChild = Node.prototype.appendChild;\n      Node.prototype.appendChild = function appendChild(child) {\n        if (child instanceof DocumentFragment) {\n          insertBefore.call(this, child, null);\n        } else {\n          origAppendChild.call(this, child);\n        }\n        return child;\n      };\n\n      var origRemoveChild = Node.prototype.removeChild;\n      var origReplaceChild = Node.prototype.replaceChild;\n      Node.prototype.replaceChild = function replaceChild(newChild, oldChild) {\n        if (newChild instanceof DocumentFragment) {\n          insertBefore.call(this, newChild, oldChild);\n          origRemoveChild.call(this, oldChild);\n        } else {\n          origReplaceChild.call(this, newChild, oldChild);\n        }\n        return oldChild;\n      };\n\n      Document.prototype.createDocumentFragment = function createDocumentFragment() {\n        var frag = this.createElement('df');\n        frag.__proto__ = DocumentFragment.prototype;\n        return frag;\n      };\n\n      var origImportNode = Document.prototype.importNode;\n      Document.prototype.importNode = function importNode(impNode, deep) {\n        deep = deep || false;\n        var newNode = origImportNode.call(this, impNode, deep);\n        if (impNode instanceof DocumentFragment) {\n          newNode.__proto__ = DocumentFragment.prototype;\n        }\n        return newNode;\n      };\n    })();\n  }\n\n  // NOTE: we rely on this cloneNode not causing element upgrade.\n  // This means this polyfill must load before the CE polyfill and\n  // this would need to be re-worked if a browser supports native CE\n  // but not <template>.\n  var capturedCloneNode = Node.prototype.cloneNode;\n  var capturedCreateElement = Document.prototype.createElement;\n  var capturedImportNode = Document.prototype.importNode;\n  var capturedRemoveChild = Node.prototype.removeChild;\n  var capturedAppendChild = Node.prototype.appendChild;\n  var capturedReplaceChild = Node.prototype.replaceChild;\n  var capturedParseFromString = DOMParser.prototype.parseFromString;\n  var capturedHTMLElementInnerHTML = Object.getOwnPropertyDescriptor(window.HTMLElement.prototype, 'innerHTML') || {\n    /**\n     * @this {!HTMLElement}\n     * @return {string}\n     */\n    get: function() {\n      return this.innerHTML;\n    },\n    /**\n     * @this {!HTMLElement}\n     * @param {string}\n     */\n    set: function(text) {\n      this.innerHTML = text;\n    }\n  };\n  var capturedChildNodes = Object.getOwnPropertyDescriptor(window.Node.prototype, 'childNodes') || {\n    /**\n     * @this {!Node}\n     * @return {!NodeList}\n     */\n    get: function() {\n      return this.childNodes;\n    }\n  };\n\n  var elementQuerySelectorAll = Element.prototype.querySelectorAll;\n  var docQuerySelectorAll = Document.prototype.querySelectorAll;\n  var fragQuerySelectorAll = DocumentFragment.prototype.querySelectorAll;\n\n  var scriptSelector = 'script:not([type]),script[type=\"application/javascript\"],script[type=\"text/javascript\"]';\n\n  function QSA(node, selector) {\n    // IE 11 throws a SyntaxError with `scriptSelector` if the node has no children due to the `:not([type])` syntax\n    if (!node.childNodes.length) {\n      return [];\n    }\n    switch (node.nodeType) {\n      case Node.DOCUMENT_NODE:\n        return docQuerySelectorAll.call(node, selector);\n      case Node.DOCUMENT_FRAGMENT_NODE:\n        return fragQuerySelectorAll.call(node, selector);\n      default:\n        return elementQuerySelectorAll.call(node, selector);\n    }\n  }\n\n  // returns true if nested templates cannot be cloned (they cannot be on\n  // some impl's like Safari 8 and Edge)\n  // OR if cloning a document fragment does not result in a document fragment\n  var needsCloning = (function() {\n    if (!needsTemplate) {\n      var t = document.createElement('template');\n      var t2 = document.createElement('template');\n      t2.content.appendChild(document.createElement('div'));\n      t.content.appendChild(t2);\n      var clone = t.cloneNode(true);\n      return (clone.content.childNodes.length === 0 || clone.content.firstChild.content.childNodes.length === 0\n        || brokenDocFragment);\n    }\n  })();\n\n  var TEMPLATE_TAG = 'template';\n  var PolyfilledHTMLTemplateElement = function() {};\n\n  if (needsTemplate) {\n\n    var contentDoc = document.implementation.createHTMLDocument('template');\n    var canDecorate = true;\n\n    var templateStyle = document.createElement('style');\n    templateStyle.textContent = TEMPLATE_TAG + '{display:none;}';\n\n    var head = document.head;\n    head.insertBefore(templateStyle, head.firstElementChild);\n\n    /**\n      Provides a minimal shim for the <template> element.\n    */\n    PolyfilledHTMLTemplateElement.prototype = Object.create(HTMLElement.prototype);\n\n\n    // if elements do not have `innerHTML` on instances, then\n    // templates can be patched by swizzling their prototypes.\n    var canProtoPatch =\n      !(document.createElement('div').hasOwnProperty('innerHTML'));\n\n    /**\n      The `decorate` method moves element children to the template's `content`.\n      NOTE: there is no support for dynamically adding elements to templates.\n    */\n    PolyfilledHTMLTemplateElement.decorate = function(template) {\n      // if the template is decorated or not in HTML namespace, return fast\n      if (template.content ||\n          template.namespaceURI !== document.documentElement.namespaceURI) {\n        return;\n      }\n      template.content = contentDoc.createDocumentFragment();\n      var child;\n      while ((child = template.firstChild)) {\n        capturedAppendChild.call(template.content, child);\n      }\n      // NOTE: prefer prototype patching for performance and\n      // because on some browsers (IE11), re-defining `innerHTML`\n      // can result in intermittent errors.\n      if (canProtoPatch) {\n        template.__proto__ = PolyfilledHTMLTemplateElement.prototype;\n      } else {\n        template.cloneNode = function(deep) {\n          return PolyfilledHTMLTemplateElement._cloneNode(this, deep);\n        };\n        // add innerHTML to template, if possible\n        // Note: this throws on Safari 7\n        if (canDecorate) {\n          try {\n            defineInnerHTML(template);\n            defineOuterHTML(template);\n          } catch (err) {\n            canDecorate = false;\n          }\n        }\n      }\n      // bootstrap recursively\n      PolyfilledHTMLTemplateElement.bootstrap(template.content);\n    };\n\n    // Taken from https://github.com/jquery/jquery/blob/73d7e6259c63ac45f42c6593da8c2796c6ce9281/src/manipulation/wrapMap.js\n    var topLevelWrappingMap = {\n      'option': ['select'],\n      'thead': ['table'],\n      'col': ['colgroup', 'table'],\n      'tr': ['tbody', 'table'],\n      'th': ['tr', 'tbody', 'table'],\n      'td': ['tr', 'tbody', 'table']\n    };\n\n    var getTagName = function(text) {\n      // Taken from https://github.com/jquery/jquery/blob/73d7e6259c63ac45f42c6593da8c2796c6ce9281/src/manipulation/var/rtagName.js\n      return ( /<([a-z][^/\\0>\\x20\\t\\r\\n\\f]+)/i.exec(text) || ['', ''])[1].toLowerCase();\n    };\n\n    var defineInnerHTML = function defineInnerHTML(obj) {\n      Object.defineProperty(obj, 'innerHTML', {\n        get: function() {\n          return getInnerHTML(this);\n        },\n        set: function(text) {\n          // For IE11, wrap the text in the correct (table) context\n          var wrap = topLevelWrappingMap[getTagName(text)];\n          if (wrap) {\n            for (var i = 0; i < wrap.length; i++) {\n              text = '<' + wrap[i] + '>' + text + '</' + wrap[i] + '>';\n            }\n          }\n          contentDoc.body.innerHTML = text;\n          PolyfilledHTMLTemplateElement.bootstrap(contentDoc);\n          while (this.content.firstChild) {\n            capturedRemoveChild.call(this.content, this.content.firstChild);\n          }\n          var body = contentDoc.body;\n          // If we had wrapped, get back to the original node\n          if (wrap) {\n            for (var j = 0; j < wrap.length; j++) {\n              body = body.lastChild;\n            }\n          }\n          while (body.firstChild) {\n            capturedAppendChild.call(this.content, body.firstChild);\n          }\n        },\n        configurable: true\n      });\n    };\n\n    var defineOuterHTML = function defineOuterHTML(obj) {\n      Object.defineProperty(obj, 'outerHTML', {\n        get: function() {\n          return '<' + TEMPLATE_TAG + '>' + this.innerHTML + '</' + TEMPLATE_TAG + '>';\n        },\n        set: function(innerHTML) {\n          if (this.parentNode) {\n            contentDoc.body.innerHTML = innerHTML;\n            var docFrag = this.ownerDocument.createDocumentFragment();\n            while (contentDoc.body.firstChild) {\n              capturedAppendChild.call(docFrag, contentDoc.body.firstChild);\n            }\n            capturedReplaceChild.call(this.parentNode, docFrag, this);\n          } else {\n            throw new Error(\"Failed to set the 'outerHTML' property on 'Element': This element has no parent node.\");\n          }\n        },\n        configurable: true\n      });\n    };\n\n    defineInnerHTML(PolyfilledHTMLTemplateElement.prototype);\n    defineOuterHTML(PolyfilledHTMLTemplateElement.prototype);\n\n    /**\n      The `bootstrap` method is called automatically and \"fixes\" all\n      <template> elements in the document referenced by the `doc` argument.\n    */\n    PolyfilledHTMLTemplateElement.bootstrap = function bootstrap(doc) {\n      var templates = QSA(doc, TEMPLATE_TAG);\n      for (var i=0, l=templates.length, t; (i<l) && (t=templates[i]); i++) {\n        PolyfilledHTMLTemplateElement.decorate(t);\n      }\n    };\n\n    // auto-bootstrapping for main document\n    document.addEventListener('DOMContentLoaded', function() {\n      PolyfilledHTMLTemplateElement.bootstrap(document);\n    });\n\n    // Patch document.createElement to ensure newly created templates have content\n    Document.prototype.createElement = function createElement() {\n      var el = capturedCreateElement.apply(this, arguments);\n      if (el.localName === 'template') {\n        PolyfilledHTMLTemplateElement.decorate(el);\n      }\n      return el;\n    };\n\n    DOMParser.prototype.parseFromString = function() {\n      var el = capturedParseFromString.apply(this, arguments);\n      PolyfilledHTMLTemplateElement.bootstrap(el);\n      return el;\n    };\n\n    Object.defineProperty(HTMLElement.prototype, 'innerHTML', {\n      get: function() {\n        return getInnerHTML(this);\n      },\n      set: function(text) {\n        capturedHTMLElementInnerHTML.set.call(this, text);\n        PolyfilledHTMLTemplateElement.bootstrap(this);\n      },\n      configurable: true,\n      enumerable: true\n    });\n\n    // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#escapingString\n    var escapeAttrRegExp = /[&\\u00A0\"]/g;\n    var escapeDataRegExp = /[&\\u00A0<>]/g;\n\n    var escapeReplace = function(c) {\n      switch (c) {\n        case '&':\n          return '&amp;';\n        case '<':\n          return '&lt;';\n        case '>':\n          return '&gt;';\n        case '\"':\n          return '&quot;';\n        case '\\u00A0':\n          return '&nbsp;';\n      }\n    };\n\n    var escapeAttr = function(s) {\n      return s.replace(escapeAttrRegExp, escapeReplace);\n    };\n\n    var escapeData = function(s) {\n      return s.replace(escapeDataRegExp, escapeReplace);\n    };\n\n    var makeSet = function(arr) {\n      var set = {};\n      for (var i = 0; i < arr.length; i++) {\n        set[arr[i]] = true;\n      }\n      return set;\n    };\n\n    // http://www.whatwg.org/specs/web-apps/current-work/#void-elements\n    var voidElements = makeSet([\n      'area',\n      'base',\n      'br',\n      'col',\n      'command',\n      'embed',\n      'hr',\n      'img',\n      'input',\n      'keygen',\n      'link',\n      'meta',\n      'param',\n      'source',\n      'track',\n      'wbr'\n    ]);\n\n    var plaintextParents = makeSet([\n      'style',\n      'script',\n      'xmp',\n      'iframe',\n      'noembed',\n      'noframes',\n      'plaintext',\n      'noscript'\n    ]);\n\n    /**\n     * @param {Node} node\n     * @param {Node} parentNode\n     * @param {Function=} callback\n     */\n    var getOuterHTML = function(node, parentNode, callback) {\n      switch (node.nodeType) {\n        case Node.ELEMENT_NODE: {\n          var tagName = node.localName;\n          var s = '<' + tagName;\n          var attrs = node.attributes;\n          for (var i = 0, attr; (attr = attrs[i]); i++) {\n            s += ' ' + attr.name + '=\"' + escapeAttr(attr.value) + '\"';\n          }\n          s += '>';\n          if (voidElements[tagName]) {\n            return s;\n          }\n          return s + getInnerHTML(node, callback) + '</' + tagName + '>';\n        }\n        case Node.TEXT_NODE: {\n          var data = /** @type {Text} */ (node).data;\n          if (parentNode && plaintextParents[parentNode.localName]) {\n            return data;\n          }\n          return escapeData(data);\n        }\n        case Node.COMMENT_NODE: {\n          return '<!--' + /** @type {Comment} */ (node).data + '-->';\n        }\n        default: {\n          window.console.error(node);\n          throw new Error('not implemented');\n        }\n      }\n    };\n\n    /**\n     * @param {Node} node\n     * @param {Function=} callback\n     */\n    var getInnerHTML = function(node, callback) {\n      if (node.localName === 'template') {\n        node =  /** @type {HTMLTemplateElement} */ (node).content;\n      }\n      var s = '';\n      var c$ = callback ? callback(node) : capturedChildNodes.get.call(node);\n      for (var i=0, l=c$.length, child; (i<l) && (child=c$[i]); i++) {\n        s += getOuterHTML(child, node, callback);\n      }\n      return s;\n    };\n\n  }\n\n  // make cloning/importing work!\n  if (needsTemplate || needsCloning) {\n\n    PolyfilledHTMLTemplateElement._cloneNode = function _cloneNode(template, deep) {\n      var clone = capturedCloneNode.call(template, false);\n      // NOTE: decorate doesn't auto-fix children because they are already\n      // decorated so they need special clone fixup.\n      if (this.decorate) {\n        this.decorate(clone);\n      }\n      if (deep) {\n        // NOTE: use native clone node to make sure CE's wrapped\n        // cloneNode does not cause elements to upgrade.\n        capturedAppendChild.call(clone.content, capturedCloneNode.call(template.content, true));\n        // now ensure nested templates are cloned correctly.\n        fixClonedDom(clone.content, template.content);\n      }\n      return clone;\n    };\n\n    // Given a source and cloned subtree, find <template>'s in the cloned\n    // subtree and replace them with cloned <template>'s from source.\n    // We must do this because only the source templates have proper .content.\n    var fixClonedDom = function fixClonedDom(clone, source) {\n      // do nothing if cloned node is not an element\n      if (!source.querySelectorAll) return;\n      // these two lists should be coincident\n      var s$ = QSA(source, TEMPLATE_TAG);\n      if (s$.length === 0) {\n        return;\n      }\n      var t$ = QSA(clone, TEMPLATE_TAG);\n      for (var i=0, l=t$.length, t, s; i<l; i++) {\n        s = s$[i];\n        t = t$[i];\n        if (PolyfilledHTMLTemplateElement && PolyfilledHTMLTemplateElement.decorate) {\n          PolyfilledHTMLTemplateElement.decorate(s);\n        }\n        capturedReplaceChild.call(t.parentNode, cloneNode.call(s, true), t);\n      }\n    };\n\n    // make sure scripts inside of a cloned template are executable\n    var fixClonedScripts = function fixClonedScripts(fragment) {\n      var scripts = QSA(fragment, scriptSelector);\n      for (var ns, s, i = 0; i < scripts.length; i++) {\n        s = scripts[i];\n        ns = capturedCreateElement.call(document, 'script');\n        ns.textContent = s.textContent;\n        var attrs = s.attributes;\n        for (var ai = 0, a; ai < attrs.length; ai++) {\n          a = attrs[ai];\n          ns.setAttribute(a.name, a.value);\n        }\n        capturedReplaceChild.call(s.parentNode, ns, s);\n      }\n    };\n\n    // override all cloning to fix the cloned subtree to contain properly\n    // cloned templates.\n    var cloneNode = Node.prototype.cloneNode = function cloneNode(deep) {\n      var dom;\n      // workaround for Edge bug cloning documentFragments\n      // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/8619646/\n      if (!needsDocFrag && brokenDocFragment && this instanceof DocumentFragment) {\n        if (!deep) {\n          return this.ownerDocument.createDocumentFragment();\n        } else {\n          dom = importNode.call(this.ownerDocument, this, true);\n        }\n      } else if (this.nodeType === Node.ELEMENT_NODE &&\n                 this.localName === TEMPLATE_TAG &&\n                 this.namespaceURI == document.documentElement.namespaceURI) {\n        dom = PolyfilledHTMLTemplateElement._cloneNode(this, deep);\n      } else {\n        dom = capturedCloneNode.call(this, deep);\n      }\n      // template.content is cloned iff `deep`.\n      if (deep) {\n        fixClonedDom(dom, this);\n      }\n      return dom;\n    };\n\n    // NOTE: we are cloning instead of importing <template>'s.\n    // However, the ownerDocument of the cloned template will be correct!\n    // This is because the native import node creates the right document owned\n    // subtree and `fixClonedDom` inserts cloned templates into this subtree,\n    // thus updating the owner doc.\n    var importNode = Document.prototype.importNode = function importNode(element, deep) {\n      deep = deep || false;\n      if (element.localName === TEMPLATE_TAG) {\n        return PolyfilledHTMLTemplateElement._cloneNode(element, deep);\n      } else {\n        var dom = capturedImportNode.call(this, element, deep);\n        if (deep) {\n          fixClonedDom(dom, element);\n          fixClonedScripts(dom);\n        }\n        return dom;\n      }\n    };\n  }\n\n  if (needsTemplate) {\n    window.HTMLTemplateElement = PolyfilledHTMLTemplateElement;\n  }\n\n})();\n","import promiseFinally from './finally';\n\n// Store setTimeout reference so promise-polyfill will be unaffected by\n// other code modifying setTimeout (like sinon.useFakeTimers())\nvar setTimeoutFunc = setTimeout;\n\nfunction noop() {}\n\n// Polyfill for Function.prototype.bind\nfunction bind(fn, thisArg) {\n  return function() {\n    fn.apply(thisArg, arguments);\n  };\n}\n\n/**\n * @constructor\n * @param {Function} fn\n */\nfunction Promise(fn) {\n  if (!(this instanceof Promise))\n    throw new TypeError('Promises must be constructed via new');\n  if (typeof fn !== 'function') throw new TypeError('not a function');\n  /** @type {!number} */\n  this._state = 0;\n  /** @type {!boolean} */\n  this._handled = false;\n  /** @type {Promise|undefined} */\n  this._value = undefined;\n  /** @type {!Array<!Function>} */\n  this._deferreds = [];\n\n  doResolve(fn, this);\n}\n\nfunction handle(self, deferred) {\n  while (self._state === 3) {\n    self = self._value;\n  }\n  if (self._state === 0) {\n    self._deferreds.push(deferred);\n    return;\n  }\n  self._handled = true;\n  Promise._immediateFn(function() {\n    var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;\n    if (cb === null) {\n      (self._state === 1 ? resolve : reject)(deferred.promise, self._value);\n      return;\n    }\n    var ret;\n    try {\n      ret = cb(self._value);\n    } catch (e) {\n      reject(deferred.promise, e);\n      return;\n    }\n    resolve(deferred.promise, ret);\n  });\n}\n\nfunction resolve(self, newValue) {\n  try {\n    // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n    if (newValue === self)\n      throw new TypeError('A promise cannot be resolved with itself.');\n    if (\n      newValue &&\n      (typeof newValue === 'object' || typeof newValue === 'function')\n    ) {\n      var then = newValue.then;\n      if (newValue instanceof Promise) {\n        self._state = 3;\n        self._value = newValue;\n        finale(self);\n        return;\n      } else if (typeof then === 'function') {\n        doResolve(bind(then, newValue), self);\n        return;\n      }\n    }\n    self._state = 1;\n    self._value = newValue;\n    finale(self);\n  } catch (e) {\n    reject(self, e);\n  }\n}\n\nfunction reject(self, newValue) {\n  self._state = 2;\n  self._value = newValue;\n  finale(self);\n}\n\nfunction finale(self) {\n  if (self._state === 2 && self._deferreds.length === 0) {\n    Promise._immediateFn(function() {\n      if (!self._handled) {\n        Promise._unhandledRejectionFn(self._value);\n      }\n    });\n  }\n\n  for (var i = 0, len = self._deferreds.length; i < len; i++) {\n    handle(self, self._deferreds[i]);\n  }\n  self._deferreds = null;\n}\n\n/**\n * @constructor\n */\nfunction Handler(onFulfilled, onRejected, promise) {\n  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n  this.onRejected = typeof onRejected === 'function' ? onRejected : null;\n  this.promise = promise;\n}\n\n/**\n * Take a potentially misbehaving resolver function and make sure\n * onFulfilled and onRejected are only called once.\n *\n * Makes no guarantees about asynchrony.\n */\nfunction doResolve(fn, self) {\n  var done = false;\n  try {\n    fn(\n      function(value) {\n        if (done) return;\n        done = true;\n        resolve(self, value);\n      },\n      function(reason) {\n        if (done) return;\n        done = true;\n        reject(self, reason);\n      }\n    );\n  } catch (ex) {\n    if (done) return;\n    done = true;\n    reject(self, ex);\n  }\n}\n\nPromise.prototype['catch'] = function(onRejected) {\n  return this.then(null, onRejected);\n};\n\nPromise.prototype.then = function(onFulfilled, onRejected) {\n  // @ts-ignore\n  var prom = new this.constructor(noop);\n\n  handle(this, new Handler(onFulfilled, onRejected, prom));\n  return prom;\n};\n\nPromise.prototype['finally'] = promiseFinally;\n\nPromise.all = function(arr) {\n  return new Promise(function(resolve, reject) {\n    if (!arr || typeof arr.length === 'undefined')\n      throw new TypeError('Promise.all accepts an array');\n    var args = Array.prototype.slice.call(arr);\n    if (args.length === 0) return resolve([]);\n    var remaining = args.length;\n\n    function res(i, val) {\n      try {\n        if (val && (typeof val === 'object' || typeof val === 'function')) {\n          var then = val.then;\n          if (typeof then === 'function') {\n            then.call(\n              val,\n              function(val) {\n                res(i, val);\n              },\n              reject\n            );\n            return;\n          }\n        }\n        args[i] = val;\n        if (--remaining === 0) {\n          resolve(args);\n        }\n      } catch (ex) {\n        reject(ex);\n      }\n    }\n\n    for (var i = 0; i < args.length; i++) {\n      res(i, args[i]);\n    }\n  });\n};\n\nPromise.resolve = function(value) {\n  if (value && typeof value === 'object' && value.constructor === Promise) {\n    return value;\n  }\n\n  return new Promise(function(resolve) {\n    resolve(value);\n  });\n};\n\nPromise.reject = function(value) {\n  return new Promise(function(resolve, reject) {\n    reject(value);\n  });\n};\n\nPromise.race = function(values) {\n  return new Promise(function(resolve, reject) {\n    for (var i = 0, len = values.length; i < len; i++) {\n      values[i].then(resolve, reject);\n    }\n  });\n};\n\n// Use polyfill for setImmediate for performance gains\nPromise._immediateFn =\n  (typeof setImmediate === 'function' &&\n    function(fn) {\n      setImmediate(fn);\n    }) ||\n  function(fn) {\n    setTimeoutFunc(fn, 0);\n  };\n\nPromise._unhandledRejectionFn = function _unhandledRejectionFn(err) {\n  if (typeof console !== 'undefined' && console) {\n    console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console\n  }\n};\n\nexport default Promise;\n","/**\n * @this {Promise}\n */\nfunction finallyConstructor(callback) {\n  var constructor = this.constructor;\n  return this.then(\n    function(value) {\n      return constructor.resolve(callback()).then(function() {\n        return value;\n      });\n    },\n    function(reason) {\n      return constructor.resolve(callback()).then(function() {\n        return constructor.reject(reason);\n      });\n    }\n  );\n}\n\nexport default finallyConstructor;\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 PromisePolyfill from '../node_modules/promise-polyfill/src/index.js';\n\nif (!window.Promise) {\n  window.Promise = PromisePolyfill;\n  // save Promise API that is removed by closure compiler\n  // catch and finally are safe, as they are stringified in the library source\n  /* eslint-disable no-self-assign */\n  PromisePolyfill.prototype['then'] = PromisePolyfill.prototype.then;\n  PromisePolyfill['all'] = PromisePolyfill.all;\n  PromisePolyfill['race'] = PromisePolyfill.race;\n  PromisePolyfill['resolve'] = PromisePolyfill.resolve;\n  PromisePolyfill['reject'] = PromisePolyfill.reject;\n  /* eslint-enable */\n\n  // approach copied from https://github.com/Polymer/polymer/blob/v3.0.2/lib/utils/async.js\n  const node = document.createTextNode('');\n  const twiddleNode = function twiddleNode() {\n    node.textContent = node.textContent.length > 0 ? '' : 'a';\n  };\n  /** @type {!Array<function():void>} */\n  const callbacks = [];\n  (new MutationObserver(() => {\n    const len = callbacks.length;\n    for (let i = 0; i < len; i++) {\n      callbacks[i]();\n    }\n    callbacks.splice(0, len);\n  }).observe(node, {characterData: true}));\n\n  // set _immediateFn to a MutationObserver for close-to-native timing\n  PromisePolyfill._immediateFn = (fn) => {\n    callbacks.push(fn);\n    twiddleNode();\n  };\n}\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 */\n(scope => {\n\n  /********************* base setup *********************/\n  const link = document.createElement('link');\n  const useNative = Boolean('import' in link);\n  const emptyNodeList = link.querySelectorAll('*');\n\n  // Polyfill `currentScript` for browsers without it.\n  let currentScript = null;\n  if ('currentScript' in document === false) {\n    Object.defineProperty(document, 'currentScript', {\n      get() {\n        return currentScript ||\n          // NOTE: only works when called in synchronously executing code.\n          // readyState should check if `loading` but IE10 is\n          // interactive when scripts run so we cheat. This is not needed by\n          // html-imports polyfill but helps generally polyfill `currentScript`.\n          (document.readyState !== 'complete' ?\n            document.scripts[document.scripts.length - 1] : null);\n      },\n      configurable: true\n    });\n  }\n\n  /**\n   * @param {Array|NodeList|NamedNodeMap} list\n   * @param {!Function} callback\n   * @param {boolean=} inverseOrder\n   */\n  const forEach = (list, callback, inverseOrder) => {\n    const length = list ? list.length : 0;\n    const increment = inverseOrder ? -1 : 1;\n    let i = inverseOrder ? length - 1 : 0;\n    for (; i < length && i >= 0; i = i + increment) {\n      callback(list[i], i);\n    }\n  };\n\n  /**\n   * @param {!Node} node\n   * @param {!string} selector\n   * @return {!NodeList<!Element>}\n   */\n  const QSA = (node, selector) => {\n    // IE 11 throws a SyntaxError if a node with no children is queried with\n    // a selector containing the `:not([type])` syntax.\n    if (!node.childNodes.length) {\n      return emptyNodeList;\n    }\n    return node.querySelectorAll(selector);\n  };\n\n  /**\n   * @param {!DocumentFragment} fragment\n   */\n  const replaceScripts = (fragment) => {\n    forEach(QSA(fragment, 'template'), template => {\n      forEach(QSA(template.content, scriptsSelector), script => {\n        const clone = /** @type {!HTMLScriptElement} */\n          (document.createElement('script'));\n        forEach(script.attributes, attr => clone.setAttribute(attr.name, attr.value));\n        clone.textContent = script.textContent;\n        script.parentNode.replaceChild(clone, script);\n      });\n      replaceScripts(template.content);\n    });\n  };\n\n  /********************* path fixup *********************/\n  const CSS_URL_REGEXP = /(url\\()([^)]*)(\\))/g;\n  const CSS_IMPORT_REGEXP = /(@import[\\s]+(?!url\\())([^;]*)(;)/g;\n  const STYLESHEET_REGEXP = /(<link[^>]*)(rel=['|\"]?stylesheet['|\"]?[^>]*>)/g;\n\n  // path fixup: style elements in imports must be made relative to the main\n  // document. We fixup url's in url() and @import.\n  const Path = {\n\n    fixUrls(element, base) {\n      if (element.href) {\n        element.setAttribute('href',\n          Path.resolveUrl(element.getAttribute('href'), base));\n      }\n      if (element.src) {\n        element.setAttribute('src',\n          Path.resolveUrl(element.getAttribute('src'), base));\n      }\n      if (element.localName === 'style') {\n        const r = Path.replaceUrls(element.textContent, base, CSS_URL_REGEXP);\n        element.textContent = Path.replaceUrls(r, base, CSS_IMPORT_REGEXP);\n      }\n    },\n\n    replaceUrls(text, linkUrl, regexp) {\n      return text.replace(regexp, (m, pre, url, post) => {\n        let urlPath = url.replace(/[\"']/g, '');\n        if (linkUrl) {\n          urlPath = Path.resolveUrl(urlPath, linkUrl);\n        }\n        return pre + '\\'' + urlPath + '\\'' + post;\n      });\n    },\n\n    resolveUrl(url, base) {\n      // Lazy feature detection.\n      if (Path.__workingURL === undefined) {\n        Path.__workingURL = false;\n        try {\n          const u = new URL('b', 'http://a');\n          u.pathname = 'c%20d';\n          Path.__workingURL = (u.href === 'http://a/c%20d');\n        } catch (e) {}\n      }\n\n      if (Path.__workingURL) {\n        return (new URL(url, base)).href;\n      }\n\n      // Fallback to creating an anchor into a disconnected document.\n      let doc = Path.__tempDoc;\n      if (!doc) {\n        doc = document.implementation.createHTMLDocument('temp');\n        Path.__tempDoc = doc;\n        doc.__base = doc.createElement('base');\n        doc.head.appendChild(doc.__base);\n        doc.__anchor = doc.createElement('a');\n      }\n      doc.__base.href = base;\n      doc.__anchor.href = url;\n      return doc.__anchor.href || url;\n    }\n  };\n\n  /********************* Xhr processor *********************/\n  const Xhr = {\n\n    async: true,\n\n    /**\n     * @param {!string} url\n     * @param {!function(!string, string=)} success\n     * @param {!function(!string)} fail\n     */\n    load(url, success, fail) {\n      if (!url) {\n        fail('error: href must be specified');\n      } else if (url.match(/^data:/)) {\n        // Handle Data URI Scheme\n        const pieces = url.split(',');\n        const header = pieces[0];\n        let resource = pieces[1];\n        if (header.indexOf(';base64') > -1) {\n          resource = atob(resource);\n        } else {\n          resource = decodeURIComponent(resource);\n        }\n        success(resource);\n      } else {\n        const request = new XMLHttpRequest();\n        request.open('GET', url, Xhr.async);\n        request.onload = () => {\n          // Servers redirecting an import can add a Location header to help us\n          // polyfill correctly. Handle relative and full paths.\n          // Prefer responseURL which already resolves redirects\n          // https://xhr.spec.whatwg.org/#the-responseurl-attribute\n          let redirectedUrl = request.responseURL || request.getResponseHeader('Location');\n          if (redirectedUrl && redirectedUrl.indexOf('/') === 0) {\n            // In IE location.origin might not work\n            // https://connect.microsoft.com/IE/feedback/details/1763802/location-origin-is-undefined-in-ie-11-on-windows-10-but-works-on-windows-7\n            const origin = (location.origin || location.protocol + '//' + location.host);\n            redirectedUrl = origin + redirectedUrl;\n          }\n          const resource = /** @type {string} */ (request.response || request.responseText);\n          if (request.status === 304 || request.status === 0 ||\n            request.status >= 200 && request.status < 300) {\n            success(resource, redirectedUrl);\n          } else {\n            fail(resource);\n          }\n        };\n        request.send();\n      }\n    }\n  };\n\n  /********************* importer *********************/\n\n  const isIE = /Trident/.test(navigator.userAgent) ||\n    /Edge\\/\\d./i.test(navigator.userAgent);\n\n  const importSelector = 'link[rel=import]';\n\n  // Used to disable loading of resources.\n  const importDisableType = 'import-disable';\n\n  const disabledLinkSelector = `link[rel=stylesheet][href][type=${importDisableType}]`;\n\n  const scriptsSelector = `script:not([type]),script[type=\"application/javascript\"],` +\n    `script[type=\"text/javascript\"],script[type=\"module\"]`;\n\n  const importDependenciesSelector = `${importSelector},${disabledLinkSelector},` +\n    `style:not([type]),link[rel=stylesheet][href]:not([type]),` + scriptsSelector;\n\n  const importDependencyAttr = 'import-dependency';\n\n  const rootImportSelector = `${importSelector}:not([${importDependencyAttr}])`;\n\n  const pendingScriptsSelector = `script[${importDependencyAttr}]`;\n\n  const pendingStylesSelector = `style[${importDependencyAttr}],` +\n    `link[rel=stylesheet][${importDependencyAttr}]`;\n\n  /**\n   * Importer will:\n   * - load any linked import documents (with deduping)\n   * - whenever an import is loaded, prompt the parser to try to parse\n   * - observe imported documents for new elements (these are handled via the\n   *   dynamic importer)\n   */\n  class Importer {\n    constructor() {\n      this.documents = {};\n      // Used to keep track of pending loads, so that flattening and firing of\n      // events can be done when all resources are ready.\n      this.inflight = 0;\n      this.dynamicImportsMO = new MutationObserver(m => this.handleMutations(m));\n      // Observe changes on <head>.\n      this.dynamicImportsMO.observe(document.head, {\n        childList: true,\n        subtree: true\n      });\n      // 1. Load imports contents\n      // 2. Assign them to first import links on the document\n      // 3. Wait for import styles & scripts to be done loading/running\n      // 4. Fire load/error events\n      this.loadImports(document);\n    }\n\n    /**\n     * @param {!(HTMLDocument|DocumentFragment|Element)} doc\n     */\n    loadImports(doc) {\n      const links = /** @type {!NodeList<!HTMLLinkElement>} */\n        (QSA(doc, importSelector));\n      forEach(links, link => this.loadImport(link));\n    }\n\n    /**\n     * @param {!HTMLLinkElement} link\n     */\n    loadImport(link) {\n      const url = link.href;\n      // This resource is already being handled by another import.\n      if (this.documents[url] !== undefined) {\n        // If import is already loaded, we can safely associate it to the link\n        // and fire the load/error event.\n        const imp = this.documents[url];\n        if (imp && imp['__loaded']) {\n          link['__import'] = imp;\n          this.fireEventIfNeeded(link);\n        }\n        return;\n      }\n      this.inflight++;\n      // Mark it as pending to notify others this url is being loaded.\n      this.documents[url] = 'pending';\n      Xhr.load(url, (resource, redirectedUrl) => {\n        const doc = this.makeDocument(resource, redirectedUrl || url);\n        this.documents[url] = doc;\n        this.inflight--;\n        // Load subtree.\n        this.loadImports(doc);\n        this.processImportsIfLoadingDone();\n      }, () => {\n        // If load fails, handle error.\n        this.documents[url] = null;\n        this.inflight--;\n        this.processImportsIfLoadingDone();\n      });\n    }\n\n    /**\n     * Creates a new document containing resource and normalizes urls accordingly.\n     * @param {string=} resource\n     * @param {string=} url\n     * @return {!DocumentFragment}\n     */\n    makeDocument(resource, url) {\n      if (!resource) {\n        return document.createDocumentFragment();\n      }\n\n      if (isIE) {\n        // <link rel=stylesheet> should be appended to <head>. Not doing so\n        // in IE/Edge breaks the cascading order. We disable the loading by\n        // setting the type before setting innerHTML to avoid loading\n        // resources twice.\n        resource = resource.replace(STYLESHEET_REGEXP, (match, p1, p2) => {\n          if (match.indexOf('type=') === -1) {\n            return `${p1} type=${importDisableType} ${p2}`;\n          }\n          return match;\n        });\n      }\n\n      let content;\n      const template = /** @type {!HTMLTemplateElement} */\n        (document.createElement('template'));\n      template.innerHTML = resource;\n      if (template.content) {\n        content = template.content;\n        // Clone scripts inside templates since they won't execute when the\n        // hosting template is cloned.\n        replaceScripts(content);\n      } else {\n        // <template> not supported, create fragment and move content into it.\n        content = document.createDocumentFragment();\n        while (template.firstChild) {\n          content.appendChild(template.firstChild);\n        }\n      }\n\n      // Support <base> in imported docs. Resolve url and remove its href.\n      const baseEl = content.querySelector('base');\n      if (baseEl) {\n        url = Path.resolveUrl(baseEl.getAttribute('href'), url);\n        baseEl.removeAttribute('href');\n      }\n\n      const n$ = /** @type {!NodeList<!(HTMLLinkElement|HTMLScriptElement|HTMLStyleElement)>} */\n        (QSA(content, importDependenciesSelector));\n      // For source map hints.\n      let inlineScriptIndex = 0;\n      forEach(n$, n => {\n        // Listen for load/error events, then fix urls.\n        whenElementLoaded(n);\n        Path.fixUrls(n, url);\n        // Mark for easier selectors.\n        n.setAttribute(importDependencyAttr, '');\n        // Generate source map hints for inline scripts.\n        if (n.localName === 'script' && !n.src && n.textContent) {\n          if(n.type === 'module') {\n            throw new Error('Inline module scripts are not supported in HTML Imports.');\n          }\n          const num = inlineScriptIndex ? `-${inlineScriptIndex}` : '';\n          const content = n.textContent + `\\n//# sourceURL=${url}${num}.js\\n`;\n          // We use the src attribute so it triggers load/error events, and it's\n          // easier to capture errors (e.g. parsing) like this.\n          n.setAttribute('src', 'data:text/javascript;charset=utf-8,' + encodeURIComponent(content));\n          n.textContent = '';\n          inlineScriptIndex++;\n        }\n      });\n      return content;\n    }\n\n    /**\n     * Waits for loaded imports to finish loading scripts and styles, then fires\n     * the load/error events.\n     */\n    processImportsIfLoadingDone() {\n      // Wait until all resources are ready, then load import resources.\n      if (this.inflight) return;\n\n      // Stop observing, flatten & load resource, then restart observing <head>.\n      this.dynamicImportsMO.disconnect();\n      this.flatten(document);\n      // We wait for styles to load, and at the same time we execute the scripts,\n      // then fire the load/error events for imports to have faster whenReady\n      // callback execution.\n      // NOTE: This is different for native behavior where scripts would be\n      // executed after the styles before them are loaded.\n      // To achieve that, we could select pending styles and scripts in the\n      // document and execute them sequentially in their dom order.\n      let scriptsOk = false,\n        stylesOk = false;\n      const onLoadingDone = () => {\n        if (stylesOk && scriptsOk) {\n          // Catch any imports that might have been added while we\n          // weren't looking, wait for them as well.\n          this.loadImports(document);\n          if (this.inflight) return;\n\n          // Restart observing.\n          this.dynamicImportsMO.observe(document.head, {\n            childList: true,\n            subtree: true\n          });\n          this.fireEvents();\n        }\n      }\n      this.waitForStyles(() => {\n        stylesOk = true;\n        onLoadingDone();\n      });\n      this.runScripts(() => {\n        scriptsOk = true;\n        onLoadingDone();\n      });\n    }\n\n    /**\n     * @param {!HTMLDocument} doc\n     */\n    flatten(doc) {\n      const n$ = /** @type {!NodeList<!HTMLLinkElement>} */\n        (QSA(doc, importSelector));\n      forEach(n$, n => {\n        const imp = this.documents[n.href];\n        n['__import'] = /** @type {!Document} */ (imp);\n        if (imp && imp.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n          // We set the .import to be the link itself, and update its readyState.\n          // Other links with the same href will point to this link.\n          this.documents[n.href] = n;\n          n.readyState = 'loading';\n          n['__import'] = n;\n          this.flatten(imp);\n          n.appendChild(imp);\n        }\n      });\n    }\n\n    /**\n     * Replaces all the imported scripts with a clone in order to execute them.\n     * Updates the `currentScript`.\n     * @param {!function()} callback\n     */\n    runScripts(callback) {\n      const s$ = QSA(document, pendingScriptsSelector);\n      const l = s$.length;\n      const cloneScript = i => {\n        if (i < l) {\n          // The pending scripts have been generated through innerHTML and\n          // browsers won't execute them for security reasons. We cannot use\n          // s.cloneNode(true) either, the only way to run the script is manually\n          // creating a new element and copying its attributes.\n          const s = s$[i];\n          const clone = /** @type {!HTMLScriptElement} */\n            (document.createElement('script'));\n          // Remove import-dependency attribute to avoid double cloning.\n          s.removeAttribute(importDependencyAttr);\n          forEach(s.attributes, attr => clone.setAttribute(attr.name, attr.value));\n          // Update currentScript and replace original with clone script.\n          currentScript = clone;\n          s.parentNode.replaceChild(clone, s);\n          whenElementLoaded(clone, () => {\n            currentScript = null;\n            cloneScript(i + 1);\n          });\n        } else {\n          callback();\n        }\n      };\n      cloneScript(0);\n    }\n\n    /**\n     * Waits for all the imported stylesheets/styles to be loaded.\n     * @param {!function()} callback\n     */\n    waitForStyles(callback) {\n      const s$ = /** @type {!NodeList<!(HTMLLinkElement|HTMLStyleElement)>} */\n        (QSA(document, pendingStylesSelector));\n      let pending = s$.length;\n      if (!pending) {\n        callback();\n        return;\n      }\n      // <link rel=stylesheet> should be appended to <head>. Not doing so\n      // in IE/Edge breaks the cascading order\n      // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/10472273/\n      // If there is one <link rel=stylesheet> imported, we must move all imported\n      // links and styles to <head>.\n      const needsMove = isIE && !!document.querySelector(disabledLinkSelector);\n      forEach(s$, s => {\n        // Listen for load/error events, remove selector once is done loading.\n        whenElementLoaded(s, () => {\n          s.removeAttribute(importDependencyAttr);\n          if (--pending === 0) {\n            callback();\n          }\n        });\n        // Check if was already moved to head, to handle the case where the element\n        // has already been moved but it is still loading.\n        if (needsMove && s.parentNode !== document.head) {\n          // Replace the element we're about to move with a placeholder.\n          const placeholder = document.createElement(s.localName);\n          // Add reference of the moved element.\n          placeholder['__appliedElement'] = s;\n          // Disable this from appearing in document.styleSheets.\n          placeholder.setAttribute('type', 'import-placeholder');\n          // Append placeholder next to the sibling, and move original to <head>.\n          s.parentNode.insertBefore(placeholder, s.nextSibling);\n          let newSibling = importForElement(s);\n          while (newSibling && importForElement(newSibling)) {\n            newSibling = importForElement(newSibling);\n          }\n          if (newSibling.parentNode !== document.head) {\n            newSibling = null;\n          }\n          document.head.insertBefore(s, newSibling);\n          // Enable the loading of <link rel=stylesheet>.\n          s.removeAttribute('type');\n        }\n      });\n    }\n\n    /**\n     * Fires load/error events for imports in the right order .\n     */\n    fireEvents() {\n      const n$ = /** @type {!NodeList<!HTMLLinkElement>} */\n        (QSA(document, importSelector));\n      // Inverse order to have events firing bottom-up.\n      forEach(n$, n => this.fireEventIfNeeded(n), true);\n    }\n\n    /**\n     * Fires load/error event for the import if this wasn't done already.\n     * @param {!HTMLLinkElement} link\n     */\n    fireEventIfNeeded(link) {\n      // Don't fire twice same event.\n      if (!link['__loaded']) {\n        link['__loaded'] = true;\n        // Update link's import readyState.\n        link.import && (link.import.readyState = 'complete');\n        const eventType = link.import ? 'load' : 'error';\n        link.dispatchEvent(newCustomEvent(eventType, {\n          bubbles: false,\n          cancelable: false,\n          detail: undefined\n        }));\n      }\n    }\n\n    /**\n     * @param {Array<MutationRecord>} mutations\n     */\n    handleMutations(mutations) {\n      forEach(mutations, m => forEach(m.addedNodes, elem => {\n        if (elem && elem.nodeType === Node.ELEMENT_NODE) {\n          // NOTE: added scripts are not updating currentScript in IE.\n          if (isImportLink(elem)) {\n            this.loadImport( /** @type {!HTMLLinkElement} */ (elem));\n          } else {\n            this.loadImports( /** @type {!Element} */ (elem));\n          }\n        }\n      }));\n    }\n  }\n\n  /**\n   * @param {!Node} node\n   * @return {boolean}\n   */\n  const isImportLink = node => {\n    return node.nodeType === Node.ELEMENT_NODE && node.localName === 'link' &&\n      ( /** @type {!HTMLLinkElement} */ (node).rel === 'import');\n  };\n\n  /**\n   * Waits for an element to finish loading. If already done loading, it will\n   * mark the element accordingly.\n   * @param {!(HTMLLinkElement|HTMLScriptElement|HTMLStyleElement)} element\n   * @param {function()=} callback\n   */\n  const whenElementLoaded = (element, callback) => {\n    if (element['__loaded']) {\n      callback && callback();\n    } else if ((element.localName === 'script' && !element.src) ||\n      (element.localName === 'style' && !element.firstChild)) {\n      // Inline scripts and empty styles don't trigger load/error events,\n      // consider them already loaded.\n      element['__loaded'] = true;\n      callback && callback();\n    } else {\n      const onLoadingDone = event => {\n        element.removeEventListener(event.type, onLoadingDone);\n        element['__loaded'] = true;\n        callback && callback();\n      };\n      element.addEventListener('load', onLoadingDone);\n      // NOTE: We listen only for load events in IE/Edge, because in IE/Edge\n      // <style> with @import will fire error events for each failing @import,\n      // and finally will trigger the load event when all @import are\n      // finished (even if all fail).\n      if (!isIE || element.localName !== 'style') {\n        element.addEventListener('error', onLoadingDone);\n      }\n    }\n  }\n\n  /**\n   * Calls the callback when all imports in the document at call time\n   * (or at least document ready) have loaded. Callback is called synchronously\n   * if imports are already done loading.\n   * @param {function()=} callback\n   */\n  const whenReady = callback => {\n    // 1. ensure the document is in a ready state (has dom), then\n    // 2. watch for loading of imports and call callback when done\n    whenDocumentReady(() => whenImportsReady(() => callback && callback()));\n  }\n\n  /**\n   * Invokes the callback when document is in ready state. Callback is called\n   *  synchronously if document is already done loading.\n   * @param {!function()} callback\n   */\n  const whenDocumentReady = callback => {\n    const stateChanged = () => {\n      // NOTE: Firefox can hit readystate interactive without document.body existing.\n      // This is anti-spec, but we handle it here anyways by waiting for next change.\n      if (document.readyState !== 'loading' && !!document.body) {\n        document.removeEventListener('readystatechange', stateChanged);\n        callback();\n      }\n    }\n    document.addEventListener('readystatechange', stateChanged);\n    stateChanged();\n  }\n\n  /**\n   * Invokes the callback after all imports are loaded. Callback is called\n   * synchronously if imports are already done loading.\n   * @param {!function()} callback\n   */\n  const whenImportsReady = callback => {\n    let imports = /** @type {!NodeList<!HTMLLinkElement>} */\n      (QSA(document, rootImportSelector));\n    let pending = imports.length;\n    if (!pending) {\n      callback();\n      return;\n    }\n    forEach(imports, imp => whenElementLoaded(imp, () => {\n      if (--pending === 0) {\n        callback();\n      }\n    }));\n  }\n\n  /**\n   * Returns the import document containing the element.\n   * @param {!Node} element\n   * @return {HTMLLinkElement|Document|undefined}\n   */\n  const importForElement = element => {\n    if (useNative) {\n      // Return only if not in the main doc!\n      return element.ownerDocument !== document ? element.ownerDocument : null;\n    }\n    let doc = element['__importDoc'];\n    if (!doc && element.parentNode) {\n      doc = /** @type {!Element} */ (element.parentNode);\n      if (typeof doc.closest === 'function') {\n        // Element.closest returns the element itself if it matches the selector,\n        // so we search the closest import starting from the parent.\n        doc = doc.closest(importSelector);\n      } else {\n        // Walk up the parent tree until we find an import.\n        while (!isImportLink(doc) && (doc = doc.parentNode)) {}\n      }\n      element['__importDoc'] = doc;\n    }\n    return doc;\n  }\n\n  let importer = null;\n  /**\n   * Ensures imports contained in the element are imported.\n   * Use this to handle dynamic imports attached to body.\n   * @param {!(HTMLDocument|Element)} doc\n   */\n  const loadImports = (doc) => {\n    if (importer) {\n      importer.loadImports(doc);\n    }\n  };\n\n  const newCustomEvent = (type, params) => {\n    if (typeof window.CustomEvent === 'function') {\n      return new CustomEvent(type, params);\n    }\n    const event = /** @type {!CustomEvent} */ (document.createEvent('CustomEvent'));\n    event.initCustomEvent(type, Boolean(params.bubbles), Boolean(params.cancelable), params.detail);\n    return event;\n  };\n\n  if (useNative) {\n    // Check for imports that might already be done loading by the time this\n    // script is actually executed. Native imports are blocking, so the ones\n    // available in the document by this time should already have failed\n    // or have .import defined.\n    const imps = /** @type {!NodeList<!HTMLLinkElement>} */\n      (QSA(document, importSelector));\n    forEach(imps, imp => {\n      if (!imp.import || imp.import.readyState !== 'loading') {\n        imp['__loaded'] = true;\n      }\n    });\n    // Listen for load/error events to capture dynamically added scripts.\n    /**\n     * @type {!function(!Event)}\n     */\n    const onLoadingDone = event => {\n      const elem = /** @type {!Element} */ (event.target);\n      if (isImportLink(elem)) {\n        elem['__loaded'] = true;\n      }\n    };\n    document.addEventListener('load', onLoadingDone, true /* useCapture */ );\n    document.addEventListener('error', onLoadingDone, true /* useCapture */ );\n  } else {\n    // Override baseURI so that imported elements' baseURI can be used seemlessly\n    // on native or polyfilled html-imports.\n    // NOTE: a <link rel=import> will have `link.baseURI === link.href`, as the link\n    // itself is used as the `import` document.\n    /** @type {Object|undefined} */\n    const native_baseURI = Object.getOwnPropertyDescriptor(Node.prototype, 'baseURI');\n    // NOTE: if not configurable (e.g. safari9), set it on the Element prototype.\n    const klass = !native_baseURI || native_baseURI.configurable ? Node : Element;\n    Object.defineProperty(klass.prototype, 'baseURI', {\n      get() {\n        const ownerDoc = /** @type {HTMLLinkElement} */ (isImportLink(this) ? this : importForElement(this));\n        if (ownerDoc) return ownerDoc.href;\n        // Use native baseURI if possible.\n        if (native_baseURI && native_baseURI.get) return native_baseURI.get.call(this);\n        // Polyfill it if not available.\n        const base = /** @type {HTMLBaseElement} */ (document.querySelector('base'));\n        return (base || window.location).href;\n      },\n      configurable: true,\n      enumerable: true\n    });\n\n    // Define 'import' read-only property.\n    Object.defineProperty(HTMLLinkElement.prototype, 'import', {\n      get() {\n        return /** @type {HTMLLinkElement} */ (this)['__import'] || null;\n      },\n      configurable: true,\n      enumerable: true\n    });\n\n    whenDocumentReady(() => {\n      importer = new Importer()\n    });\n  }\n\n  /**\n    Add support for the `HTMLImportsLoaded` event and the `HTMLImports.whenReady`\n    method. This api is necessary because unlike the native implementation,\n    script elements do not force imports to resolve. Instead, users should wrap\n    code in either an `HTMLImportsLoaded` handler or after load time in an\n    `HTMLImports.whenReady(callback)` call.\n\n    NOTE: This module also supports these apis under the native implementation.\n    Therefore, if this file is loaded, the same code can be used under both\n    the polyfill and native implementation.\n   */\n  whenReady(() => document.dispatchEvent(newCustomEvent('HTMLImportsLoaded', {\n    cancelable: true,\n    bubbles: true,\n    detail: undefined\n  })));\n\n  // exports\n  scope.useNative = useNative;\n  scope.whenReady = whenReady;\n  scope.importForElement = importForElement;\n  scope.loadImports = loadImports;\n\n})(window.HTMLImports = (window.HTMLImports || {}));","/**\n * @license\n * Copyright (c) 2014 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\nexport {};\n\n// Establish scope.\nwindow['WebComponents'] = window['WebComponents'] || {'flags':{}};\n\n// loading script\nlet file = 'webcomponents-lite.js';\nlet script = document.querySelector('script[src*=\"' + file + '\"]');\nlet flagMatcher = /wc-(.+)/;\n\n// Flags. Convert url arguments to flags\nlet flags = {};\nif (!flags['noOpts']) {\n  // from url\n  location.search.slice(1).split('&').forEach(function(option) {\n    let parts = option.split('=');\n    let match;\n    if (parts[0] && (match = parts[0].match(flagMatcher))) {\n      flags[match[1]] = parts[1] || true;\n    }\n  });\n  // from script\n  if (script) {\n    for (let i=0, a; (a=script.attributes[i]); i++) {\n      if (a.name !== 'src') {\n        flags[a.name] = a.value || true;\n      }\n    }\n  }\n  // log flags\n  if (flags['log'] && flags['log']['split']) {\n    let parts = flags['log'].split(',');\n    flags['log'] = {};\n    parts.forEach(function(f) {\n      flags['log'][f] = true;\n    });\n  } else {\n    flags['log'] = {};\n  }\n}\n\n// exports\nwindow['WebComponents']['flags'] = flags;\nlet forceShady = flags['shadydom'];\nif (forceShady) {\n  window['ShadyDOM'] = window['ShadyDOM'] || {};\n  window['ShadyDOM']['force'] = forceShady;\n}\n\nlet forceCE = flags['register'] || flags['ce'];\nif (forceCE && window['customElements']) {\n  window['customElements']['forcePolyfill'] = forceCE;\n}\n","/**\n@license\nCopyright (c) 2016 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\nexport class ShadyData {\n  constructor() {\n    /** @type {ShadowRoot} */\n    this.root = null;\n    /** @type {ShadowRoot} */\n    this.publicRoot = null;\n    this.dirty = false;\n    this.observer = null;\n    /** @type {Array<Node>} */\n    this.assignedNodes = null;\n    /** @type {Element} */\n    this.assignedSlot = null;\n    /** @type {Array<Node>} */\n    this._previouslyAssignedNodes = null;\n    /** @type {Element} */\n    this._prevAssignedSlot = null;\n    /** @type {Array<Node>} */\n    this.flattenedNodes = null;\n    this.ownerShadyRoot = undefined;\n    /** @type {Node|undefined} */\n    this.parentNode = undefined;\n    /** @type {Node|undefined} */\n    this.firstChild = undefined;\n    /** @type {Node|undefined} */\n    this.lastChild = undefined;\n    /** @type {Node|undefined} */\n    this.previousSibling = undefined;\n    /** @type {Node|undefined} */\n    this.nextSibling = undefined;\n    /** @type {Array<Node>|undefined} */\n    this.childNodes = undefined;\n    this.__outsideAccessors = false;\n    this.__insideAccessors = false;\n    this.__onCallbackListeners = {};\n  }\n\n  /** @override */\n  toJSON() {\n    return {};\n  }\n}\n\nexport function ensureShadyDataForNode(node) {\n  if (!node.__shady) {\n    node.__shady = new ShadyData();\n  }\n  return node.__shady;\n}\n\nexport function shadyDataForNode(node) {\n  return node && node.__shady;\n}\n","/**\n@license\nCopyright (c) 2016 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 {shadyDataForNode} from './shady-data.js';\n\n/** @type {!Object} */\nexport const settings = window['ShadyDOM'] || {};\n\nsettings.hasNativeShadowDOM = Boolean(Element.prototype.attachShadow && Node.prototype.getRootNode);\n\nconst desc = Object.getOwnPropertyDescriptor(Node.prototype, 'firstChild');\n\nsettings.hasDescriptors = Boolean(desc && desc.configurable && desc.get);\nsettings.inUse = settings['force'] || !settings.hasNativeShadowDOM;\nsettings.noPatch = settings['noPatch'] || false;\nsettings.preferPerformance = settings['preferPerformance'];\n\nexport const isTrackingLogicalChildNodes = (node) => {\n  const nodeData = shadyDataForNode(node);\n  return (nodeData && nodeData.firstChild !== undefined);\n}\n\nexport const isShadyRoot = (obj) => {\n  return Boolean(obj._localName === 'ShadyRoot');\n}\n\nexport const hasShadowRootWithSlot = (node) => {\n  const nodeData = shadyDataForNode(node);\n  let root = nodeData && nodeData.root;\n  return (root && root._hasInsertionPoint());\n}\n\nlet p = Element.prototype;\nlet matches = p.matches || p.matchesSelector ||\n  p.mozMatchesSelector || p.msMatchesSelector ||\n  p.oMatchesSelector || p.webkitMatchesSelector;\n\nexport const matchesSelector = (element, selector) => {\n  return matches.call(element, selector);\n}\n\nexport const mixin = (target, source) => {\n  for (var i in source) {\n    target[i] = source[i];\n  }\n  return target;\n}\n\n// NOTE, prefer MutationObserver over Promise for microtask timing\n// for consistency x-platform.\nlet twiddle = document.createTextNode('');\nlet content = 0;\nlet queue = [];\nnew MutationObserver(() => {\n  while (queue.length) {\n    // catch errors in user code...\n    try {\n      queue.shift()();\n    } catch(e) {\n      // enqueue another record and throw\n      twiddle.textContent = content++;\n      throw(e);\n    }\n  }\n}).observe(twiddle, {characterData: true});\n\n// use MutationObserver to get microtask async timing.\nexport const microtask = (callback) => {\n  queue.push(callback);\n  twiddle.textContent = content++;\n}\n\nexport const hasDocumentContains = Boolean(document.contains);\n\nexport const contains = (container, node) => {\n  while (node) {\n    if (node == container) {\n      return true;\n    }\n    node = node[SHADY_PREFIX + 'parentNode'];\n  }\n  return false;\n}\n\nconst getNodeHTMLCollectionName = (node) =>\n    node.getAttribute('id') || node.getAttribute('name');\n\nconst isValidHTMLCollectionName = (name) => name !== 'length' && isNaN(name);\n\nexport const createPolyfilledHTMLCollection = (nodes) => {\n  // Note: loop in reverse so that the first named item matches the named property\n  for (let l = nodes.length - 1; l >= 0; l--) {\n    const node = nodes[l];\n    const name = getNodeHTMLCollectionName(node);\n\n    if (name && isValidHTMLCollectionName(name)) {\n      nodes[name] = node;\n    }\n  }\n  nodes.item = function(index) {\n    return nodes[index];\n  }\n  nodes.namedItem = function(name) {\n    if (isValidHTMLCollectionName(name) && nodes[name]) {\n      return nodes[name];\n    }\n\n    for (const node of nodes) {\n      const nodeName = getNodeHTMLCollectionName(node);\n\n      if (nodeName == name) {\n        return node;\n      }\n    }\n\n    return null;\n  };\n  return nodes;\n}\n\nexport const NATIVE_PREFIX = '__shady_native_';\nexport const SHADY_PREFIX = '__shady_';\n\n\n\n/**\n * Patch a group of accessors on an object only if it exists or if the `force`\n * argument is true.\n * @param {!Object} proto\n * @param {!Object} descriptors\n * @param {string=} prefix\n * @param {Array=} disallowedPatches\n */\nexport const patchProperties = (proto, descriptors, prefix = '', disallowedPatches) => {\n  for (let p in descriptors) {\n    const newDescriptor = descriptors[p];\n    if (disallowedPatches && disallowedPatches.indexOf(p) >= 0) {\n      continue;\n    }\n    newDescriptor.configurable = true;\n    const name = prefix + p;\n    // NOTE: we prefer writing directly because some browsers\n    // have descriptors that are writable but not configurable (e.g.\n    // `appendChild` on older browsers)\n    if (newDescriptor.value) {\n      proto[name] = newDescriptor.value;\n    } else {\n      // NOTE: this can throw if 'force' is used so catch the error.\n      try {\n        Object.defineProperty(proto, name, newDescriptor);\n      } catch(e) {\n        // this error is harmless so we just trap it.\n      }\n    }\n  }\n}\n\n/** @type {!function(new:HTMLElement)} */\nexport const NativeHTMLElement =\n    (window['customElements'] && window['customElements']['nativeHTMLElement']) ||\n    HTMLElement;\n\n// note, this is not a perfect polyfill since it doesn't include symbols\n/** @return {!Object<!ObjectPropertyDescriptor>} */\nexport const getOwnPropertyDescriptors = (obj) => {\n  const descriptors = {};\n  Object.getOwnPropertyNames(obj).forEach((name) => {\n    descriptors[name] = Object.getOwnPropertyDescriptor(obj, name);\n  });\n  return descriptors;\n};\n","/**\n@license\nCopyright (c) 2016 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 * as utils from './utils.js';\n\n// render enqueuer/flusher\nlet flushList = [];\nlet scheduled;\nexport function enqueue(callback) {\n  if (!scheduled) {\n    scheduled = true;\n    utils.microtask(flush);\n  }\n  flushList.push(callback);\n}\n\nexport function flush() {\n  scheduled = false;\n  let didFlush = Boolean(flushList.length);\n  while (flushList.length) {\n    flushList.shift()();\n  }\n  return didFlush;\n}\n\nflush['list'] = flushList;\n","/**\n@license\nCopyright (c) 2016 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 * as utils from './utils.js';\nimport {ensureShadyDataForNode} from './shady-data.js';\n\nclass AsyncObserver {\n\n  constructor() {\n    this._scheduled = false;\n    this.addedNodes = [];\n    this.removedNodes = [];\n    this.callbacks = new Set();\n  }\n\n  schedule() {\n    if (!this._scheduled) {\n      this._scheduled = true;\n      utils.microtask(() => {\n        this.flush();\n      });\n    }\n  }\n\n  flush() {\n    if (this._scheduled) {\n      this._scheduled = false;\n      let mutations = this.takeRecords();\n      if (mutations.length) {\n        this.callbacks.forEach(function(cb) {\n          cb(mutations);\n        });\n      }\n    }\n  }\n\n  takeRecords() {\n    if (this.addedNodes.length || this.removedNodes.length) {\n      let mutations = [{\n        addedNodes: this.addedNodes,\n        removedNodes: this.removedNodes\n      }];\n      this.addedNodes = [];\n      this.removedNodes = [];\n      return mutations;\n    }\n    return [];\n  }\n\n}\n\n// TODO(sorvell): consider instead polyfilling MutationObserver\n// directly so that users do not have to fork their code.\n// Supporting the entire api may be challenging: e.g. filtering out\n// removed nodes in the wrong scope and seeing non-distributing\n// subtree child mutations.\nexport let observeChildren = function(node, callback) {\n  const sd = ensureShadyDataForNode(node);\n  if (!sd.observer) {\n    sd.observer = new AsyncObserver();\n  }\n  sd.observer.callbacks.add(callback);\n  let observer = sd.observer;\n  return {\n    _callback: callback,\n    _observer: observer,\n    _node: node,\n    takeRecords() {\n      return observer.takeRecords()\n    }\n  };\n}\n\nexport let unobserveChildren = function(handle) {\n  let observer = handle && handle._observer;\n  if (observer) {\n    observer.callbacks.delete(handle._callback);\n    if (!observer.callbacks.size) {\n      ensureShadyDataForNode(handle._node).observer = null;\n    }\n  }\n}\n\nexport function filterMutations(mutations, target) {\n  /** @const {Node} */\n  const targetRootNode = target.getRootNode();\n  return mutations.map(function(mutation) {\n    /** @const {boolean} */\n    const mutationInScope = (targetRootNode === mutation.target.getRootNode());\n    if (mutationInScope && mutation.addedNodes) {\n      let nodes = Array.from(mutation.addedNodes).filter(function(n) {\n        return (targetRootNode === n.getRootNode());\n      });\n      if (nodes.length) {\n        mutation = Object.create(mutation);\n        Object.defineProperty(mutation, 'addedNodes', {\n          value: nodes,\n          configurable: true\n        });\n        return mutation;\n      }\n    } else if (mutationInScope) {\n      return mutation;\n    }\n  }).filter(function(m) { return m});\n}\n","/**\n@license\nCopyright (c) 2016 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// Cribbed from ShadowDOM polyfill\n// https://github.com/webcomponents/webcomponentsjs/blob/master/src/ShadowDOM/wrappers/HTMLElement.js#L28\n/////////////////////////////////////////////////////////////////////////////\n// innerHTML and outerHTML\n\n// http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#escapingString\nlet escapeAttrRegExp = /[&\\u00A0\"]/g;\nlet escapeDataRegExp = /[&\\u00A0<>]/g;\n\nfunction escapeReplace(c) {\n  switch (c) {\n    case '&':\n      return '&amp;';\n    case '<':\n      return '&lt;';\n    case '>':\n      return '&gt;';\n    case '\"':\n      return '&quot;';\n    case '\\u00A0':\n      return '&nbsp;';\n  }\n}\n\nfunction escapeAttr(s) {\n  return s.replace(escapeAttrRegExp, escapeReplace);\n}\n\nfunction escapeData(s) {\n  return s.replace(escapeDataRegExp, escapeReplace);\n}\n\nfunction makeSet(arr) {\n  let set = {};\n  for (let i = 0; i < arr.length; i++) {\n    set[arr[i]] = true;\n  }\n  return set;\n}\n\n// http://www.whatwg.org/specs/web-apps/current-work/#void-elements\nlet voidElements = makeSet([\n  'area',\n  'base',\n  'br',\n  'col',\n  'command',\n  'embed',\n  'hr',\n  'img',\n  'input',\n  'keygen',\n  'link',\n  'meta',\n  'param',\n  'source',\n  'track',\n  'wbr'\n]);\n\nlet plaintextParents = makeSet([\n  'style',\n  'script',\n  'xmp',\n  'iframe',\n  'noembed',\n  'noframes',\n  'plaintext',\n  'noscript'\n]);\n\n/**\n * @param {Node} node\n * @param {Node} parentNode\n * @param {Function=} callback\n */\nexport function getOuterHTML(node, parentNode, callback) {\n  switch (node.nodeType) {\n    case Node.ELEMENT_NODE: {\n      let tagName = node.localName;\n      let s = '<' + tagName;\n      let attrs = node.attributes;\n      for (let i = 0, attr; (attr = attrs[i]); i++) {\n        s += ' ' + attr.name + '=\"' + escapeAttr(attr.value) + '\"';\n      }\n      s += '>';\n      if (voidElements[tagName]) {\n        return s;\n      }\n      return s + getInnerHTML(node, callback) + '</' + tagName + '>';\n    }\n    case Node.TEXT_NODE: {\n      let data = /** @type {Text} */ (node).data;\n      if (parentNode && plaintextParents[parentNode.localName]) {\n        return data;\n      }\n      return escapeData(data);\n    }\n    case Node.COMMENT_NODE: {\n      return '<!--' + /** @type {Comment} */ (node).data + '-->';\n    }\n    default: {\n      window.console.error(node);\n      throw new Error('not implemented');\n    }\n  }\n}\n\n/**\n * @param {Node} node\n * @param {Function=} callback\n */\nexport function getInnerHTML(node, callback) {\n  if (node.localName === 'template') {\n    node =  /** @type {HTMLTemplateElement} */ (node).content;\n  }\n  let s = '';\n  let c$ = callback ? callback(node) : node.childNodes;\n  for (let i=0, l=c$.length, child; (i<l) && (child=c$[i]); i++) {\n    s += getOuterHTML(child, node, callback);\n  }\n  return s;\n}\n","/**\n@license\nCopyright (c) 2016 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 * as utils from './utils.js';\nimport {patchProperties} from './utils.js';\nimport {getInnerHTML} from './innerHTML.js';\n\nconst hasDescriptors = utils.settings.hasDescriptors;\nexport const NATIVE_PREFIX = utils.NATIVE_PREFIX;\n\n// Object on which raw native methods are stored.\n// e.g. `nativeMethods.querySelector.call(node, selector)`\n// same as `node.querySelector(selector)`\nexport const nativeMethods = {\n  /** @this {Element} */\n  querySelector(selector) {\n    return this[NATIVE_PREFIX + 'querySelector'](selector);\n  },\n  /** @this {Element} */\n  querySelectorAll(selector) {\n    return this[NATIVE_PREFIX + 'querySelectorAll'](selector);\n  }\n};\n// Object on which raw native accessors are available via `accessorName(node)`.\n// e.g. `nativeTree.firstChild(node)`\n// same as `node.firstChild`\nexport const nativeTree = {};\n\nconst installNativeAccessor = (name) => {\n  nativeTree[name] = (node) => node[NATIVE_PREFIX + name];\n}\n\nconst installNativeMethod = (name, fn) => {\n  if (!nativeMethods[name]) {\n    nativeMethods[name] = fn;\n  }\n}\n\n\nconst defineNativeAccessors = (proto, descriptors) => {\n  patchProperties(proto, descriptors, NATIVE_PREFIX);\n  // make native accessors available to users\n  for (let prop in descriptors) {\n    installNativeAccessor(prop);\n  }\n}\n\nconst copyProperties = (proto, list = []) => {\n  for (let i = 0; i < list.length; i++) {\n    const name = list[i];\n    const descriptor = Object.getOwnPropertyDescriptor(proto, name);\n    if (descriptor) {\n      Object.defineProperty(proto, NATIVE_PREFIX + name, descriptor);\n      // make native methods/accessors available to users\n      if (descriptor.value) {\n        installNativeMethod(name, descriptor.value);\n      } else {\n        installNativeAccessor(name);\n\n      }\n    }\n  }\n}\n\n/** @type {!TreeWalker} */\nconst nodeWalker = document.createTreeWalker(document, NodeFilter.SHOW_ALL,\n  null, false);\n\n/** @type {!TreeWalker} */\nconst elementWalker = document.createTreeWalker(document, NodeFilter.SHOW_ELEMENT,\n  null, false);\n\n/** @type {!Document} */\nconst inertDoc = document.implementation.createHTMLDocument('inert');\n\nconst clearNode = node => {\n  let firstChild;\n  while ((firstChild = node[NATIVE_PREFIX + 'firstChild'])) {\n    node[NATIVE_PREFIX + 'removeChild'](firstChild);\n  }\n}\n\nconst ParentNodeAccessors = [\n  'firstElementChild',\n  'lastElementChild',\n  'children',\n  'childElementCount',\n];\n\nconst ParentNodeMethods = [\n  'querySelector',\n  'querySelectorAll'\n  // 'append', 'prepend'\n];\n\nexport const addNativePrefixedProperties = () => {\n\n  // EventTarget\n  const eventProps = [\n    'dispatchEvent',\n    'addEventListener',\n    'removeEventListener'\n  ];\n  if (window.EventTarget) {\n    copyProperties(window.EventTarget.prototype, eventProps);\n  } else {\n    copyProperties(Node.prototype, eventProps);\n    copyProperties(Window.prototype, eventProps);\n  }\n\n\n  // Node\n  if (hasDescriptors) {\n    copyProperties(Node.prototype, [\n      'parentNode',\n      'firstChild',\n      'lastChild',\n      'previousSibling',\n      'nextSibling',\n      'childNodes',\n      'parentElement',\n      'textContent',\n    ]);\n  } else {\n    defineNativeAccessors(Node.prototype, {\n      parentNode: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.parentNode();\n        }\n      },\n      firstChild: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.firstChild();\n        }\n      },\n      lastChild: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.lastChild();\n        }\n\n      },\n      previousSibling: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.previousSibling();\n        }\n      },\n      nextSibling: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.nextSibling();\n        }\n      },\n      // TODO(sorvell): make this a NodeList or whatever\n      childNodes: {\n        /** @this {Node} */\n        get() {\n          const nodes = [];\n          nodeWalker.currentNode = this;\n          let n = nodeWalker.firstChild();\n          while (n) {\n            nodes.push(n);\n            n = nodeWalker.nextSibling();\n          }\n          return nodes;\n        }\n      },\n      parentElement: {\n        /** @this {Node} */\n        get() {\n          elementWalker.currentNode = this;\n          return elementWalker.parentNode();\n        }\n      },\n      textContent: {\n        /** @this {Node} */\n        get() {\n          /* eslint-disable no-case-declarations */\n          switch (this.nodeType) {\n            case Node.ELEMENT_NODE:\n            case Node.DOCUMENT_FRAGMENT_NODE:\n              // TODO(sorvell): This cannot be a single TreeWalker that's reused\n              // at least for Safari 9, but it's unclear why.\n              const textWalker = document.createTreeWalker(this, NodeFilter.SHOW_TEXT,\n                null, false);\n              let content = '', n;\n              while ( (n = textWalker.nextNode()) ) {\n                // TODO(sorvell): can't use textContent since we patch it on Node.prototype!\n                // However, should probably patch it only on element.\n                content += n.nodeValue;\n              }\n              return content;\n            default:\n              return this.nodeValue;\n          }\n        },\n        // Needed on browsers that do not proper accessors (e.g. old versions of Chrome)\n        /** @this {Node} */\n        set(value) {\n          if (typeof value === 'undefined' || value === null) {\n            value = ''\n          }\n          switch (this.nodeType) {\n            case Node.ELEMENT_NODE:\n            case Node.DOCUMENT_FRAGMENT_NODE:\n              clearNode(this);\n              // Document fragments must have no childnodes if setting a blank string\n              if (value.length > 0 || this.nodeType === Node.ELEMENT_NODE) {\n                // Note: old Chrome versions require 2nd argument here\n                this[NATIVE_PREFIX + 'insertBefore'](document.createTextNode(value), undefined);\n              }\n              break;\n            default:\n              // TODO(sorvell): can't do this if patch nodeValue.\n              this.nodeValue = value;\n              break;\n          }\n        }\n      }\n    });\n  }\n\n  copyProperties(Node.prototype, [\n    'appendChild',\n    'insertBefore',\n    'removeChild',\n    'replaceChild',\n    'cloneNode',\n    'contains'\n  ]);\n\n  const ParentNodeWalkerDescriptors = {\n    firstElementChild: {\n      /** @this {ParentNode} */\n      get() {\n        elementWalker.currentNode = this;\n        return elementWalker.firstChild();\n      }\n    },\n    lastElementChild: {\n      /** @this {ParentNode} */\n      get() {\n        elementWalker.currentNode = this;\n        return elementWalker.lastChild();\n      }\n    },\n    children: {\n      /** @this {ParentNode} */\n      get() {\n        let nodes = [];\n        elementWalker.currentNode = this;\n        let n = elementWalker.firstChild();\n        while (n) {\n          nodes.push(n);\n          n = elementWalker.nextSibling();\n        }\n        return utils.createPolyfilledHTMLCollection(nodes);\n      }\n    },\n    childElementCount: {\n      /** @this {ParentNode} */\n      get() {\n        if (this.children) {\n          return this.children.length;\n        }\n        return 0;\n      }\n    }\n  };\n\n  // Element\n  if (hasDescriptors) {\n    copyProperties(Element.prototype, ParentNodeAccessors);\n\n    copyProperties(Element.prototype, [\n      'previousElementSibling',\n      'nextElementSibling',\n      'innerHTML'\n    ]);\n\n    // NOTE, on IE 11 / Edge 15 children and/or innerHTML are on HTMLElement instead of Element\n    if (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'children')) {\n      copyProperties(HTMLElement.prototype, [\n        'children'\n      ]);\n    }\n    if (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'innerHTML')) {\n      copyProperties(HTMLElement.prototype, [\n        'innerHTML'\n      ]);\n    }\n  } else {\n    defineNativeAccessors(Element.prototype, ParentNodeWalkerDescriptors);\n    defineNativeAccessors(Element.prototype, {\n      previousElementSibling: {\n        /** @this {Element} */\n        get() {\n          elementWalker.currentNode = this;\n          return elementWalker.previousSibling();\n        }\n      },\n      nextElementSibling: {\n        /** @this {Element} */\n        get() {\n          elementWalker.currentNode = this;\n          return elementWalker.nextSibling();\n        }\n      },\n      innerHTML: {\n        /** @this {Element} */\n        get() {\n          return getInnerHTML(this, n => n[NATIVE_PREFIX + 'childNodes']);\n        },\n        // Needed on browsers that do not proper accessors (e.g. old versions of Chrome)\n        /** @this {Element} */\n        set(value) {\n          const content = this.localName === 'template' ?\n          /** @type {HTMLTemplateElement} */(this).content : this;\n          clearNode(content);\n          const containerName = this.localName || 'div';\n          let htmlContainer;\n          if (!this.namespaceURI || this.namespaceURI === inertDoc.namespaceURI) {\n            htmlContainer = inertDoc.createElement(containerName);\n          } else {\n            htmlContainer = inertDoc.createElementNS(this.namespaceURI, containerName);\n          }\n          htmlContainer.innerHTML = value;\n          const newContent = this.localName === 'template' ?\n            /** @type {HTMLTemplateElement} */(htmlContainer).content : htmlContainer;\n          let firstChild;\n          while ((firstChild = newContent[NATIVE_PREFIX + 'firstChild'])) {\n            // Note: old Chrome versions require 2nd argument here\n            content[NATIVE_PREFIX + 'insertBefore'](firstChild, undefined);\n          }\n        }\n      }\n    });\n  }\n\n  copyProperties(Element.prototype, [\n    'setAttribute',\n    'getAttribute',\n    'hasAttribute',\n    'removeAttribute',\n    // on older Safari, these are on Element.\n    'focus',\n    'blur',\n  ]);\n  copyProperties(Element.prototype, ParentNodeMethods);\n\n  // HTMLElement\n  copyProperties(HTMLElement.prototype, [\n    'focus',\n    'blur',\n    // On IE these are on HTMLElement\n    'contains'\n  ]);\n\n  if (hasDescriptors) {\n    copyProperties(HTMLElement.prototype, [\n      'parentElement',\n      'children',\n      'innerHTML'\n    ]);\n  }\n\n  // HTMLTemplateElement\n  if (window.HTMLTemplateElement) {\n    copyProperties(window.HTMLTemplateElement.prototype, ['innerHTML']);\n  }\n\n  // DocumentFragment\n  if (hasDescriptors) {\n    // NOTE, IE 11 does not have on DocumentFragment\n    // firstElementChild\n    // lastElementChild\n    copyProperties(DocumentFragment.prototype, ParentNodeAccessors);\n  } else {\n    defineNativeAccessors(DocumentFragment.prototype, ParentNodeWalkerDescriptors);\n  }\n\n  copyProperties(DocumentFragment.prototype, ParentNodeMethods);\n\n  // Document\n  if (hasDescriptors) {\n    copyProperties(Document.prototype, ParentNodeAccessors);\n    copyProperties(Document.prototype, [\n      'activeElement'\n    ]);\n  } else {\n    defineNativeAccessors(Document.prototype, ParentNodeWalkerDescriptors);\n  }\n\n  copyProperties(Document.prototype, [\n    'importNode',\n    'getElementById'\n  ]);\n  copyProperties(Document.prototype, ParentNodeMethods);\n\n};\n","/**\n@license\nCopyright (c) 2016 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 * as utils from './utils.js';\nimport {ensureShadyDataForNode} from './shady-data.js';\n\nexport const InsideDescriptors = utils.getOwnPropertyDescriptors({\n\n  /** @this {Node} */\n  get childNodes() {\n    return this[utils.SHADY_PREFIX + 'childNodes'];\n  },\n\n  /** @this {Node} */\n  get firstChild() {\n    return this[utils.SHADY_PREFIX + 'firstChild'];\n  },\n\n  /** @this {Node} */\n  get lastChild() {\n    return this[utils.SHADY_PREFIX + 'lastChild'];\n  },\n\n  /** @this {Node} */\n  get textContent() {\n    return this[utils.SHADY_PREFIX + 'textContent'];\n  },\n\n  /** @this {Node} */\n  set textContent(value) {\n    this[utils.SHADY_PREFIX + 'textContent'] = value;\n  },\n\n  /** @this {Node} */\n  get childElementCount() {\n    return this[utils.SHADY_PREFIX + 'childElementCount'];\n  },\n\n  /** @this {Node} */\n  get children() {\n    return this[utils.SHADY_PREFIX + 'children'];\n  },\n\n  /** @this {Node} */\n  get firstElementChild() {\n    return this[utils.SHADY_PREFIX + 'firstElementChild'];\n  },\n\n  /** @this {Node} */\n  get lastElementChild() {\n    return this[utils.SHADY_PREFIX + 'lastElementChild'];\n  },\n\n  /** @this {Node} */\n  get innerHTML() {\n    return this[utils.SHADY_PREFIX + 'innerHTML'];\n  },\n\n  /** @this {Node} */\n  set innerHTML(value) {\n    return this[utils.SHADY_PREFIX + 'innerHTML'] = value;\n  },\n\n  /** @this {Node} */\n  get shadowRoot() {\n    return this[utils.SHADY_PREFIX + 'shadowRoot'];\n  }\n\n});\n\nexport const OutsideDescriptors = utils.getOwnPropertyDescriptors({\n\n  /** @this {Node} */\n  get parentElement() {\n    return this[utils.SHADY_PREFIX + 'parentElement'];\n  },\n\n  /** @this {Node} */\n  get parentNode() {\n    return this[utils.SHADY_PREFIX + 'parentNode'];\n  },\n\n  /** @this {Node} */\n  get nextSibling() {\n    return this[utils.SHADY_PREFIX + 'nextSibling'];\n  },\n\n  /** @this {Node} */\n  get previousSibling() {\n    return this[utils.SHADY_PREFIX + 'previousSibling'];\n  },\n\n  /** @this {Node} */\n  get nextElementSibling() {\n    return this[utils.SHADY_PREFIX + 'nextElementSibling'];\n  },\n\n  /** @this {Node} */\n  get previousElementSibling() {\n    return this[utils.SHADY_PREFIX + 'previousElementSibling'];\n  },\n\n  /** @this {Node} */\n  get className() {\n    return this[utils.SHADY_PREFIX + 'className'];\n  },\n\n  /** @this {Node} */\n  set className(value) {\n    return this[utils.SHADY_PREFIX + 'className'] = value;\n  }\n\n});\n\nfor (let prop in InsideDescriptors) {\n  InsideDescriptors[prop].enumerable = false;\n}\n\nfor (let prop in OutsideDescriptors) {\n  OutsideDescriptors[prop].enumerable = false;\n}\n\nconst noInstancePatching = utils.settings.hasDescriptors || utils.settings.noPatch;\n\n// ensure an element has patched \"outside\" accessors; no-op when not needed\nexport let patchOutsideElementAccessors = noInstancePatching ?\n  function() {} : function(element) {\n    const sd = ensureShadyDataForNode(element);\n    if (!sd.__outsideAccessors) {\n      sd.__outsideAccessors = true;\n      utils.patchProperties(element, OutsideDescriptors);\n    }\n  }\n\n// ensure an element has patched \"inside\" accessors; no-op when not needed\nexport let patchInsideElementAccessors = noInstancePatching ?\n  function() {} : function(element) {\n    const sd = ensureShadyDataForNode(element);\n    if (!sd.__insideAccessors) {\n      sd.__insideAccessors = true;\n      utils.patchProperties(element, InsideDescriptors);\n    }\n  }","/**\n@license\nCopyright (c) 2016 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 * as utils from './utils.js';\nimport {shadyDataForNode} from './shady-data.js';\n\n/*\nMake this name unique so it is unlikely to conflict with properties on objects passed to `addEventListener`\nhttps://github.com/webcomponents/shadydom/issues/173\n*/\nconst /** string */ eventWrappersName = `__eventWrappers${Date.now()}`;\n\n/** @type {?function(!Event): boolean} */\nconst composedGetter = (() => {\n  const composedProp = Object.getOwnPropertyDescriptor(Event.prototype, 'composed');\n  return composedProp ? (ev) => composedProp.get.call(ev) : null;\n})();\n\n// https://github.com/w3c/webcomponents/issues/513#issuecomment-224183937\nconst alwaysComposed = {\n  'blur': true,\n  'focus': true,\n  'focusin': true,\n  'focusout': true,\n  'click': true,\n  'dblclick': true,\n  'mousedown': true,\n  'mouseenter': true,\n  'mouseleave': true,\n  'mousemove': true,\n  'mouseout': true,\n  'mouseover': true,\n  'mouseup': true,\n  'wheel': true,\n  'beforeinput': true,\n  'input': true,\n  'keydown': true,\n  'keyup': true,\n  'compositionstart': true,\n  'compositionupdate': true,\n  'compositionend': true,\n  'touchstart': true,\n  'touchend': true,\n  'touchmove': true,\n  'touchcancel': true,\n  'pointerover': true,\n  'pointerenter': true,\n  'pointerdown': true,\n  'pointermove': true,\n  'pointerup': true,\n  'pointercancel': true,\n  'pointerout': true,\n  'pointerleave': true,\n  'gotpointercapture': true,\n  'lostpointercapture': true,\n  'dragstart': true,\n  'drag': true,\n  'dragenter': true,\n  'dragleave': true,\n  'dragover': true,\n  'drop': true,\n  'dragend': true,\n  'DOMActivate': true,\n  'DOMFocusIn': true,\n  'DOMFocusOut': true,\n  'keypress': true\n};\n\nconst unpatchedEvents = {\n  'DOMAttrModified': true,\n  'DOMAttributeNameChanged': true,\n  'DOMCharacterDataModified': true,\n  'DOMElementNameChanged': true,\n  'DOMNodeInserted': true,\n  'DOMNodeInsertedIntoDocument': true,\n  'DOMNodeRemoved': true,\n  'DOMNodeRemovedFromDocument': true,\n  'DOMSubtreeModified': true\n}\n\n/**\n * Some EventTarget subclasses are not Node subclasses, and you cannot call\n * `getRootNode()` on them.\n *\n * @param {!(Node|EventTarget)} eventTarget\n * @return {!(Node|EventTarget)}\n */\nfunction getRootNodeWithFallback(eventTarget) {\n  if (eventTarget instanceof Node) {\n    return eventTarget[utils.SHADY_PREFIX + 'getRootNode']();\n  } else {\n    return eventTarget;\n  }\n}\n\nfunction pathComposer(startNode, composed) {\n  let composedPath = [];\n  let current = startNode;\n  let startRoot = getRootNodeWithFallback(startNode);\n  while (current) {\n    composedPath.push(current);\n    if (current[utils.SHADY_PREFIX + 'assignedSlot']) {\n      current = current[utils.SHADY_PREFIX + 'assignedSlot'];\n    } else if (current.nodeType === Node.DOCUMENT_FRAGMENT_NODE && current.host && (composed || current !== startRoot)) {\n      current = current.host;\n    } else {\n      current = current[utils.SHADY_PREFIX + 'parentNode'];\n    }\n  }\n  // event composedPath includes window when startNode's ownerRoot is document\n  if (composedPath[composedPath.length - 1] === document) {\n    composedPath.push(window);\n  }\n  return composedPath;\n}\n\nexport const composedPath = (event) => {\n  if (!event.__composedPath) {\n    event.__composedPath = pathComposer(event.target, true);\n  }\n  return event.__composedPath;\n}\n\nfunction retarget(refNode, path) {\n  if (!utils.isShadyRoot) {\n    return refNode;\n  }\n  // If ANCESTOR's root is not a shadow root or ANCESTOR's root is BASE's\n  // shadow-including inclusive ancestor, return ANCESTOR.\n  let refNodePath = pathComposer(refNode, true);\n  let p$ = path;\n  for (let i=0, ancestor, lastRoot, root, rootIdx; i < p$.length; i++) {\n    ancestor = p$[i];\n    root = getRootNodeWithFallback(ancestor);\n    if (root !== lastRoot) {\n      rootIdx = refNodePath.indexOf(root);\n      lastRoot = root;\n    }\n    if (!utils.isShadyRoot(root) || rootIdx > -1) {\n      return ancestor;\n    }\n  }\n}\n\nlet EventPatches = {\n\n  /**\n   * @this {Event}\n   */\n  get composed() {\n    if (this.__composed === undefined) {\n      // if there's an original `composed` getter on the Event prototype, use that\n      if (composedGetter) {\n        // TODO(web-padawan): see https://github.com/webcomponents/shadydom/issues/275\n        this.__composed = this.type === 'focusin' || this.type === 'focusout' || composedGetter(this);\n      // If the event is trusted, or `isTrusted` is not supported, check the list of always composed events\n      } else if (this.isTrusted !== false) {\n        this.__composed = alwaysComposed[this.type];\n      }\n    }\n    return /** @type {!Event} */(this).__composed || false;\n  },\n\n  /**\n   * @this {Event}\n   */\n  composedPath() {\n    if (!this.__composedPath) {\n      this.__composedPath = pathComposer(this['__target'], this.composed);\n    }\n    return /** @type {!Event} */(this).__composedPath;\n  },\n\n  /**\n   * @this {Event}\n   */\n  get target() {\n    return retarget(this.currentTarget || this['__previousCurrentTarget'], this.composedPath());\n  },\n\n  // http://w3c.github.io/webcomponents/spec/shadow/#event-relatedtarget-retargeting\n  /**\n   * @this {Event}\n   */\n  get relatedTarget() {\n    if (!this.__relatedTarget) {\n      return null;\n    }\n    if (!this.__relatedTargetComposedPath) {\n      this.__relatedTargetComposedPath = pathComposer(this.__relatedTarget, true);\n    }\n    // find the deepest node in relatedTarget composed path that is in the same root with the currentTarget\n    return retarget(this.currentTarget || this['__previousCurrentTarget'], /** @type {!Event} */(this).__relatedTargetComposedPath);\n  },\n  /**\n   * @this {Event}\n   */\n  stopPropagation() {\n    Event.prototype.stopPropagation.call(this);\n    this.__propagationStopped = true;\n  },\n  /**\n   * @this {Event}\n   */\n  stopImmediatePropagation() {\n    Event.prototype.stopImmediatePropagation.call(this);\n    this.__immediatePropagationStopped = true;\n    this.__propagationStopped = true;\n  }\n\n};\n\nfunction mixinComposedFlag(Base) {\n  // NOTE: avoiding use of `class` here so that transpiled output does not\n  // try to do `Base.call` with a dom construtor.\n  let klazz = function(type, options) {\n    let event = new Base(type, options);\n    event.__composed = options && Boolean(options['composed']);\n    return event;\n  }\n  // put constructor properties on subclass\n  klazz.__proto__ = Base;\n  klazz.prototype = Base.prototype;\n  return klazz;\n}\n\nlet nonBubblingEventsToRetarget = {\n  'focus': true,\n  'blur': true\n};\n\n\n/**\n * Check if the event has been retargeted by comparing original `target`, and calculated `target`\n * @param {Event} event\n * @return {boolean} True if the original target and calculated target are the same\n */\nfunction hasRetargeted(event) {\n  return event['__target'] !== event.target || event.__relatedTarget !== event.relatedTarget;\n}\n\n/**\n *\n * @param {Event} event\n * @param {Node} node\n * @param {string} phase\n */\nfunction fireHandlers(event, node, phase) {\n  let hs = node.__handlers && node.__handlers[event.type] &&\n    node.__handlers[event.type][phase];\n  if (hs) {\n    for (let i = 0, fn; (fn = hs[i]); i++) {\n      if (hasRetargeted(event) && event.target === event.relatedTarget) {\n        return;\n      }\n      fn.call(node, event);\n      if (event.__immediatePropagationStopped) {\n        return;\n      }\n    }\n  }\n}\n\nfunction retargetNonBubblingEvent(e) {\n  let path = e.composedPath();\n  let node;\n  // override `currentTarget` to let patched `target` calculate correctly\n  Object.defineProperty(e, 'currentTarget', {\n    get: function() {\n      return node;\n    },\n    configurable: true\n  });\n  for (let i = path.length - 1; i >= 0; i--) {\n    node = path[i];\n    // capture phase fires all capture handlers\n    fireHandlers(e, node, 'capture');\n    if (e.__propagationStopped) {\n      return;\n    }\n  }\n\n  // set the event phase to `AT_TARGET` as in spec\n  Object.defineProperty(e, 'eventPhase', {get() { return Event.AT_TARGET }});\n\n  // the event only needs to be fired when owner roots change when iterating the event path\n  // keep track of the last seen owner root\n  let lastFiredRoot;\n  for (let i = 0; i < path.length; i++) {\n    node = path[i];\n    const nodeData = shadyDataForNode(node);\n    const root = nodeData && nodeData.root;\n    if (i === 0 || (root && root === lastFiredRoot)) {\n      fireHandlers(e, node, 'bubble');\n      // don't bother with window, it doesn't have `getRootNode` and will be last in the path anyway\n      if (node !== window) {\n        lastFiredRoot = node[utils.SHADY_PREFIX + 'getRootNode']();\n      }\n      if (e.__propagationStopped) {\n        return;\n      }\n    }\n  }\n}\n\nfunction listenerSettingsEqual(savedListener, node, type, capture, once, passive) {\n  let {\n    node: savedNode,\n    type: savedType,\n    capture: savedCapture,\n    once: savedOnce,\n    passive: savedPassive\n  } = savedListener;\n  return node === savedNode &&\n    type === savedType &&\n    capture === savedCapture &&\n    once === savedOnce &&\n    passive === savedPassive;\n}\n\nexport function findListener(wrappers, node, type, capture, once, passive) {\n  for (let i = 0; i < wrappers.length; i++) {\n    if (listenerSettingsEqual(wrappers[i], node, type, capture, once, passive)) {\n      return i;\n    }\n  }\n  return -1;\n}\n\n/**\n * Firefox can throw on accessing eventWrappers inside of `removeEventListener` during a selenium run\n * Try/Catch accessing eventWrappers to work around\n * https://bugzilla.mozilla.org/show_bug.cgi?id=1353074\n */\nfunction getEventWrappers(eventLike) {\n  let wrappers = null;\n  try {\n    wrappers = eventLike[eventWrappersName];\n  } catch (e) {} // eslint-disable-line no-empty\n  return wrappers;\n}\n\n/**\n * @this {EventTarget}\n */\nexport function addEventListener(type, fnOrObj, optionsOrCapture) {\n  if (!fnOrObj) {\n    return;\n  }\n\n  const handlerType = typeof fnOrObj;\n\n  // bail if `fnOrObj` is not a function, not an object\n  if (handlerType !== 'function' && handlerType !== 'object') {\n    return;\n  }\n\n  // bail if `fnOrObj` is an object without a `handleEvent` method\n  if (handlerType === 'object' && (!fnOrObj.handleEvent || typeof fnOrObj.handleEvent !== 'function')) {\n    return;\n  }\n\n  if (unpatchedEvents[type]) {\n    return this[utils.NATIVE_PREFIX + 'addEventListener'](type, fnOrObj, optionsOrCapture);\n  }\n\n  // The callback `fn` might be used for multiple nodes/events. Since we generate\n  // a wrapper function, we need to keep track of it when we remove the listener.\n  // It's more efficient to store the node/type/options information as Array in\n  // `fn` itself rather than the node (we assume that the same callback is used\n  // for few nodes at most, whereas a node will likely have many event listeners).\n  // NOTE(valdrin) invoking external functions is costly, inline has better perf.\n  let capture, once, passive;\n  if (optionsOrCapture && typeof optionsOrCapture === 'object') {\n    capture = Boolean(optionsOrCapture.capture);\n    once = Boolean(optionsOrCapture.once);\n    passive = Boolean(optionsOrCapture.passive);\n  } else {\n    capture = Boolean(optionsOrCapture);\n    once = false;\n    passive = false;\n  }\n  // hack to let ShadyRoots have event listeners\n  // event listener will be on host, but `currentTarget`\n  // will be set to shadyroot for event listener\n  let target = (optionsOrCapture && optionsOrCapture.__shadyTarget) || this;\n\n  let wrappers = fnOrObj[eventWrappersName];\n  if (wrappers) {\n    // Stop if the wrapper function has already been created.\n    if (findListener(wrappers, target, type, capture, once, passive) > -1) {\n      return;\n    }\n  } else {\n    fnOrObj[eventWrappersName] = [];\n  }\n\n  /**\n   * @this {HTMLElement}\n   * @param {Event} e\n   */\n  const wrapperFn = function(e) {\n    // Support `once` option.\n    if (once) {\n      this[utils.SHADY_PREFIX + 'removeEventListener'](type, fnOrObj, optionsOrCapture);\n    }\n    if (!e['__target']) {\n      patchEvent(e);\n    }\n    let lastCurrentTargetDesc;\n    if (target !== this) {\n      // replace `currentTarget` to make `target` and `relatedTarget` correct for inside the shadowroot\n      lastCurrentTargetDesc = Object.getOwnPropertyDescriptor(e, 'currentTarget');\n      Object.defineProperty(e, 'currentTarget', {get() { return target }, configurable: true});\n    }\n    e['__previousCurrentTarget'] = e['currentTarget'];\n    // Always check if a shadowRoot is in the current event path.\n    // If it is not, the event was generated on either the host of the shadowRoot\n    // or a children of the host.\n    if (utils.isShadyRoot(target) && e.composedPath().indexOf(target) == -1) {\n      return;\n    }\n    // There are two critera that should stop events from firing on this node\n    // 1. the event is not composed and the current node is not in the same root as the target\n    // 2. when bubbling, if after retargeting, relatedTarget and target point to the same node\n    if (e.composed || e.composedPath().indexOf(target) > -1) {\n      if (hasRetargeted(e) && e.target === e.relatedTarget) {\n        if (e.eventPhase === Event.BUBBLING_PHASE) {\n          e.stopImmediatePropagation();\n        }\n        return;\n      }\n      // prevent non-bubbling events from triggering bubbling handlers on shadowroot, but only if not in capture phase\n      if (e.eventPhase !== Event.CAPTURING_PHASE && !e.bubbles && e.target !== target && !(target instanceof Window)) {\n        return;\n      }\n      let ret = handlerType === 'function' ?\n        fnOrObj.call(target, e) :\n        (fnOrObj.handleEvent && fnOrObj.handleEvent(e));\n      if (target !== this) {\n        // replace the \"correct\" `currentTarget`\n        if (lastCurrentTargetDesc) {\n          Object.defineProperty(e, 'currentTarget', lastCurrentTargetDesc);\n          lastCurrentTargetDesc = null;\n        } else {\n          delete e['currentTarget'];\n        }\n      }\n      return ret;\n    }\n  };\n\n  // Store the wrapper information.\n  fnOrObj[eventWrappersName].push({\n    // note: use target here which is either a shadowRoot\n    // (when the host element is proxy'ing the event) or this element\n    node: target,\n    type: type,\n    capture: capture,\n    once: once,\n    passive: passive,\n    wrapperFn: wrapperFn\n  });\n\n  if (nonBubblingEventsToRetarget[type]) {\n    this.__handlers = this.__handlers || {};\n    this.__handlers[type] = this.__handlers[type] ||\n      {'capture': [], 'bubble': []};\n    this.__handlers[type][capture ? 'capture' : 'bubble'].push(wrapperFn);\n  } else {\n    this[utils.NATIVE_PREFIX + 'addEventListener'](type, wrapperFn, optionsOrCapture);\n  }\n}\n\n/**\n * @this {EventTarget}\n */\nexport function removeEventListener(type, fnOrObj, optionsOrCapture) {\n  if (!fnOrObj) {\n    return;\n  }\n  if (unpatchedEvents[type]) {\n    return this[utils.NATIVE_PREFIX + 'removeEventListener'](type, fnOrObj, optionsOrCapture);\n  }\n  // NOTE(valdrin) invoking external functions is costly, inline has better perf.\n  let capture, once, passive;\n  if (optionsOrCapture && typeof optionsOrCapture === 'object') {\n    capture = Boolean(optionsOrCapture.capture);\n    once = Boolean(optionsOrCapture.once);\n    passive = Boolean(optionsOrCapture.passive);\n  } else {\n    capture = Boolean(optionsOrCapture);\n    once = false;\n    passive = false;\n  }\n  let target = (optionsOrCapture && optionsOrCapture.__shadyTarget) || this;\n  // Search the wrapped function.\n  let wrapperFn = undefined;\n  let wrappers = getEventWrappers(fnOrObj);\n  if (wrappers) {\n    let idx = findListener(wrappers, target, type, capture, once, passive);\n    if (idx > -1) {\n      wrapperFn = wrappers.splice(idx, 1)[0].wrapperFn;\n      // Cleanup.\n      if (!wrappers.length) {\n        fnOrObj[eventWrappersName] = undefined;\n      }\n    }\n  }\n  this[utils.NATIVE_PREFIX + 'removeEventListener'](type, wrapperFn || fnOrObj, optionsOrCapture);\n  if (wrapperFn && nonBubblingEventsToRetarget[type] &&\n      this.__handlers && this.__handlers[type]) {\n    const arr = this.__handlers[type][capture ? 'capture' : 'bubble'];\n    const idx = arr.indexOf(wrapperFn);\n    if (idx > -1) {\n      arr.splice(idx, 1);\n    }\n  }\n}\n\nfunction activateFocusEventOverrides() {\n  for (let ev in nonBubblingEventsToRetarget) {\n    window[utils.NATIVE_PREFIX + 'addEventListener'](ev, function(e) {\n      if (!e['__target']) {\n        patchEvent(e);\n        retargetNonBubblingEvent(e);\n      }\n    }, true);\n  }\n}\n\nconst EventPatchesDescriptors = utils.getOwnPropertyDescriptors(EventPatches);\n\nconst SHADY_PROTO = '__shady_patchedProto';\nconst SHADY_SOURCE_PROTO = '__shady_sourceProto';\n\nfunction patchEvent(event) {\n  event['__target'] = event.target;\n  event.__relatedTarget = event.relatedTarget;\n  // attempt to patch prototype (via cache)\n  if (utils.settings.hasDescriptors) {\n    const proto = Object.getPrototypeOf(event);\n    if (!Object.hasOwnProperty(proto, SHADY_PROTO)) {\n      const patchedProto = Object.create(proto);\n      patchedProto[SHADY_SOURCE_PROTO] = proto;\n      utils.patchProperties(patchedProto, EventPatchesDescriptors);\n      proto[SHADY_PROTO] = patchedProto;\n    }\n    event.__proto__ = proto[SHADY_PROTO];\n  // and fallback to patching instance\n  } else {\n    utils.patchProperties(event, EventPatchesDescriptors);\n  }\n}\n\nlet PatchedEvent = mixinComposedFlag(Event);\nlet PatchedCustomEvent = mixinComposedFlag(CustomEvent);\nlet PatchedMouseEvent = mixinComposedFlag(MouseEvent);\n\n\nexport function patchEvents() {\n  activateFocusEventOverrides();\n  window.Event = PatchedEvent;\n  window.CustomEvent = PatchedCustomEvent;\n  window.MouseEvent = PatchedMouseEvent;\n}\n\nexport function patchClick() {\n  // Fix up `Element.prototype.click()` if `isTrusted` is supported, but `composed` isn't\n  if (!composedGetter && Object.getOwnPropertyDescriptor(Event.prototype, 'isTrusted')) {\n    /** @this {Element} */\n    const composedClickFn = function() {\n      const ev = new MouseEvent('click', {\n        bubbles: true,\n        cancelable: true,\n        composed: true\n      });\n      this[utils.SHADY_PREFIX + 'dispatchEvent'](ev);\n    };\n    if (Element.prototype.click) {\n      Element.prototype.click = composedClickFn;\n    } else if (HTMLElement.prototype.click) {\n      HTMLElement.prototype.click = composedClickFn;\n    }\n  }\n}\n\nexport const eventPropertyNames = Object.getOwnPropertyNames(Document.prototype)\n    .filter(name => name.substring(0,2) === 'on');\n","/**\n@license\nCopyright (c) 2016 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\nfunction newSplice(index, removed, addedCount) {\n  return {\n    index: index,\n    removed: removed,\n    addedCount: addedCount\n  };\n}\n\nconst EDIT_LEAVE = 0;\nconst EDIT_UPDATE = 1;\nconst EDIT_ADD = 2;\nconst EDIT_DELETE = 3;\n\n// Note: This function is *based* on the computation of the Levenshtein\n// \"edit\" distance. The one change is that \"updates\" are treated as two\n// edits - not one. With Array splices, an update is really a delete\n// followed by an add. By retaining this, we optimize for \"keeping\" the\n// maximum array items in the original array. For example:\n//\n//   'xxxx123' -> '123yyyy'\n//\n// With 1-edit updates, the shortest path would be just to update all seven\n// characters. With 2-edit updates, we delete 4, leave 3, and add 4. This\n// leaves the substring '123' intact.\nfunction calcEditDistances(current, currentStart, currentEnd,\n                            old, oldStart, oldEnd) {\n  // \"Deletion\" columns\n  let rowCount = oldEnd - oldStart + 1;\n  let columnCount = currentEnd - currentStart + 1;\n  let distances = new Array(rowCount);\n\n  // \"Addition\" rows. Initialize null column.\n  for (let i = 0; i < rowCount; i++) {\n    distances[i] = new Array(columnCount);\n    distances[i][0] = i;\n  }\n\n  // Initialize null row\n  for (let j = 0; j < columnCount; j++)\n    distances[0][j] = j;\n\n  for (let i = 1; i < rowCount; i++) {\n    for (let j = 1; j < columnCount; j++) {\n      if (equals(current[currentStart + j - 1], old[oldStart + i - 1]))\n        distances[i][j] = distances[i - 1][j - 1];\n      else {\n        let north = distances[i - 1][j] + 1;\n        let west = distances[i][j - 1] + 1;\n        distances[i][j] = north < west ? north : west;\n      }\n    }\n  }\n\n  return distances;\n}\n\n// This starts at the final weight, and walks \"backward\" by finding\n// the minimum previous weight recursively until the origin of the weight\n// matrix.\nfunction spliceOperationsFromEditDistances(distances) {\n  let i = distances.length - 1;\n  let j = distances[0].length - 1;\n  let current = distances[i][j];\n  let edits = [];\n  while (i > 0 || j > 0) {\n    if (i == 0) {\n      edits.push(EDIT_ADD);\n      j--;\n      continue;\n    }\n    if (j == 0) {\n      edits.push(EDIT_DELETE);\n      i--;\n      continue;\n    }\n    let northWest = distances[i - 1][j - 1];\n    let west = distances[i - 1][j];\n    let north = distances[i][j - 1];\n\n    let min;\n    if (west < north)\n      min = west < northWest ? west : northWest;\n    else\n      min = north < northWest ? north : northWest;\n\n    if (min == northWest) {\n      if (northWest == current) {\n        edits.push(EDIT_LEAVE);\n      } else {\n        edits.push(EDIT_UPDATE);\n        current = northWest;\n      }\n      i--;\n      j--;\n    } else if (min == west) {\n      edits.push(EDIT_DELETE);\n      i--;\n      current = west;\n    } else {\n      edits.push(EDIT_ADD);\n      j--;\n      current = north;\n    }\n  }\n\n  edits.reverse();\n  return edits;\n}\n\n/**\n * Splice Projection functions:\n *\n * A splice map is a representation of how a previous array of items\n * was transformed into a new array of items. Conceptually it is a list of\n * tuples of\n *\n *   <index, removed, addedCount>\n *\n * which are kept in ascending index order of. The tuple represents that at\n * the |index|, |removed| sequence of items were removed, and counting forward\n * from |index|, |addedCount| items were added.\n */\n\n/**\n * Lacking individual splice mutation information, the minimal set of\n * splices can be synthesized given the previous state and final state of an\n * array. The basic approach is to calculate the edit distance matrix and\n * choose the shortest path through it.\n *\n * Complexity: O(l * p)\n *   l: The length of the current array\n *   p: The length of the old array\n */\nfunction calcSplices(current, currentStart, currentEnd,\n                      old, oldStart, oldEnd) {\n  let prefixCount = 0;\n  let suffixCount = 0;\n  let splice;\n\n  let minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart);\n  if (currentStart == 0 && oldStart == 0)\n    prefixCount = sharedPrefix(current, old, minLength);\n\n  if (currentEnd == current.length && oldEnd == old.length)\n    suffixCount = sharedSuffix(current, old, minLength - prefixCount);\n\n  currentStart += prefixCount;\n  oldStart += prefixCount;\n  currentEnd -= suffixCount;\n  oldEnd -= suffixCount;\n\n  if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0)\n    return [];\n\n  if (currentStart == currentEnd) {\n    splice = newSplice(currentStart, [], 0);\n    while (oldStart < oldEnd)\n      splice.removed.push(old[oldStart++]);\n\n    return [ splice ];\n  } else if (oldStart == oldEnd)\n    return [ newSplice(currentStart, [], currentEnd - currentStart) ];\n\n  let ops = spliceOperationsFromEditDistances(\n      calcEditDistances(current, currentStart, currentEnd,\n                             old, oldStart, oldEnd));\n\n  splice = undefined;\n  let splices = [];\n  let index = currentStart;\n  let oldIndex = oldStart;\n  for (let i = 0; i < ops.length; i++) {\n    switch(ops[i]) {\n      case EDIT_LEAVE:\n        if (splice) {\n          splices.push(splice);\n          splice = undefined;\n        }\n\n        index++;\n        oldIndex++;\n        break;\n      case EDIT_UPDATE:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.addedCount++;\n        index++;\n\n        splice.removed.push(old[oldIndex]);\n        oldIndex++;\n        break;\n      case EDIT_ADD:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.addedCount++;\n        index++;\n        break;\n      case EDIT_DELETE:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.removed.push(old[oldIndex]);\n        oldIndex++;\n        break;\n    }\n  }\n\n  if (splice) {\n    splices.push(splice);\n  }\n  return splices;\n}\n\nfunction sharedPrefix(current, old, searchLength) {\n  for (let i = 0; i < searchLength; i++)\n    if (!equals(current[i], old[i]))\n      return i;\n  return searchLength;\n}\n\nfunction sharedSuffix(current, old, searchLength) {\n  let index1 = current.length;\n  let index2 = old.length;\n  let count = 0;\n  while (count < searchLength && equals(current[--index1], old[--index2]))\n    count++;\n\n  return count;\n}\n\nfunction equals(currentValue, previousValue) {\n  return currentValue === previousValue;\n}\n\nexport function calculateSplices(current, previous) {\n  return calcSplices(current, 0, current.length, previous, 0,\n                          previous.length);\n}\n\n","/**\n@license\nCopyright (c) 2016 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 * as utils from './utils.js';\nimport {shadyDataForNode, ensureShadyDataForNode} from './shady-data.js';\nimport {patchInsideElementAccessors, patchOutsideElementAccessors} from './patch-instances.js';\n\nfunction linkNode(node, container, ref_node) {\n  patchOutsideElementAccessors(node);\n  ref_node = ref_node || null;\n  const nodeData = ensureShadyDataForNode(node);\n  const containerData = ensureShadyDataForNode(container);\n  const ref_nodeData = ref_node ? ensureShadyDataForNode(ref_node) : null;\n  // update ref_node.previousSibling <-> node\n  nodeData.previousSibling = ref_node ? ref_nodeData.previousSibling :\n    container[utils.SHADY_PREFIX + 'lastChild'];\n  let psd = shadyDataForNode(nodeData.previousSibling);\n  if (psd) {\n    psd.nextSibling = node;\n  }\n  // update node <-> ref_node\n  let nsd = shadyDataForNode(nodeData.nextSibling = ref_node);\n  if (nsd) {\n    nsd.previousSibling = node;\n  }\n  // update node <-> container\n  nodeData.parentNode = container;\n  if (ref_node) {\n    if (ref_node === containerData.firstChild) {\n      containerData.firstChild = node;\n    }\n  } else {\n    containerData.lastChild = node;\n    if (!containerData.firstChild) {\n      containerData.firstChild = node;\n    }\n  }\n  // remove caching of childNodes\n  containerData.childNodes = null;\n}\n\nexport const recordInsertBefore = (node, container, ref_node) => {\n  patchInsideElementAccessors(container);\n  const containerData = ensureShadyDataForNode(container);\n  if (containerData.firstChild !== undefined) {\n    containerData.childNodes = null;\n  }\n  // handle document fragments\n  if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n    let c$ = node[utils.SHADY_PREFIX + 'childNodes'];\n    for (let i=0; i < c$.length; i++) {\n      linkNode(c$[i], container, ref_node);\n    }\n    // cleanup logical dom in doc fragment.\n    const nodeData = ensureShadyDataForNode(node);\n    let resetTo = (nodeData.firstChild !== undefined) ? null : undefined;\n    nodeData.firstChild = nodeData.lastChild = resetTo;\n    nodeData.childNodes = resetTo;\n  } else {\n    linkNode(node, container, ref_node);\n  }\n}\n\nexport const recordRemoveChild = (node, container) => {\n  const nodeData = ensureShadyDataForNode(node);\n  const containerData = ensureShadyDataForNode(container);\n  if (node === containerData.firstChild) {\n    containerData.firstChild = nodeData.nextSibling;\n  }\n  if (node === containerData.lastChild) {\n    containerData.lastChild = nodeData.previousSibling;\n  }\n  let p = nodeData.previousSibling;\n  let n = nodeData.nextSibling;\n  if (p) {\n    ensureShadyDataForNode(p).nextSibling = n;\n  }\n  if (n) {\n    ensureShadyDataForNode(n).previousSibling = p;\n  }\n  // When an element is removed, logical data is no longer tracked.\n  // Explicitly set `undefined` here to indicate this. This is disginguished\n  // from `null` which is set if info is null.\n  nodeData.parentNode = nodeData.previousSibling =\n  nodeData.nextSibling = undefined;\n  if (containerData.childNodes !== undefined) {\n    // remove caching of childNodes\n    containerData.childNodes = null;\n  }\n}\n\n/**\n * @param  {!Node} node\n */\nexport const recordChildNodes = (node) => {\n  const nodeData = ensureShadyDataForNode(node);\n  if (nodeData.firstChild === undefined) {\n    // remove caching of childNodes\n    nodeData.childNodes = null;\n    const first = nodeData.firstChild = node[utils.NATIVE_PREFIX + 'firstChild'] || null;\n    nodeData.lastChild = node[utils.NATIVE_PREFIX + 'lastChild'] || null;\n    patchInsideElementAccessors(node);\n    for (let n = first, previous; n; (n = n[utils.NATIVE_PREFIX + 'nextSibling'])) {\n      const sd = ensureShadyDataForNode(n);\n      sd.parentNode = node;\n      sd.nextSibling = n[utils.NATIVE_PREFIX + 'nextSibling'] || null;\n      sd.previousSibling = previous || null;\n      previous = n;\n      patchOutsideElementAccessors(n);\n    }\n  }\n}\n","/**\n@license\nCopyright (c) 2016 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 * as utils from './utils.js';\n\nlet scopingShim = null;\n\nexport function getScopingShim() {\n  if (!scopingShim) {\n    scopingShim = window['ShadyCSS'] && window['ShadyCSS']['ScopingShim'];\n  }\n  return scopingShim || null;\n}\n\n/**\n * @param {!Node} node\n * @param {string} attr\n * @param {string} value\n */\nexport function scopeClassAttribute(node, attr, value) {\n  const scopingShim = getScopingShim();\n  if (scopingShim && attr === 'class') {\n    scopingShim['setElementClass'](node, value);\n    return true;\n  }\n  return false;\n}\n\n/**\n * @param {!Node} node\n * @param {string} newScopeName\n */\nexport function addShadyScoping(node, newScopeName) {\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return;\n  }\n  scopingShim['scopeNode'](node, newScopeName);\n}\n\n/**\n * @param {!Node} node\n * @param {string} currentScopeName\n */\nexport function removeShadyScoping(node, currentScopeName) {\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return;\n  }\n  scopingShim['unscopeNode'](node, currentScopeName);\n}\n\n/**\n * @param {!Node} node\n * @param {string} newScopeName\n * @param {string} oldScopeName\n */\nexport function replaceShadyScoping(node, newScopeName, oldScopeName) {\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return;\n  }\n  if (oldScopeName) {\n    removeShadyScoping(node, oldScopeName);\n  }\n  addShadyScoping(node, newScopeName);\n}\n\n/**\n * @param {!Node} node\n * @param {string} newScopeName\n * @return {boolean}\n */\nexport function currentScopeIsCorrect(node, newScopeName) {\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return true;\n  }\n  if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n    // NOTE: as an optimization, only check that all the top-level children\n    // have the correct scope.\n    let correctScope = true;\n    const childNodes = node[utils.SHADY_PREFIX + 'childNodes'];\n    for (let idx = 0; correctScope && (idx < childNodes.length); idx++) {\n      correctScope = correctScope &&\n        currentScopeIsCorrect(childNodes[idx], newScopeName);\n    }\n    return correctScope;\n  }\n  if (node.nodeType !== Node.ELEMENT_NODE) {\n    return true;\n  }\n  const currentScope = scopingShim['currentScopeForNode'](node);\n  return currentScope === newScopeName;\n}\n\n/**\n * @param {!Node} node\n * @return {string}\n */\nexport function currentScopeForNode(node) {\n  if (node.nodeType !== Node.ELEMENT_NODE) {\n    return '';\n  }\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return '';\n  }\n  return scopingShim['currentScopeForNode'](node);\n}\n\n/**\n * Walk over a node's tree and apply visitorFn to each element node\n *\n * @param {Node} node\n * @param {function(!Node):void} visitorFn\n */\nexport function treeVisitor(node, visitorFn) {\n  if (!node) {\n    return;\n  }\n  // this check is necessary if `node` is a Document Fragment\n  if (node.nodeType === Node.ELEMENT_NODE) {\n    visitorFn(node);\n  }\n  const childNodes = node[utils.SHADY_PREFIX + 'childNodes'];\n  for (let idx = 0, n; idx < childNodes.length; idx++) {\n    n = childNodes[idx];\n    if (n.nodeType === Node.ELEMENT_NODE) {\n      treeVisitor(n, visitorFn);\n    }\n  }\n}","/**\n@license\nCopyright (c) 2016 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 * as utils from '../utils.js';\nimport {getScopingShim, removeShadyScoping, replaceShadyScoping,\n  treeVisitor, currentScopeForNode, currentScopeIsCorrect } from '../style-scoping.js';\nimport {shadyDataForNode, ensureShadyDataForNode} from '../shady-data.js';\nimport {recordInsertBefore, recordRemoveChild} from '../link-nodes.js';\nimport {ownerShadyRootForNode} from '../attach-shadow.js';\n\nconst doc = window.document;\n\nconst preferPerformance = utils.settings.preferPerformance;\n\nconst nativeIsConnectedAccessors =\n/** @type {ObjectPropertyDescriptor} */(\n  Object.getOwnPropertyDescriptor(Node.prototype, 'isConnected')\n);\n\nconst nativeIsConnected = nativeIsConnectedAccessors && nativeIsConnectedAccessors.get;\n\nexport function clearNode(node) {\n  let firstChild;\n  while ((firstChild = node[utils.SHADY_PREFIX + 'firstChild'])) {\n    node[utils.SHADY_PREFIX + 'removeChild'](firstChild);\n  }\n}\n\nfunction removeOwnerShadyRoot(node) {\n  // optimization: only reset the tree if node is actually in a root\n  if (hasCachedOwnerRoot(node)) {\n    let c$ = node[utils.SHADY_PREFIX + 'childNodes'];\n    for (let i=0, l=c$.length, n; (i<l) && (n=c$[i]); i++) {\n      removeOwnerShadyRoot(n);\n    }\n  }\n  const nodeData = shadyDataForNode(node);\n  if (nodeData) {\n    nodeData.ownerShadyRoot = undefined;\n  }\n}\n\nfunction hasCachedOwnerRoot(node) {\n  const nodeData = shadyDataForNode(node);\n  return Boolean(nodeData && nodeData.ownerShadyRoot !== undefined);\n}\n\n/**\n * Finds the first flattened node that is composed in the node's parent.\n * If the given node is a slot, then the first flattened node is returned\n * if it exists, otherwise advance to the node's nextSibling.\n * @param {Node} node within which to find first composed node\n * @returns {Node} first composed node\n */\nfunction firstComposedNode(node) {\n  let composed = node;\n  if (node && node.localName === 'slot') {\n    const nodeData = shadyDataForNode(node);\n    const flattened = nodeData && nodeData.flattenedNodes;\n    composed = flattened && flattened.length ? flattened[0] :\n      firstComposedNode(node[utils.SHADY_PREFIX + 'nextSibling']);\n  }\n  return composed;\n}\n\n/**\n * @param {Node} node\n * @param {Node=} addedNode\n * @param {Node=} removedNode\n */\nfunction scheduleObserver(node, addedNode, removedNode) {\n  const nodeData = shadyDataForNode(node);\n  const observer = nodeData && nodeData.observer;\n  if (observer) {\n    if (addedNode) {\n      observer.addedNodes.push(addedNode);\n    }\n    if (removedNode) {\n      observer.removedNodes.push(removedNode);\n    }\n    observer.schedule();\n  }\n}\n\nexport const NodePatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Node} */\n  get parentNode() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.parentNode;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'parentNode'];\n  },\n\n  /** @this {Node} */\n  get firstChild() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.firstChild;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'firstChild'];\n  },\n\n  /** @this {Node} */\n  get lastChild() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.lastChild;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'lastChild'];\n  },\n\n  /** @this {Node} */\n  get nextSibling() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.nextSibling;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'nextSibling'];\n  },\n\n  /** @this {Node} */\n  get previousSibling() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.previousSibling;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'previousSibling'];\n  },\n\n  /** @this {Node} */\n  get childNodes() {\n    let childNodes;\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      const nodeData = shadyDataForNode(this);\n      if (!nodeData.childNodes) {\n        nodeData.childNodes = [];\n        for (let n=this[utils.SHADY_PREFIX + 'firstChild']; n; n=n[utils.SHADY_PREFIX + 'nextSibling']) {\n          nodeData.childNodes.push(n);\n        }\n      }\n      childNodes = nodeData.childNodes;\n    } else {\n      childNodes = this[utils.NATIVE_PREFIX + 'childNodes'];\n    }\n    childNodes.item = function(index) {\n      return childNodes[index];\n    }\n    return childNodes;\n  },\n\n  /** @this {Node} */\n  get parentElement() {\n    const nodeData = shadyDataForNode(this);\n    let l = nodeData && nodeData.parentNode;\n    if (l && l.nodeType !== Node.ELEMENT_NODE) {\n      l = null;\n    }\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'parentElement'];\n  },\n\n  /** @this {Node} */\n  get isConnected() {\n    if (nativeIsConnected && nativeIsConnected.call(this)) {\n      return true;\n    }\n    if (this.nodeType == Node.DOCUMENT_FRAGMENT_NODE) {\n      return false;\n    }\n    // Fast path for distributed nodes.\n    const ownerDocument = this.ownerDocument;\n    if (utils.hasDocumentContains) {\n      if (ownerDocument[utils.NATIVE_PREFIX + 'contains'](this)) {\n        return true;\n      }\n    } else if (ownerDocument.documentElement &&\n      ownerDocument.documentElement[utils.NATIVE_PREFIX + 'contains'](this)) {\n      return true;\n    }\n    // Slow path for non-distributed nodes.\n    let node = this;\n    while (node && !(node instanceof Document)) {\n      node = node[utils.SHADY_PREFIX + 'parentNode'] || (utils.isShadyRoot(node) ? /** @type {ShadowRoot} */(node).host : undefined);\n    }\n    return !!(node && node instanceof Document);\n  },\n\n  /** @this {Node} */\n  get textContent() {\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      let tc = [];\n      for (let i = 0, cn = this[utils.SHADY_PREFIX + 'childNodes'], c; (c = cn[i]); i++) {\n        if (c.nodeType !== Node.COMMENT_NODE) {\n          tc.push(c[utils.SHADY_PREFIX + 'textContent']);\n        }\n      }\n      return tc.join('');\n    } else {\n      return this[utils.NATIVE_PREFIX + 'textContent'];\n    }\n  },\n\n  /**\n   * @this {Node}\n   * @param {string} value\n   */\n  set textContent(value) {\n    if (typeof value === 'undefined' || value === null) {\n      value = ''\n    }\n    switch (this.nodeType) {\n      case Node.ELEMENT_NODE:\n      case Node.DOCUMENT_FRAGMENT_NODE:\n        if (!utils.isTrackingLogicalChildNodes(this) && utils.settings.hasDescriptors) {\n          // may be removing a nested slot but fast path if we know we are not.\n          const firstChild = this[utils.SHADY_PREFIX + 'firstChild'];\n          if (firstChild != this[utils.SHADY_PREFIX + 'lastChild'] ||\n            (firstChild && firstChild.nodeType != Node.TEXT_NODE)) {\n            clearNode(this);\n          }\n          this[utils.NATIVE_PREFIX + 'textContent'] = value;\n        } else {\n          clearNode(this);\n          // Document fragments must have no childNodes if setting a blank string\n          if (value.length > 0 || this.nodeType === Node.ELEMENT_NODE) {\n            this[utils.SHADY_PREFIX + 'insertBefore'](document.createTextNode(value))\n          }\n        }\n        break;\n      default:\n        // Note, be wary of patching `nodeValue`.\n        this.nodeValue = value;\n        break;\n    }\n  },\n\n  // Patched `insertBefore`. Note that all mutations that add nodes are routed\n  // here. When a <slot> is added or a node is added to a host with a shadowRoot\n  // with a slot, a standard dom `insert` call is aborted and `_asyncRender`\n  // is called on the relevant shadowRoot. In all other cases, a standard dom\n  // `insert` can be made, but the location and ref_node may need to be changed.\n  /**\n   * @this {Node}\n   * @param {Node} node\n   * @param {Node=} ref_node\n   */\n  insertBefore(node, ref_node) {\n    // optimization: assume native insertBefore is ok if the nodes are not in the document.\n    if (this.ownerDocument !== doc && node.ownerDocument !== doc) {\n      this[utils.NATIVE_PREFIX + 'insertBefore'](node, ref_node);\n      return node;\n    }\n    if (node === this) {\n      throw Error(`Failed to execute 'appendChild' on 'Node': The new child element contains the parent.`);\n    }\n    if (ref_node) {\n      const refData = shadyDataForNode(ref_node);\n      const p = refData && refData.parentNode;\n      if ((p !== undefined && p !== this) ||\n        (p === undefined && ref_node[utils.NATIVE_PREFIX + 'parentNode'] !== this)) {\n        throw Error(`Failed to execute 'insertBefore' on 'Node': The node ` +\n        `before which the new node is to be inserted is not a child of this node.`);\n      }\n    }\n    if (ref_node === node) {\n      return node;\n    }\n    /** @type {!Array<!HTMLSlotElement>} */\n    const slotsAdded = [];\n    const ownerRoot = ownerShadyRootForNode(this);\n    /** @type {string} */\n    const newScopeName = ownerRoot ? ownerRoot.host.localName : currentScopeForNode(this);\n    /** @type {string} */\n    let oldScopeName;\n    // remove from existing location\n    const parentNode = node[utils.SHADY_PREFIX + 'parentNode'];\n    if (parentNode) {\n      oldScopeName = currentScopeForNode(node);\n      parentNode[utils.SHADY_PREFIX + 'removeChild'](node,\n        Boolean(ownerRoot) || !ownerShadyRootForNode(node));\n    }\n    // add to new parent\n    let allowNativeInsert = true;\n    const needsScoping = (!preferPerformance || node['__noInsertionPoint'] === undefined) &&\n        !currentScopeIsCorrect(node, newScopeName);\n    const needsSlotFinding = ownerRoot && !node['__noInsertionPoint'] &&\n        (!preferPerformance || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE);\n    if (needsSlotFinding || needsScoping) {\n      // NOTE: avoid node.removeChild as this *can* trigger another patched\n      // method (e.g. custom elements) and we want only the shady method to run.\n      // The following table describes what style scoping actions should happen as a result of this insertion.\n      // document -> shadowRoot: replace\n      // shadowRoot -> shadowRoot: replace\n      // shadowRoot -> shadowRoot of same type: do nothing\n      // shadowRoot -> document: allow unscoping\n      // document -> document: do nothing\n      // The \"same type of shadowRoot\" and \"document to document cases rely on `currentScopeIsCorrect` returning true\n      if (needsScoping) {\n        // in a document or disconnected tree, replace scoping if necessary\n        oldScopeName = oldScopeName || currentScopeForNode(node);\n      }\n      treeVisitor(node, (node) => {\n        if (needsSlotFinding && node.localName === 'slot') {\n          slotsAdded.push(/** @type {!HTMLSlotElement} */(node));\n        }\n        if (needsScoping) {\n          replaceShadyScoping(node, newScopeName, oldScopeName);\n        }\n      });\n    }\n    // if a slot is added, must render containing root.\n    if (this.localName === 'slot' || slotsAdded.length) {\n      if (slotsAdded.length) {\n        ownerRoot._addSlots(slotsAdded);\n      }\n      if (ownerRoot) {\n        ownerRoot._asyncRender();\n      }\n    }\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      recordInsertBefore(node, this, ref_node);\n      // when inserting into a host with a shadowRoot with slot, use\n      // `shadowRoot._asyncRender()` via `attach-shadow` module\n      const parentData = shadyDataForNode(this);\n      if (utils.hasShadowRootWithSlot(this)) {\n        parentData.root._asyncRender();\n        allowNativeInsert = false;\n      // when inserting into a host with shadowRoot with NO slot, do nothing\n      // as the node should not be added to composed dome anywhere.\n      } else if (parentData.root) {\n        allowNativeInsert = false;\n      }\n    }\n    if (allowNativeInsert) {\n      // if adding to a shadyRoot, add to host instead\n      let container = utils.isShadyRoot(this) ?\n        /** @type {ShadowRoot} */(this).host : this;\n      // if ref_node, get the ref_node that's actually in composed dom.\n      if (ref_node) {\n        ref_node = firstComposedNode(ref_node);\n        container[utils.NATIVE_PREFIX + 'insertBefore'](node, ref_node);\n      } else {\n        container[utils.NATIVE_PREFIX + 'appendChild'](node);\n      }\n    // Since ownerDocument is not patched, it can be incorrect after this call\n    // if the node is physically appended via distribution. This can result\n    // in the custom elements polyfill not upgrading the node if it's in an inert doc.\n    // We correct this by calling `adoptNode`.\n    } else if (node.ownerDocument !== this.ownerDocument) {\n      this.ownerDocument.adoptNode(node);\n    }\n    scheduleObserver(this, node);\n    return node;\n  },\n\n  /**\n   * @this {Node}\n   * @param {Node} node\n   */\n  appendChild(node) {\n    return this[utils.SHADY_PREFIX + 'insertBefore'](node);\n  },\n\n  /**\n   * Patched `removeChild`. Note that all dom \"removals\" are routed here.\n   * Removes the given `node` from the element's `children`.\n   * This method also performs dom composition.\n   * @this {Node}\n   * @param {Node} node\n   * @param {boolean=} skipUnscoping\n   */\n  removeChild(node, skipUnscoping = false) {\n    if (this.ownerDocument !== doc) {\n      return this[utils.NATIVE_PREFIX + 'removeChild'](node);\n    }\n    if (node[utils.SHADY_PREFIX + 'parentNode'] !== this) {\n      throw Error('The node to be removed is not a child of this node: ' +\n        node);\n    }\n    let preventNativeRemove;\n    let ownerRoot = ownerShadyRootForNode(node);\n    const removingInsertionPoint = ownerRoot && ownerRoot._removeContainedSlots(node);\n    const parentData = shadyDataForNode(this);\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      recordRemoveChild(node, this);\n      if (utils.hasShadowRootWithSlot(this)) {\n        parentData.root._asyncRender();\n        preventNativeRemove = true;\n      }\n    }\n    // unscope a node leaving a ShadowRoot if ShadyCSS is present, and this node\n    // is not going to be rescoped in `insertBefore`\n    if (getScopingShim() && !skipUnscoping && ownerRoot) {\n      const oldScopeName = currentScopeForNode(node);\n      treeVisitor(node, (node) => {\n        removeShadyScoping(node, oldScopeName);\n      });\n    }\n    removeOwnerShadyRoot(node);\n    // if removing slot, must render containing root\n    if (ownerRoot) {\n      let changeSlotContent = this && this.localName === 'slot';\n      if (changeSlotContent) {\n        preventNativeRemove = true;\n      }\n      if (removingInsertionPoint || changeSlotContent) {\n        ownerRoot._asyncRender();\n      }\n    }\n    if (!preventNativeRemove) {\n      // if removing from a shadyRoot, remove from host instead\n      let container = utils.isShadyRoot(this) ?\n        /** @type {ShadowRoot} */(this).host :\n        this;\n      // not guaranteed to physically be in container; e.g.\n      // (1) if parent has a shadyRoot, element may or may not at distributed\n      // location (could be undistributed)\n      // (2) if parent is a slot, element may not ben in composed dom\n      if (!(parentData.root || node.localName === 'slot') ||\n        (container === node[utils.NATIVE_PREFIX + 'parentNode'])) {\n        container[utils.NATIVE_PREFIX + 'removeChild'](node);\n      }\n    }\n    scheduleObserver(this, null, node);\n    return node;\n  },\n\n  /**\n   * @this {Node}\n   * @param {Node} node\n   * @param {Node=} ref_node\n   */\n  replaceChild(node, ref_node) {\n    this[utils.SHADY_PREFIX + 'insertBefore'](node, ref_node);\n    this[utils.SHADY_PREFIX + 'removeChild'](ref_node);\n    return node;\n  },\n\n  /**\n   * @this {Node}\n   * @param {boolean=} deep\n   */\n  cloneNode(deep) {\n    if (this.localName == 'template') {\n      return this[utils.NATIVE_PREFIX + 'cloneNode'](deep);\n    } else {\n      const n = this[utils.NATIVE_PREFIX + 'cloneNode'](false);\n      // Attribute nodes historically had childNodes, but they have later\n      // been removed from the spec.\n      // Make sure we do not do a deep clone on them for old browsers (IE11)\n      if (deep && n.nodeType !== Node.ATTRIBUTE_NODE) {\n        let c$ = this[utils.SHADY_PREFIX + 'childNodes'];\n        for (let i=0, nc; i < c$.length; i++) {\n          nc = c$[i][utils.SHADY_PREFIX + 'cloneNode'](true);\n          n[utils.SHADY_PREFIX + 'appendChild'](nc);\n        }\n      }\n      return n;\n    }\n  },\n\n  /**\n   * @this {Node}\n   * @param {Object=} options\n   */\n  // TODO(sorvell): implement `options` e.g. `{ composed: boolean }`\n  getRootNode(options) { // eslint-disable-line no-unused-vars\n    if (!this || !this.nodeType) {\n      return;\n    }\n    const nodeData = ensureShadyDataForNode(this);\n    let root = nodeData.ownerShadyRoot;\n    if (root === undefined) {\n      if (utils.isShadyRoot(this)) {\n        root = this;\n        nodeData.ownerShadyRoot = root;\n      } else {\n        let parent = this[utils.SHADY_PREFIX + 'parentNode'];\n        root = parent ? parent[utils.SHADY_PREFIX + 'getRootNode'](options) : this;\n        // memo-ize result for performance but only memo-ize\n        // result if node is in the document. This avoids a problem where a root\n        // can be cached while an element is inside a fragment.\n        // If this happens and we cache the result, the value can become stale\n        // because for perf we avoid processing the subtree of added fragments.\n        if (document.documentElement[utils.NATIVE_PREFIX + 'contains'](this)) {\n          nodeData.ownerShadyRoot = root;\n        }\n      }\n\n    }\n    return root;\n  },\n\n  /** @this {Node} */\n  contains(node) {\n    return utils.contains(this, node);\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 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 {calculateSplices} from './array-splice.js';\nimport * as utils from './utils.js';\nimport {enqueue} from './flush.js';\nimport {ensureShadyDataForNode, shadyDataForNode} from './shady-data.js';\nimport {recordChildNodes} from './link-nodes.js';\nimport {patchShadyRoot} from './patch-shadyRoot.js';\n\n// Do not export this object. It must be passed as the first argument to the\n// ShadyRoot constructor in `attachShadow` to prevent the constructor from\n// throwing. This prevents the user from being able to manually construct a\n// ShadyRoot (i.e. `new ShadowRoot()`).\nconst ShadyRootConstructionToken = {};\n\nconst CATCHALL_NAME = '__catchall';\nconst SHADYROOT_NAME = 'ShadyRoot';\n\nconst MODE_CLOSED = 'closed';\n\nlet isRendering = utils.settings['deferConnectionCallbacks'] && document.readyState === 'loading';\nlet rootRendered;\n\nfunction ancestorList(node) {\n  let ancestors = [];\n  do {\n    ancestors.unshift(node);\n  } while ((node = node[utils.SHADY_PREFIX + 'parentNode']));\n  return ancestors;\n}\n\n/**\n * @extends {ShadowRoot}\n */\nclass ShadyRoot {\n\n  constructor(token, host, options) {\n    if (token !== ShadyRootConstructionToken) {\n      throw new TypeError('Illegal constructor');\n    }\n    // NOTE: set a fake local name so this element can be\n    // distinguished from a DocumentFragment when patching.\n    // FF doesn't allow this to be `localName`\n    this._localName = SHADYROOT_NAME;\n    // root <=> host\n    this.host = host;\n    /** @type {!string|undefined} */\n    this.mode = options && options.mode;\n    recordChildNodes(host);\n    const hostData = ensureShadyDataForNode(host);\n    /** @type {!ShadyRoot} */\n    hostData.root = this;\n    hostData.publicRoot = this.mode !== MODE_CLOSED ? this : null;\n    // setup root\n    const rootData = ensureShadyDataForNode(this);\n    rootData.firstChild = rootData.lastChild =\n        rootData.parentNode = rootData.nextSibling =\n        rootData.previousSibling = null;\n    rootData.childNodes = [];\n    // state flags\n    this._renderPending = false;\n    this._hasRendered = false;\n    // marsalled lazily\n    this._slotList = null;\n    /** @type {Object<string, Array<HTMLSlotElement>>} */\n    this._slotMap = null;\n    this._pendingSlots = null;\n    // NOTE: optimization flag, only require an asynchronous render\n    // to record parsed children if flag is not set.\n    if (utils.settings['preferPerformance']) {\n      let n;\n      while ((n = host[utils.NATIVE_PREFIX + 'firstChild'])) {\n        host[utils.NATIVE_PREFIX + 'removeChild'](n);\n      }\n    } else {\n      this._asyncRender();\n    }\n  }\n\n  _asyncRender() {\n    if (!this._renderPending) {\n      this._renderPending = true;\n      enqueue(() => this._render());\n    }\n  }\n\n  // returns the oldest renderPending ancestor root.\n  _getPendingDistributionRoot() {\n    let renderRoot;\n    let root = this;\n    while (root) {\n      if (root._renderPending) {\n        renderRoot = root;\n      }\n      root = root._getDistributionParent();\n    }\n    return renderRoot;\n  }\n\n  // Returns the shadyRoot `this.host` if `this.host`\n  // has children that require distribution.\n  _getDistributionParent() {\n    let root = this.host[utils.SHADY_PREFIX + 'getRootNode']();\n    if (!utils.isShadyRoot(root)) {\n      return;\n    }\n    const nodeData = shadyDataForNode(this.host);\n    if (nodeData && nodeData.__childSlotCount > 0) {\n      return root;\n    }\n  }\n\n  // Renders the top most render pending shadowRoot in the distribution tree.\n  // This is safe because when a distribution parent renders, all children render.\n  _render() {\n    // If this root is not pending, it needs no rendering work. Any pending\n    // parent that needs to render wll cause this root to render.\n    const root = this._renderPending && this._getPendingDistributionRoot();\n    if (root) {\n      root._renderSelf();\n    }\n  }\n\n  _flushInitial() {\n    if (!this._hasRendered && this._renderPending) {\n      this._render();\n    }\n  }\n\n  /** @override */\n  _renderSelf() {\n    // track rendering state.\n    const wasRendering = isRendering;\n    isRendering = true;\n    this._renderPending = false;\n    if (this._slotList) {\n      this._distribute();\n      this._compose();\n    }\n    // NOTE: optimization flag, only process parsed children\n    // if optimization flag is not set.\n    // on initial render remove any undistributed children.\n    if (!utils.settings['preferPerformance'] && !this._hasRendered) {\n      const c$ = this.host[utils.SHADY_PREFIX + 'childNodes'];\n      for (let i=0, l=c$.length; i < l; i++) {\n        const child = c$[i];\n        const data = shadyDataForNode(child);\n        if (child[utils.NATIVE_PREFIX + 'parentNode'] === this.host &&\n            (child.localName === 'slot' || !data.assignedSlot)) {\n          this.host[utils.NATIVE_PREFIX + 'removeChild'](child);\n        }\n      }\n    }\n    this._hasRendered = true;\n    isRendering = wasRendering;\n    if (rootRendered) {\n      rootRendered();\n    }\n  }\n\n  _distribute() {\n    this._validateSlots();\n    // capture # of previously assigned nodes to help determine if dirty.\n    for (let i=0, slot; i < this._slotList.length; i++) {\n      slot = this._slotList[i];\n      this._clearSlotAssignedNodes(slot);\n    }\n    // distribute host children.\n    for (let n=this.host[utils.SHADY_PREFIX + 'firstChild']; n; n=n[utils.SHADY_PREFIX + 'nextSibling']) {\n      this._distributeNodeToSlot(n);\n    }\n    // fallback content, slotchange, and dirty roots\n    for (let i=0; i < this._slotList.length; i++) {\n      const slot = this._slotList[i];\n      const slotData = shadyDataForNode(slot);\n      // distribute fallback content\n      if (!slotData.assignedNodes.length) {\n        for (let n=slot[utils.SHADY_PREFIX + 'firstChild']; n; n=n[utils.SHADY_PREFIX + 'nextSibling']) {\n          this._distributeNodeToSlot(n, slot);\n        }\n      }\n      const slotParentData = shadyDataForNode(slot[utils.SHADY_PREFIX + 'parentNode']);\n      const slotParentRoot = slotParentData && slotParentData.root;\n      if (slotParentRoot && (slotParentRoot._hasInsertionPoint() || slotParentRoot._renderPending)) {\n        slotParentRoot._renderSelf();\n      }\n      this._addAssignedToFlattenedNodes(slotData.flattenedNodes,\n        slotData.assignedNodes);\n      let prevAssignedNodes = slotData._previouslyAssignedNodes;\n      if (prevAssignedNodes) {\n        for (let i=0; i < prevAssignedNodes.length; i++) {\n          shadyDataForNode(prevAssignedNodes[i])._prevAssignedSlot = null;\n        }\n        slotData._previouslyAssignedNodes = null;\n        // dirty if previously less assigned nodes than previously assigned.\n        if (prevAssignedNodes.length > slotData.assignedNodes.length) {\n          slotData.dirty = true;\n        }\n      }\n      /* Note: A slot is marked dirty whenever a node is newly assigned to it\n      or a node is assigned to a different slot (done in `_distributeNodeToSlot`)\n      or if the number of nodes assigned to the slot has decreased (done above);\n      */\n      if (slotData.dirty) {\n        slotData.dirty = false;\n        this._fireSlotChange(slot);\n      }\n    }\n  }\n\n  /**\n   * Distributes given `node` to the appropriate slot based on its `slot`\n   * attribute. If `forcedSlot` is given, then the node is distributed to the\n   * `forcedSlot`.\n   * Note: slot to which the node is assigned will be marked dirty for firing\n   * `slotchange`.\n   * @param {Node} node\n   * @param {Node=} forcedSlot\n   *\n   */\n  _distributeNodeToSlot(node, forcedSlot) {\n    const nodeData = ensureShadyDataForNode(node);\n    let oldSlot = nodeData._prevAssignedSlot;\n    nodeData._prevAssignedSlot = null;\n    let slot = forcedSlot;\n    if (!slot) {\n      let name = node[utils.SHADY_PREFIX + 'slot'] || CATCHALL_NAME;\n      const list = this._slotMap[name];\n      slot = list && list[0];\n    }\n    if (slot) {\n      const slotData = ensureShadyDataForNode(slot);\n      slotData.assignedNodes.push(node);\n      nodeData.assignedSlot = slot;\n    } else {\n      nodeData.assignedSlot = undefined;\n    }\n    if (oldSlot !== nodeData.assignedSlot) {\n      if (nodeData.assignedSlot) {\n        ensureShadyDataForNode(nodeData.assignedSlot).dirty = true;\n      }\n    }\n  }\n\n  /**\n   * Clears the assignedNodes tracking data for a given `slot`. Note, the current\n   * assigned node data is tracked (via _previouslyAssignedNodes and\n   * _prevAssignedSlot) to see if `slotchange` should fire. This data may be out\n   *  of date at this time because the assigned nodes may have already been\n   * distributed to another root. This is ok since this data is only used to\n   * track changes.\n   * @param {HTMLSlotElement} slot\n   */\n  _clearSlotAssignedNodes(slot) {\n    const slotData = shadyDataForNode(slot);\n    let n$ = slotData.assignedNodes;\n    slotData.assignedNodes = [];\n    slotData.flattenedNodes = [];\n    slotData._previouslyAssignedNodes = n$;\n    if (n$) {\n      for (let i=0; i < n$.length; i++) {\n        let n = shadyDataForNode(n$[i]);\n        n._prevAssignedSlot = n.assignedSlot;\n        // only clear if it was previously set to this slot;\n        // this helps ensure that if the node has otherwise been distributed\n        // ignore it.\n        if (n.assignedSlot === slot) {\n          n.assignedSlot = null;\n        }\n      }\n    }\n  }\n\n  _addAssignedToFlattenedNodes(flattened, assigned) {\n    for (let i=0, n; (i<assigned.length) && (n=assigned[i]); i++) {\n      if (n.localName == 'slot') {\n        const nestedAssigned = shadyDataForNode(n).assignedNodes;\n        if (nestedAssigned && nestedAssigned.length) {\n          this._addAssignedToFlattenedNodes(flattened, nestedAssigned);\n        }\n      } else {\n        flattened.push(assigned[i]);\n      }\n    }\n  }\n\n  _fireSlotChange(slot) {\n    // NOTE: cannot bubble correctly here so not setting bubbles: true\n    // Safari tech preview does not bubble but chrome does\n    // Spec says it bubbles (https://dom.spec.whatwg.org/#mutation-observers)\n    slot[utils.NATIVE_PREFIX + 'dispatchEvent'](new Event('slotchange'));\n    const slotData = shadyDataForNode(slot);\n    if (slotData.assignedSlot) {\n      this._fireSlotChange(slotData.assignedSlot);\n    }\n  }\n\n  // Reify dom such that it is at its correct rendering position\n  // based on logical distribution.\n  // NOTE: here we only compose parents of <slot> elements and not the\n  // shadowRoot into the host. The latter is performend via a fast path\n  // in the `logical-mutation`.insertBefore.\n  _compose() {\n    const slots = this._slotList;\n    let composeList = [];\n    for (let i=0; i < slots.length; i++) {\n      const parent = slots[i][utils.SHADY_PREFIX + 'parentNode'];\n      /* compose node only if:\n        (1) parent does not have a shadowRoot since shadowRoot has already\n        composed into the host\n        (2) we're not already composing it\n        [consider (n^2) but rare better than Set]\n      */\n      const parentData = shadyDataForNode(parent);\n      if (!(parentData && parentData.root) &&\n        composeList.indexOf(parent) < 0) {\n        composeList.push(parent);\n      }\n    }\n    for (let i=0; i < composeList.length; i++) {\n      const node = composeList[i];\n      const targetNode = node === this ? this.host : node;\n      this._updateChildNodes(targetNode, this._composeNode(node));\n    }\n  }\n\n  // Returns the list of nodes which should be rendered inside `node`.\n  _composeNode(node) {\n    let children = [];\n    let c$ = node[utils.SHADY_PREFIX + 'childNodes'];\n    for (let i = 0; i < c$.length; i++) {\n      let child = c$[i];\n      // Note: if we see a slot here, the nodes are guaranteed to need to be\n      // composed here. This is because if there is redistribution, it has\n      // already been handled by this point.\n      if (this._isInsertionPoint(child)) {\n        let flattenedNodes = shadyDataForNode(child).flattenedNodes;\n        for (let j = 0; j < flattenedNodes.length; j++) {\n          let distributedNode = flattenedNodes[j];\n            children.push(distributedNode);\n        }\n      } else {\n        children.push(child);\n      }\n    }\n    return children;\n  }\n\n  _isInsertionPoint(node) {\n      return node.localName == 'slot';\n    }\n\n  // Ensures that the rendered node list inside `container` is `children`.\n  _updateChildNodes(container, children) {\n    let composed = Array.prototype.slice.call(container[utils.NATIVE_PREFIX + 'childNodes']);\n    let splices = calculateSplices(children, composed);\n    // process removals\n    for (let i=0, d=0, s; (i<splices.length) && (s=splices[i]); i++) {\n      for (let j=0, n; (j < s.removed.length) && (n=s.removed[j]); j++) {\n        // check if the node is still where we expect it is before trying\n        // to remove it; this can happen if we move a node and\n        // then schedule its previous host for distribution resulting in\n        // the node being removed here.\n        if (n[utils.NATIVE_PREFIX + 'parentNode'] === container) {\n          container[utils.NATIVE_PREFIX + 'removeChild'](n);\n        }\n        // TODO(sorvell): avoid the need for splicing here.\n        composed.splice(s.index + d, 1);\n      }\n      d -= s.addedCount;\n    }\n    // process adds\n    for (let i=0, s, next; (i<splices.length) && (s=splices[i]); i++) { //eslint-disable-line no-redeclare\n      next = composed[s.index];\n      for (let j=s.index, n; j < s.index + s.addedCount; j++) {\n        n = children[j];\n        container[utils.NATIVE_PREFIX + 'insertBefore'](n, next);\n        composed.splice(j, 0, n);\n      }\n    }\n  }\n\n  _ensureSlotData() {\n    this._pendingSlots = this._pendingSlots || [];\n    this._slotList = this._slotList || [];\n    this._slotMap = this._slotMap || {};\n  }\n\n  _addSlots(slots) {\n    this._ensureSlotData();\n    this._pendingSlots.push(...slots);\n  }\n\n  _validateSlots() {\n    if (this._pendingSlots && this._pendingSlots.length) {\n      this._mapSlots(this._pendingSlots);\n      this._pendingSlots = [];\n    }\n  }\n\n  /**\n   * Adds the given slots. Slots are maintained in an dom-ordered list.\n   * In addition a map of name to slot is updated.\n   */\n  _mapSlots(slots) {\n    let slotNamesToSort;\n    for (let i=0; i < slots.length; i++) {\n      const slot = slots[i];\n      // ensure insertionPoints's and their parents have logical dom info.\n      // save logical tree info\n      // a. for shadyRoot\n      // b. for insertion points (fallback)\n      // c. for parents of insertion points\n      recordChildNodes(slot);\n      const slotParent = slot[utils.SHADY_PREFIX + 'parentNode'];\n      recordChildNodes(slotParent);\n      const slotParentData = shadyDataForNode(slotParent);\n      slotParentData.__childSlotCount = (slotParentData.__childSlotCount || 0) + 1;\n      let name = this._nameForSlot(slot);\n      if (this._slotMap[name]) {\n        slotNamesToSort = slotNamesToSort || {};\n        slotNamesToSort[name] = true;\n        this._slotMap[name].push(slot);\n      } else {\n        this._slotMap[name] = [slot];\n      }\n      this._slotList.push(slot);\n    }\n    if (slotNamesToSort) {\n      for (let n in slotNamesToSort) {\n        this._slotMap[n] = this._sortSlots(this._slotMap[n]);\n      }\n    }\n  }\n\n  _nameForSlot(slot) {\n    const name = slot['name'] || slot.getAttribute('name') || CATCHALL_NAME;\n    slot.__slotName = name;\n    return name;\n  }\n\n  /**\n   * Slots are kept in an ordered list. Slots with the same name\n   * are sorted here by tree order.\n   */\n  _sortSlots(slots) {\n    // NOTE: Cannot use `compareDocumentPosition` because it's not polyfilled,\n    // but the code here could be used to polyfill the preceeding/following info\n    // in `compareDocumentPosition`.\n    return slots.sort((a, b) => {\n      let listA = ancestorList(a);\n      let listB = ancestorList(b);\n      for (var i=0; i < listA.length; i++) {\n        let nA = listA[i];\n        let nB = listB[i];\n        if (nA !== nB) {\n          let c$ = Array.from(nA[utils.SHADY_PREFIX + 'parentNode'][utils.SHADY_PREFIX + 'childNodes']);\n          return c$.indexOf(nA) - c$.indexOf(nB);\n        }\n      }\n    });\n  }\n\n  /**\n   * Removes from tracked slot data any slots contained within `container` and\n   * then updates the tracked data (_slotList and _slotMap).\n   * Any removed slots also have their `assignedNodes` removed from comopsed dom.\n   */\n  _removeContainedSlots(container) {\n    if (!this._slotList) {\n      return;\n    }\n    this._validateSlots();\n    let didRemove;\n    const map = this._slotMap;\n    for (let n in map) {\n      const slots = map[n];\n      for (let i=0; i < slots.length; i++) {\n        const slot = slots[i];\n        if (utils.contains(container, slot)) {\n          slots.splice(i, 1);\n          const x = this._slotList.indexOf(slot);\n          if (x >= 0) {\n            this._slotList.splice(x, 1);\n            const slotParentData = shadyDataForNode(slot[utils.SHADY_PREFIX + 'parentNode']);\n            if (slotParentData && slotParentData.__childSlotCount) {\n              slotParentData.__childSlotCount--;\n            }\n          }\n          i--;\n          this._removeFlattenedNodes(slot);\n          didRemove = true;\n        }\n      }\n    }\n    return didRemove;\n  }\n\n  _updateSlotName(slot) {\n    if (!this._slotList) {\n      return;\n    }\n    // make sure slotMap is initialized with this slot\n    this._validateSlots();\n    const oldName = slot.__slotName;\n    const name = this._nameForSlot(slot);\n    if (name === oldName) {\n      return;\n    }\n    // remove from existing tracking\n    let slots = this._slotMap[oldName];\n    const i = slots.indexOf(slot);\n    if (i >= 0) {\n      slots.splice(i, 1);\n    }\n    // add to new location and sort if nedessary\n    let list = this._slotMap[name] || (this._slotMap[name] = []);\n    list.push(slot);\n    if (list.length > 1) {\n      this._slotMap[name] = this._sortSlots(list);\n    }\n  }\n\n  _removeFlattenedNodes(slot) {\n    const data = shadyDataForNode(slot);\n    let n$ = data.flattenedNodes;\n    if (n$) {\n      for (let i=0; i<n$.length; i++) {\n        let node = n$[i];\n        let parent = node[utils.NATIVE_PREFIX + 'parentNode'];\n        if (parent) {\n          parent[utils.NATIVE_PREFIX + 'removeChild'](node);\n        }\n      }\n    }\n    data.flattenedNodes = [];\n    data.assignedNodes = [];\n  }\n\n  _hasInsertionPoint() {\n    this._validateSlots();\n    return Boolean(this._slotList && this._slotList.length);\n  }\n}\n\npatchShadyRoot(ShadyRoot.prototype);\nexport {ShadyRoot};\n\n/**\n  Implements a pared down version of ShadowDOM's scoping, which is easy to\n  polyfill across browsers.\n*/\nexport const attachShadow = (host, options) => {\n  if (!host) {\n    throw new Error('Must provide a host.');\n  }\n  if (!options) {\n    throw new Error('Not enough arguments.');\n  }\n  return new ShadyRoot(ShadyRootConstructionToken, host, options);\n}\n\n// Mitigate connect/disconnect spam by wrapping custom element classes.\nif (window['customElements'] && utils.settings.inUse && !utils.settings['preferPerformance']) {\n\n  // process connect/disconnect after roots have rendered to avoid\n  // issues with reaction stack.\n  let connectMap = new Map();\n  rootRendered = function() {\n    // allow elements to connect\n    // save map state (without needing polyfills on IE11)\n    const r = [];\n    connectMap.forEach((v, k) => {\n      r.push([k, v]);\n    });\n    connectMap.clear();\n    for (let i=0; i < r.length; i++) {\n      const e = r[i][0], value = r[i][1];\n      if (value) {\n        e.__shadydom_connectedCallback();\n      } else {\n        e.__shadydom_disconnectedCallback();\n      }\n    }\n  }\n\n  // Document is in loading state and flag is set (deferConnectionCallbacks)\n  // so process connection stack when `readystatechange` fires.\n  if (isRendering) {\n    document.addEventListener('readystatechange', () => {\n      isRendering = false;\n      rootRendered();\n    }, {once: true});\n  }\n\n  /*\n   * (1) elements can only be connected/disconnected if they are in the expected\n   * state.\n   * (2) never run connect/disconnect during rendering to avoid reaction stack issues.\n   */\n  const ManageConnect = (base, connected, disconnected) => {\n    let counter = 0;\n    const connectFlag = `__isConnected${counter++}`;\n    if (connected || disconnected) {\n\n      /** @this {!HTMLElement} */\n      base.prototype.connectedCallback = base.prototype.__shadydom_connectedCallback = function() {\n        // if rendering defer connected\n        // otherwise connect only if we haven't already\n        if (isRendering) {\n          connectMap.set(this, true);\n        } else if (!this[connectFlag]) {\n          this[connectFlag] = true;\n          if (connected) {\n            connected.call(this);\n          }\n        }\n      }\n\n      /** @this {!HTMLElement} */\n      base.prototype.disconnectedCallback = base.prototype.__shadydom_disconnectedCallback = function() {\n        // if rendering, cancel a pending connection and queue disconnect,\n        // otherwise disconnect only if a connection has been allowed\n        if (isRendering) {\n          // This is necessary only because calling removeChild\n          // on a node that requires distribution leaves it in the DOM tree\n          // until distribution.\n          // NOTE: remember this is checking the patched isConnected to determine\n          // if the node is in the logical tree.\n          if (!this.isConnected) {\n            connectMap.set(this, false);\n          }\n        } else if (this[connectFlag]) {\n          this[connectFlag] = false;\n          if (disconnected) {\n            disconnected.call(this);\n          }\n        }\n      }\n    }\n\n    return base;\n  }\n\n  const define = window['customElements']['define'];\n  // NOTE: Instead of patching customElements.define,\n  // re-define on the CustomElementRegistry.prototype.define\n  // for Safari 10 compatibility (it's flakey otherwise).\n  Object.defineProperty(window['CustomElementRegistry'].prototype, 'define', {\n    value: function(name, constructor) {\n      const connected = constructor.prototype.connectedCallback;\n      const disconnected = constructor.prototype.disconnectedCallback;\n      define.call(window['customElements'], name,\n          ManageConnect(constructor, connected, disconnected));\n      // unpatch connected/disconnected on class; custom elements tears this off\n      // so the patch is maintained, but if the user calls these methods for\n      // e.g. testing, they will be as expected.\n      constructor.prototype.connectedCallback = connected;\n      constructor.prototype.disconnectedCallback = disconnected;\n    }\n  });\n\n}\n\n/** @return {!ShadyRoot|undefined} */\nexport const ownerShadyRootForNode = (node) => {\n  let root = node[utils.SHADY_PREFIX + 'getRootNode']();\n  if (utils.isShadyRoot(root)) {\n    return root;\n  }\n}\n",null,"/**\n@license\nCopyright (c) 2016 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 * as utils from '../utils.js';\nimport {shadyDataForNode} from '../shady-data.js';\n\n/**\n * @param {Node} node\n * @param {Function} matcher\n * @param {Function=} halter\n */\nexport function query(node, matcher, halter) {\n  let list = [];\n  queryElements(node[utils.SHADY_PREFIX + 'childNodes'], matcher,\n    halter, list);\n  return list;\n}\n\nfunction queryElements(elements, matcher, halter, list) {\n  for (let i=0, l=elements.length, c; (i<l) && (c=elements[i]); i++) {\n    if (c.nodeType === Node.ELEMENT_NODE &&\n        queryElement(c, matcher, halter, list)) {\n      return true;\n    }\n  }\n}\n\nfunction queryElement(node, matcher, halter, list) {\n  let result = matcher(node);\n  if (result) {\n    list.push(node);\n  }\n  if (halter && halter(result)) {\n    return result;\n  }\n  queryElements(node[utils.SHADY_PREFIX + 'childNodes'], matcher,\n    halter, list);\n}\n\n// Needed on Element, DocumentFragment, Document\nexport const ParentNodePatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Element} */\n  get firstElementChild() {\n    const nodeData = shadyDataForNode(this);\n    if (nodeData && nodeData.firstChild !== undefined) {\n      let n = this[utils.SHADY_PREFIX + 'firstChild'];\n      while (n && n.nodeType !== Node.ELEMENT_NODE) {\n        n = n[utils.SHADY_PREFIX + 'nextSibling'];\n      }\n      return n;\n    } else {\n      return this[utils.NATIVE_PREFIX + 'firstElementChild'];\n    }\n  },\n\n  /** @this {Element} */\n  get lastElementChild() {\n    const nodeData = shadyDataForNode(this);\n    if (nodeData && nodeData.lastChild !== undefined) {\n      let n = this[utils.SHADY_PREFIX + 'lastChild'];\n      while (n && n.nodeType !== Node.ELEMENT_NODE) {\n        n = n[utils.SHADY_PREFIX + 'previousSibling'];\n      }\n      return n;\n    } else {\n      return this[utils.NATIVE_PREFIX + 'lastElementChild'];\n    }\n  },\n\n  /** @this {Element} */\n  get children() {\n    if (!utils.isTrackingLogicalChildNodes(this)) {\n      return this[utils.NATIVE_PREFIX + 'children'];\n    }\n    return utils.createPolyfilledHTMLCollection(Array.prototype.filter.call(\n        this[utils.SHADY_PREFIX + 'childNodes'], function(n) {\n      return (n.nodeType === Node.ELEMENT_NODE);\n    }));\n  },\n\n  /** @this {Element} */\n  get childElementCount() {\n    let children = this[utils.SHADY_PREFIX + 'children'];\n    if(children) {\n      return children.length;\n    }\n    return 0;\n  }\n\n});\n\nexport const QueryPatches = utils.getOwnPropertyDescriptors({\n  // TODO(sorvell): consider doing native QSA and filtering results.\n  /**\n   * @this {Element}\n   * @param  {string} selector\n   */\n  querySelector(selector) {\n    // match selector and halt on first result.\n    let result = query(this, function(n) {\n      return utils.matchesSelector(n, selector);\n    }, function(n) {\n      return Boolean(n);\n    })[0];\n    return result || null;\n  },\n\n  /**\n   * @this {Element}\n   * @param  {string} selector\n   * @param  {boolean} useNative\n   */\n  // TODO(sorvell): `useNative` option relies on native querySelectorAll and\n  // misses distributed nodes, see\n  // https://github.com/webcomponents/shadydom/pull/210#issuecomment-361435503\n  querySelectorAll(selector, useNative) {\n    if (useNative) {\n      const o = Array.prototype.slice.call(this[utils.NATIVE_PREFIX + 'querySelectorAll'](selector));\n      const root = this[utils.SHADY_PREFIX + 'getRootNode']();\n      return o.filter(e => e[utils.SHADY_PREFIX + 'getRootNode']() == root);\n    }\n    return query(this, function(n) {\n      return utils.matchesSelector(n, selector);\n    });\n  }\n\n});\n\n// Create a custom `ParentNodeDocumentOrFragment` that optionally does not\n// mixin querySelector/All; this is a performance optimization.\nexport const ParentNodeDocumentOrFragmentPatches = utils.settings.preferPerformance ?\n  Object.assign({}, ParentNodePatches) : ParentNodePatches;\n\nObject.assign(ParentNodePatches, QueryPatches);","/**\n@license\nCopyright (c) 2016 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 * as utils from '../utils.js';\nimport { query } from './ParentNode.js';\n\nexport const DocumentOrFragmentPatches = utils.getOwnPropertyDescriptors({\n\n  /**\n   * @this {Element}\n   * @param {string} id\n   */\n  getElementById(id) {\n    if (id === '') {\n      return null;\n    }\n    let result = query(this, function(n) {\n      return n.id == id;\n    }, function(n) {\n      return Boolean(n);\n    })[0];\n    return result || null;\n  }\n\n});","/**\n@license\nCopyright (c) 2016 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 * as utils from '../utils.js';\nimport {ownerShadyRootForNode} from '../attach-shadow.js';\n\nfunction getDocumentActiveElement() {\n  if (utils.settings.hasDescriptors) {\n    return document[utils.NATIVE_PREFIX + 'activeElement'];\n  } else {\n    return document.activeElement;\n  }\n}\n\nexport const DocumentOrShadowRootPatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Document|ShadowRoot} */\n  get activeElement() {\n    let active = getDocumentActiveElement();\n    // In IE11, activeElement might be an empty object if the document is\n    // contained in an iframe.\n    // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/10998788/\n    if (!active || !active.nodeType) {\n      return null;\n    }\n    let isShadyRoot = !!(utils.isShadyRoot(this));\n    if (this !== document) {\n      // If this node isn't a document or shady root, then it doesn't have\n      // an active element.\n      if (!isShadyRoot) {\n        return null;\n      }\n      // If this shady root's host is the active element or the active\n      // element is not a descendant of the host (in the composed tree),\n      // then it doesn't have an active element.\n      if (this.host === active ||\n          !this.host[utils.NATIVE_PREFIX + 'contains'](active)) {\n        return null;\n      }\n    }\n    // This node is either the document or a shady root of which the active\n    // element is a (composed) descendant of its host; iterate upwards to\n    // find the active element's most shallow host within it.\n    let activeRoot = ownerShadyRootForNode(active);\n    while (activeRoot && activeRoot !== this) {\n      active = activeRoot.host;\n      activeRoot = ownerShadyRootForNode(active);\n    }\n    if (this === document) {\n      // This node is the document, so activeRoot should be null.\n      return activeRoot ? null : active;\n    } else {\n      // This node is a non-document shady root, and it should be\n      // activeRoot.\n      return activeRoot === this ? active : null;\n    }\n  }\n});\n","/**\n@license\nCopyright (c) 2016 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 * as utils from '../utils.js';\nimport {getInnerHTML} from '../innerHTML.js';\nimport {clearNode} from './Node.js';\n\n/** @type {!Document} */\nconst inertDoc = document.implementation.createHTMLDocument('inert');\n\nexport const ElementOrShadowRootPatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Element} */\n  get innerHTML() {\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      const content = this.localName === 'template' ?\n      /** @type {HTMLTemplateElement} */(this).content : this;\n      return getInnerHTML(content, (e) => e[utils.SHADY_PREFIX + 'childNodes']);\n    } else {\n      return this[utils.NATIVE_PREFIX + 'innerHTML'];\n    }\n  },\n\n  /**\n   * @this {Element}\n   * @param {string} value\n   */\n  set innerHTML(value) {\n    if (this.localName === 'template') {\n      this[utils.NATIVE_PREFIX + 'innerHTML'] = value;\n    } else {\n      clearNode(this);\n      const containerName = this.localName || 'div';\n      let htmlContainer;\n      if (!this.namespaceURI || this.namespaceURI === inertDoc.namespaceURI) {\n        htmlContainer = inertDoc.createElement(containerName);\n      } else {\n        htmlContainer = inertDoc.createElementNS(this.namespaceURI, containerName);\n      }\n      if (utils.settings.hasDescriptors) {\n        htmlContainer[utils.NATIVE_PREFIX + 'innerHTML'] = value;\n      } else {\n        htmlContainer.innerHTML = value;\n      }\n      let firstChild;\n      while ((firstChild = htmlContainer[utils.SHADY_PREFIX + 'firstChild'])) {\n        this[utils.SHADY_PREFIX + 'insertBefore'](firstChild);\n      }\n    }\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 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 * as utils from '../utils.js';\n\nexport const ShadowRootPatches = utils.getOwnPropertyDescriptors({\n\n  /**\n   * @this {ShadowRoot}\n   * @param {string} type\n   * @param {Function} fn\n   * @param {Object|boolean=} optionsOrCapture\n   */\n  addEventListener(type, fn, optionsOrCapture) {\n    if (typeof optionsOrCapture !== 'object') {\n      optionsOrCapture = {\n        capture: Boolean(optionsOrCapture)\n      }\n    }\n    optionsOrCapture.__shadyTarget = this;\n    this.host[utils.SHADY_PREFIX + 'addEventListener'](type, fn, optionsOrCapture);\n  },\n\n  /**\n   * @this {ShadowRoot}\n   * @param {string} type\n   * @param {Function} fn\n   * @param {Object|boolean=} optionsOrCapture\n   */\n  removeEventListener(type, fn, optionsOrCapture) {\n    if (typeof optionsOrCapture !== 'object') {\n      optionsOrCapture = {\n        capture: Boolean(optionsOrCapture)\n      }\n    }\n    optionsOrCapture.__shadyTarget = this;\n    this.host[utils.SHADY_PREFIX + 'removeEventListener'](type, fn, optionsOrCapture);\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 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 * as utils from './utils.js';\nimport {NodePatches} from './patches/Node.js';\nimport {OutsideDescriptors, InsideDescriptors} from './patch-instances.js';\nimport {ParentNodePatches} from './patches/ParentNode.js';\nimport {DocumentOrFragmentPatches} from './patches/DocumentOrFragment.js';\nimport {DocumentOrShadowRootPatches} from './patches/DocumentOrShadowRoot.js';\nimport {ElementOrShadowRootPatches} from './patches/ElementOrShadowRoot.js';\nimport {ShadowRootPatches} from './patches/ShadowRoot.js';\n\n/**\n * @param {!Object} proto\n * @param {string=} prefix\n */\nconst patchShadyAccessors = (proto, prefix) => {\n  utils.patchProperties(proto, ShadowRootPatches, prefix);\n  utils.patchProperties(proto, DocumentOrShadowRootPatches, prefix);\n  utils.patchProperties(proto, ElementOrShadowRootPatches, prefix);\n  // We ensure ParentNode accessors since these do not exist in Edge/IE on DocumentFragments.\n  utils.patchProperties(proto, ParentNodePatches, prefix);\n  // Ensure `shadowRoot` has basic descriptors when we cannot rely\n  // on them coming from DocumentFragment.\n  //\n  // Case 1, noPatching: Because we want noPatch ShadyRoots to have native property\n  // names so that they do not have to be wrapped...\n  // When we do *not* patch Node/DocumentFragment.prototype\n  // we must manually install those properties on ShadyRoot's prototype.\n  // Note, it's important to only install these in this mode so as not to stomp\n  // over CustomElements polyfill's patches on Node/DocumentFragment methods.\n  if (utils.settings.noPatch && !prefix) {\n    utils.patchProperties(proto, NodePatches, prefix);\n    utils.patchProperties(proto, DocumentOrFragmentPatches, prefix);\n  // Case 2, bad descriptors: Ensure accessors are on ShadowRoot.\n  // These descriptors are normally used for instance patching but because\n  // ShadyRoot can always be patched, just do it to the prototype.\n  } else if (!utils.settings.hasDescriptors) {\n    utils.patchProperties(proto, OutsideDescriptors);\n    utils.patchProperties(proto, InsideDescriptors);\n  }\n}\n\nexport const patchShadyRoot = (proto) => {\n  proto.__proto__ = DocumentFragment.prototype;\n\n  // patch both prefixed and not, even when noPatch == true.\n  patchShadyAccessors(proto, utils.SHADY_PREFIX);\n  patchShadyAccessors(proto);\n\n  // Ensure native properties are all safely wrapped since ShadowRoot is not an\n  // actual DocumentFragment instance.\n  Object.defineProperties(proto, {\n    nodeType: {\n      value: Node.DOCUMENT_FRAGMENT_NODE,\n      configurable: true\n    },\n    nodeName: {\n      value: '#document-fragment',\n      configurable: true\n    },\n    nodeValue: {\n      value: null,\n      configurable: true\n    }\n  });\n\n  // make undefined\n  [\n    'localName',\n    'namespaceURI',\n    'prefix'\n  ].forEach((prop) => {\n    Object.defineProperty(proto, prop, {\n      value: undefined,\n      configurable: true\n    });\n  });\n\n  // defer properties to host\n  [\n    'ownerDocument',\n    'baseURI',\n    'isConnected'\n  ].forEach((prop) => {\n    Object.defineProperty(proto, prop, {\n      /** @this {ShadowRoot} */\n      get() {\n        return this.host[prop];\n      },\n      configurable: true\n    });\n  });\n}\n","/**\n@license\nCopyright (c) 2016 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 * as utils from './utils.js';\nimport {eventPropertyNames} from './patch-events.js';\n\n/** @implements {IWrapper} */\nclass Wrapper {\n\n  /** @param {!Node} node */\n  constructor(node) {\n    this.node = node;\n  }\n\n  // node\n  addEventListener(name, fn, options) {\n    return this.node[utils.SHADY_PREFIX + 'addEventListener'](name, fn, options);\n  }\n\n  removeEventListener(name, fn, options) {\n    return this.node[utils.SHADY_PREFIX + 'removeEventListener'](name, fn, options);\n  }\n\n  appendChild(node) {\n    return this.node[utils.SHADY_PREFIX + 'appendChild'](node);\n  }\n\n  insertBefore(node, ref_node) {\n    return this.node[utils.SHADY_PREFIX + 'insertBefore'](node, ref_node);\n  }\n\n  removeChild(node) {\n    return this.node[utils.SHADY_PREFIX + 'removeChild'](node);\n  }\n\n  replaceChild(node, ref_node) {\n    return this.node[utils.SHADY_PREFIX + 'replaceChild'](node, ref_node);\n  }\n\n  cloneNode(deep) {\n    return this.node[utils.SHADY_PREFIX + 'cloneNode'](deep);\n  }\n\n  getRootNode(options) {\n    return this.node[utils.SHADY_PREFIX + 'getRootNode'](options);\n  }\n\n  contains(node) {\n    return this.node[utils.SHADY_PREFIX + 'contains'](node);\n  }\n\n  dispatchEvent(event) {\n    return this.node[utils.SHADY_PREFIX + 'dispatchEvent'](event);\n  }\n\n  // element\n  setAttribute(name, value) {\n    this.node[utils.SHADY_PREFIX + 'setAttribute'](name, value);\n  }\n\n  // NOTE: not needed, just here for balance\n  getAttribute(name) {\n    return this.node[utils.NATIVE_PREFIX + 'getAttribute'](name);\n  }\n\n  // NOTE: not needed, just here for balance\n  hasAttribute(name) {\n    return this.node[utils.NATIVE_PREFIX + 'hasAttribute'](name);\n  }\n\n  removeAttribute(name) {\n    this.node[utils.SHADY_PREFIX + 'removeAttribute'](name);\n  }\n\n  attachShadow(options) {\n    return this.node[utils.SHADY_PREFIX + 'attachShadow'](options);\n  }\n\n  /** @return {!Node|undefined} */\n  get activeElement() {\n    if (utils.isShadyRoot(this.node) || this.node.nodeType === Node.DOCUMENT_NODE) {\n      const e = this.node[utils.SHADY_PREFIX + 'activeElement'];\n      return e;\n    }\n  }\n\n  /**\n   * Installed for compatibility with browsers (older Chrome/Safari) that do\n   * not have a configurable `activeElement` accessor. Enables noPatch and\n   * patch mode both to consistently use ShadyDOM.wrap(document)._activeElement.\n   * @override\n   * @return {!Node|undefined}\n   */\n  get _activeElement() {\n    return this.activeElement;\n  }\n\n  // NOTE: not needed, just here for balance\n  /** @override */\n  focus() {\n    this.node[utils.NATIVE_PREFIX + 'focus']();\n  }\n\n  blur() {\n    this.node[utils.SHADY_PREFIX + 'blur']();\n  }\n\n  // document\n  importNode(node, deep) {\n    if (this.node.nodeType === Node.DOCUMENT_NODE) {\n      return this.node[utils.SHADY_PREFIX + 'importNode'](node, deep);\n    }\n  }\n\n  getElementById(id) {\n    if (this.node.nodeType === Node.DOCUMENT_NODE) {\n      return this.node[utils.SHADY_PREFIX + 'getElementById'](id);\n    }\n  }\n\n  // query\n  querySelector(selector) {\n    return this.node[utils.SHADY_PREFIX + 'querySelector'](selector);\n  }\n\n  querySelectorAll(selector, useNative) {\n    return this.node[utils.SHADY_PREFIX + 'querySelectorAll'](selector, useNative);\n  }\n\n  // slot\n  assignedNodes(options) {\n    if (this.node.localName === 'slot') {\n      return this.node[utils.SHADY_PREFIX + 'assignedNodes'](options);\n    }\n  }\n\n  get host() {\n    if (utils.isShadyRoot(this.node)) {\n      return /** @type {!ShadowRoot} */(this.node).host;\n    }\n  }\n\n  get parentNode() {\n    return this.node[utils.SHADY_PREFIX + 'parentNode'];\n  }\n\n  get firstChild() {\n    return this.node[utils.SHADY_PREFIX + 'firstChild'];\n  }\n\n  get lastChild() {\n    return this.node[utils.SHADY_PREFIX + 'lastChild'];\n  }\n\n  get nextSibling() {\n    return this.node[utils.SHADY_PREFIX + 'nextSibling'];\n  }\n\n  get previousSibling() {\n    return this.node[utils.SHADY_PREFIX + 'previousSibling'];\n  }\n\n  get childNodes() {\n    return this.node[utils.SHADY_PREFIX + 'childNodes'];\n  }\n\n  get parentElement() {\n    return this.node[utils.SHADY_PREFIX + 'parentElement'];\n  }\n\n  get firstElementChild() {\n    return this.node[utils.SHADY_PREFIX + 'firstElementChild'];\n  }\n\n  get lastElementChild() {\n    return this.node[utils.SHADY_PREFIX + 'lastElementChild'];\n  }\n\n  get nextElementSibling() {\n    return this.node[utils.SHADY_PREFIX + 'nextElementSibling'];\n  }\n\n  get previousElementSibling() {\n    return this.node[utils.SHADY_PREFIX + 'previousElementSibling'];\n  }\n\n  get children() {\n    return this.node[utils.SHADY_PREFIX + 'children'];\n  }\n\n  get childElementCount() {\n    return this.node[utils.SHADY_PREFIX + 'childElementCount'];\n  }\n\n  get shadowRoot() {\n    return this.node[utils.SHADY_PREFIX + 'shadowRoot'];\n  }\n\n  get assignedSlot() {\n    return this.node[utils.SHADY_PREFIX + 'assignedSlot'];\n  }\n\n  get isConnected() {\n    return this.node[utils.SHADY_PREFIX + 'isConnected'];\n  }\n\n  get innerHTML() {\n    return this.node[utils.SHADY_PREFIX + 'innerHTML'];\n  }\n\n  set innerHTML(value) {\n    this.node[utils.SHADY_PREFIX + 'innerHTML'] = value;\n  }\n\n  get textContent() {\n    return this.node[utils.SHADY_PREFIX + 'textContent'];\n  }\n\n  set textContent(value) {\n    this.node[utils.SHADY_PREFIX + 'textContent'] = value;\n  }\n\n  get slot() {\n    return this.node[utils.SHADY_PREFIX + 'slot'];\n  }\n\n  set slot(value) {\n    this.node[utils.SHADY_PREFIX + 'slot'] = value;\n  }\n\n}\n\neventPropertyNames.forEach(name => {\n  Object.defineProperty(Wrapper.prototype, name, {\n    /** @this {Wrapper} */\n    get() {\n      return this.node[utils.SHADY_PREFIX + name];\n    },\n    /** @this {Wrapper} */\n    set(value) {\n      this.node[utils.SHADY_PREFIX + name] = value;\n    },\n    configurable: true\n  });\n\n});\n\nexport {Wrapper};\n\nconst wrapperMap = new WeakMap();\n\nexport function wrap(obj) {\n  if (utils.isShadyRoot(obj) || obj instanceof Wrapper) {\n    return obj;\n  }\n  let wrapper = wrapperMap.get(obj)\n  if (!wrapper) {\n    wrapper = new Wrapper(obj);\n    wrapperMap.set(obj, wrapper);\n  }\n  return wrapper;\n}\n","/**\n@license\nCopyright (c) 2016 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 * as utils from '../utils.js';\nimport {flush} from '../flush.js';\nimport {addEventListener, removeEventListener} from '../patch-events.js';\n\nexport const EventTargetPatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Node} */\n  dispatchEvent(event) {\n    flush();\n    return this[utils.NATIVE_PREFIX + 'dispatchEvent'](event);\n  },\n\n  addEventListener,\n\n  removeEventListener\n\n});","/**\n@license\nCopyright (c) 2016 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 * as utils from '../utils.js';\nimport {shadyDataForNode} from '../shady-data.js';\n\nexport const SlotablePatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Node} */\n  get assignedSlot() {\n    // Force any parent's shadowRoot to flush so that distribution occurs\n    // and this node has an assignedSlot.\n    const parent = this[utils.SHADY_PREFIX + 'parentNode'];\n    const ownerRoot = parent && parent[utils.SHADY_PREFIX + 'shadowRoot'];\n    if (ownerRoot) {\n      ownerRoot._render();\n    }\n    const nodeData = shadyDataForNode(this);\n    return nodeData && nodeData.assignedSlot || null;\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 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 * as utils from '../utils.js';\nimport {scopeClassAttribute} from '../style-scoping.js';\nimport {shadyDataForNode} from '../shady-data.js';\nimport {attachShadow, ownerShadyRootForNode} from '../attach-shadow.js';\n\nconst doc = window.document;\n\n/**\n * Should be called whenever an attribute changes. If the `slot` attribute\n * changes, provokes rendering if necessary. If a `<slot>` element's `name`\n * attribute changes, updates the root's slot map and renders.\n * @param {Node} node\n * @param {string} name\n */\nfunction distributeAttributeChange(node, name) {\n  if (name === 'slot') {\n    const parent = node[utils.SHADY_PREFIX + 'parentNode'];\n    if (utils.hasShadowRootWithSlot(parent)) {\n      shadyDataForNode(parent).root._asyncRender();\n    }\n  } else if (node.localName === 'slot' && name === 'name') {\n    let root = ownerShadyRootForNode(node);\n    if (root) {\n      root._updateSlotName(node);\n      root._asyncRender();\n    }\n  }\n}\n\nexport const ElementPatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Element} */\n  get previousElementSibling() {\n    const nodeData = shadyDataForNode(this);\n    if (nodeData && nodeData.previousSibling !== undefined) {\n      let n = this[utils.SHADY_PREFIX + 'previousSibling'];\n      while (n && n.nodeType !== Node.ELEMENT_NODE) {\n        n = n[utils.SHADY_PREFIX + 'previousSibling'];\n      }\n      return n;\n    } else {\n      return this[utils.NATIVE_PREFIX + 'previousElementSibling'];\n    }\n  },\n\n  /** @this {Element} */\n  get nextElementSibling() {\n    const nodeData = shadyDataForNode(this);\n    if (nodeData && nodeData.nextSibling !== undefined) {\n      let n = this[utils.SHADY_PREFIX + 'nextSibling'];\n      while (n && n.nodeType !== Node.ELEMENT_NODE) {\n        n = n[utils.SHADY_PREFIX + 'nextSibling'];\n      }\n      return n;\n    } else {\n      return this[utils.NATIVE_PREFIX + 'nextElementSibling'];\n    }\n  },\n\n  /** @this {Element} */\n  get slot() {\n    return this.getAttribute('slot');\n  },\n\n  /** @this {Element} */\n  set slot(value) {\n    this[utils.SHADY_PREFIX + 'setAttribute']('slot', value);\n  },\n\n  // Note: Can be patched on element prototype on all browsers.\n  // Must be patched on instance on browsers that support native Shadow DOM\n  // but do not have builtin accessors (old Chrome).\n  /** @this {Element} */\n  get shadowRoot() {\n    const nodeData = shadyDataForNode(this);\n    return nodeData && nodeData.publicRoot || null;\n  },\n\n  /** @this {Element} */\n  get className() {\n    return this.getAttribute('class') || '';\n  },\n\n  /**\n   * @this {Element}\n   * @param {string} value\n   */\n  set className(value) {\n    this[utils.SHADY_PREFIX + 'setAttribute']('class', value);\n  },\n\n  /**\n   * @this {Element}\n   * @param {string} attr\n   * @param {string} value\n   */\n  setAttribute(attr, value) {\n    if (this.ownerDocument !== doc) {\n      this[utils.NATIVE_PREFIX + 'setAttribute'](attr, value);\n    } else if (!scopeClassAttribute(this, attr, value)) {\n      this[utils.NATIVE_PREFIX + 'setAttribute'](attr, value);\n      distributeAttributeChange(this, attr);\n    }\n  },\n\n  /**\n   * @this {Element}\n   * @param {string} attr\n   */\n  removeAttribute(attr) {\n    this[utils.NATIVE_PREFIX + 'removeAttribute'](attr);\n    distributeAttributeChange(this, attr);\n  },\n\n  /**\n   * @this {Element}\n   * @param {!{mode: string}} options\n   */\n  attachShadow(options) {\n    return attachShadow(this, options);\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 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 * as utils from '../utils.js';\nimport {eventPropertyNames} from '../patch-events.js';\nimport {shadyDataForNode, ensureShadyDataForNode} from '../shady-data.js';\n\nexport const HTMLElementPatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {HTMLElement} */\n  blur() {\n    const nodeData = shadyDataForNode(this);\n    let root = nodeData && nodeData.root;\n    let shadowActive = root && root.activeElement;\n    if (shadowActive) {\n      shadowActive[utils.SHADY_PREFIX + 'blur']();\n    } else {\n      this[utils.NATIVE_PREFIX + 'blur']();\n    }\n  }\n\n});\n\neventPropertyNames.forEach(property => {\n  HTMLElementPatches[property] = {\n    /** @this {HTMLElement} */\n    set: function(fn) {\n      const shadyData = ensureShadyDataForNode(this);\n      const eventName = property.substring(2);\n      shadyData.__onCallbackListeners[property] && this.removeEventListener(eventName, shadyData.__onCallbackListeners[property]);\n      this[utils.SHADY_PREFIX + 'addEventListener'](eventName, fn);\n      shadyData.__onCallbackListeners[property] = fn;\n    },\n    /** @this {HTMLElement} */\n    get() {\n      const shadyData = shadyDataForNode(this);\n      return shadyData && shadyData.__onCallbackListeners[property];\n    },\n    configurable: true\n  };\n});\n\n","/**\n@license\nCopyright (c) 2016 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 * as utils from '../utils.js';\nimport {shadyDataForNode} from '../shady-data.js';\n\nexport const SlotPatches = utils.getOwnPropertyDescriptors({\n\n  /**\n   * @this {HTMLSlotElement}\n   * @param {Object=} options\n   */\n  assignedNodes(options) {\n    if (this.localName === 'slot') {\n      // Force any containing shadowRoot to flush so that distribution occurs\n      // and this node has assignedNodes.\n      const root = this[utils.SHADY_PREFIX + 'getRootNode']();\n      if (root && utils.isShadyRoot(root)) {\n        root._render();\n      }\n      const nodeData = shadyDataForNode(this);\n      return nodeData ?\n        ((options && options.flatten ? nodeData.flattenedNodes :\n          nodeData.assignedNodes) || []) :\n        [];\n    }\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 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 * as utils from '../utils.js';\n\nconst doc = window.document;\n\nexport const DocumentPatches = utils.getOwnPropertyDescriptors({\n\n  // note: Though not technically correct, we fast path `importNode`\n  // when called on a node not owned by the main document.\n  // This allows, for example, elements that cannot\n  // contain custom elements and are therefore not likely to contain shadowRoots\n  // to cloned natively. This is a fairly significant performance win.\n  /**\n   * @this {Document}\n   * @param {Node} node\n   * @param {boolean} deep\n   */\n  importNode(node, deep) {\n    // A template element normally has no children with shadowRoots, so make\n    // sure we always make a deep copy to correctly construct the template.content\n    if (node.ownerDocument !== doc || node.localName === 'template') {\n      return this[utils.NATIVE_PREFIX + 'importNode'](node, deep);\n    }\n    let n = this[utils.NATIVE_PREFIX + 'importNode'](node, false);\n    if (deep) {\n      let c$ = node[utils.SHADY_PREFIX + 'childNodes'];\n      for (let i=0, nc; i < c$.length; i++) {\n        nc = this[utils.SHADY_PREFIX + 'importNode'](c$[i], true);\n        n[utils.SHADY_PREFIX + 'appendChild'](nc);\n      }\n    }\n    return n;\n  }\n\n});","/**\n@license\nCopyright (c) 2016 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 * as utils from '../utils.js';\nimport {addEventListener, removeEventListener} from '../patch-events.js';\n\nexport const WindowPatches = utils.getOwnPropertyDescriptors({\n\n  // NOTE: ensure these methods are bound to `window` so that `this` is correct\n  // when called directly from global context without a receiver; e.g.\n  // `addEventListener(...)`.\n  addEventListener: addEventListener.bind(window),\n\n  removeEventListener: removeEventListener.bind(window)\n\n});","/**\n@license\nCopyright (c) 2016 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 * as utils from './utils.js';\nimport {EventTargetPatches} from './patches/EventTarget.js';\nimport {NodePatches} from './patches/Node.js';\nimport {SlotablePatches} from './patches/Slotable.js';\nimport {ParentNodePatches, ParentNodeDocumentOrFragmentPatches} from './patches/ParentNode.js';\nimport {ElementPatches} from './patches/Element.js';\nimport {ElementOrShadowRootPatches} from './patches/ElementOrShadowRoot.js';\nimport {HTMLElementPatches} from './patches/HTMLElement.js';\nimport {SlotPatches} from './patches/Slot.js';\nimport {DocumentOrFragmentPatches} from './patches/DocumentOrFragment.js';\nimport {DocumentOrShadowRootPatches} from './patches/DocumentOrShadowRoot.js';\nimport {DocumentPatches} from './patches/Document.js';\nimport {WindowPatches} from './patches/Window.js';\n\n// Some browsers (IE/Edge) have non-standard HTMLElement accessors.\nconst NonStandardHTMLElement = {};\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'parentElement')) {\n  NonStandardHTMLElement.parentElement = NodePatches.parentElement;\n}\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'contains')) {\n  NonStandardHTMLElement.contains = NodePatches.contains;\n}\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'children')) {\n  NonStandardHTMLElement.children = ParentNodePatches.children;\n}\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'innerHTML')) {\n  NonStandardHTMLElement.innerHTML = ElementOrShadowRootPatches.innerHTML;\n}\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'className')) {\n  NonStandardHTMLElement.className = ElementPatches.className;\n}\n\n// Avoid patching `innerHTML` if it does not exist on Element (IE)\n// and we can patch accessors (hasDescriptors).\nconst ElementShouldHaveInnerHTML = !utils.settings.hasDescriptors || 'innerHTML' in Element.prototype;\n\n// setup patching\nconst patchMap = {\n  EventTarget: [EventTargetPatches],\n  Node: [NodePatches, !window.EventTarget ? EventTargetPatches : null],\n  Text: [SlotablePatches],\n  Element: [ElementPatches, ParentNodePatches, SlotablePatches,\n    ElementShouldHaveInnerHTML ? ElementOrShadowRootPatches : null,\n    !window.HTMLSlotElement ? SlotPatches : null],\n  HTMLElement: [HTMLElementPatches, NonStandardHTMLElement],\n  HTMLSlotElement: [SlotPatches],\n  DocumentFragment: [ParentNodeDocumentOrFragmentPatches, DocumentOrFragmentPatches],\n  Document: [DocumentPatches, ParentNodeDocumentOrFragmentPatches, DocumentOrFragmentPatches, DocumentOrShadowRootPatches],\n  Window: [WindowPatches]\n}\n\nconst getPatchPrototype = (name) => window[name] && window[name].prototype;\n\n// Note, must avoid patching accessors on prototypes when descriptors are not correct\n// because the CustomElements polyfill checks if these exist before patching instances.\n// CustomElements polyfill *only* cares about these accessors.\nconst disallowedNativePatches = utils.settings.hasDescriptors ? null : ['innerHTML', 'textContent'];\n\n/** @param {string=} prefix */\nexport const applyPatches = (prefix) => {\n  const disallowed = prefix ? null : disallowedNativePatches;\n  for (let p in patchMap) {\n    const proto = getPatchPrototype(p);\n    patchMap[p].forEach(patch => proto && patch &&\n        utils.patchProperties(proto, patch, prefix, disallowed));\n  }\n}\n\nexport const addShadyPrefixedProperties = () => {\n  // perform shady patches\n  applyPatches(utils.SHADY_PREFIX);\n\n  // install `_activeElement` because some browsers (older Chrome/Safari) do not have\n  // a 'configurable' `activeElement` accesssor.\n  const descriptor = DocumentOrShadowRootPatches.activeElement;\n  Object.defineProperty(document, '_activeElement', descriptor);\n\n  // On Window, we're patching `addEventListener` which is a weird auto-bound\n  // property that is not directly on the Window prototype.\n  utils.patchProperties(Window.prototype, WindowPatches, utils.SHADY_PREFIX);\n};\n","/**\n@license\nCopyright (c) 2016 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 * Patches elements that interacts with ShadyDOM\n * such that tree traversal and mutation apis act like they would under\n * ShadowDOM.\n *\n * This import enables seemless interaction with ShadyDOM powered\n * custom elements, enabling better interoperation with 3rd party code,\n * libraries, and frameworks that use DOM tree manipulation apis.\n */\n\nimport * as utils from './utils.js';\nimport {flush, enqueue} from './flush.js';\nimport {observeChildren, unobserveChildren, filterMutations} from './observe-changes.js';\nimport {addNativePrefixedProperties, nativeMethods, nativeTree} from './patch-native.js';\nimport {patchInsideElementAccessors, patchOutsideElementAccessors} from './patch-instances.js';\nimport {patchEvents, patchClick, composedPath} from './patch-events.js';\nimport {ShadyRoot} from './attach-shadow.js';\nimport {wrap, Wrapper} from './wrapper.js';\nimport {addShadyPrefixedProperties, applyPatches} from './patch-prototypes.js';\n\nif (utils.settings.inUse) {\n  let ShadyDOM = {\n    // TODO(sorvell): remove when Polymer does not depend on this.\n    'inUse': utils.settings.inUse,\n    // NOTE: old browsers without prototype accessors (very old Chrome\n    // and Safari) need manually patched accessors to properly set\n    // `innerHTML` and `textContent` when an element is:\n    // (1) inside a shadowRoot\n    // (2) does not have special (slot) children itself\n    // (3) and setting the property needs to provoke distribution (because\n    // a nested slot is added/removed)\n    'patch': (node) => {\n      patchInsideElementAccessors(node);\n      patchOutsideElementAccessors(node);\n      return node;\n    },\n    'isShadyRoot': utils.isShadyRoot,\n    'enqueue': enqueue,\n    'flush': flush,\n    'flushInitial': (root) => {\n      root._flushInitial();\n    },\n    'settings': utils.settings,\n    'filterMutations': filterMutations,\n    'observeChildren': observeChildren,\n    'unobserveChildren': unobserveChildren,\n    // Set to true to defer native custom elements connection until the\n    // document has fully parsed. This enables custom elements that create\n    // shadowRoots to be defined while the document is loading. Elements\n    // customized as they are created by the parser will successfully\n    // render with this flag on.\n    'deferConnectionCallbacks': utils.settings['deferConnectionCallbacks'],\n    // Set to true to speed up the polyfill slightly at the cost of correctness\n    // * does not patch querySelector/All on Document or DocumentFragment\n    // * does not wrap connected/disconnected callbacks to de-dup these\n    // when using native customElements\n    // * does not wait to process children of elements with shadowRoots\n    // meaning shadowRoots should not be created while an element is parsing\n    // (e.g. if a custom element that creates a shadowRoot is defined before\n    // a candidate element in the document below it.\n    'preferPerformance': utils.settings['preferPerformance'],\n    // Integration point with ShadyCSS to disable styling MutationObserver,\n    // as ShadyDOM will now handle dynamic scoping.\n    'handlesDynamicScoping': true,\n    'wrap': utils.settings.noPatch ? wrap : (n) => n,\n    'Wrapper': Wrapper,\n    'composedPath': composedPath,\n    // Set to true to avoid patching regular platform property names. When set,\n    // Shadow DOM compatible behavior is only available when accessing DOM\n    // API using `ShadyDOM.wrap`, e.g. `ShadyDOM.wrap(element).shadowRoot`.\n    // This setting provides a small performance boost, but requires all DOM API\n    // access that requires Shadow DOM behavior to be proxied via `ShadyDOM.wrap`.\n    'noPatch': utils.settings.noPatch,\n    'nativeMethods': nativeMethods,\n    'nativeTree': nativeTree\n  };\n\n  window['ShadyDOM'] = ShadyDOM;\n\n  // Modifies native prototypes for Node, Element, etc. to\n  // make native platform behavior available at prefixed names, e.g.\n  // `utils.NATIVE_PREFIX + 'firstChild'` or `__shady_native_firstChild`.\n  // This allows the standard names to be safely patched while retaining the\n  // ability for native behavior to be used. This polyfill manipulates DOM\n  // by using this saved native behavior.\n  // Note, some browsers do not have proper element descriptors for\n  // accessors; in this case, native behavior for these accessors is simulated\n  // via a TreeWalker.\n  addNativePrefixedProperties();\n\n  // Modifies native prototypes for Node, Element, etc. to make ShadowDOM\n  // behavior available at prefixed names, e.g.\n  // `utils.SHADY_PREFIX + 'firstChild` or `__shady_firstChild`. This is done\n  // so this polyfill can perform Shadow DOM style DOM manipulation.\n  // Because patching normal platform property names is optional, these prefixed\n  // names are used internally.\n  addShadyPrefixedProperties();\n\n  // Modifies native prototypes for Node, Element, etc. to patch\n  // regular platform property names to have Shadow DOM compatible API behavior.\n  // This applies the utils.SHADY_PREFIX behavior to normal names. For example,\n  // if `noPatch` is not set, then `el.__shady_firstChild` is equivalent to\n  // `el.firstChild`.\n  // NOTE, on older browsers (old Chrome/Safari) native accessors cannot be\n  // patched on prototypes (e.g. Node.prototype.firstChild cannot be modified).\n  // On these browsers, instance level patching is performed where needed; this\n  // instance patching is only done when `noPatch` is *not* set.\n  if (!utils.settings.noPatch) {\n    applyPatches();\n    // Patch click event behavior only if we're patching\n    patchClick()\n  }\n\n  // For simplicity, patch events unconditionally.\n  // Patches the event system to have Shadow DOM compatible behavior (e.g.\n  // event retargeting). When `noPatch` is set, retargeting is only available\n  // when adding event listeners and dispatching events via `ShadyDOM.wrap`\n  // (e.g. `ShadyDOM.wrap(element).addEventListener(...)`).\n  patchEvents();\n\n  window.ShadowRoot = /** @type {function(new:ShadowRoot)} */(ShadyRoot);\n}\n","const reservedTagList = new Set([\n  'annotation-xml',\n  'color-profile',\n  'font-face',\n  'font-face-src',\n  'font-face-uri',\n  'font-face-format',\n  'font-face-name',\n  'missing-glyph',\n]);\n\n/**\n * @param {string} localName\n * @returns {boolean}\n */\nexport function isValidCustomElementName(localName) {\n  const reserved = reservedTagList.has(localName);\n  const validForm = /^[a-z][.0-9_a-z]*-[\\-.0-9_a-z]*$/.test(localName);\n  return !reserved && validForm;\n}\n\n/**\n * @private\n * @param {!Node} node\n * @return {boolean}\n */\nexport function isConnected(node) {\n  // Use `Node#isConnected`, if defined.\n  const nativeValue = node.isConnected;\n  if (nativeValue !== undefined) {\n    return nativeValue;\n  }\n\n  /** @type {?Node|undefined} */\n  let current = node;\n  while (current && !(current.__CE_isImportDocument || current instanceof Document)) {\n    current = current.parentNode || (window.ShadowRoot && current instanceof ShadowRoot ? current.host : undefined);\n  }\n  return !!(current && (current.__CE_isImportDocument || current instanceof Document));\n}\n\n/**\n * @param {!Node} root\n * @param {!Node} start\n * @return {?Node}\n */\nfunction nextSiblingOrAncestorSibling(root, start) {\n  let node = start;\n  while (node && node !== root && !node.nextSibling) {\n    node = node.parentNode;\n  }\n  return (!node || node === root) ? null : node.nextSibling;\n}\n\n/**\n * @param {!Node} root\n * @param {!Node} start\n * @return {?Node}\n */\nfunction nextNode(root, start) {\n  return start.firstChild ? start.firstChild : nextSiblingOrAncestorSibling(root, start);\n}\n\n/**\n * @param {!Node} root\n * @param {!function(!Element)} callback\n * @param {!Set<Node>=} visitedImports\n */\nexport function walkDeepDescendantElements(root, callback, visitedImports = new Set()) {\n  let node = root;\n  while (node) {\n    if (node.nodeType === Node.ELEMENT_NODE) {\n      const element = /** @type {!Element} */(node);\n\n      callback(element);\n\n      const localName = element.localName;\n      if (localName === 'link' && element.getAttribute('rel') === 'import') {\n        // If this import (polyfilled or not) has it's root node available,\n        // walk it.\n        const importNode = /** @type {!Node} */ (element.import);\n        if (importNode instanceof Node && !visitedImports.has(importNode)) {\n          // Prevent multiple walks of the same import root.\n          visitedImports.add(importNode);\n\n          for (let child = importNode.firstChild; child; child = child.nextSibling) {\n            walkDeepDescendantElements(child, callback, visitedImports);\n          }\n        }\n\n        // Ignore descendants of import links to prevent attempting to walk the\n        // elements created by the HTML Imports polyfill that we just walked\n        // above.\n        node = nextSiblingOrAncestorSibling(root, element);\n        continue;\n      } else if (localName === 'template') {\n        // Ignore descendants of templates. There shouldn't be any descendants\n        // because they will be moved into `.content` during construction in\n        // browsers that support template but, in case they exist and are still\n        // waiting to be moved by a polyfill, they will be ignored.\n        node = nextSiblingOrAncestorSibling(root, element);\n        continue;\n      }\n\n      // Walk shadow roots.\n      const shadowRoot = element.__CE_shadowRoot;\n      if (shadowRoot) {\n        for (let child = shadowRoot.firstChild; child; child = child.nextSibling) {\n          walkDeepDescendantElements(child, callback, visitedImports);\n        }\n      }\n    }\n\n    node = nextNode(root, node);\n  }\n}\n\n/**\n * Used to suppress Closure's \"Modifying the prototype is only allowed if the\n * constructor is in the same scope\" warning without using\n * `@suppress {newCheckTypes, duplicate}` because `newCheckTypes` is too broad.\n *\n * @param {!Object} destination\n * @param {string} name\n * @param {*} value\n */\nexport function setPropertyUnchecked(destination, name, value) {\n  destination[name] = value;\n}\n","import * as Utilities from './Utilities.js';\nimport CEState from './CustomElementState.js';\n\nexport default class CustomElementInternals {\n  constructor() {\n    /** @type {!Map<string, !CustomElementDefinition>} */\n    this._localNameToDefinition = new Map();\n\n    /** @type {!Map<!Function, !CustomElementDefinition>} */\n    this._constructorToDefinition = new Map();\n\n    /** @type {!Array<!function(!Node)>} */\n    this._patches = [];\n\n    /** @type {boolean} */\n    this._hasPatches = false;\n  }\n\n  /**\n   * @param {string} localName\n   * @param {!CustomElementDefinition} definition\n   */\n  setDefinition(localName, definition) {\n    this._localNameToDefinition.set(localName, definition);\n    this._constructorToDefinition.set(definition.constructorFunction, definition);\n  }\n\n  /**\n   * @param {string} localName\n   * @return {!CustomElementDefinition|undefined}\n   */\n  localNameToDefinition(localName) {\n    return this._localNameToDefinition.get(localName);\n  }\n\n  /**\n   * @param {!Function} constructor\n   * @return {!CustomElementDefinition|undefined}\n   */\n  constructorToDefinition(constructor) {\n    return this._constructorToDefinition.get(constructor);\n  }\n\n  /**\n   * @param {!function(!Node)} listener\n   */\n  addPatch(listener) {\n    this._hasPatches = true;\n    this._patches.push(listener);\n  }\n\n  /**\n   * @param {!Node} node\n   */\n  patchTree(node) {\n    if (!this._hasPatches) return;\n\n    Utilities.walkDeepDescendantElements(node, element => this.patch(element));\n  }\n\n  /**\n   * @param {!Node} node\n   */\n  patch(node) {\n    if (!this._hasPatches) return;\n\n    if (node.__CE_patched) return;\n    node.__CE_patched = true;\n\n    for (let i = 0; i < this._patches.length; i++) {\n      this._patches[i](node);\n    }\n  }\n\n  /**\n   * @param {!Node} root\n   */\n  connectTree(root) {\n    const elements = [];\n\n    Utilities.walkDeepDescendantElements(root, element => elements.push(element));\n\n    for (let i = 0; i < elements.length; i++) {\n      const element = elements[i];\n      if (element.__CE_state === CEState.custom) {\n        this.connectedCallback(element);\n      } else {\n        this.upgradeElement(element);\n      }\n    }\n  }\n\n  /**\n   * @param {!Node} root\n   */\n  disconnectTree(root) {\n    const elements = [];\n\n    Utilities.walkDeepDescendantElements(root, element => elements.push(element));\n\n    for (let i = 0; i < elements.length; i++) {\n      const element = elements[i];\n      if (element.__CE_state === CEState.custom) {\n        this.disconnectedCallback(element);\n      }\n    }\n  }\n\n  /**\n   * Upgrades all uncustomized custom elements at and below a root node for\n   * which there is a definition. When custom element reaction callbacks are\n   * assumed to be called synchronously (which, by the current DOM / HTML spec\n   * definitions, they are *not*), callbacks for both elements customized\n   * synchronously by the parser and elements being upgraded occur in the same\n   * relative order.\n   *\n   * NOTE: This function, when used to simulate the construction of a tree that\n   * is already created but not customized (i.e. by the parser), does *not*\n   * prevent the element from reading the 'final' (true) state of the tree. For\n   * example, the element, during truly synchronous parsing / construction would\n   * see that it contains no children as they have not yet been inserted.\n   * However, this function does not modify the tree, the element will\n   * (incorrectly) have children. Additionally, self-modification restrictions\n   * for custom element constructors imposed by the DOM spec are *not* enforced.\n   *\n   *\n   * The following nested list shows the steps extending down from the HTML\n   * spec's parsing section that cause elements to be synchronously created and\n   * upgraded:\n   *\n   * The \"in body\" insertion mode:\n   * https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody\n   * - Switch on token:\n   *   .. other cases ..\n   *   -> Any other start tag\n   *      - [Insert an HTML element](below) for the token.\n   *\n   * Insert an HTML element:\n   * https://html.spec.whatwg.org/multipage/syntax.html#insert-an-html-element\n   * - Insert a foreign element for the token in the HTML namespace:\n   *   https://html.spec.whatwg.org/multipage/syntax.html#insert-a-foreign-element\n   *   - Create an element for a token:\n   *     https://html.spec.whatwg.org/multipage/syntax.html#create-an-element-for-the-token\n   *     - Will execute script flag is true?\n   *       - (Element queue pushed to the custom element reactions stack.)\n   *     - Create an element:\n   *       https://dom.spec.whatwg.org/#concept-create-element\n   *       - Sync CE flag is true?\n   *         - Constructor called.\n   *         - Self-modification restrictions enforced.\n   *       - Sync CE flag is false?\n   *         - (Upgrade reaction enqueued.)\n   *     - Attributes appended to element.\n   *       (`attributeChangedCallback` reactions enqueued.)\n   *     - Will execute script flag is true?\n   *       - (Element queue popped from the custom element reactions stack.\n   *         Reactions in the popped stack are invoked.)\n   *   - (Element queue pushed to the custom element reactions stack.)\n   *   - Insert the element:\n   *     https://dom.spec.whatwg.org/#concept-node-insert\n   *     - Shadow-including descendants are connected. During parsing\n   *       construction, there are no shadow-*excluding* descendants.\n   *       However, the constructor may have validly attached a shadow\n   *       tree to itself and added descendants to that shadow tree.\n   *       (`connectedCallback` reactions enqueued.)\n   *   - (Element queue popped from the custom element reactions stack.\n   *     Reactions in the popped stack are invoked.)\n   *\n   * @param {!Node} root\n   * @param {{\n   *   visitedImports: (!Set<!Node>|undefined),\n   *   upgrade: (!function(!Element)|undefined),\n   * }=} options\n   */\n  patchAndUpgradeTree(root, options = {}) {\n    const visitedImports = options.visitedImports || new Set();\n    const upgrade = options.upgrade || (element => this.upgradeElement(element));\n\n    const elements = [];\n\n    const gatherElements = element => {\n      if (element.localName === 'link' && element.getAttribute('rel') === 'import') {\n        // The HTML Imports polyfill sets a descendant element of the link to\n        // the `import` property, specifically this is *not* a Document.\n        const importNode = /** @type {?Node} */ (element.import);\n\n        if (importNode instanceof Node) {\n          importNode.__CE_isImportDocument = true;\n          // Connected links are associated with the registry.\n          importNode.__CE_hasRegistry = true;\n        }\n\n        if (importNode && importNode.readyState === 'complete') {\n          importNode.__CE_documentLoadHandled = true;\n        } else {\n          // If this link's import root is not available, its contents can't be\n          // walked. Wait for 'load' and walk it when it's ready.\n          element.addEventListener('load', () => {\n            const importNode = /** @type {!Node} */ (element.import);\n\n            if (importNode.__CE_documentLoadHandled) return;\n            importNode.__CE_documentLoadHandled = true;\n\n            // Clone the `visitedImports` set that was populated sync during\n            // the `patchAndUpgradeTree` call that caused this 'load' handler to\n            // be added. Then, remove *this* link's import node so that we can\n            // walk that import again, even if it was partially walked later\n            // during the same `patchAndUpgradeTree` call.\n            const clonedVisitedImports = new Set(visitedImports);\n            clonedVisitedImports.delete(importNode);\n\n            this.patchAndUpgradeTree(importNode, {visitedImports: clonedVisitedImports, upgrade});\n          });\n        }\n      } else {\n        elements.push(element);\n      }\n    };\n\n    // `walkDeepDescendantElements` populates (and internally checks against)\n    // `visitedImports` when traversing a loaded import.\n    Utilities.walkDeepDescendantElements(root, gatherElements, visitedImports);\n\n    if (this._hasPatches) {\n      for (let i = 0; i < elements.length; i++) {\n        this.patch(elements[i]);\n      }\n    }\n\n    for (let i = 0; i < elements.length; i++) {\n      upgrade(elements[i]);\n    }\n  }\n\n  /**\n   * @param {!HTMLElement} element\n   */\n  upgradeElement(element) {\n    const currentState = element.__CE_state;\n    if (currentState !== undefined) return;\n\n    // Prevent elements created in documents without a browsing context from\n    // upgrading.\n    //\n    // https://html.spec.whatwg.org/multipage/custom-elements.html#look-up-a-custom-element-definition\n    //   \"If document does not have a browsing context, return null.\"\n    //\n    // https://html.spec.whatwg.org/multipage/window-object.html#dom-document-defaultview\n    //   \"The defaultView IDL attribute of the Document interface, on getting,\n    //   must return this Document's browsing context's WindowProxy object, if\n    //   this Document has an associated browsing context, or null otherwise.\"\n    const ownerDocument = element.ownerDocument;\n    if (\n      !ownerDocument.defaultView &&\n      !(ownerDocument.__CE_isImportDocument && ownerDocument.__CE_hasRegistry)\n    ) return;\n\n    const definition = this.localNameToDefinition(element.localName);\n    if (!definition) return;\n\n    definition.constructionStack.push(element);\n\n    const constructor = definition.constructorFunction;\n    try {\n      try {\n        let result = new (constructor)();\n        if (result !== element) {\n          throw new Error('The custom element constructor did not produce the element being upgraded.');\n        }\n      } finally {\n        definition.constructionStack.pop();\n      }\n    } catch (e) {\n      element.__CE_state = CEState.failed;\n      throw e;\n    }\n\n    element.__CE_state = CEState.custom;\n    element.__CE_definition = definition;\n\n    if (definition.attributeChangedCallback) {\n      const observedAttributes = definition.observedAttributes;\n      for (let i = 0; i < observedAttributes.length; i++) {\n        const name = observedAttributes[i];\n        const value = element.getAttribute(name);\n        if (value !== null) {\n          this.attributeChangedCallback(element, name, null, value, null);\n        }\n      }\n    }\n\n    if (Utilities.isConnected(element)) {\n      this.connectedCallback(element);\n    }\n  }\n\n  /**\n   * @param {!Element} element\n   */\n  connectedCallback(element) {\n    const definition = element.__CE_definition;\n    if (definition.connectedCallback) {\n      definition.connectedCallback.call(element);\n    }\n  }\n\n  /**\n   * @param {!Element} element\n   */\n  disconnectedCallback(element) {\n    const definition = element.__CE_definition;\n    if (definition.disconnectedCallback) {\n      definition.disconnectedCallback.call(element);\n    }\n  }\n\n  /**\n   * @param {!Element} element\n   * @param {string} name\n   * @param {?string} oldValue\n   * @param {?string} newValue\n   * @param {?string} namespace\n   */\n  attributeChangedCallback(element, name, oldValue, newValue, namespace) {\n    const definition = element.__CE_definition;\n    if (\n      definition.attributeChangedCallback &&\n      definition.observedAttributes.indexOf(name) > -1\n    ) {\n      definition.attributeChangedCallback.call(element, name, oldValue, newValue, namespace);\n    }\n  }\n}\n","/**\n * @enum {number}\n */\nconst CustomElementState = {\n  custom: 1,\n  failed: 2,\n};\n\nexport default CustomElementState;\n","import CustomElementInternals from './CustomElementInternals.js';\n\nexport default class DocumentConstructionObserver {\n  constructor(internals, doc) {\n    /**\n     * @type {!CustomElementInternals}\n     */\n    this._internals = internals;\n\n    /**\n     * @type {!Document}\n     */\n    this._document = doc;\n\n    /**\n     * @type {MutationObserver|undefined}\n     */\n    this._observer = undefined;\n\n\n    // Simulate tree construction for all currently accessible nodes in the\n    // document.\n    this._internals.patchAndUpgradeTree(this._document);\n\n    if (this._document.readyState === 'loading') {\n      this._observer = new MutationObserver(this._handleMutations.bind(this));\n\n      // Nodes created by the parser are given to the observer *before* the next\n      // task runs. Inline scripts are run in a new task. This means that the\n      // observer will be able to handle the newly parsed nodes before the inline\n      // script is run.\n      this._observer.observe(this._document, {\n        childList: true,\n        subtree: true,\n      });\n    }\n  }\n\n  disconnect() {\n    if (this._observer) {\n      this._observer.disconnect();\n    }\n  }\n\n  /**\n   * @param {!Array<!MutationRecord>} mutations\n   */\n  _handleMutations(mutations) {\n    // Once the document's `readyState` is 'interactive' or 'complete', all new\n    // nodes created within that document will be the result of script and\n    // should be handled by patching.\n    const readyState = this._document.readyState;\n    if (readyState === 'interactive' || readyState === 'complete') {\n      this.disconnect();\n    }\n\n    for (let i = 0; i < mutations.length; i++) {\n      const addedNodes = mutations[i].addedNodes;\n      for (let j = 0; j < addedNodes.length; j++) {\n        const node = addedNodes[j];\n        this._internals.patchAndUpgradeTree(node);\n      }\n    }\n  }\n}\n","import CustomElementInternals from './CustomElementInternals.js';\nimport DocumentConstructionObserver from './DocumentConstructionObserver.js';\nimport Deferred from './Deferred.js';\nimport * as Utilities from './Utilities.js';\n\n/**\n * @unrestricted\n */\nexport default class CustomElementRegistry {\n\n  /**\n   * @param {!CustomElementInternals} internals\n   */\n  constructor(internals) {\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this._elementDefinitionIsRunning = false;\n\n    /**\n     * @private\n     * @type {!CustomElementInternals}\n     */\n    this._internals = internals;\n\n    /**\n     * @private\n     * @type {!Map<string, !Deferred<undefined>>}\n     */\n    this._whenDefinedDeferred = new Map();\n\n    /**\n     * The default flush callback triggers the document walk synchronously.\n     * @private\n     * @type {!Function}\n     */\n    this._flushCallback = fn => fn();\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this._flushPending = false;\n\n    /**\n     * @private\n     * @type {!Array<!CustomElementDefinition>}\n     */\n    this._pendingDefinitions = [];\n\n    /**\n     * @private\n     * @type {!DocumentConstructionObserver}\n     */\n    this._documentConstructionObserver = new DocumentConstructionObserver(internals, document);\n  }\n\n  /**\n   * @param {string} localName\n   * @param {!Function} constructor\n   */\n  define(localName, constructor) {\n    if (!(constructor instanceof Function)) {\n      throw new TypeError('Custom element constructors must be functions.');\n    }\n\n    if (!Utilities.isValidCustomElementName(localName)) {\n      throw new SyntaxError(`The element name '${localName}' is not valid.`);\n    }\n\n    if (this._internals.localNameToDefinition(localName)) {\n      throw new Error(`A custom element with name '${localName}' has already been defined.`);\n    }\n\n    if (this._elementDefinitionIsRunning) {\n      throw new Error('A custom element is already being defined.');\n    }\n    this._elementDefinitionIsRunning = true;\n\n    let connectedCallback;\n    let disconnectedCallback;\n    let adoptedCallback;\n    let attributeChangedCallback;\n    let observedAttributes;\n    try {\n      /** @type {!Object} */\n      const prototype = constructor.prototype;\n      if (!(prototype instanceof Object)) {\n        throw new TypeError('The custom element constructor\\'s prototype is not an object.');\n      }\n\n      function getCallback(name) {\n        const callbackValue = prototype[name];\n        if (callbackValue !== undefined && !(callbackValue instanceof Function)) {\n          throw new Error(`The '${name}' callback must be a function.`);\n        }\n        return callbackValue;\n      }\n\n      connectedCallback = getCallback('connectedCallback');\n      disconnectedCallback = getCallback('disconnectedCallback');\n      adoptedCallback = getCallback('adoptedCallback');\n      attributeChangedCallback = getCallback('attributeChangedCallback');\n      observedAttributes = constructor['observedAttributes'] || [];\n    } catch (e) {\n      return;\n    } finally {\n      this._elementDefinitionIsRunning = false;\n    }\n\n    const definition = {\n      localName,\n      constructorFunction: constructor,\n      connectedCallback,\n      disconnectedCallback,\n      adoptedCallback,\n      attributeChangedCallback,\n      observedAttributes,\n      constructionStack: [],\n    };\n\n    this._internals.setDefinition(localName, definition);\n    this._pendingDefinitions.push(definition);\n\n    // If we've already called the flush callback and it hasn't called back yet,\n    // don't call it again.\n    if (!this._flushPending) {\n      this._flushPending = true;\n      this._flushCallback(() => this._flush());\n    }\n  }\n\n  upgrade(element) {\n    this._internals.patchAndUpgradeTree(element);\n  }\n\n  _flush() {\n    // If no new definitions were defined, don't attempt to flush. This could\n    // happen if a flush callback keeps the function it is given and calls it\n    // multiple times.\n    if (this._flushPending === false) return;\n    this._flushPending = false;\n\n    const pendingDefinitions = this._pendingDefinitions;\n\n    /**\n     * Unupgraded elements with definitions that were defined *before* the last\n     * flush, in document order.\n     * @type {!Array<!HTMLElement>}\n     */\n    const elementsWithStableDefinitions = [];\n\n    /**\n     * A map from `localName`s of definitions that were defined *after* the last\n     * flush to unupgraded elements matching that definition, in document order.\n     * @type {!Map<string, !Array<!HTMLElement>>}\n     */\n    const elementsWithPendingDefinitions = new Map();\n    for (let i = 0; i < pendingDefinitions.length; i++) {\n      elementsWithPendingDefinitions.set(pendingDefinitions[i].localName, []);\n    }\n\n    this._internals.patchAndUpgradeTree(document, {\n      upgrade: element => {\n        // Ignore the element if it has already upgraded or failed to upgrade.\n        if (element.__CE_state !== undefined) return;\n\n        const localName = element.localName;\n\n        // If there is an applicable pending definition for the element, add the\n        // element to the list of elements to be upgraded with that definition.\n        const pendingElements = elementsWithPendingDefinitions.get(localName);\n        if (pendingElements) {\n          pendingElements.push(element);\n        // If there is *any other* applicable definition for the element, add it\n        // to the list of elements with stable definitions that need to be upgraded.\n        } else if (this._internals.localNameToDefinition(localName)) {\n          elementsWithStableDefinitions.push(element);\n        }\n      },\n    });\n\n    // Upgrade elements with 'stable' definitions first.\n    for (let i = 0; i < elementsWithStableDefinitions.length; i++) {\n      this._internals.upgradeElement(elementsWithStableDefinitions[i]);\n    }\n\n    // Upgrade elements with 'pending' definitions in the order they were defined.\n    while (pendingDefinitions.length > 0) {\n      const definition = pendingDefinitions.shift();\n      const localName = definition.localName;\n\n      // Attempt to upgrade all applicable elements.\n      const pendingUpgradableElements = elementsWithPendingDefinitions.get(definition.localName);\n      for (let i = 0; i < pendingUpgradableElements.length; i++) {\n        this._internals.upgradeElement(pendingUpgradableElements[i]);\n      }\n\n      // Resolve any promises created by `whenDefined` for the definition.\n      const deferred = this._whenDefinedDeferred.get(localName);\n      if (deferred) {\n        deferred.resolve(undefined);\n      }\n    }\n  }\n\n  /**\n   * @param {string} localName\n   * @return {Function|undefined}\n   */\n  get(localName) {\n    const definition = this._internals.localNameToDefinition(localName);\n    if (definition) {\n      return definition.constructorFunction;\n    }\n\n    return undefined;\n  }\n\n  /**\n   * @param {string} localName\n   * @return {!Promise<undefined>}\n   */\n  whenDefined(localName) {\n    if (!Utilities.isValidCustomElementName(localName)) {\n      return Promise.reject(new SyntaxError(`'${localName}' is not a valid custom element name.`));\n    }\n\n    const prior = this._whenDefinedDeferred.get(localName);\n    if (prior) {\n      return prior.toPromise();\n    }\n\n    const deferred = new Deferred();\n    this._whenDefinedDeferred.set(localName, deferred);\n\n    const definition = this._internals.localNameToDefinition(localName);\n    // Resolve immediately only if the given local name has a definition *and*\n    // the full document walk to upgrade elements with that local name has\n    // already happened.\n    if (definition && !this._pendingDefinitions.some(d => d.localName === localName)) {\n      deferred.resolve(undefined);\n    }\n\n    return deferred.toPromise();\n  }\n\n  polyfillWrapFlushCallback(outer) {\n    this._documentConstructionObserver.disconnect();\n    const inner = this._flushCallback;\n    this._flushCallback = flush => outer(() => inner(flush));\n  }\n}\n\n// Closure compiler exports.\nwindow['CustomElementRegistry'] = CustomElementRegistry;\nCustomElementRegistry.prototype['define'] = CustomElementRegistry.prototype.define;\nCustomElementRegistry.prototype['upgrade'] = CustomElementRegistry.prototype.upgrade;\nCustomElementRegistry.prototype['get'] = CustomElementRegistry.prototype.get;\nCustomElementRegistry.prototype['whenDefined'] = CustomElementRegistry.prototype.whenDefined;\nCustomElementRegistry.prototype['polyfillWrapFlushCallback'] = CustomElementRegistry.prototype.polyfillWrapFlushCallback;\n","/**\n * @template T\n */\nexport default class Deferred {\n  constructor() {\n    /**\n     * @private\n     * @type {T|undefined}\n     */\n    this._value = undefined;\n\n    /**\n     * @private\n     * @type {Function|undefined}\n     */\n    this._resolve = undefined;\n\n    /**\n     * @private\n     * @type {!Promise<T>}\n     */\n    this._promise = new Promise(resolve => {\n      this._resolve = resolve;\n\n      if (this._value) {\n        resolve(this._value);\n      }\n    });\n  }\n\n  /**\n   * @param {T} value\n   */\n  resolve(value) {\n    if (this._value) {\n      throw new Error('Already resolved.');\n    }\n\n    this._value = value;\n\n    if (this._resolve) {\n      this._resolve(value);\n    }\n  }\n\n  /**\n   * @return {!Promise<T>}\n   */\n  toPromise() {\n    return this._promise;\n  }\n}\n","export default {\n  Document_createElement: window.Document.prototype.createElement,\n  Document_createElementNS: window.Document.prototype.createElementNS,\n  Document_importNode: window.Document.prototype.importNode,\n  Document_prepend: window.Document.prototype['prepend'],\n  Document_append: window.Document.prototype['append'],\n  DocumentFragment_prepend: window.DocumentFragment.prototype['prepend'],\n  DocumentFragment_append: window.DocumentFragment.prototype['append'],\n  Node_cloneNode: window.Node.prototype.cloneNode,\n  Node_appendChild: window.Node.prototype.appendChild,\n  Node_insertBefore: window.Node.prototype.insertBefore,\n  Node_removeChild: window.Node.prototype.removeChild,\n  Node_replaceChild: window.Node.prototype.replaceChild,\n  Node_textContent: Object.getOwnPropertyDescriptor(window.Node.prototype, 'textContent'),\n  Element_attachShadow: window.Element.prototype['attachShadow'],\n  Element_innerHTML: Object.getOwnPropertyDescriptor(window.Element.prototype, 'innerHTML'),\n  Element_getAttribute: window.Element.prototype.getAttribute,\n  Element_setAttribute: window.Element.prototype.setAttribute,\n  Element_removeAttribute: window.Element.prototype.removeAttribute,\n  Element_getAttributeNS: window.Element.prototype.getAttributeNS,\n  Element_setAttributeNS: window.Element.prototype.setAttributeNS,\n  Element_removeAttributeNS: window.Element.prototype.removeAttributeNS,\n  Element_insertAdjacentElement: window.Element.prototype['insertAdjacentElement'],\n  Element_insertAdjacentHTML: window.Element.prototype['insertAdjacentHTML'],\n  Element_prepend: window.Element.prototype['prepend'],\n  Element_append: window.Element.prototype['append'],\n  Element_before: window.Element.prototype['before'],\n  Element_after: window.Element.prototype['after'],\n  Element_replaceWith: window.Element.prototype['replaceWith'],\n  Element_remove: window.Element.prototype['remove'],\n  HTMLElement: window.HTMLElement,\n  HTMLElement_innerHTML: Object.getOwnPropertyDescriptor(window.HTMLElement.prototype, 'innerHTML'),\n  HTMLElement_insertAdjacentElement: window.HTMLElement.prototype['insertAdjacentElement'],\n  HTMLElement_insertAdjacentHTML: window.HTMLElement.prototype['insertAdjacentHTML'],\n};\n","/**\n * This class exists only to work around Closure's lack of a way to describe\n * singletons. It represents the 'already constructed marker' used in custom\n * element construction stacks.\n *\n * https://html.spec.whatwg.org/#concept-already-constructed-marker\n * @extends AlreadyConstructedMarkerType\n */\nclass AlreadyConstructedMarker {}\n\nexport default new AlreadyConstructedMarker();\n","import Native from './Native.js';\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport CEState from '../CustomElementState.js';\nimport AlreadyConstructedMarker from '../AlreadyConstructedMarker.js';\n\n/**\n * @param {!CustomElementInternals} internals\n */\nexport default function(internals) {\n  window['HTMLElement'] = (function() {\n    /**\n     * @type {function(new: HTMLElement): !HTMLElement}\n     */\n    function HTMLElement() {\n      // This should really be `new.target` but `new.target` can't be emulated\n      // in ES5. Assuming the user keeps the default value of the constructor's\n      // prototype's `constructor` property, this is equivalent.\n      const constructor = /** @type {!Function} */ (this.constructor);\n\n      const definition = internals.constructorToDefinition(constructor);\n      if (!definition) {\n        throw new Error('The custom element being constructed was not registered with `customElements`.');\n      }\n\n      const constructionStack = definition.constructionStack;\n\n      if (constructionStack.length === 0) {\n        const element = /** @type {!HTMLElement} */ (Native.Document_createElement.call(document, definition.localName));\n        Object.setPrototypeOf(element, constructor.prototype);\n        element.__CE_state = CEState.custom;\n        element.__CE_definition = definition;\n        internals.patch(element);\n        return element;\n      }\n\n      const lastIndex = constructionStack.length - 1;\n      const element = constructionStack[lastIndex];\n      if (element === AlreadyConstructedMarker) {\n        throw new Error('The HTMLElement constructor was either called reentrantly for this constructor or called multiple times.');\n      }\n      const toConstructElement = /** @type {!HTMLElement} */ (element);\n      constructionStack[lastIndex] = AlreadyConstructedMarker;\n\n      Object.setPrototypeOf(toConstructElement, constructor.prototype);\n      internals.patch(toConstructElement);\n\n      return toConstructElement;\n    }\n\n    HTMLElement.prototype = Native.HTMLElement.prototype;\n    // Safari 9 has `writable: false` on the propertyDescriptor\n    // Make it writable so that TypeScript can patch up the\n    // constructor in the ES5 compiled code.\n    Object.defineProperty(HTMLElement.prototype, 'constructor', {\n      writable: true,\n      configurable: true,\n      enumerable: false,\n      value: HTMLElement\n    });\n\n    return HTMLElement;\n  })();\n};\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 */\n\nimport CustomElementInternals from './CustomElementInternals.js';\nimport CustomElementRegistry from './CustomElementRegistry.js';\n\nimport PatchHTMLElement from './Patch/HTMLElement.js';\nimport PatchDocument from './Patch/Document.js';\nimport PatchDocumentFragment from './Patch/DocumentFragment.js';\nimport PatchNode from './Patch/Node.js';\nimport PatchElement from './Patch/Element.js';\n\nconst priorCustomElements = window['customElements'];\n\nif (!priorCustomElements ||\n     priorCustomElements['forcePolyfill'] ||\n     (typeof priorCustomElements['define'] != 'function') ||\n     (typeof priorCustomElements['get'] != 'function')) {\n  /** @type {!CustomElementInternals} */\n  const internals = new CustomElementInternals();\n\n  PatchHTMLElement(internals);\n  PatchDocument(internals);\n  PatchDocumentFragment(internals);\n  PatchNode(internals);\n  PatchElement(internals);\n\n  // The main document is always associated with the registry.\n  document.__CE_hasRegistry = true;\n\n  /** @type {!CustomElementRegistry} */\n  const customElements = new CustomElementRegistry(internals);\n\n  Object.defineProperty(window, 'customElements', {\n    configurable: true,\n    enumerable: true,\n    value: customElements,\n  });\n}\n","import CustomElementInternals from '../../CustomElementInternals.js';\nimport * as Utilities from '../../Utilities.js';\n\n/**\n * @typedef {{\n *   prepend: !function(...(!Node|string)),\n  *  append: !function(...(!Node|string)),\n * }}\n */\nlet ParentNodeNativeMethods;\n\n/**\n * @param {!CustomElementInternals} internals\n * @param {!Object} destination\n * @param {!ParentNodeNativeMethods} builtIn\n */\nexport default function(internals, destination, builtIn) {\n  /**\n   * @param {!function(...(!Node|string))} builtInMethod\n   * @return {!function(...(!Node|string))}\n   */\n  function appendPrependPatch(builtInMethod) {\n    return function(...nodes) {\n      /**\n       * A copy of `nodes`, with any DocumentFragment replaced by its children.\n       * @type {!Array<!Node>}\n       */\n      const flattenedNodes = [];\n\n      /**\n       * Elements in `nodes` that were connected before this call.\n       * @type {!Array<!Node>}\n       */\n      const connectedElements = [];\n\n      for (var i = 0; i < nodes.length; i++) {\n        const node = nodes[i];\n\n        if (node instanceof Element && Utilities.isConnected(node)) {\n          connectedElements.push(node);\n        }\n\n        if (node instanceof DocumentFragment) {\n          for (let child = node.firstChild; child; child = child.nextSibling) {\n            flattenedNodes.push(child);\n          }\n        } else {\n          flattenedNodes.push(node);\n        }\n      }\n\n      builtInMethod.apply(this, nodes);\n\n      for (let i = 0; i < connectedElements.length; i++) {\n        internals.disconnectTree(connectedElements[i]);\n      }\n\n      if (Utilities.isConnected(this)) {\n        for (let i = 0; i < flattenedNodes.length; i++) {\n          const node = flattenedNodes[i];\n          if (node instanceof Element) {\n            internals.connectTree(node);\n          }\n        }\n      }\n    };\n  }\n\n  if (builtIn.prepend !== undefined) {\n    Utilities.setPropertyUnchecked(destination, 'prepend', appendPrependPatch(builtIn.prepend));\n  }\n\n  if (builtIn.append !== undefined) {\n    Utilities.setPropertyUnchecked(destination, 'append', appendPrependPatch(builtIn.append));\n  }\n};\n","import Native from './Native.js';\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport * as Utilities from '../Utilities.js';\n\nimport PatchParentNode from './Interface/ParentNode.js';\n\n/**\n * @param {!CustomElementInternals} internals\n */\nexport default function(internals) {\n  Utilities.setPropertyUnchecked(Document.prototype, 'createElement',\n    /**\n     * @this {Document}\n     * @param {string} localName\n     * @return {!Element}\n     */\n    function(localName) {\n      // Only create custom elements if this document is associated with the registry.\n      if (this.__CE_hasRegistry) {\n        const definition = internals.localNameToDefinition(localName);\n        if (definition) {\n          return new (definition.constructorFunction)();\n        }\n      }\n\n      const result = /** @type {!Element} */\n        (Native.Document_createElement.call(this, localName));\n      internals.patch(result);\n      return result;\n    });\n\n  Utilities.setPropertyUnchecked(Document.prototype, 'importNode',\n    /**\n     * @this {Document}\n     * @param {!Node} node\n     * @param {boolean=} deep\n     * @return {!Node}\n     */\n    function(node, deep) {\n      const clone = /** @type {!Node} */ (Native.Document_importNode.call(this, node, !!deep));\n      // Only create custom elements if this document is associated with the registry.\n      if (!this.__CE_hasRegistry) {\n        internals.patchTree(clone);\n      } else {\n        internals.patchAndUpgradeTree(clone);\n      }\n      return clone;\n    });\n\n  const NS_HTML = \"http://www.w3.org/1999/xhtml\";\n\n  Utilities.setPropertyUnchecked(Document.prototype, 'createElementNS',\n    /**\n     * @this {Document}\n     * @param {?string} namespace\n     * @param {string} localName\n     * @return {!Element}\n     */\n    function(namespace, localName) {\n      // Only create custom elements if this document is associated with the registry.\n      if (this.__CE_hasRegistry && (namespace === null || namespace === NS_HTML)) {\n        const definition = internals.localNameToDefinition(localName);\n        if (definition) {\n          return new (definition.constructorFunction)();\n        }\n      }\n\n      const result = /** @type {!Element} */\n        (Native.Document_createElementNS.call(this, namespace, localName));\n      internals.patch(result);\n      return result;\n    });\n\n  PatchParentNode(internals, Document.prototype, {\n    prepend: Native.Document_prepend,\n    append: Native.Document_append,\n  });\n};\n","import Native from './Native.js';\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport * as Utilities from '../Utilities.js';\n\n/**\n * @param {!CustomElementInternals} internals\n */\nexport default function(internals) {\n  // `Node#nodeValue` is implemented on `Attr`.\n  // `Node#textContent` is implemented on `Attr`, `Element`.\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'insertBefore',\n    /**\n     * @this {Node}\n     * @param {!Node} node\n     * @param {?Node} refNode\n     * @return {!Node}\n     */\n    function(node, refNode) {\n      if (node instanceof DocumentFragment) {\n        const insertedNodes = Array.prototype.slice.apply(node.childNodes);\n        const nativeResult = Native.Node_insertBefore.call(this, node, refNode);\n\n        // DocumentFragments can't be connected, so `disconnectTree` will never\n        // need to be called on a DocumentFragment's children after inserting it.\n\n        if (Utilities.isConnected(this)) {\n          for (let i = 0; i < insertedNodes.length; i++) {\n            internals.connectTree(insertedNodes[i]);\n          }\n        }\n\n        return nativeResult;\n      }\n\n      const nodeWasConnected = Utilities.isConnected(node);\n      const nativeResult = Native.Node_insertBefore.call(this, node, refNode);\n\n      if (nodeWasConnected) {\n        internals.disconnectTree(node);\n      }\n\n      if (Utilities.isConnected(this)) {\n        internals.connectTree(node);\n      }\n\n      return nativeResult;\n    });\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'appendChild',\n    /**\n     * @this {Node}\n     * @param {!Node} node\n     * @return {!Node}\n     */\n    function(node) {\n      if (node instanceof DocumentFragment) {\n        const insertedNodes = Array.prototype.slice.apply(node.childNodes);\n        const nativeResult = Native.Node_appendChild.call(this, node);\n\n        // DocumentFragments can't be connected, so `disconnectTree` will never\n        // need to be called on a DocumentFragment's children after inserting it.\n\n        if (Utilities.isConnected(this)) {\n          for (let i = 0; i < insertedNodes.length; i++) {\n            internals.connectTree(insertedNodes[i]);\n          }\n        }\n\n        return nativeResult;\n      }\n\n      const nodeWasConnected = Utilities.isConnected(node);\n      const nativeResult = Native.Node_appendChild.call(this, node);\n\n      if (nodeWasConnected) {\n        internals.disconnectTree(node);\n      }\n\n      if (Utilities.isConnected(this)) {\n        internals.connectTree(node);\n      }\n\n      return nativeResult;\n    });\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'cloneNode',\n    /**\n     * @this {Node}\n     * @param {boolean=} deep\n     * @return {!Node}\n     */\n    function(deep) {\n      const clone = Native.Node_cloneNode.call(this, !!deep);\n      // Only create custom elements if this element's owner document is\n      // associated with the registry.\n      if (!this.ownerDocument.__CE_hasRegistry) {\n        internals.patchTree(clone);\n      } else {\n        internals.patchAndUpgradeTree(clone);\n      }\n      return clone;\n    });\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'removeChild',\n    /**\n     * @this {Node}\n     * @param {!Node} node\n     * @return {!Node}\n     */\n    function(node) {\n      const nodeWasConnected = Utilities.isConnected(node);\n      const nativeResult = Native.Node_removeChild.call(this, node);\n\n      if (nodeWasConnected) {\n        internals.disconnectTree(node);\n      }\n\n      return nativeResult;\n    });\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'replaceChild',\n    /**\n     * @this {Node}\n     * @param {!Node} nodeToInsert\n     * @param {!Node} nodeToRemove\n     * @return {!Node}\n     */\n    function(nodeToInsert, nodeToRemove) {\n      if (nodeToInsert instanceof DocumentFragment) {\n        const insertedNodes = Array.prototype.slice.apply(nodeToInsert.childNodes);\n        const nativeResult = Native.Node_replaceChild.call(this, nodeToInsert, nodeToRemove);\n\n        // DocumentFragments can't be connected, so `disconnectTree` will never\n        // need to be called on a DocumentFragment's children after inserting it.\n\n        if (Utilities.isConnected(this)) {\n          internals.disconnectTree(nodeToRemove);\n          for (let i = 0; i < insertedNodes.length; i++) {\n            internals.connectTree(insertedNodes[i]);\n          }\n        }\n\n        return nativeResult;\n      }\n\n      const nodeToInsertWasConnected = Utilities.isConnected(nodeToInsert);\n      const nativeResult = Native.Node_replaceChild.call(this, nodeToInsert, nodeToRemove);\n      const thisIsConnected = Utilities.isConnected(this);\n\n      if (thisIsConnected) {\n        internals.disconnectTree(nodeToRemove);\n      }\n\n      if (nodeToInsertWasConnected) {\n        internals.disconnectTree(nodeToInsert);\n      }\n\n      if (thisIsConnected) {\n        internals.connectTree(nodeToInsert);\n      }\n\n      return nativeResult;\n    });\n\n\n  function patch_textContent(destination, baseDescriptor) {\n    Object.defineProperty(destination, 'textContent', {\n      enumerable: baseDescriptor.enumerable,\n      configurable: true,\n      get: baseDescriptor.get,\n      set: /** @this {Node} */ function(assignedValue) {\n        // If this is a text node then there are no nodes to disconnect.\n        if (this.nodeType === Node.TEXT_NODE) {\n          baseDescriptor.set.call(this, assignedValue);\n          return;\n        }\n\n        let removedNodes = undefined;\n        // Checking for `firstChild` is faster than reading `childNodes.length`\n        // to compare with 0.\n        if (this.firstChild) {\n          // Using `childNodes` is faster than `children`, even though we only\n          // care about elements.\n          const childNodes = this.childNodes;\n          const childNodesLength = childNodes.length;\n          if (childNodesLength > 0 && Utilities.isConnected(this)) {\n            // Copying an array by iterating is faster than using slice.\n            removedNodes = new Array(childNodesLength);\n            for (let i = 0; i < childNodesLength; i++) {\n              removedNodes[i] = childNodes[i];\n            }\n          }\n        }\n\n        baseDescriptor.set.call(this, assignedValue);\n\n        if (removedNodes) {\n          for (let i = 0; i < removedNodes.length; i++) {\n            internals.disconnectTree(removedNodes[i]);\n          }\n        }\n      },\n    });\n  }\n\n  if (Native.Node_textContent && Native.Node_textContent.get) {\n    patch_textContent(Node.prototype, Native.Node_textContent);\n  } else {\n    internals.addPatch(function(element) {\n      patch_textContent(element, {\n        enumerable: true,\n        configurable: true,\n        // NOTE: This implementation of the `textContent` getter assumes that\n        // text nodes' `textContent` getter will not be patched.\n        get: /** @this {Node} */ function() {\n          /** @type {!Array<string>} */\n          const parts = [];\n\n          for (let i = 0; i < this.childNodes.length; i++) {\n            parts.push(this.childNodes[i].textContent);\n          }\n\n          return parts.join('');\n        },\n        set: /** @this {Node} */ function(assignedValue) {\n          while (this.firstChild) {\n            Native.Node_removeChild.call(this, this.firstChild);\n          }\n          Native.Node_appendChild.call(this, document.createTextNode(assignedValue));\n        },\n      });\n    });\n  }\n};\n","import CustomElementInternals from '../../CustomElementInternals.js';\nimport * as Utilities from '../../Utilities.js';\n\n/**\n * @typedef {{\n *   before: !function(...(!Node|string)),\n *   after: !function(...(!Node|string)),\n *   replaceWith: !function(...(!Node|string)),\n *   remove: !function(),\n * }}\n */\nlet ChildNodeNativeMethods;\n\n/**\n * @param {!CustomElementInternals} internals\n * @param {!Object} destination\n * @param {!ChildNodeNativeMethods} builtIn\n */\nexport default function(internals, destination, builtIn) {\n  /**\n   * @param {!function(...(!Node|string))} builtInMethod\n   * @return {!function(...(!Node|string))}\n   */\n  function beforeAfterPatch(builtInMethod) {\n    return function(...nodes) {\n      /**\n       * A copy of `nodes`, with any DocumentFragment replaced by its children.\n       * @type {!Array<!Node>}\n       */\n      const flattenedNodes = [];\n\n      /**\n       * Elements in `nodes` that were connected before this call.\n       * @type {!Array<!Node>}\n       */\n      const connectedElements = [];\n\n      for (var i = 0; i < nodes.length; i++) {\n        const node = nodes[i];\n\n        if (node instanceof Element && Utilities.isConnected(node)) {\n          connectedElements.push(node);\n        }\n\n        if (node instanceof DocumentFragment) {\n          for (let child = node.firstChild; child; child = child.nextSibling) {\n            flattenedNodes.push(child);\n          }\n        } else {\n          flattenedNodes.push(node);\n        }\n      }\n\n      builtInMethod.apply(this, nodes);\n\n      for (let i = 0; i < connectedElements.length; i++) {\n        internals.disconnectTree(connectedElements[i]);\n      }\n\n      if (Utilities.isConnected(this)) {\n        for (let i = 0; i < flattenedNodes.length; i++) {\n          const node = flattenedNodes[i];\n          if (node instanceof Element) {\n            internals.connectTree(node);\n          }\n        }\n      }\n    };\n  }\n\n  if (builtIn.before !== undefined) {\n    Utilities.setPropertyUnchecked(destination, 'before', beforeAfterPatch(builtIn.before));\n  }\n\n  if (builtIn.before !== undefined) {\n    Utilities.setPropertyUnchecked(destination, 'after', beforeAfterPatch(builtIn.after));\n  }\n\n  if (builtIn.replaceWith !== undefined) {\n    Utilities.setPropertyUnchecked(destination, 'replaceWith',\n      /**\n       * @param {...(!Node|string)} nodes\n       */\n      function(...nodes) {\n        /**\n         * A copy of `nodes`, with any DocumentFragment replaced by its children.\n         * @type {!Array<!Node|string>}\n         */\n        const flattenedNodes = [];\n\n        /**\n         * Elements in `nodes` that were connected before this call.\n         * @type {!Array<!Node>}\n         */\n        const connectedElements = [];\n\n        for (var i = 0; i < nodes.length; i++) {\n          const node = nodes[i];\n\n          if (node instanceof Element && Utilities.isConnected(node)) {\n            connectedElements.push(node);\n          }\n\n          if (node instanceof DocumentFragment) {\n            for (let child = node.firstChild; child; child = child.nextSibling) {\n              flattenedNodes.push(child);\n            }\n          } else {\n            flattenedNodes.push(node);\n          }\n        }\n\n        const wasConnected = Utilities.isConnected(this);\n\n        builtIn.replaceWith.apply(this, nodes);\n\n        for (let i = 0; i < connectedElements.length; i++) {\n          internals.disconnectTree(connectedElements[i]);\n        }\n\n        if (wasConnected) {\n          internals.disconnectTree(this);\n          for (let i = 0; i < flattenedNodes.length; i++) {\n            const node = flattenedNodes[i];\n            if (node instanceof Element) {\n              internals.connectTree(node);\n            }\n          }\n        }\n      });\n    }\n\n  if (builtIn.remove !== undefined) {\n    Utilities.setPropertyUnchecked(destination, 'remove',\n      function() {\n        const wasConnected = Utilities.isConnected(this);\n\n        builtIn.remove.call(this);\n\n        if (wasConnected) {\n          internals.disconnectTree(this);\n        }\n      });\n  }\n};\n","import Native from './Native.js';\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport CEState from '../CustomElementState.js';\nimport * as Utilities from '../Utilities.js';\n\nimport PatchParentNode from './Interface/ParentNode.js';\nimport PatchChildNode from './Interface/ChildNode.js';\n\n/**\n * @param {!CustomElementInternals} internals\n */\nexport default function(internals) {\n  if (Native.Element_attachShadow) {\n    Utilities.setPropertyUnchecked(Element.prototype, 'attachShadow',\n      /**\n       * @this {Element}\n       * @param {!{mode: string}} init\n       * @return {ShadowRoot}\n       */\n      function(init) {\n        const shadowRoot = Native.Element_attachShadow.call(this, init);\n        this.__CE_shadowRoot = shadowRoot;\n        return shadowRoot;\n      });\n  }\n\n\n  function patch_innerHTML(destination, baseDescriptor) {\n    Object.defineProperty(destination, 'innerHTML', {\n      enumerable: baseDescriptor.enumerable,\n      configurable: true,\n      get: baseDescriptor.get,\n      set: /** @this {Element} */ function(htmlString) {\n        const isConnected = Utilities.isConnected(this);\n\n        // NOTE: In IE11, when using the native `innerHTML` setter, all nodes\n        // that were previously descendants of the context element have all of\n        // their children removed as part of the set - the entire subtree is\n        // 'disassembled'. This work around walks the subtree *before* using the\n        // native setter.\n        /** @type {!Array<!Element>|undefined} */\n        let removedElements = undefined;\n        if (isConnected) {\n          removedElements = [];\n          Utilities.walkDeepDescendantElements(this, element => {\n            if (element !== this) {\n              removedElements.push(element);\n            }\n          });\n        }\n\n        baseDescriptor.set.call(this, htmlString);\n\n        if (removedElements) {\n          for (let i = 0; i < removedElements.length; i++) {\n            const element = removedElements[i];\n            if (element.__CE_state === CEState.custom) {\n              internals.disconnectedCallback(element);\n            }\n          }\n        }\n\n        // Only create custom elements if this element's owner document is\n        // associated with the registry.\n        if (!this.ownerDocument.__CE_hasRegistry) {\n          internals.patchTree(this);\n        } else {\n          internals.patchAndUpgradeTree(this);\n        }\n        return htmlString;\n      },\n    });\n  }\n\n  if (Native.Element_innerHTML && Native.Element_innerHTML.get) {\n    patch_innerHTML(Element.prototype, Native.Element_innerHTML);\n  } else if (Native.HTMLElement_innerHTML && Native.HTMLElement_innerHTML.get) {\n    patch_innerHTML(HTMLElement.prototype, Native.HTMLElement_innerHTML);\n  } else {\n\n    internals.addPatch(function(element) {\n      patch_innerHTML(element, {\n        enumerable: true,\n        configurable: true,\n        // Implements getting `innerHTML` by performing an unpatched `cloneNode`\n        // of the element and returning the resulting element's `innerHTML`.\n        // TODO: Is this too expensive?\n        get: /** @this {Element} */ function() {\n          return Native.Node_cloneNode.call(this, true).innerHTML;\n        },\n        // Implements setting `innerHTML` by creating an unpatched element,\n        // setting `innerHTML` of that element and replacing the target\n        // element's children with those of the unpatched element.\n        set: /** @this {Element} */ function(assignedValue) {\n          // NOTE: re-route to `content` for `template` elements.\n          // We need to do this because `template.appendChild` does not\n          // route into `template.content`.\n          const isTemplate = (this.localName === 'template');\n          /** @type {!Node} */\n          const content = isTemplate ? (/** @type {!HTMLTemplateElement} */\n            (this)).content : this;\n          /** @type {!Node} */\n          const rawElement = Native.Document_createElementNS.call(document,\n              this.namespaceURI, this.localName);\n          rawElement.innerHTML = assignedValue;\n\n          while (content.childNodes.length > 0) {\n            Native.Node_removeChild.call(content, content.childNodes[0]);\n          }\n          const container = isTemplate ? rawElement.content : rawElement;\n          while (container.childNodes.length > 0) {\n            Native.Node_appendChild.call(content, container.childNodes[0]);\n          }\n        },\n      });\n    });\n  }\n\n\n  Utilities.setPropertyUnchecked(Element.prototype, 'setAttribute',\n    /**\n     * @this {Element}\n     * @param {string} name\n     * @param {string} newValue\n     */\n    function(name, newValue) {\n      // Fast path for non-custom elements.\n      if (this.__CE_state !== CEState.custom) {\n        return Native.Element_setAttribute.call(this, name, newValue);\n      }\n\n      const oldValue = Native.Element_getAttribute.call(this, name);\n      Native.Element_setAttribute.call(this, name, newValue);\n      newValue = Native.Element_getAttribute.call(this, name);\n      internals.attributeChangedCallback(this, name, oldValue, newValue, null);\n    });\n\n  Utilities.setPropertyUnchecked(Element.prototype, 'setAttributeNS',\n    /**\n     * @this {Element}\n     * @param {?string} namespace\n     * @param {string} name\n     * @param {string} newValue\n     */\n    function(namespace, name, newValue) {\n      // Fast path for non-custom elements.\n      if (this.__CE_state !== CEState.custom) {\n        return Native.Element_setAttributeNS.call(this, namespace, name, newValue);\n      }\n\n      const oldValue = Native.Element_getAttributeNS.call(this, namespace, name);\n      Native.Element_setAttributeNS.call(this, namespace, name, newValue);\n      newValue = Native.Element_getAttributeNS.call(this, namespace, name);\n      internals.attributeChangedCallback(this, name, oldValue, newValue, namespace);\n    });\n\n  Utilities.setPropertyUnchecked(Element.prototype, 'removeAttribute',\n    /**\n     * @this {Element}\n     * @param {string} name\n     */\n    function(name) {\n      // Fast path for non-custom elements.\n      if (this.__CE_state !== CEState.custom) {\n        return Native.Element_removeAttribute.call(this, name);\n      }\n\n      const oldValue = Native.Element_getAttribute.call(this, name);\n      Native.Element_removeAttribute.call(this, name);\n      if (oldValue !== null) {\n        internals.attributeChangedCallback(this, name, oldValue, null, null);\n      }\n    });\n\n  Utilities.setPropertyUnchecked(Element.prototype, 'removeAttributeNS',\n    /**\n     * @this {Element}\n     * @param {?string} namespace\n     * @param {string} name\n     */\n    function(namespace, name) {\n      // Fast path for non-custom elements.\n      if (this.__CE_state !== CEState.custom) {\n        return Native.Element_removeAttributeNS.call(this, namespace, name);\n      }\n\n      const oldValue = Native.Element_getAttributeNS.call(this, namespace, name);\n      Native.Element_removeAttributeNS.call(this, namespace, name);\n      // In older browsers, `Element#getAttributeNS` may return the empty string\n      // instead of null if the attribute does not exist. For details, see;\n      // https://developer.mozilla.org/en-US/docs/Web/API/Element/getAttributeNS#Notes\n      const newValue = Native.Element_getAttributeNS.call(this, namespace, name);\n      if (oldValue !== newValue) {\n        internals.attributeChangedCallback(this, name, oldValue, newValue, namespace);\n      }\n    });\n\n\n  function patch_insertAdjacentElement(destination, baseMethod) {\n    Utilities.setPropertyUnchecked(destination, 'insertAdjacentElement',\n      /**\n       * @this {Element}\n       * @param {string} position\n       * @param {!Element} element\n       * @return {?Element}\n       */\n      function(position, element) {\n        const wasConnected = Utilities.isConnected(element);\n        const insertedElement = /** @type {!Element} */\n          (baseMethod.call(this, position, element));\n\n        if (wasConnected) {\n          internals.disconnectTree(element);\n        }\n\n        if (Utilities.isConnected(insertedElement)) {\n          internals.connectTree(element);\n        }\n        return insertedElement;\n      });\n  }\n\n  if (Native.HTMLElement_insertAdjacentElement) {\n    patch_insertAdjacentElement(HTMLElement.prototype, Native.HTMLElement_insertAdjacentElement);\n  } else if (Native.Element_insertAdjacentElement) {\n    patch_insertAdjacentElement(Element.prototype, Native.Element_insertAdjacentElement);\n  } else {\n    console.warn('Custom Elements: `Element#insertAdjacentElement` was not patched.');\n  }\n\n\n  function patch_insertAdjacentHTML(destination, baseMethod) {\n    /**\n     * Patches and upgrades all nodes which are siblings between `start`\n     * (inclusive) and `end` (exclusive). If `end` is `null`, then all siblings\n     * following `start` will be patched and upgraded.\n     * @param {!Node} start\n     * @param {?Node} end\n     */\n    function upgradeNodesInRange(start, end) {\n      const nodes = [];\n      for (let node = start; node !== end; node = node.nextSibling) {\n        nodes.push(node);\n      }\n      for (let i = 0; i < nodes.length; i++) {\n        internals.patchAndUpgradeTree(nodes[i]);\n      }\n    }\n\n    Utilities.setPropertyUnchecked(destination, 'insertAdjacentHTML',\n      /**\n       * @this {Element}\n       * @param {string} position\n       * @param {string} text\n       */\n      function(position, text) {\n        position = position.toLowerCase();\n\n        if (position === \"beforebegin\") {\n          const marker = this.previousSibling;\n          baseMethod.call(this, position, text);\n          upgradeNodesInRange(marker || /** @type {!Node} */ (this.parentNode.firstChild), this);\n        } else if (position === \"afterbegin\") {\n          const marker = this.firstChild;\n          baseMethod.call(this, position, text);\n          upgradeNodesInRange(/** @type {!Node} */ (this.firstChild), marker);\n        } else if (position === \"beforeend\") {\n          const marker = this.lastChild;\n          baseMethod.call(this, position, text);\n          upgradeNodesInRange(marker || /** @type {!Node} */ (this.firstChild), null);\n        } else if (position === \"afterend\") {\n          const marker = this.nextSibling;\n          baseMethod.call(this, position, text);\n          upgradeNodesInRange(/** @type {!Node} */ (this.nextSibling), marker);\n        } else {\n          throw new SyntaxError(`The value provided (${String(position)}) is ` +\n            \"not one of 'beforebegin', 'afterbegin', 'beforeend', or 'afterend'.\");\n        }\n      });\n  }\n\n  if (Native.HTMLElement_insertAdjacentHTML) {\n    patch_insertAdjacentHTML(HTMLElement.prototype, Native.HTMLElement_insertAdjacentHTML);\n  } else if (Native.Element_insertAdjacentHTML) {\n    patch_insertAdjacentHTML(Element.prototype, Native.Element_insertAdjacentHTML);\n  } else {\n    console.warn('Custom Elements: `Element#insertAdjacentHTML` was not patched.');\n  }\n\n\n  PatchParentNode(internals, Element.prototype, {\n    prepend: Native.Element_prepend,\n    append: Native.Element_append,\n  });\n\n  PatchChildNode(internals, Element.prototype, {\n    before: Native.Element_before,\n    after: Native.Element_after,\n    replaceWith: Native.Element_replaceWith,\n    remove: Native.Element_remove,\n  });\n};\n","import CustomElementInternals from '../CustomElementInternals.js';\nimport Native from './Native.js';\nimport PatchParentNode from './Interface/ParentNode.js';\n\n/**\n * @param {!CustomElementInternals} internals\n */\nexport default function(internals) {\n  PatchParentNode(internals, DocumentFragment.prototype, {\n    prepend: Native.DocumentFragment_prepend,\n    append: Native.DocumentFragment_append,\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/*\nExtremely simple css parser. Intended to be not more than what we need\nand definitely not necessarily correct =).\n*/\n\n'use strict';\n\n/** @unrestricted */\nclass StyleNode {\n  constructor() {\n    /** @type {number} */\n    this['start'] = 0;\n    /** @type {number} */\n    this['end'] = 0;\n    /** @type {StyleNode} */\n    this['previous'] = null;\n    /** @type {StyleNode} */\n    this['parent'] = null;\n    /** @type {Array<StyleNode>} */\n    this['rules'] = null;\n    /** @type {string} */\n    this['parsedCssText'] = '';\n    /** @type {string} */\n    this['cssText'] = '';\n    /** @type {boolean} */\n    this['atRule'] = false;\n    /** @type {number} */\n    this['type'] = 0;\n    /** @type {string} */\n    this['keyframesName'] = '';\n    /** @type {string} */\n    this['selector'] = '';\n    /** @type {string} */\n    this['parsedSelector'] = '';\n  }\n}\n\nexport {StyleNode}\n\n// given a string of css, return a simple rule tree\n/**\n * @param {string} text\n * @return {StyleNode}\n */\nexport function parse(text) {\n  text = clean(text);\n  return parseCss(lex(text), text);\n}\n\n// remove stuff we don't care about that may hinder parsing\n/**\n * @param {string} cssText\n * @return {string}\n */\nfunction clean(cssText) {\n  return cssText.replace(RX.comments, '').replace(RX.port, '');\n}\n\n// super simple {...} lexer that returns a node tree\n/**\n * @param {string} text\n * @return {StyleNode}\n */\nfunction lex(text) {\n  let root = new StyleNode();\n  root['start'] = 0;\n  root['end'] = text.length\n  let n = root;\n  for (let i = 0, l = text.length; i < l; i++) {\n    if (text[i] === OPEN_BRACE) {\n      if (!n['rules']) {\n        n['rules'] = [];\n      }\n      let p = n;\n      let previous = p['rules'][p['rules'].length - 1] || null;\n      n = new StyleNode();\n      n['start'] = i + 1;\n      n['parent'] = p;\n      n['previous'] = previous;\n      p['rules'].push(n);\n    } else if (text[i] === CLOSE_BRACE) {\n      n['end'] = i + 1;\n      n = n['parent'] || root;\n    }\n  }\n  return root;\n}\n\n// add selectors/cssText to node tree\n/**\n * @param {StyleNode} node\n * @param {string} text\n * @return {StyleNode}\n */\nfunction parseCss(node, text) {\n  let t = text.substring(node['start'], node['end'] - 1);\n  node['parsedCssText'] = node['cssText'] = t.trim();\n  if (node['parent']) {\n    let ss = node['previous'] ? node['previous']['end'] : node['parent']['start'];\n    t = text.substring(ss, node['start'] - 1);\n    t = _expandUnicodeEscapes(t);\n    t = t.replace(RX.multipleSpaces, ' ');\n    // TODO(sorvell): ad hoc; make selector include only after last ;\n    // helps with mixin syntax\n    t = t.substring(t.lastIndexOf(';') + 1);\n    let s = node['parsedSelector'] = node['selector'] = t.trim();\n    node['atRule'] = (s.indexOf(AT_START) === 0);\n    // note, support a subset of rule types...\n    if (node['atRule']) {\n      if (s.indexOf(MEDIA_START) === 0) {\n        node['type'] = types.MEDIA_RULE;\n      } else if (s.match(RX.keyframesRule)) {\n        node['type'] = types.KEYFRAMES_RULE;\n        node['keyframesName'] =\n          node['selector'].split(RX.multipleSpaces).pop();\n      }\n    } else {\n      if (s.indexOf(VAR_START) === 0) {\n        node['type'] = types.MIXIN_RULE;\n      } else {\n        node['type'] = types.STYLE_RULE;\n      }\n    }\n  }\n  let r$ = node['rules'];\n  if (r$) {\n    for (let i = 0, l = r$.length, r;\n      (i < l) && (r = r$[i]); i++) {\n      parseCss(r, text);\n    }\n  }\n  return node;\n}\n\n/**\n * conversion of sort unicode escapes with spaces like `\\33 ` (and longer) into\n * expanded form that doesn't require trailing space `\\000033`\n * @param {string} s\n * @return {string}\n */\nfunction _expandUnicodeEscapes(s) {\n  return s.replace(/\\\\([0-9a-f]{1,6})\\s/gi, function() {\n    let code = arguments[1],\n      repeat = 6 - code.length;\n    while (repeat--) {\n      code = '0' + code;\n    }\n    return '\\\\' + code;\n  });\n}\n\n/**\n * stringify parsed css.\n * @param {StyleNode} node\n * @param {boolean=} preserveProperties\n * @param {string=} text\n * @return {string}\n */\nexport function stringify(node, preserveProperties, text = '') {\n  // calc rule cssText\n  let cssText = '';\n  if (node['cssText'] || node['rules']) {\n    let r$ = node['rules'];\n    if (r$ && !_hasMixinRules(r$)) {\n      for (let i = 0, l = r$.length, r;\n        (i < l) && (r = r$[i]); i++) {\n        cssText = stringify(r, preserveProperties, cssText);\n      }\n    } else {\n      cssText = preserveProperties ? node['cssText'] :\n        removeCustomProps(node['cssText']);\n      cssText = cssText.trim();\n      if (cssText) {\n        cssText = '  ' + cssText + '\\n';\n      }\n    }\n  }\n  // emit rule if there is cssText\n  if (cssText) {\n    if (node['selector']) {\n      text += node['selector'] + ' ' + OPEN_BRACE + '\\n';\n    }\n    text += cssText;\n    if (node['selector']) {\n      text += CLOSE_BRACE + '\\n\\n';\n    }\n  }\n  return text;\n}\n\n/**\n * @param {Array<StyleNode>} rules\n * @return {boolean}\n */\nfunction _hasMixinRules(rules) {\n  let r = rules[0];\n  return Boolean(r) && Boolean(r['selector']) && r['selector'].indexOf(VAR_START) === 0;\n}\n\n/**\n * @param {string} cssText\n * @return {string}\n */\nfunction removeCustomProps(cssText) {\n  cssText = removeCustomPropAssignment(cssText);\n  return removeCustomPropApply(cssText);\n}\n\n/**\n * @param {string} cssText\n * @return {string}\n */\nexport function removeCustomPropAssignment(cssText) {\n  return cssText\n    .replace(RX.customProp, '')\n    .replace(RX.mixinProp, '');\n}\n\n/**\n * @param {string} cssText\n * @return {string}\n */\nfunction removeCustomPropApply(cssText) {\n  return cssText\n    .replace(RX.mixinApply, '')\n    .replace(RX.varApply, '');\n}\n\n/** @enum {number} */\nexport const types = {\n  STYLE_RULE: 1,\n  KEYFRAMES_RULE: 7,\n  MEDIA_RULE: 4,\n  MIXIN_RULE: 1000\n}\n\nconst OPEN_BRACE = '{';\nconst CLOSE_BRACE = '}';\n\n// helper regexp's\nconst RX = {\n  comments: /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//gim,\n  port: /@import[^;]*;/gim,\n  customProp: /(?:^[^;\\-\\s}]+)?--[^;{}]*?:[^{};]*?(?:[;\\n]|$)/gim,\n  mixinProp: /(?:^[^;\\-\\s}]+)?--[^;{}]*?:[^{};]*?{[^}]*?}(?:[;\\n]|$)?/gim,\n  mixinApply: /@apply\\s*\\(?[^);]*\\)?\\s*(?:[;\\n]|$)?/gim,\n  varApply: /[^;:]*?:[^;]*?var\\([^;]*\\)(?:[;\\n]|$)?/gim,\n  keyframesRule: /^@[^\\s]*keyframes/,\n  multipleSpaces: /\\s+/g\n}\n\nconst VAR_START = '--';\nconst MEDIA_START = '@media';\nconst AT_START = '@';\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'use strict';\n\nexport const nativeShadow = !(window['ShadyDOM'] && window['ShadyDOM']['inUse']);\nlet nativeCssVariables_;\n\n/**\n * @param {(ShadyCSSOptions | ShadyCSSInterface)=} settings\n */\nfunction calcCssVariables(settings) {\n  if (settings && settings['shimcssproperties']) {\n    nativeCssVariables_ = false;\n  } else {\n    // chrome 49 has semi-working css vars, check if box-shadow works\n    // safari 9.1 has a recalc bug: https://bugs.webkit.org/show_bug.cgi?id=155782\n    // However, shim css custom properties are only supported with ShadyDOM enabled,\n    // so fall back on native if we do not detect ShadyDOM\n    // Edge 15: custom properties used in ::before and ::after will also be used in the parent element\n    // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12414257/\n    nativeCssVariables_ = nativeShadow || Boolean(!navigator.userAgent.match(/AppleWebKit\\/601|Edge\\/15/) &&\n      window.CSS && CSS.supports && CSS.supports('box-shadow', '0 0 0 var(--foo)'));\n  }\n}\n\n/** @type {string | undefined} */\nexport let cssBuild;\nif (window.ShadyCSS && window.ShadyCSS.cssBuild !== undefined) {\n  cssBuild = window.ShadyCSS.cssBuild;\n}\n\n/** @type {boolean} */\nexport const disableRuntime = Boolean(window.ShadyCSS && window.ShadyCSS.disableRuntime);\n\nif (window.ShadyCSS && window.ShadyCSS.nativeCss !== undefined) {\n  nativeCssVariables_ = window.ShadyCSS.nativeCss;\n} else if (window.ShadyCSS) {\n  calcCssVariables(window.ShadyCSS);\n  // reset window variable to let ShadyCSS API take its place\n  window.ShadyCSS = undefined;\n} else {\n  calcCssVariables(window['WebComponents'] && window['WebComponents']['flags']);\n}\n\n// Hack for type error under new type inference which doesn't like that\n// nativeCssVariables is updated in a function and assigns the type\n// `function(): ?` instead of `boolean`.\nexport const nativeCssVariables = /** @type {boolean} */(nativeCssVariables_);","/**\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\nexport const VAR_ASSIGN = /(?:^|[;\\s{]\\s*)(--[\\w-]*?)\\s*:\\s*(?:((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^)]*?\\)|[^};{])+)|\\{([^}]*)\\}(?:(?=[;\\s}])|$))/gi;\nexport const MIXIN_MATCH = /(?:^|\\W+)@apply\\s*\\(?([^);\\n]*)\\)?/gi;\nexport const VAR_CONSUMED = /(--[\\w-]+)\\s*([:,;)]|$)/gi;\nexport const ANIMATION_MATCH = /(animation\\s*:)|(animation-name\\s*:)/;\nexport const MEDIA_MATCH = /@media\\s(.*)/;\nexport const IS_VAR = /^--/;\nexport const BRACKETED = /\\{[^}]*\\}/g;\nexport const HOST_PREFIX = '(?:^|[^.#[:])';\nexport const HOST_SUFFIX = '($|[.:[\\\\s>+~])';\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'use strict';\n\n/** @type {!Set<string>} */\nconst styleTextSet = new Set();\n\nexport const scopingAttribute = 'shady-unscoped';\n\n/**\n * Add a specifically-marked style to the document directly, and only one copy of that style.\n *\n * @param {!HTMLStyleElement} style\n * @return {undefined}\n */\nexport function processUnscopedStyle(style) {\n  const text = style.textContent;\n  if (!styleTextSet.has(text)) {\n    styleTextSet.add(text);\n    const newStyle = style.cloneNode(true);\n    document.head.appendChild(newStyle);\n  }\n}\n\n/**\n * Check if a style is supposed to be unscoped\n * @param {!HTMLStyleElement} style\n * @return {boolean} true if the style has the unscoping attribute\n */\nexport function isUnscopedStyle(style) {\n  return style.hasAttribute(scopingAttribute);\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'use strict';\n\nimport {nativeShadow, nativeCssVariables, cssBuild} from './style-settings.js';\nimport {parse, stringify, types, StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\nimport {MEDIA_MATCH} from './common-regex.js';\nimport {processUnscopedStyle, isUnscopedStyle} from './unscoped-style-handler.js';\n\n/**\n * @param {string|StyleNode} rules\n * @param {function(StyleNode)=} callback\n * @return {string}\n */\nexport function toCssText (rules, callback) {\n  if (!rules) {\n    return '';\n  }\n  if (typeof rules === 'string') {\n    rules = parse(rules);\n  }\n  if (callback) {\n    forEachRule(rules, callback);\n  }\n  return stringify(rules, nativeCssVariables);\n}\n\n/**\n * @param {HTMLStyleElement} style\n * @return {StyleNode}\n */\nexport function rulesForStyle(style) {\n  if (!style['__cssRules'] && style.textContent) {\n    style['__cssRules'] = parse(style.textContent);\n  }\n  return style['__cssRules'] || null;\n}\n\n// Tests if a rule is a keyframes selector, which looks almost exactly\n// like a normal selector but is not (it has nothing to do with scoping\n// for example).\n/**\n * @param {StyleNode} rule\n * @return {boolean}\n */\nexport function isKeyframesSelector(rule) {\n  return Boolean(rule['parent']) &&\n  rule['parent']['type'] === types.KEYFRAMES_RULE;\n}\n\n/**\n * @param {StyleNode} node\n * @param {Function=} styleRuleCallback\n * @param {Function=} keyframesRuleCallback\n * @param {boolean=} onlyActiveRules\n */\nexport function forEachRule(node, styleRuleCallback, keyframesRuleCallback, onlyActiveRules) {\n  if (!node) {\n    return;\n  }\n  let skipRules = false;\n  let type = node['type'];\n  if (onlyActiveRules) {\n    if (type === types.MEDIA_RULE) {\n      let matchMedia = node['selector'].match(MEDIA_MATCH);\n      if (matchMedia) {\n        // if rule is a non matching @media rule, skip subrules\n        if (!window.matchMedia(matchMedia[1]).matches) {\n          skipRules = true;\n        }\n      }\n    }\n  }\n  if (type === types.STYLE_RULE) {\n    styleRuleCallback(node);\n  } else if (keyframesRuleCallback &&\n    type === types.KEYFRAMES_RULE) {\n    keyframesRuleCallback(node);\n  } else if (type === types.MIXIN_RULE) {\n    skipRules = true;\n  }\n  let r$ = node['rules'];\n  if (r$ && !skipRules) {\n    for (let i=0, l=r$.length, r; (i<l) && (r=r$[i]); i++) {\n      forEachRule(r, styleRuleCallback, keyframesRuleCallback, onlyActiveRules);\n    }\n  }\n}\n\n// add a string of cssText to the document.\n/**\n * @param {string} cssText\n * @param {string} moniker\n * @param {Node} target\n * @param {Node} contextNode\n * @return {HTMLStyleElement}\n */\nexport function applyCss(cssText, moniker, target, contextNode) {\n  let style = createScopeStyle(cssText, moniker);\n  applyStyle(style, target, contextNode);\n  return style;\n}\n\n/**\n * @param {string} cssText\n * @param {string} moniker\n * @return {HTMLStyleElement}\n */\nexport function createScopeStyle(cssText, moniker) {\n  let style = /** @type {HTMLStyleElement} */(document.createElement('style'));\n  if (moniker) {\n    style.setAttribute('scope', moniker);\n  }\n  style.textContent = cssText;\n  return style;\n}\n\n/**\n * Track the position of the last added style for placing placeholders\n * @type {Node}\n */\nlet lastHeadApplyNode = null;\n\n// insert a comment node as a styling position placeholder.\n/**\n * @param {string} moniker\n * @return {!Comment}\n */\nexport function applyStylePlaceHolder(moniker) {\n  let placeHolder = document.createComment(' Shady DOM styles for ' +\n    moniker + ' ');\n  let after = lastHeadApplyNode ?\n    lastHeadApplyNode['nextSibling'] : null;\n  let scope = document.head;\n  scope.insertBefore(placeHolder, after || scope.firstChild);\n  lastHeadApplyNode = placeHolder;\n  return placeHolder;\n}\n\n/**\n * @param {HTMLStyleElement} style\n * @param {?Node} target\n * @param {?Node} contextNode\n */\nexport function applyStyle(style, target, contextNode) {\n  target = target || document.head;\n  let after = (contextNode && contextNode.nextSibling) ||\n    target.firstChild;\n  target.insertBefore(style, after);\n  if (!lastHeadApplyNode) {\n    lastHeadApplyNode = style;\n  } else {\n    // only update lastHeadApplyNode if the new style is inserted after the old lastHeadApplyNode\n    let position = style.compareDocumentPosition(lastHeadApplyNode);\n    if (position === Node.DOCUMENT_POSITION_PRECEDING) {\n      lastHeadApplyNode = style;\n    }\n  }\n}\n\n/**\n * @param {string} buildType\n * @return {boolean}\n */\nexport function isTargetedBuild(buildType) {\n  return nativeShadow ? buildType === 'shadow' : buildType === 'shady';\n}\n\n/**\n * Walk from text[start] matching parens and\n * returns position of the outer end paren\n * @param {string} text\n * @param {number} start\n * @return {number}\n */\nexport function findMatchingParen(text, start) {\n  let level = 0;\n  for (let i=start, l=text.length; i < l; i++) {\n    if (text[i] === '(') {\n      level++;\n    } else if (text[i] === ')') {\n      if (--level === 0) {\n        return i;\n      }\n    }\n  }\n  return -1;\n}\n\n/**\n * @param {string} str\n * @param {function(string, string, string, string)} callback\n */\nexport function processVariableAndFallback(str, callback) {\n  // find 'var('\n  let start = str.indexOf('var(');\n  if (start === -1) {\n    // no var?, everything is prefix\n    return callback(str, '', '', '');\n  }\n  //${prefix}var(${inner})${suffix}\n  let end = findMatchingParen(str, start + 3);\n  let inner = str.substring(start + 4, end);\n  let prefix = str.substring(0, start);\n  // suffix may have other variables\n  let suffix = processVariableAndFallback(str.substring(end + 1), callback);\n  let comma = inner.indexOf(',');\n  // value and fallback args should be trimmed to match in property lookup\n  if (comma === -1) {\n    // variable, no fallback\n    return callback(prefix, inner.trim(), '', suffix);\n  }\n  // var(${value},${fallback})\n  let value = inner.substring(0, comma).trim();\n  let fallback = inner.substring(comma + 1).trim();\n  return callback(prefix, value, fallback, suffix);\n}\n\n/**\n * @param {Element} element\n * @param {string} value\n */\nexport function setElementClassRaw(element, value) {\n  // use native setAttribute provided by ShadyDOM when setAttribute is patched\n  if (nativeShadow) {\n    element.setAttribute('class', value);\n  } else {\n    window['ShadyDOM']['nativeMethods']['setAttribute'].call(element, 'class', value);\n  }\n}\n\n/**\n * @type {function(*):*}\n */\nexport const wrap = window['ShadyDOM'] && window['ShadyDOM']['wrap'] || ((node) => node);\n\n/**\n * @param {Element | {is: string, extends: string}} element\n * @return {{is: string, typeExtension: string}}\n */\nexport function getIsExtends(element) {\n  let localName = element['localName'];\n  let is = '', typeExtension = '';\n  /*\n  NOTE: technically, this can be wrong for certain svg elements\n  with `-` in the name like `<font-face>`\n  */\n  if (localName) {\n    if (localName.indexOf('-') > -1) {\n      is = localName;\n    } else {\n      typeExtension = localName;\n      is = (element.getAttribute && element.getAttribute('is')) || '';\n    }\n  } else {\n    is = /** @type {?} */(element).is;\n    typeExtension = /** @type {?} */(element).extends;\n  }\n  return {is, typeExtension};\n}\n\n/**\n * @param {Element|DocumentFragment} element\n * @return {string}\n */\nexport function gatherStyleText(element) {\n  /** @type {!Array<string>} */\n  const styleTextParts = [];\n  const styles = /** @type {!NodeList<!HTMLStyleElement>} */(element.querySelectorAll('style'));\n  for (let i = 0; i < styles.length; i++) {\n    const style = styles[i];\n    if (isUnscopedStyle(style)) {\n      if (!nativeShadow) {\n        processUnscopedStyle(style);\n        style.parentNode.removeChild(style);\n      }\n    } else {\n      styleTextParts.push(style.textContent);\n      style.parentNode.removeChild(style);\n    }\n  }\n  return styleTextParts.join('').trim();\n}\n\n/**\n * Split a selector separated by commas into an array in a smart way\n * @param {string} selector\n * @return {!Array<string>}\n */\nexport function splitSelectorList(selector) {\n  const parts = [];\n  let part = '';\n  for (let i = 0; i >= 0 && i < selector.length; i++) {\n    // A selector with parentheses will be one complete part\n    if (selector[i] === '(') {\n      // find the matching paren\n      const end = findMatchingParen(selector, i);\n      // push the paren block into the part\n      part += selector.slice(i, end + 1);\n      // move the index to after the paren block\n      i = end;\n    } else if (selector[i] === ',') {\n      parts.push(part);\n      part = '';\n    } else {\n      part += selector[i];\n    }\n  }\n  // catch any pieces after the last comma\n  if (part) {\n    parts.push(part);\n  }\n  return parts;\n}\n\nconst CSS_BUILD_ATTR = 'css-build';\n\n/**\n * Return the polymer-css-build \"build type\" applied to this element\n *\n * @param {!HTMLElement} element\n * @return {string} Can be \"\", \"shady\", or \"shadow\"\n */\nexport function getCssBuild(element) {\n  if (cssBuild !== undefined) {\n    return /** @type {string} */(cssBuild);\n  }\n  if (element.__cssBuild === undefined) {\n    // try attribute first, as it is the common case\n    const attrValue = element.getAttribute(CSS_BUILD_ATTR);\n    if (attrValue) {\n      element.__cssBuild = attrValue;\n    } else {\n      const buildComment = getBuildComment(element);\n      if (buildComment !== '') {\n        // remove build comment so it is not needlessly copied into every element instance\n        removeBuildComment(element);\n      }\n      element.__cssBuild = buildComment;\n    }\n  }\n  return element.__cssBuild || '';\n}\n\n/**\n * Check if the given element, either a <template> or <style>, has been processed\n * by polymer-css-build.\n *\n * If so, then we can make a number of optimizations:\n * - polymer-css-build will decompose mixins into individual CSS Custom Properties,\n * so the ApplyShim can be skipped entirely.\n * - Under native ShadowDOM, the style text can just be copied into each instance\n * without modification\n * - If the build is \"shady\" and ShadyDOM is in use, the styling does not need\n * scoping beyond the shimming of CSS Custom Properties\n *\n * @param {!HTMLElement} element\n * @return {boolean}\n */\nexport function elementHasBuiltCss(element) {\n  return getCssBuild(element) !== '';\n}\n\n/**\n * For templates made with tagged template literals, polymer-css-build will\n * insert a comment of the form `<!--css-build:shadow-->`\n *\n * @param {!HTMLElement} element\n * @return {string}\n */\nexport function getBuildComment(element) {\n  const buildComment = element.localName === 'template' ?\n      /** @type {!HTMLTemplateElement} */ (element).content.firstChild :\n      element.firstChild;\n  if (buildComment instanceof Comment) {\n    const commentParts = buildComment.textContent.trim().split(':');\n    if (commentParts[0] === CSS_BUILD_ATTR) {\n      return commentParts[1];\n    }\n  }\n  return '';\n}\n\n/**\n * Check if the css build status is optimal, and do no unneeded work.\n *\n * @param {string=} cssBuild CSS build status\n * @return {boolean} css build is optimal or not\n */\nexport function isOptimalCssBuild(cssBuild = '') {\n  // CSS custom property shim always requires work\n  if (cssBuild === '' || !nativeCssVariables) {\n    return false;\n  }\n  return nativeShadow ? cssBuild === 'shadow' : cssBuild === 'shady';\n}\n\n/**\n * @param {!HTMLElement} element\n */\nfunction removeBuildComment(element) {\n  const buildComment = element.localName === 'template' ?\n      /** @type {!HTMLTemplateElement} */ (element).content.firstChild :\n      element.firstChild;\n  buildComment.parentNode.removeChild(buildComment);\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'use strict';\n\nimport {StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\nimport * as StyleUtil from './style-util.js';\nimport {nativeShadow} from './style-settings.js';\n\n/* Transforms ShadowDOM styling into ShadyDOM styling\n\n* scoping:\n\n  * elements in scope get scoping selector class=\"x-foo-scope\"\n  * selectors re-written as follows:\n\n    div button -> div.x-foo-scope button.x-foo-scope\n\n* :host -> scopeName\n\n* :host(...) -> scopeName...\n\n* ::slotted(...) -> scopeName > ...\n\n* ...:dir(ltr|rtl) -> [dir=\"ltr|rtl\"] ..., ...[dir=\"ltr|rtl\"]\n\n* :host(:dir[rtl]) -> scopeName:dir(rtl) -> [dir=\"rtl\"] scopeName, scopeName[dir=\"rtl\"]\n\n*/\nconst SCOPE_NAME = 'style-scope';\n\nclass StyleTransformer {\n  get SCOPE_NAME() {\n    return SCOPE_NAME;\n  }\n  /**\n   * Given a node and scope name, add a scoping class to each node\n   * in the tree. This facilitates transforming css into scoped rules.\n   * @param {!Node} node\n   * @param {string} scope\n   * @param {boolean=} shouldRemoveScope\n   * @deprecated\n   */\n  dom(node, scope, shouldRemoveScope) {\n    const fn = (node) => {\n      this.element(node, scope || '', shouldRemoveScope);\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * Given a node and scope name, add a scoping class to each node in the tree.\n   * @param {!Node} node\n   * @param {string} scope\n   */\n  domAddScope(node, scope) {\n    const fn = (node) => {\n      this.element(node, scope || '');\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * @param {!Node} startNode\n   * @param {!function(!Node)} transformer\n   */\n  _transformDom(startNode, transformer) {\n    if (startNode.nodeType === Node.ELEMENT_NODE) {\n      transformer(startNode)\n    }\n    let c$;\n    if (startNode.localName === 'template') {\n      const template = /** @type {!HTMLTemplateElement} */ (startNode);\n      // In case the template is in svg context, fall back to the node\n      // since it won't be an HTMLTemplateElement with a .content property\n      c$ = (template.content || template._content || template).childNodes;\n    } else {\n      c$ = /** @type {!ParentNode} */ (startNode).children ||\n          startNode.childNodes;\n    }\n    if (c$) {\n      for (let i = 0; i < c$.length; i++) {\n        this._transformDom(c$[i], transformer);\n      }\n    }\n  }\n\n  /**\n   * @param {?} element\n   * @param {?} scope\n   * @param {?=} shouldRemoveScope\n   */\n  element(element, scope, shouldRemoveScope) {\n    // note: if using classes, we add both the general 'style-scope' class\n    // as well as the specific scope. This enables easy filtering of all\n    // `style-scope` elements\n    if (scope) {\n      // note: svg on IE does not have classList so fallback to class\n      if (element.classList) {\n        if (shouldRemoveScope) {\n          element.classList.remove(SCOPE_NAME);\n          element.classList.remove(scope);\n        } else {\n          element.classList.add(SCOPE_NAME);\n          element.classList.add(scope);\n        }\n      } else if (element.getAttribute) {\n        let c = element.getAttribute(CLASS);\n        if (shouldRemoveScope) {\n          if (c) {\n            let newValue = c.replace(SCOPE_NAME, '').replace(scope, '');\n            StyleUtil.setElementClassRaw(element, newValue);\n          }\n        } else {\n          let newValue = (c ? c + ' ' : '') + SCOPE_NAME + ' ' + scope;\n          StyleUtil.setElementClassRaw(element, newValue);\n        }\n      }\n    }\n  }\n\n  /**\n   * Given a node, replace the scoping class to each subnode in the tree.\n   * @param {!Node} node\n   * @param {string} oldScope\n   * @param {string} newScope\n   */\n  domReplaceScope(node, oldScope, newScope) {\n    const fn = (node) => {\n      this.element(node, oldScope, true);\n      this.element(node, newScope);\n    };\n    this._transformDom(node, fn);\n  }\n  /**\n   * Given a node, remove the scoping class to each subnode in the tree.\n   * @param {!Node} node\n   * @param {string} oldScope\n   */\n  domRemoveScope(node, oldScope) {\n    const fn = (node) => {\n      this.element(node, oldScope || '', true);\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * @param {?} element\n   * @param {?} styleRules\n   * @param {?=} callback\n   * @param {string=} cssBuild\n   * @param {string=} cssText\n   * @return {string}\n   */\n  elementStyles(element, styleRules, callback, cssBuild = '', cssText = '') {\n    // no need to shim selectors if settings.useNativeShadow, also\n    // a shady css build will already have transformed selectors\n    // NOTE: This method may be called as part of static or property shimming.\n    // When there is a targeted build it will not be called for static shimming,\n    // but when the property shim is used it is called and should opt out of\n    // static shimming work when a proper build exists.\n    if (cssText === '') {\n      if (nativeShadow || cssBuild === 'shady') {\n        cssText = StyleUtil.toCssText(styleRules, callback);\n      } else {\n        let {is, typeExtension} = StyleUtil.getIsExtends(element);\n        cssText = this.css(styleRules, is, typeExtension, callback) + '\\n\\n';\n      }\n    }\n    return cssText.trim();\n  }\n\n  // Given a string of cssText and a scoping string (scope), returns\n  // a string of scoped css where each selector is transformed to include\n  // a class created from the scope. ShadowDOM selectors are also transformed\n  // (e.g. :host) to use the scoping selector.\n  css(rules, scope, ext, callback) {\n    let hostScope = this._calcHostScope(scope, ext);\n    scope = this._calcElementScope(scope);\n    let self = this;\n    return StyleUtil.toCssText(rules, function(/** StyleNode */rule) {\n      if (!rule.isScoped) {\n        self.rule(rule, scope, hostScope);\n        rule.isScoped = true;\n      }\n      if (callback) {\n        callback(rule, scope, hostScope);\n      }\n    });\n  }\n\n  _calcElementScope(scope) {\n    if (scope) {\n      return CSS_CLASS_PREFIX + scope;\n    } else {\n      return '';\n    }\n  }\n\n  _calcHostScope(scope, ext) {\n    return ext ? `[is=${scope}]` : scope;\n  }\n\n  rule(rule, scope, hostScope) {\n    this._transformRule(rule, this._transformComplexSelector,\n      scope, hostScope);\n  }\n\n  /**\n   * transforms a css rule to a scoped rule.\n   *\n   * @param {StyleNode} rule\n   * @param {Function} transformer\n   * @param {string=} scope\n   * @param {string=} hostScope\n   */\n  _transformRule(rule, transformer, scope, hostScope) {\n    // NOTE: save transformedSelector for subsequent matching of elements\n    // against selectors (e.g. when calculating style properties)\n    rule['selector'] = rule.transformedSelector =\n      this._transformRuleCss(rule, transformer, scope, hostScope);\n  }\n\n  /**\n   * @param {StyleNode} rule\n   * @param {Function} transformer\n   * @param {string=} scope\n   * @param {string=} hostScope\n   */\n  _transformRuleCss(rule, transformer, scope, hostScope) {\n    let p$ = StyleUtil.splitSelectorList(rule['selector']);\n    // we want to skip transformation of rules that appear in keyframes,\n    // because they are keyframe selectors, not element selectors.\n    if (!StyleUtil.isKeyframesSelector(rule)) {\n      for (let i=0, l=p$.length, p; (i<l) && (p=p$[i]); i++) {\n        p$[i] = transformer.call(this, p, scope, hostScope);\n      }\n    }\n    return p$.filter((part) => Boolean(part)).join(COMPLEX_SELECTOR_SEP);\n  }\n\n  /**\n   * @param {string} selector\n   * @return {string}\n   */\n  _twiddleNthPlus(selector) {\n    return selector.replace(NTH, (m, type, inside) => {\n      if (inside.indexOf('+') > -1) {\n        inside = inside.replace(/\\+/g, '___');\n      } else if (inside.indexOf('___') > -1) {\n        inside = inside.replace(/___/g, '+');\n      }\n      return `:${type}(${inside})`;\n    });\n  }\n\n  /**\n   * Preserve `:matches()` selectors by replacing them with MATCHES_REPLACMENT\n   * and returning an array of `:matches()` selectors.\n   * Use `_replacesMatchesPseudo` to replace the `:matches()` parts\n   *\n   * @param {string} selector\n   * @return {{selector: string, matches: !Array<string>}}\n   */\n  _preserveMatchesPseudo(selector) {\n    /** @type {!Array<string>} */\n    const matches = [];\n    let match;\n    while ((match = selector.match(MATCHES))) {\n      const start = match.index;\n      const end = StyleUtil.findMatchingParen(selector, start);\n      if (end === -1) {\n        throw new Error(`${match.input} selector missing ')'`)\n      }\n      const part = selector.slice(start, end + 1);\n      selector = selector.replace(part, MATCHES_REPLACEMENT);\n      matches.push(part);\n    }\n    return {selector, matches};\n  }\n\n  /**\n   * Replace MATCHES_REPLACMENT character with the given set of `:matches()`\n   * selectors.\n   *\n   * @param {string} selector\n   * @param {!Array<string>} matches\n   * @return {string}\n   */\n  _replaceMatchesPseudo(selector, matches) {\n    const parts = selector.split(MATCHES_REPLACEMENT);\n    return matches.reduce((acc, cur, idx) => acc + cur + parts[idx + 1], parts[0]);\n  }\n\n/**\n * @param {string} selector\n * @param {string} scope\n * @param {string=} hostScope\n */\n  _transformComplexSelector(selector, scope, hostScope) {\n    let stop = false;\n    selector = selector.trim();\n    // Remove spaces inside of selectors like `:nth-of-type` because it confuses SIMPLE_SELECTOR_SEP\n    let isNth = NTH.test(selector);\n    if (isNth) {\n      selector = selector.replace(NTH, (m, type, inner) => `:${type}(${inner.replace(/\\s/g, '')})`)\n      selector = this._twiddleNthPlus(selector);\n    }\n    // Preserve selectors like `:-webkit-any` so that SIMPLE_SELECTOR_SEP does\n    // not get confused by spaces inside the pseudo selector\n    const isMatches = MATCHES.test(selector);\n    /** @type {!Array<string>} */\n    let matches;\n    if (isMatches) {\n      ({selector, matches} = this._preserveMatchesPseudo(selector));\n    }\n    selector = selector.replace(SLOTTED_START, `${HOST} $1`);\n    selector = selector.replace(SIMPLE_SELECTOR_SEP, (m, c, s) => {\n      if (!stop) {\n        let info = this._transformCompoundSelector(s, c, scope, hostScope);\n        stop = stop || info.stop;\n        c = info.combinator;\n        s = info.value;\n      }\n      return c + s;\n    });\n    // replace `:matches()` selectors\n    if (isMatches) {\n      selector = this._replaceMatchesPseudo(selector, matches);\n    }\n    if (isNth) {\n      selector = this._twiddleNthPlus(selector);\n    }\n    return selector;\n  }\n\n  _transformCompoundSelector(selector, combinator, scope, hostScope) {\n    // replace :host with host scoping class\n    let slottedIndex = selector.indexOf(SLOTTED);\n    if (selector.indexOf(HOST) >= 0) {\n      selector = this._transformHostSelector(selector, hostScope);\n    // replace other selectors with scoping class\n    } else if (slottedIndex !== 0) {\n      selector = scope ? this._transformSimpleSelector(selector, scope) :\n        selector;\n    }\n    // mark ::slotted() scope jump to replace with descendant selector + arg\n    // also ignore left-side combinator\n    let slotted = false;\n    if (slottedIndex >= 0) {\n      combinator = '';\n      slotted = true;\n    }\n    // process scope jumping selectors up to the scope jump and then stop\n    let stop;\n    if (slotted) {\n      stop = true;\n      if (slotted) {\n        // .zonk ::slotted(.foo) -> .zonk.scope > .foo\n        selector = selector.replace(SLOTTED_PAREN, (m, paren) => ` > ${paren}`);\n      }\n    }\n    selector = selector.replace(DIR_PAREN, (m, before, dir) =>\n      `[dir=\"${dir}\"] ${before}, ${before}[dir=\"${dir}\"]`);\n    return {value: selector, combinator, stop};\n  }\n\n  _transformSimpleSelector(selector, scope) {\n    const attributes = selector.split(/(\\[.+?\\])/);\n\n    const output = [];\n    for (let i = 0; i < attributes.length; i++) {\n      // Do not attempt to transform any attribute selector content\n      if ((i % 2) === 1) {\n        output.push(attributes[i]);\n      } else {\n        const part = attributes[i];\n\n        if (!(part === '' && i === attributes.length - 1)) {\n          let p$ = part.split(PSEUDO_PREFIX);\n          p$[0] += scope;\n          output.push(p$.join(PSEUDO_PREFIX));\n        }\n      }\n    }\n\n    return output.join('');\n  }\n\n  // :host(...) -> scopeName...\n  _transformHostSelector(selector, hostScope) {\n    let m = selector.match(HOST_PAREN);\n    let paren = m && m[2].trim() || '';\n    if (paren) {\n      if (!paren[0].match(SIMPLE_SELECTOR_PREFIX)) {\n        // paren starts with a type selector\n        let typeSelector = paren.split(SIMPLE_SELECTOR_PREFIX)[0];\n        // if the type selector is our hostScope then avoid pre-pending it\n        if (typeSelector === hostScope) {\n          return paren;\n        // otherwise, this selector should not match in this scope so\n        // output a bogus selector.\n        } else {\n          return SELECTOR_NO_MATCH;\n        }\n      } else {\n        // make sure to do a replace here to catch selectors like:\n        // `:host(.foo)::before`\n        return selector.replace(HOST_PAREN, function(m, host, paren) {\n          return hostScope + paren;\n        });\n      }\n    // if no paren, do a straight :host replacement.\n    // TODO(sorvell): this should not strictly be necessary but\n    // it's needed to maintain support for `:host[foo]` type selectors\n    // which have been improperly used under Shady DOM. This should be\n    // deprecated.\n    } else {\n      return selector.replace(HOST, hostScope);\n    }\n  }\n\n  /**\n   * @param {StyleNode} rule\n   */\n  documentRule(rule) {\n    // reset selector in case this is redone.\n    rule['selector'] = rule['parsedSelector'];\n    this.normalizeRootSelector(rule);\n    this._transformRule(rule, this._transformDocumentSelector);\n  }\n\n  /**\n   * @param {StyleNode} rule\n   */\n  normalizeRootSelector(rule) {\n    if (rule['selector'] === ROOT) {\n      rule['selector'] = 'html';\n    }\n  }\n\n/**\n * @param {string} selector\n */\n  _transformDocumentSelector(selector) {\n    if (selector.match(HOST)) {\n      // remove ':host' type selectors in document rules\n      return '';\n    } else if (selector.match(SLOTTED)) {\n      return this._transformComplexSelector(selector, SCOPE_DOC_SELECTOR)\n    } else {\n      return this._transformSimpleSelector(selector.trim(), SCOPE_DOC_SELECTOR);\n    }\n  }\n}\n\nconst NTH = /:(nth[-\\w]+)\\(([^)]+)\\)/;\nconst SCOPE_DOC_SELECTOR = `:not(.${SCOPE_NAME})`;\nconst COMPLEX_SELECTOR_SEP = ',';\nconst SIMPLE_SELECTOR_SEP = /(^|[\\s>+~]+)((?:\\[.+?\\]|[^\\s>+~=[])+)/g;\nconst SIMPLE_SELECTOR_PREFIX = /[[.:#*]/;\nconst HOST = ':host';\nconst ROOT = ':root';\nconst SLOTTED = '::slotted';\nconst SLOTTED_START = new RegExp(`^(${SLOTTED})`);\n// NOTE: this supports 1 nested () pair for things like\n// :host(:not([selected]), more general support requires\n// parsing which seems like overkill\nconst HOST_PAREN = /(:host)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))/;\n// similar to HOST_PAREN\nconst SLOTTED_PAREN = /(?:::slotted)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))/;\nconst DIR_PAREN = /(.*):dir\\((?:(ltr|rtl))\\)/;\nconst CSS_CLASS_PREFIX = '.';\nconst PSEUDO_PREFIX = ':';\nconst CLASS = 'class';\nconst SELECTOR_NO_MATCH = 'should_not_match';\nconst MATCHES = /:(?:matches|any|-(?:webkit|moz)-any)/;\nconst MATCHES_REPLACEMENT = '\\u{e000}';\n\nexport default new StyleTransformer()\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'use strict';\n\nimport {parse, StyleNode} from './css-parse.js';\nimport {nativeShadow, nativeCssVariables, disableRuntime} from './style-settings.js';\nimport StyleTransformer from './style-transformer.js';\nimport * as StyleUtil from './style-util.js';\nimport StyleProperties from './style-properties.js';\nimport {ensureStylePlaceholder, getStylePlaceholder} from './style-placeholder.js';\nimport StyleInfo from './style-info.js';\nimport StyleCache from './style-cache.js';\nimport {flush as watcherFlush, getOwnerScope, getCurrentScope} from './document-watcher.js';\nimport templateMap from './template-map.js';\nimport * as ApplyShimUtils from './apply-shim-utils.js';\nimport {updateNativeProperties, detectMixin} from './common-utils.js';\nimport {CustomStyleInterfaceInterface} from './custom-style-interface.js'; // eslint-disable-line no-unused-vars\n\n/** @type {!Object<string, string>} */\nconst adoptedCssTextMap = {};\n\n/**\n * @const {StyleCache}\n */\nconst styleCache = new StyleCache();\n\nexport default class ScopingShim {\n  constructor() {\n    this._scopeCounter = {};\n    this._documentOwner = /** @type {!HTMLElement} */(document.documentElement);\n    let ast = new StyleNode();\n    ast['rules'] = [];\n    this._documentOwnerStyleInfo = StyleInfo.set(this._documentOwner, new StyleInfo(ast));\n    this._elementsHaveApplied = false;\n    /** @type {?Object} */\n    this._applyShim = null;\n    /** @type {?CustomStyleInterfaceInterface} */\n    this._customStyleInterface = null;\n  }\n  flush() {\n    watcherFlush();\n  }\n  _generateScopeSelector(name) {\n    let id = this._scopeCounter[name] = (this._scopeCounter[name] || 0) + 1;\n    return `${name}-${id}`;\n  }\n  getStyleAst(style) {\n    return StyleUtil.rulesForStyle(style);\n  }\n  styleAstToString(ast) {\n    return StyleUtil.toCssText(ast);\n  }\n  _gatherStyles(template) {\n    return StyleUtil.gatherStyleText(template.content);\n  }\n  /**\n   * Prepare the styling and template for the given element type\n   *\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} typeExtension\n   */\n  prepareTemplate(template, elementName, typeExtension) {\n    this.prepareTemplateDom(template, elementName);\n    this.prepareTemplateStyles(template, elementName, typeExtension);\n  }\n  /**\n   * Prepare styling for the given element type\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} typeExtension\n   */\n  prepareTemplateStyles(template, elementName, typeExtension) {\n    if (template._prepared || disableRuntime) {\n      return;\n    }\n    // style placeholders are only used when ShadyDOM is active\n    if (!nativeShadow) {\n      ensureStylePlaceholder(elementName);\n    }\n    template._prepared = true;\n    template.name = elementName;\n    template.extends = typeExtension;\n    templateMap[elementName] = template;\n    let cssBuild = StyleUtil.getCssBuild(template);\n    const optimalBuild = StyleUtil.isOptimalCssBuild(cssBuild);\n    let info = {\n      is: elementName,\n      extends: typeExtension,\n    };\n    let cssText = this._gatherStyles(template) + (adoptedCssTextMap[elementName] || '');\n    // check if the styling has mixin definitions or uses\n    this._ensure();\n    if (!optimalBuild) {\n      let hasMixins = !cssBuild && detectMixin(cssText);\n      let ast = parse(cssText);\n      // only run the applyshim transforms if there is a mixin involved\n      if (hasMixins && nativeCssVariables && this._applyShim) {\n        this._applyShim['transformRules'](ast, elementName);\n      }\n      template['_styleAst'] = ast;\n    }\n    let ownPropertyNames = [];\n    if (!nativeCssVariables) {\n      ownPropertyNames = StyleProperties.decorateStyles(template['_styleAst']);\n    }\n    if (!ownPropertyNames.length || nativeCssVariables) {\n      let root = nativeShadow ? template.content : null;\n      let placeholder = getStylePlaceholder(elementName);\n      let style = this._generateStaticStyle(info, template['_styleAst'], root, placeholder, cssBuild, optimalBuild ? cssText : '');\n      template._style = style;\n    }\n    template._ownPropertyNames = ownPropertyNames;\n  }\n\n  /**\n   * @param {!Array<string>} cssTextArray\n   * @param {string} elementName\n   */\n  prepareAdoptedCssText(cssTextArray, elementName) {\n    adoptedCssTextMap[elementName] = cssTextArray.join(' ');\n  }\n  /**\n   * Prepare template for the given element type\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   */\n  prepareTemplateDom(template, elementName) {\n    if (disableRuntime) {\n      return;\n    }\n    const cssBuild = StyleUtil.getCssBuild(template);\n    if (!nativeShadow && cssBuild !== 'shady' && !template._domPrepared) {\n      template._domPrepared = true;\n      StyleTransformer.domAddScope(template.content, elementName);\n    }\n  }\n  /**\n   * @param {!{is: string, extends: (string|undefined)}} info\n   * @param {!StyleNode} rules\n   * @param {DocumentFragment} shadowroot\n   * @param {Node} placeholder\n   * @param {string} cssBuild\n   * @param {string=} cssText\n   * @return {?HTMLStyleElement}\n   */\n  _generateStaticStyle(info, rules, shadowroot, placeholder, cssBuild, cssText) {\n    cssText = StyleTransformer.elementStyles(info, rules, null, cssBuild, cssText);\n    if (cssText.length) {\n      return StyleUtil.applyCss(cssText, info.is, shadowroot, placeholder);\n    }\n    return null;\n  }\n  _prepareHost(host) {\n    const {is, typeExtension} = StyleUtil.getIsExtends(host);\n    const placeholder = getStylePlaceholder(is);\n    const template = templateMap[is];\n    if (!template) {\n      return;\n    }\n    const ast = template['_styleAst'];\n    const ownStylePropertyNames = template._ownPropertyNames;\n    const cssBuild = StyleUtil.getCssBuild(template);\n    const styleInfo = new StyleInfo(\n      ast,\n      placeholder,\n      ownStylePropertyNames,\n      is,\n      typeExtension,\n      cssBuild\n    );\n    StyleInfo.set(host, styleInfo);\n    return styleInfo;\n  }\n  _ensureApplyShim() {\n    if (this._applyShim) {\n      return;\n    } else if (window.ShadyCSS && window.ShadyCSS.ApplyShim) {\n      this._applyShim = /** @type {!Object} */ (window.ShadyCSS.ApplyShim);\n      this._applyShim['invalidCallback'] = ApplyShimUtils.invalidate;\n    }\n  }\n  _ensureCustomStyleInterface() {\n    if (this._customStyleInterface) {\n      return;\n    } else if (window.ShadyCSS && window.ShadyCSS.CustomStyleInterface) {\n      this._customStyleInterface = /** @type {!CustomStyleInterfaceInterface} */(window.ShadyCSS.CustomStyleInterface);\n      /** @type {function(!HTMLStyleElement)} */\n      this._customStyleInterface['transformCallback'] = (style) => {this.transformCustomStyleForDocument(style)};\n      this._customStyleInterface['validateCallback'] = () => {\n        requestAnimationFrame(() => {\n          if (this._customStyleInterface['enqueued'] || this._elementsHaveApplied) {\n            this.flushCustomStyles();\n          }\n        })\n      };\n    }\n  }\n  _ensure() {\n    this._ensureApplyShim();\n    this._ensureCustomStyleInterface();\n  }\n  /**\n   * Flush and apply custom styles to document\n   */\n  flushCustomStyles() {\n    if (disableRuntime) {\n      return;\n    }\n    this._ensure();\n    if (!this._customStyleInterface) {\n      return;\n    }\n    let customStyles = this._customStyleInterface['processStyles']();\n    // early return if custom-styles don't need validation\n    if (!this._customStyleInterface['enqueued']) {\n      return;\n    }\n    // bail if custom styles are built optimally\n    if (StyleUtil.isOptimalCssBuild(this._documentOwnerStyleInfo.cssBuild)) {\n      return;\n    }\n    if (!nativeCssVariables) {\n      this._updateProperties(this._documentOwner, this._documentOwnerStyleInfo);\n      this._applyCustomStyles(customStyles);\n      if (this._elementsHaveApplied) {\n        // if custom elements have upgraded and there are no native css variables, we must recalculate the whole tree\n        this.styleDocument();\n      }\n    } else if (!this._documentOwnerStyleInfo.cssBuild) {\n      this._revalidateCustomStyleApplyShim(customStyles);\n    }\n    this._customStyleInterface['enqueued'] = false;\n  }\n  /**\n   * Apply styles for the given element\n   *\n   * @param {!HTMLElement} host\n   * @param {Object=} overrideProps\n   */\n  styleElement(host, overrideProps) {\n    if (disableRuntime) {\n      if (overrideProps) {\n        if (!StyleInfo.get(host)) {\n          StyleInfo.set(host, new StyleInfo(null));\n        }\n        const styleInfo = /** @type {!StyleInfo} */(StyleInfo.get(host));\n        this._mixOverrideStyleProps(styleInfo, overrideProps);\n        this.styleElementNativeVariables(host, styleInfo);\n      }\n      return;\n    }\n    const styleInfo = StyleInfo.get(host) || this._prepareHost(host);\n    // if there is no style info at this point, bail\n    if (!styleInfo) {\n      return;\n    }\n    // Only trip the `elementsHaveApplied` flag if a node other that the root document has `applyStyle` called\n    if (!this._isRootOwner(host)) {\n      this._elementsHaveApplied = true;\n    }\n    if (overrideProps) {\n      this._mixOverrideStyleProps(styleInfo, overrideProps);\n    }\n    if (!nativeCssVariables) {\n      this.styleElementShimVariables(host, styleInfo);\n    } else {\n      this.styleElementNativeVariables(host, styleInfo);\n    }\n  }\n  /**\n   * @param {!StyleInfo} styleInfo\n   * @param {Object} overrideProps\n   */\n  _mixOverrideStyleProps(styleInfo, overrideProps) {\n    styleInfo.overrideStyleProperties =\n      styleInfo.overrideStyleProperties || {};\n    Object.assign(styleInfo.overrideStyleProperties, overrideProps);\n  }\n  /**\n   * @param {!HTMLElement} host\n   * @param {!StyleInfo} styleInfo\n   */\n  styleElementShimVariables(host, styleInfo) {\n    this.flush();\n    this._updateProperties(host, styleInfo);\n    if (styleInfo.ownStylePropertyNames && styleInfo.ownStylePropertyNames.length) {\n      this._applyStyleProperties(host, styleInfo);\n    }\n  }\n  /**\n   * @param {!HTMLElement} host\n   * @param {!StyleInfo} styleInfo\n   */\n  styleElementNativeVariables(host, styleInfo) {\n    const { is } = StyleUtil.getIsExtends(host);\n    if (styleInfo.overrideStyleProperties) {\n      updateNativeProperties(host, styleInfo.overrideStyleProperties);\n    }\n    const template = templateMap[is];\n    // bail early if there is no shadowroot for this element\n    if (!template && !this._isRootOwner(host)) {\n      return;\n    }\n    // bail early if the template was built with polymer-css-build\n    if (template && StyleUtil.elementHasBuiltCss(template)) {\n      return;\n    }\n    if (template && template._style && !ApplyShimUtils.templateIsValid(template)) {\n      // update template\n      if (!ApplyShimUtils.templateIsValidating(template)) {\n        this._ensure();\n        this._applyShim && this._applyShim['transformRules'](template['_styleAst'], is);\n        template._style.textContent = StyleTransformer.elementStyles(host, styleInfo.styleRules);\n        ApplyShimUtils.startValidatingTemplate(template);\n      }\n      // update instance if native shadowdom\n      if (nativeShadow) {\n        let root = host.shadowRoot;\n        if (root) {\n          let style = root.querySelector('style');\n          if (style) {\n            style.textContent = StyleTransformer.elementStyles(host, styleInfo.styleRules);\n          }\n        }\n      }\n      styleInfo.styleRules = template['_styleAst'];\n    }\n  }\n  _styleOwnerForNode(node) {\n    let root = StyleUtil.wrap(node).getRootNode();\n    let host = root.host;\n    if (host) {\n      if (StyleInfo.get(host) || this._prepareHost(host)) {\n        return host;\n      } else {\n        return this._styleOwnerForNode(host);\n      }\n    }\n    return this._documentOwner;\n  }\n  _isRootOwner(node) {\n    return (node === this._documentOwner);\n  }\n  _applyStyleProperties(host, styleInfo) {\n    let is = StyleUtil.getIsExtends(host).is;\n    let cacheEntry = styleCache.fetch(is, styleInfo.styleProperties, styleInfo.ownStylePropertyNames);\n    let cachedScopeSelector = cacheEntry && cacheEntry.scopeSelector;\n    let cachedStyle = cacheEntry ? cacheEntry.styleElement : null;\n    let oldScopeSelector = styleInfo.scopeSelector;\n    // only generate new scope if cached style is not found\n    styleInfo.scopeSelector = cachedScopeSelector || this._generateScopeSelector(is);\n    let style = StyleProperties.applyElementStyle(host, styleInfo.styleProperties, styleInfo.scopeSelector, cachedStyle);\n    if (!nativeShadow) {\n      StyleProperties.applyElementScopeSelector(host, styleInfo.scopeSelector, oldScopeSelector);\n    }\n    if (!cacheEntry) {\n      styleCache.store(is, styleInfo.styleProperties, style, styleInfo.scopeSelector);\n    }\n    return style;\n  }\n  _updateProperties(host, styleInfo) {\n    let owner = this._styleOwnerForNode(host);\n    let ownerStyleInfo = StyleInfo.get(owner);\n    let ownerProperties = ownerStyleInfo.styleProperties;\n    // style owner has not updated properties yet\n    // go up the chain and force property update,\n    // except if the owner is the document\n    if (owner !== this._documentOwner && !ownerProperties) {\n      this._updateProperties(owner, ownerStyleInfo);\n      ownerProperties = ownerStyleInfo.styleProperties;\n    }\n    let props = Object.create(ownerProperties || null);\n    let hostAndRootProps = StyleProperties.hostAndRootPropertiesForScope(host, styleInfo.styleRules, styleInfo.cssBuild);\n    let propertyData = StyleProperties.propertyDataFromStyles(ownerStyleInfo.styleRules, host);\n    let propertiesMatchingHost = propertyData.properties\n    Object.assign(\n      props,\n      hostAndRootProps.hostProps,\n      propertiesMatchingHost,\n      hostAndRootProps.rootProps\n    );\n    this._mixinOverrideStyles(props, styleInfo.overrideStyleProperties);\n    StyleProperties.reify(props);\n    styleInfo.styleProperties = props;\n  }\n  _mixinOverrideStyles(props, overrides) {\n    for (let p in overrides) {\n      let v = overrides[p];\n      // skip override props if they are not truthy or 0\n      // in order to fall back to inherited values\n      if (v || v === 0) {\n        props[p] = v;\n      }\n    }\n  }\n  /**\n   * Update styles of the whole document\n   *\n   * @param {Object=} properties\n   */\n  styleDocument(properties) {\n    this.styleSubtree(this._documentOwner, properties);\n  }\n  /**\n   * Update styles of a subtree\n   *\n   * @param {!HTMLElement} host\n   * @param {Object=} properties\n   */\n  styleSubtree(host, properties) {\n    const wrappedHost = StyleUtil.wrap(host);\n    let root = wrappedHost.shadowRoot;\n    if (root || this._isRootOwner(host)) {\n      this.styleElement(host, properties);\n    }\n    // process the shadowdom children of `host`\n    let shadowChildren =\n        root && (/** @type {!ParentNode} */ (root).children || root.childNodes);\n    if (shadowChildren) {\n      for (let i = 0; i < shadowChildren.length; i++) {\n        let c = /** @type {!HTMLElement} */(shadowChildren[i]);\n        this.styleSubtree(c);\n      }\n    } else {\n      // process the lightdom children of `host`\n      let children = wrappedHost.children || wrappedHost.childNodes;\n      if (children) {\n        for (let i = 0; i < children.length; i++) {\n          let c = /** @type {!HTMLElement} */(children[i]);\n          this.styleSubtree(c);\n        }\n      }\n    }\n  }\n  /* Custom Style operations */\n  _revalidateCustomStyleApplyShim(customStyles) {\n    for (let i = 0; i < customStyles.length; i++) {\n      let c = customStyles[i];\n      let s = this._customStyleInterface['getStyleForCustomStyle'](c);\n      if (s) {\n        this._revalidateApplyShim(s);\n      }\n    }\n  }\n  _applyCustomStyles(customStyles) {\n    for (let i = 0; i < customStyles.length; i++) {\n      let c = customStyles[i];\n      let s = this._customStyleInterface['getStyleForCustomStyle'](c);\n      if (s) {\n        StyleProperties.applyCustomStyle(s, this._documentOwnerStyleInfo.styleProperties);\n      }\n    }\n  }\n  transformCustomStyleForDocument(style) {\n    const cssBuild = StyleUtil.getCssBuild(style);\n    if (cssBuild !== this._documentOwnerStyleInfo.cssBuild) {\n      this._documentOwnerStyleInfo.cssBuild = cssBuild;\n    }\n    if (StyleUtil.isOptimalCssBuild(cssBuild)) {\n      return;\n    }\n    let ast = StyleUtil.rulesForStyle(style);\n    StyleUtil.forEachRule(ast, (rule) => {\n      if (nativeShadow) {\n        StyleTransformer.normalizeRootSelector(rule);\n      } else {\n        StyleTransformer.documentRule(rule);\n      }\n      if (nativeCssVariables && cssBuild === '') {\n        this._ensure();\n        this._applyShim && this._applyShim['transformRule'](rule);\n      }\n    });\n    if (nativeCssVariables) {\n      style.textContent = StyleUtil.toCssText(ast);\n    } else {\n      this._documentOwnerStyleInfo.styleRules['rules'].push(ast);\n    }\n  }\n  _revalidateApplyShim(style) {\n    if (nativeCssVariables && this._applyShim) {\n      let ast = StyleUtil.rulesForStyle(style);\n      this._ensure();\n      this._applyShim['transformRules'](ast);\n      style.textContent = StyleUtil.toCssText(ast);\n    }\n  }\n  getComputedStyleValue(element, property) {\n    let value;\n    if (!nativeCssVariables) {\n      // element is either a style host, or an ancestor of a style host\n      let styleInfo = StyleInfo.get(element) || StyleInfo.get(this._styleOwnerForNode(element));\n      value = styleInfo.styleProperties[property];\n    }\n    // fall back to the property value from the computed styling\n    value = value || window.getComputedStyle(element).getPropertyValue(property);\n    // trim whitespace that can come after the `:` in css\n    // example: padding: 2px -> \" 2px\"\n    return value ? value.trim() : '';\n  }\n  // given an element and a classString, replaces\n  // the element's class with the provided classString and adds\n  // any necessary ShadyCSS static and property based scoping selectors\n  setElementClass(element, classString) {\n    let root = StyleUtil.wrap(element).getRootNode();\n    let classes = classString ? classString.split(/\\s/) : [];\n    let scopeName = root.host && root.host.localName;\n    // If no scope, try to discover scope name from existing class.\n    // This can occur if, for example, a template stamped element that\n    // has been scoped is manipulated when not in a root.\n    if (!scopeName) {\n      var classAttr = element.getAttribute('class');\n      if (classAttr) {\n        let k$ = classAttr.split(/\\s/);\n        for (let i=0; i < k$.length; i++) {\n          if (k$[i] === StyleTransformer.SCOPE_NAME) {\n            scopeName = k$[i+1];\n            break;\n          }\n        }\n      }\n    }\n    if (scopeName) {\n      classes.push(StyleTransformer.SCOPE_NAME, scopeName);\n    }\n    if (!nativeCssVariables) {\n      let styleInfo = StyleInfo.get(element);\n      if (styleInfo && styleInfo.scopeSelector) {\n        classes.push(StyleProperties.XSCOPE_NAME, styleInfo.scopeSelector);\n      }\n    }\n    StyleUtil.setElementClassRaw(element, classes.join(' '));\n  }\n  _styleInfoForNode(node) {\n    return StyleInfo.get(node);\n  }\n  /**\n   * @param {!Element} node\n   * @param {string} scope\n   */\n  scopeNode(node, scope) {\n    StyleTransformer.element(node, scope);\n  }\n  /**\n   * @param {!Element} node\n   * @param {string} scope\n   */\n  unscopeNode(node, scope) {\n    StyleTransformer.element(node, scope, true);\n  }\n  /**\n   * @param {!Node} node\n   * @return {string}\n   */\n  scopeForNode(node) {\n    return getOwnerScope(node);\n  }\n  /**\n   * @param {!Element} node\n   * @return {string}\n   */\n  currentScopeForNode(node) {\n    return getCurrentScope(node);\n  }\n}\n\n/* exports */\n/* eslint-disable no-self-assign */\nScopingShim.prototype['flush'] = ScopingShim.prototype.flush;\nScopingShim.prototype['prepareTemplate'] = ScopingShim.prototype.prepareTemplate;\nScopingShim.prototype['styleElement'] = ScopingShim.prototype.styleElement;\nScopingShim.prototype['styleDocument'] = ScopingShim.prototype.styleDocument;\nScopingShim.prototype['styleSubtree'] = ScopingShim.prototype.styleSubtree;\nScopingShim.prototype['getComputedStyleValue'] = ScopingShim.prototype.getComputedStyleValue;\nScopingShim.prototype['setElementClass'] = ScopingShim.prototype.setElementClass;\nScopingShim.prototype['_styleInfoForNode'] = ScopingShim.prototype._styleInfoForNode;\nScopingShim.prototype['transformCustomStyleForDocument'] = ScopingShim.prototype.transformCustomStyleForDocument;\nScopingShim.prototype['getStyleAst'] = ScopingShim.prototype.getStyleAst;\nScopingShim.prototype['styleAstToString'] = ScopingShim.prototype.styleAstToString;\nScopingShim.prototype['flushCustomStyles'] = ScopingShim.prototype.flushCustomStyles;\nScopingShim.prototype['scopeNode'] = ScopingShim.prototype.scopeNode;\nScopingShim.prototype['unscopeNode'] = ScopingShim.prototype.unscopeNode;\nScopingShim.prototype['scopeForNode'] = ScopingShim.prototype.scopeForNode;\nScopingShim.prototype['currentScopeForNode'] = ScopingShim.prototype.currentScopeForNode;\nScopingShim.prototype['prepareAdoptedCssText'] = ScopingShim.prototype.prepareAdoptedCssText;\n/* eslint-enable no-self-assign */\nObject.defineProperties(ScopingShim.prototype, {\n  'nativeShadow': {\n    get() {\n      return nativeShadow;\n    }\n  },\n  'nativeCss': {\n    get() {\n      return nativeCssVariables;\n    }\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'use strict';\n\nimport {nativeShadow} from './style-settings.js';\nimport StyleTransformer from './style-transformer.js';\nimport {getIsExtends, elementHasBuiltCss, wrap} from './style-util.js';\n\nexport let flush = function() {};\n\n/**\n * @param {!Element} element\n * @return {string}\n */\nfunction getClasses(element) {\n  if (element.classList && element.classList.value) {\n    return element.classList.value;\n  } else {\n    // NOTE: className is patched to remove scoping classes in ShadyDOM\n    // use getAttribute('class') instead, which is unpatched\n    return element.getAttribute('class') || '';\n  }\n}\n\nconst scopeRegExp = new RegExp(`${StyleTransformer.SCOPE_NAME}\\\\s*([^\\\\s]*)`);\n\n/**\n * @param {!Element} element\n * @return {string}\n */\nexport function getCurrentScope(element) {\n  const match = getClasses(element).match(scopeRegExp);\n  if (match) {\n    return match[1];\n  } else {\n    return '';\n  }\n}\n\n/**\n * @param {!Node} node\n */\nexport function getOwnerScope(node) {\n  const ownerRoot = wrap(node).getRootNode();\n  if (ownerRoot === node || ownerRoot === node.ownerDocument) {\n    return '';\n  }\n  const host = /** @type {!ShadowRoot} */(ownerRoot).host;\n  if (!host) {\n    // this may actually be a document fragment\n    return '';\n  }\n  return getIsExtends(host).is;\n}\n\n/**\n * @param {!Element} element\n */\nexport function ensureCorrectScope(element) {\n  const currentScope = getCurrentScope(element);\n  const ownerRoot = wrap(element).getRootNode();\n  if (ownerRoot === element) {\n    return;\n  }\n  if (currentScope && ownerRoot === element.ownerDocument) {\n    // node was scoped, but now is in document\n    StyleTransformer.domRemoveScope(element, currentScope);\n  } else if (ownerRoot instanceof ShadowRoot) {\n    const ownerScope = getOwnerScope(element);\n    if (ownerScope !== currentScope) {\n      // node was scoped, but not by its current owner\n      StyleTransformer.domReplaceScope(element, currentScope, ownerScope);\n    }\n  }\n}\n\n/**\n * @param {!HTMLElement|!HTMLDocument} element\n */\nexport function ensureCorrectSubtreeScoping(element) {\n  // find unscoped subtree nodes\n  const unscopedNodes = window['ShadyDOM']['nativeMethods']['querySelectorAll'].call(\n    element, `:not(.${StyleTransformer.SCOPE_NAME})`);\n\n  for (let j = 0; j < unscopedNodes.length; j++) {\n    // it's possible, during large batch inserts, that nodes that aren't\n    // scoped within the current scope were added.\n    // To make sure that any unscoped nodes that were inserted in the current batch are correctly styled,\n    // query all unscoped nodes and force their style-scope to be applied.\n    // This could happen if a sub-element appended an unscoped node in its shadowroot and this function\n    // runs on a parent element of the host of that unscoped node:\n    // parent-element -> element -> unscoped node\n    // Here unscoped node should have the style-scope element, not parent-element.\n    const unscopedNode = unscopedNodes[j];\n    const scopeForPreviouslyUnscopedNode = getOwnerScope(unscopedNode);\n    if (scopeForPreviouslyUnscopedNode) {\n      StyleTransformer.element(unscopedNode, scopeForPreviouslyUnscopedNode);\n    }\n  }\n}\n\n/**\n * @param {HTMLElement} el\n * @return {boolean}\n */\nfunction isElementWithBuiltCss(el) {\n  if (el.localName === 'style' || el.localName === 'template') {\n    return elementHasBuiltCss(el);\n  }\n  return false;\n}\n\n/**\n * @param {Array<MutationRecord|null>|null} mxns\n */\nfunction handler(mxns) {\n  for (let x=0; x < mxns.length; x++) {\n    let mxn = mxns[x];\n    if (mxn.target === document.documentElement ||\n      mxn.target === document.head) {\n      continue;\n    }\n    for (let i=0; i < mxn.addedNodes.length; i++) {\n      let n = mxn.addedNodes[i];\n      if (n.nodeType !== Node.ELEMENT_NODE) {\n        continue;\n      }\n      n = /** @type {HTMLElement} */(n); // eslint-disable-line no-self-assign\n      let root = n.getRootNode();\n      let currentScope = getCurrentScope(n);\n      // node was scoped, but now is in document\n      // If this element has built css, we must not remove scoping as this node\n      // will be used as a template or style without re - applying scoping as an optimization\n      if (currentScope && root === n.ownerDocument && !isElementWithBuiltCss(n)) {\n        StyleTransformer.domRemoveScope(n, currentScope);\n      } else if (root instanceof ShadowRoot) {\n        const newScope = getOwnerScope(n);\n        // rescope current node and subtree if necessary\n        if (newScope !== currentScope) {\n          StyleTransformer.domReplaceScope(n, currentScope, newScope);\n        }\n        // make sure all the subtree elements are scoped correctly\n        ensureCorrectSubtreeScoping(n);\n      }\n    }\n  }\n}\n\n// if native Shadow DOM is being used, or ShadyDOM handles dynamic scoiping, do not activate the MutationObserver\nif (!nativeShadow && !(window['ShadyDOM'] && window['ShadyDOM']['handlesDynamicScoping'])) {\n  let observer = new MutationObserver(handler);\n  let start = (node) => {\n    observer.observe(node, {childList: true, subtree: true});\n  }\n  let nativeCustomElements = (window['customElements'] &&\n    !window['customElements']['polyfillWrapFlushCallback']);\n  // need to start immediately with native custom elements\n  // TODO(dfreedm): with polyfilled HTMLImports and native custom elements\n  // excessive mutations may be observed; this can be optimized via cooperation\n  // with the HTMLImports polyfill.\n  if (nativeCustomElements) {\n    start(document);\n  } else {\n    let delayedStart = () => {\n      start(document.body);\n    }\n    // use polyfill timing if it's available\n    if (window['HTMLImports']) {\n      window['HTMLImports']['whenReady'](delayedStart);\n    // otherwise push beyond native imports being ready\n    // which requires RAF + readystate interactive.\n    } else {\n      requestAnimationFrame(function() {\n        if (document.readyState === 'loading') {\n          let listener = function() {\n            delayedStart();\n            document.removeEventListener('readystatechange', listener);\n          }\n          document.addEventListener('readystatechange', listener);\n        } else {\n          delayedStart();\n        }\n      });\n    }\n  }\n\n  flush = function() {\n    handler(observer.takeRecords());\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'use strict';\n\nimport {removeCustomPropAssignment, StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\nimport {nativeShadow} from './style-settings.js';\nimport StyleTransformer from './style-transformer.js';\nimport * as StyleUtil from './style-util.js';\nimport * as RX from './common-regex.js';\nimport StyleInfo from './style-info.js';\n\n// TODO: dedupe with shady\n/**\n * @param {string} selector\n * @return {boolean}\n * @this {Element}\n */\nconst matchesSelector = function(selector) {\n  const method = this.matches || this.matchesSelector ||\n    this.mozMatchesSelector || this.msMatchesSelector ||\n    this.oMatchesSelector || this.webkitMatchesSelector;\n  return method && method.call(this, selector);\n};\n\nconst IS_IE = navigator.userAgent.match('Trident');\n\nconst XSCOPE_NAME = 'x-scope';\n\nclass StyleProperties {\n  get XSCOPE_NAME() {\n    return XSCOPE_NAME;\n  }\n/**\n * decorates styles with rule info and returns an array of used style property names\n *\n * @param {StyleNode} rules\n * @return {Array<string>}\n */\n  decorateStyles(rules) {\n    let self = this, props = {}, keyframes = [], ruleIndex = 0;\n    StyleUtil.forEachRule(rules, function(rule) {\n      self.decorateRule(rule);\n      // mark in-order position of ast rule in styles block, used for cache key\n      rule.index = ruleIndex++;\n      self.collectPropertiesInCssText(rule.propertyInfo.cssText, props);\n    }, function onKeyframesRule(rule) {\n      keyframes.push(rule);\n    });\n    // Cache all found keyframes rules for later reference:\n    rules._keyframes = keyframes;\n    // return this list of property names *consumes* in these styles.\n    let names = [];\n    for (let i in props) {\n      names.push(i);\n    }\n    return names;\n  }\n\n  // decorate a single rule with property info\n  decorateRule(rule) {\n    if (rule.propertyInfo) {\n      return rule.propertyInfo;\n    }\n    let info = {}, properties = {};\n    let hasProperties = this.collectProperties(rule, properties);\n    if (hasProperties) {\n      info.properties = properties;\n      // TODO(sorvell): workaround parser seeing mixins as additional rules\n      rule['rules'] = null;\n    }\n    info.cssText = this.collectCssText(rule);\n    rule.propertyInfo = info;\n    return info;\n  }\n\n  // collects the custom properties from a rule's cssText\n  collectProperties(rule, properties) {\n    let info = rule.propertyInfo;\n    if (info) {\n      if (info.properties) {\n        Object.assign(properties, info.properties);\n        return true;\n      }\n    } else {\n      let m, rx = RX.VAR_ASSIGN;\n      let cssText = rule['parsedCssText'];\n      let value;\n      let any;\n      while ((m = rx.exec(cssText))) {\n        // note: group 2 is var, 3 is mixin\n        value = (m[2] || m[3]).trim();\n        // value of 'inherit' or 'unset' is equivalent to not setting the property here\n        if (value !== 'inherit' || value !== 'unset') {\n          properties[m[1].trim()] = value;\n        }\n        any = true;\n      }\n      return any;\n    }\n\n  }\n\n  // returns cssText of properties that consume variables/mixins\n  collectCssText(rule) {\n    return this.collectConsumingCssText(rule['parsedCssText']);\n  }\n\n  // NOTE: we support consumption inside mixin assignment\n  // but not production, so strip out {...}\n  collectConsumingCssText(cssText) {\n    return cssText.replace(RX.BRACKETED, '')\n      .replace(RX.VAR_ASSIGN, '');\n  }\n\n  collectPropertiesInCssText(cssText, props) {\n    let m;\n    while ((m = RX.VAR_CONSUMED.exec(cssText))) {\n      let name = m[1];\n      // This regex catches all variable names, and following non-whitespace char\n      // If next char is not ':', then variable is a consumer\n      if (m[2] !== ':') {\n        props[name] = true;\n      }\n    }\n  }\n\n  // turns custom properties into realized values.\n  reify(props) {\n    // big perf optimization here: reify only *own* properties\n    // since this object has __proto__ of the element's scope properties\n    let names = Object.getOwnPropertyNames(props);\n    for (let i=0, n; i < names.length; i++) {\n      n = names[i];\n      props[n] = this.valueForProperty(props[n], props);\n    }\n  }\n\n  // given a property value, returns the reified value\n  // a property value may be:\n  // (1) a literal value like: red or 5px;\n  // (2) a variable value like: var(--a), var(--a, red), or var(--a, --b) or\n  // var(--a, var(--b));\n  // (3) a literal mixin value like { properties }. Each of these properties\n  // can have values that are: (a) literal, (b) variables, (c) @apply mixins.\n  valueForProperty(property, props) {\n    // case (1) default\n    // case (3) defines a mixin and we have to reify the internals\n    if (property) {\n      if (property.indexOf(';') >=0) {\n        property = this.valueForProperties(property, props);\n      } else {\n        // case (2) variable\n        let self = this;\n        let fn = function(prefix, value, fallback, suffix) {\n          if (!value) {\n            return prefix + suffix;\n          }\n          let propertyValue = self.valueForProperty(props[value], props);\n          // if value is \"initial\", then the variable should be treated as unset\n          if (!propertyValue || propertyValue === 'initial') {\n            // fallback may be --a or var(--a) or literal\n            propertyValue = self.valueForProperty(props[fallback] || fallback, props) ||\n            fallback;\n          } else if (propertyValue === 'apply-shim-inherit') {\n            // CSS build will replace `inherit` with `apply-shim-inherit`\n            // for use with native css variables.\n            // Since we have full control, we can use `inherit` directly.\n            propertyValue = 'inherit';\n          }\n          return prefix + (propertyValue || '') + suffix;\n        };\n        property = StyleUtil.processVariableAndFallback(property, fn);\n      }\n    }\n    return property && property.trim() || '';\n  }\n\n  // note: we do not yet support mixin within mixin\n  valueForProperties(property, props) {\n    let parts = property.split(';');\n    for (let i=0, p, m; i<parts.length; i++) {\n      if ((p = parts[i])) {\n        RX.MIXIN_MATCH.lastIndex = 0;\n        m = RX.MIXIN_MATCH.exec(p);\n        if (m) {\n          p = this.valueForProperty(props[m[1]], props);\n        } else {\n          let colon = p.indexOf(':');\n          if (colon !== -1) {\n            let pp = p.substring(colon);\n            pp = pp.trim();\n            pp = this.valueForProperty(pp, props) || pp;\n            p = p.substring(0, colon) + pp;\n          }\n        }\n        parts[i] = (p && p.lastIndexOf(';') === p.length - 1) ?\n          // strip trailing ;\n          p.slice(0, -1) :\n          p || '';\n      }\n    }\n    return parts.join(';');\n  }\n\n  applyProperties(rule, props) {\n    let output = '';\n    // dynamically added sheets may not be decorated so ensure they are.\n    if (!rule.propertyInfo) {\n      this.decorateRule(rule);\n    }\n    if (rule.propertyInfo.cssText) {\n      output = this.valueForProperties(rule.propertyInfo.cssText, props);\n    }\n    rule['cssText'] = output;\n  }\n\n  // Apply keyframe transformations to the cssText of a given rule. The\n  // keyframeTransforms object is a map of keyframe names to transformer\n  // functions which take in cssText and spit out transformed cssText.\n  applyKeyframeTransforms(rule, keyframeTransforms) {\n    let input = rule['cssText'];\n    let output = rule['cssText'];\n    if (rule.hasAnimations == null) {\n      // Cache whether or not the rule has any animations to begin with:\n      rule.hasAnimations = RX.ANIMATION_MATCH.test(input);\n    }\n    // If there are no animations referenced, we can skip transforms:\n    if (rule.hasAnimations) {\n      let transform;\n      // If we haven't transformed this rule before, we iterate over all\n      // transforms:\n      if (rule.keyframeNamesToTransform == null) {\n        rule.keyframeNamesToTransform = [];\n        for (let keyframe in keyframeTransforms) {\n          transform = keyframeTransforms[keyframe];\n          output = transform(input);\n          // If the transform actually changed the CSS text, we cache the\n          // transform name for future use:\n          if (input !== output) {\n            input = output;\n            rule.keyframeNamesToTransform.push(keyframe);\n          }\n        }\n      } else {\n        // If we already have a list of keyframe names that apply to this\n        // rule, we apply only those keyframe name transforms:\n        for (let i = 0; i < rule.keyframeNamesToTransform.length; ++i) {\n          transform = keyframeTransforms[rule.keyframeNamesToTransform[i]];\n          input = transform(input);\n        }\n        output = input;\n      }\n    }\n    rule['cssText'] = output;\n  }\n\n  // Test if the rules in these styles matches the given `element` and if so,\n  // collect any custom properties into `props`.\n  /**\n   * @param {StyleNode} rules\n   * @param {Element} element\n   */\n  propertyDataFromStyles(rules, element) {\n    let props = {};\n    // generates a unique key for these matches\n    let o = [];\n    // note: active rules excludes non-matching @media rules\n    StyleUtil.forEachRule(rules, (rule) => {\n      // TODO(sorvell): we could trim the set of rules at declaration\n      // time to only include ones that have properties\n      if (!rule.propertyInfo) {\n        this.decorateRule(rule);\n      }\n      // match element against transformedSelector: selector may contain\n      // unwanted uniquification and parsedSelector does not directly match\n      // for :host selectors.\n      let selectorToMatch = rule.transformedSelector || rule['parsedSelector'];\n      if (element && rule.propertyInfo.properties && selectorToMatch) {\n        if (matchesSelector.call(element, selectorToMatch)) {\n          this.collectProperties(rule, props);\n          // produce numeric key for these matches for lookup\n          addToBitMask(rule.index, o);\n        }\n      }\n    }, null, true);\n    return {properties: props, key: o};\n  }\n\n  /**\n   * @param {Element} scope\n   * @param {StyleNode} rule\n   * @param {string} cssBuild\n   * @param {function(Object)} callback\n   */\n  whenHostOrRootRule(scope, rule, cssBuild, callback) {\n    if (!rule.propertyInfo) {\n      this.decorateRule(rule);\n    }\n    if (!rule.propertyInfo.properties) {\n      return;\n    }\n    let {is, typeExtension} = StyleUtil.getIsExtends(scope);\n    let hostScope = is ?\n      StyleTransformer._calcHostScope(is, typeExtension) :\n      'html';\n    let parsedSelector = rule['parsedSelector'];\n    let isRoot = (parsedSelector === ':host > *' || parsedSelector === 'html');\n    let isHost = parsedSelector.indexOf(':host') === 0 && !isRoot;\n    // build info is either in scope (when scope is an element) or in the style\n    // when scope is the default scope; note: this allows default scope to have\n    // mixed mode built and unbuilt styles.\n    if (cssBuild === 'shady') {\n      // :root -> x-foo > *.x-foo for elements and html for custom-style\n      isRoot = parsedSelector === (hostScope + ' > *.' + hostScope) || parsedSelector.indexOf('html') !== -1;\n      // :host -> x-foo for elements, but sub-rules have .x-foo in them\n      isHost = !isRoot && parsedSelector.indexOf(hostScope) === 0;\n    }\n    if (!isRoot && !isHost) {\n      return;\n    }\n    let selectorToMatch = hostScope;\n    if (isHost) {\n      // need to transform :host because `:host` does not work with `matches`\n      if (!rule.transformedSelector) {\n        // transform :host into a matchable selector\n        rule.transformedSelector =\n        StyleTransformer._transformRuleCss(\n          rule,\n          StyleTransformer._transformComplexSelector,\n          StyleTransformer._calcElementScope(is),\n          hostScope\n        );\n      }\n      selectorToMatch = rule.transformedSelector || hostScope;\n    }\n    callback({\n      selector: selectorToMatch,\n      isHost: isHost,\n      isRoot: isRoot\n    });\n  }\n/**\n * @param {Element} scope\n * @param {StyleNode} rules\n * @param {string} cssBuild\n * @return {Object}\n */\n  hostAndRootPropertiesForScope(scope, rules, cssBuild) {\n    let hostProps = {}, rootProps = {};\n    // note: active rules excludes non-matching @media rules\n    StyleUtil.forEachRule(rules, (rule) => {\n      // if scope is StyleDefaults, use _element for matchesSelector\n      this.whenHostOrRootRule(scope, rule, cssBuild, (info) => {\n        let element = scope._element || scope;\n        if (matchesSelector.call(element, info.selector)) {\n          if (info.isHost) {\n            this.collectProperties(rule, hostProps);\n          } else {\n            this.collectProperties(rule, rootProps);\n          }\n        }\n      });\n    }, null, true);\n    return {rootProps: rootProps, hostProps: hostProps};\n  }\n\n  /**\n   * @param {Element} element\n   * @param {Object} properties\n   * @param {string} scopeSelector\n   */\n  transformStyles(element, properties, scopeSelector) {\n    let self = this;\n    let {is, typeExtension} = StyleUtil.getIsExtends(element);\n    let hostSelector = StyleTransformer\n      ._calcHostScope(is, typeExtension);\n    let rxHostSelector = element.extends ?\n      '\\\\' + hostSelector.slice(0, -1) + '\\\\]' :\n      hostSelector;\n    let hostRx = new RegExp(RX.HOST_PREFIX + rxHostSelector +\n      RX.HOST_SUFFIX);\n    let {styleRules: rules, cssBuild} = StyleInfo.get(element);\n    let keyframeTransforms =\n      this._elementKeyframeTransforms(element, rules, scopeSelector);\n    return StyleTransformer.elementStyles(element, rules, function(rule) {\n      self.applyProperties(rule, properties);\n      if (!nativeShadow &&\n          !StyleUtil.isKeyframesSelector(rule) &&\n          rule['cssText']) {\n        // NOTE: keyframe transforms only scope munge animation names, so it\n        // is not necessary to apply them in ShadowDOM.\n        self.applyKeyframeTransforms(rule, keyframeTransforms);\n        self._scopeSelector(rule, hostRx, hostSelector, scopeSelector);\n      }\n    }, cssBuild);\n  }\n\n  /**\n   * @param {Element} element\n   * @param {StyleNode} rules\n   * @param {string} scopeSelector\n   * @return {Object}\n   */\n  _elementKeyframeTransforms(element, rules, scopeSelector) {\n    let keyframesRules = rules._keyframes;\n    let keyframeTransforms = {};\n    if (!nativeShadow && keyframesRules) {\n      // For non-ShadowDOM, we transform all known keyframes rules in\n      // advance for the current scope. This allows us to catch keyframes\n      // rules that appear anywhere in the stylesheet:\n      for (let i = 0, keyframesRule = keyframesRules[i];\n           i < keyframesRules.length;\n           keyframesRule = keyframesRules[++i]) {\n        this._scopeKeyframes(keyframesRule, scopeSelector);\n        keyframeTransforms[keyframesRule['keyframesName']] =\n            this._keyframesRuleTransformer(keyframesRule);\n      }\n    }\n    return keyframeTransforms;\n  }\n\n  // Generate a factory for transforming a chunk of CSS text to handle a\n  // particular scoped keyframes rule.\n  /**\n   * @param {StyleNode} keyframesRule\n   * @return {function(string):string}\n   */\n  _keyframesRuleTransformer(keyframesRule) {\n    return function(cssText) {\n      return cssText.replace(\n          keyframesRule.keyframesNameRx,\n          keyframesRule.transformedKeyframesName);\n    };\n  }\n\n/**\n * Transforms `@keyframes` names to be unique for the current host.\n * Example: @keyframes foo-anim -> @keyframes foo-anim-x-foo-0\n *\n * @param {StyleNode} rule\n * @param {string} scopeId\n */\n  _scopeKeyframes(rule, scopeId) {\n    // Animation names are of the form [\\w-], so ensure that the name regex does not partially apply\n    // to similarly named keyframe names by checking for a word boundary at the beginning and\n    // a non-word boundary or `-` at the end.\n    rule.keyframesNameRx = new RegExp(`\\\\b${rule['keyframesName']}(?!\\\\B|-)`, 'g');\n    rule.transformedKeyframesName = rule['keyframesName'] + '-' + scopeId;\n    rule.transformedSelector = rule.transformedSelector || rule['selector'];\n    rule['selector'] = rule.transformedSelector.replace(\n        rule['keyframesName'], rule.transformedKeyframesName);\n  }\n\n  // Strategy: x scope shim a selector e.g. to scope `.x-foo-42` (via classes):\n  // non-host selector: .a.x-foo -> .x-foo-42 .a.x-foo\n  // host selector: x-foo.wide -> .x-foo-42.wide\n  // note: we use only the scope class (.x-foo-42) and not the hostSelector\n  // (x-foo) to scope :host rules; this helps make property host rules\n  // have low specificity. They are overrideable by class selectors but,\n  // unfortunately, not by type selectors (e.g. overriding via\n  // `.special` is ok, but not by `x-foo`).\n  /**\n   * @param {StyleNode} rule\n   * @param {RegExp} hostRx\n   * @param {string} hostSelector\n   * @param {string} scopeId\n   */\n  _scopeSelector(rule, hostRx, hostSelector, scopeId) {\n    rule.transformedSelector = rule.transformedSelector || rule['selector'];\n    let selector = rule.transformedSelector;\n    let scope = '.' + scopeId;\n    let parts = StyleUtil.splitSelectorList(selector);\n    for (let i=0, l=parts.length, p; (i<l) && (p=parts[i]); i++) {\n      parts[i] = p.match(hostRx) ?\n        p.replace(hostSelector, scope) :\n        scope + ' ' + p;\n    }\n    rule['selector'] = parts.join(',');\n  }\n\n  /**\n   * @param {Element} element\n   * @param {string} selector\n   * @param {string} old\n   */\n  applyElementScopeSelector(element, selector, old) {\n    let c = element.getAttribute('class') || '';\n    let v = c;\n    if (old) {\n      v = c.replace(\n        new RegExp('\\\\s*' + XSCOPE_NAME + '\\\\s*' + old + '\\\\s*', 'g'), ' ');\n    }\n    v += (v ? ' ' : '') + XSCOPE_NAME + ' ' + selector;\n    if (c !== v) {\n      StyleUtil.setElementClassRaw(element, v);\n    }\n  }\n\n  /**\n   * @param {HTMLElement} element\n   * @param {Object} properties\n   * @param {string} selector\n   * @param {HTMLStyleElement} style\n   * @return {HTMLStyleElement}\n   */\n  applyElementStyle(element, properties, selector, style) {\n    // calculate cssText to apply\n    let cssText = style ? style.textContent || '' :\n      this.transformStyles(element, properties, selector);\n    // if shady and we have a cached style that is not style, decrement\n    let styleInfo = StyleInfo.get(element);\n    let s = styleInfo.customStyle;\n    if (s && !nativeShadow && (s !== style)) {\n      s['_useCount']--;\n      if (s['_useCount'] <= 0 && s.parentNode) {\n        s.parentNode.removeChild(s);\n      }\n    }\n    // apply styling always under native or if we generated style\n    // or the cached style is not in document(!)\n    if (nativeShadow) {\n      // update existing style only under native\n      if (styleInfo.customStyle) {\n        styleInfo.customStyle.textContent = cssText;\n        style = styleInfo.customStyle;\n      // otherwise, if we have css to apply, do so\n      } else if (cssText) {\n        // apply css after the scope style of the element to help with\n        // style precedence rules.\n        style = StyleUtil.applyCss(cssText, selector, element.shadowRoot,\n          styleInfo.placeholder);\n      }\n    } else {\n      // shady and no cache hit\n      if (!style) {\n        // apply css after the scope style of the element to help with\n        // style precedence rules.\n        if (cssText) {\n          style = StyleUtil.applyCss(cssText, selector, null,\n            styleInfo.placeholder);\n        }\n      // shady and cache hit but not in document\n      } else if (!style.parentNode) {\n        if (IS_IE && cssText.indexOf('@media') > -1) {\n            // @media rules may be stale in IE 10 and 11\n            // refresh the text content of the style to revalidate them.\n          style.textContent = cssText;\n        }\n        StyleUtil.applyStyle(style, null, styleInfo.placeholder);\n      }\n    }\n    // ensure this style is our custom style and increment its use count.\n    if (style) {\n      style['_useCount'] = style['_useCount'] || 0;\n      // increment use count if we changed styles\n      if (styleInfo.customStyle != style) {\n        style['_useCount']++;\n      }\n      styleInfo.customStyle = style;\n    }\n    return style;\n  }\n\n  /**\n   * @param {Element} style\n   * @param {Object} properties\n   */\n  applyCustomStyle(style, properties) {\n    let rules = StyleUtil.rulesForStyle(/** @type {HTMLStyleElement} */(style));\n    let self = this;\n    style.textContent = StyleUtil.toCssText(rules, function(/** StyleNode */rule) {\n      let css = rule['cssText'] = rule['parsedCssText'];\n      if (rule.propertyInfo && rule.propertyInfo.cssText) {\n        // remove property assignments\n        // so next function isn't confused\n        // NOTE: we have 3 categories of css:\n        // (1) normal properties,\n        // (2) custom property assignments (--foo: red;),\n        // (3) custom property usage: border: var(--foo); @apply(--foo);\n        // In elements, 1 and 3 are separated for efficiency; here they\n        // are not and this makes this case unique.\n        css = removeCustomPropAssignment(/** @type {string} */(css));\n        // replace with reified properties, scenario is same as mixin\n        rule['cssText'] = self.valueForProperties(css, properties);\n      }\n    });\n  }\n}\n\n/**\n * @param {number} n\n * @param {Array<number>} bits\n */\nfunction addToBitMask(n, bits) {\n  let o = parseInt(n / 32, 10);\n  let v = 1 << (n % 32);\n  bits[o] = (bits[o] || 0) | v;\n}\n\nexport default new StyleProperties();","/**\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'use strict';\n\nimport {StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\n\n/** @const {string} */\nconst infoKey = '__styleInfo';\n\nexport default class StyleInfo {\n  /**\n   * @param {Element} node\n   * @return {StyleInfo}\n   */\n  static get(node) {\n    if (node) {\n      return node[infoKey];\n    } else {\n      return null;\n    }\n  }\n  /**\n   * @param {!Element} node\n   * @param {StyleInfo} styleInfo\n   * @return {StyleInfo}\n   */\n  static set(node, styleInfo) {\n    node[infoKey] = styleInfo;\n    return styleInfo;\n  }\n  /**\n   * @param {StyleNode} ast\n   * @param {Node=} placeholder\n   * @param {Array<string>=} ownStylePropertyNames\n   * @param {string=} elementName\n   * @param {string=} typeExtension\n   * @param {string=} cssBuild\n   */\n  constructor(ast, placeholder, ownStylePropertyNames, elementName, typeExtension, cssBuild) {\n    /** @type {StyleNode} */\n    this.styleRules = ast || null;\n    /** @type {Node} */\n    this.placeholder = placeholder || null;\n    /** @type {!Array<string>} */\n    this.ownStylePropertyNames = ownStylePropertyNames || [];\n    /** @type {Object} */\n    this.overrideStyleProperties = null;\n    /** @type {string} */\n    this.elementName = elementName || '';\n    /** @type {string} */\n    this.cssBuild = cssBuild || '';\n    /** @type {string} */\n    this.typeExtension = typeExtension || '';\n    /** @type {Object<string, string>} */\n    this.styleProperties = null;\n    /** @type {?string} */\n    this.scopeSelector = null;\n    /** @type {HTMLStyleElement} */\n    this.customStyle = null;\n  }\n  _getStyleRules() {\n    return this.styleRules;\n  }\n}\n\n/* eslint-disable-next-line no-self-assign */\nStyleInfo.prototype['_getStyleRules'] = StyleInfo.prototype._getStyleRules;\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'use strict';\n\nimport {applyStylePlaceHolder} from './style-util.js';\nimport {nativeShadow, disableRuntime} from './style-settings.js';\n\n/** @type {!Object<string, !Node>} */\nconst placeholderMap = {};\n\n/**\n * @param {string} elementName\n * @return {Node}\n */\nexport function getStylePlaceholder(elementName) {\n  return placeholderMap[elementName] || null;\n}\n\n/**\n * @param {string} elementName\n */\nexport function ensureStylePlaceholder(elementName) {\n  if (!placeholderMap[elementName]) {\n    placeholderMap[elementName] = applyStylePlaceHolder(elementName);\n  }\n}\n\n/**\n * @const {CustomElementRegistry}\n */\nconst ce = window['customElements'];\nif (ce && !nativeShadow && !disableRuntime) {\n  /**\n   * @const {function(this:CustomElementRegistry, string,function(new:HTMLElement),{extends: string}=)}\n   */\n  const origDefine = ce['define'];\n  /**\n   * @param {string} name\n   * @param {function(new:HTMLElement)} clazz\n   * @param {{extends: string}=} options\n   */\n  const wrappedDefine = (name, clazz, options) => {\n    ensureStylePlaceholder(name);\n    origDefine.call(/** @type {!CustomElementRegistry} */(ce), name, clazz, options);\n  };\n  ce['define'] = wrappedDefine;\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'use strict';\n\nexport default class StyleCache {\n  constructor(typeMax = 100) {\n    // map element name -> [{properties, styleElement, scopeSelector}]\n    this.cache = {};\n    /** @type {number} */\n    this.typeMax = typeMax;\n  }\n\n  _validate(cacheEntry, properties, ownPropertyNames) {\n    for (let idx = 0; idx < ownPropertyNames.length; idx++) {\n      let pn = ownPropertyNames[idx];\n      if (cacheEntry.properties[pn] !== properties[pn]) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  store(tagname, properties, styleElement, scopeSelector) {\n    let list = this.cache[tagname] || [];\n    list.push({properties, styleElement, scopeSelector});\n    if (list.length > this.typeMax) {\n      list.shift();\n    }\n    this.cache[tagname] = list;\n  }\n\n  fetch(tagname, properties, ownPropertyNames) {\n    let list = this.cache[tagname];\n    if (!list) {\n      return;\n    }\n    // reverse list for most-recent lookups\n    for (let idx = list.length - 1; idx >= 0; idx--) {\n      let entry = list[idx];\n      if (this._validate(entry, properties, ownPropertyNames)) {\n        return entry;\n      }\n    }\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'use strict';\n\n/**\n * @const {!Object<string, !HTMLTemplateElement>}\n */\nconst templateMap = {};\nexport default templateMap;\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'use strict';\nimport templateMap from './template-map.js';\nimport {StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\n\n/*\n * Utilities for handling invalidating apply-shim mixins for a given template.\n *\n * The invalidation strategy involves keeping track of the \"current\" version of a template's mixins, and updating that count when a mixin is invalidated.\n * The template\n */\n\n/** @const {string} */\nconst CURRENT_VERSION = '_applyShimCurrentVersion';\n\n/** @const {string} */\nconst NEXT_VERSION = '_applyShimNextVersion';\n\n/** @const {string} */\nconst VALIDATING_VERSION = '_applyShimValidatingVersion';\n\n/**\n * @const {Promise<void>}\n */\nconst promise = Promise.resolve();\n\n/**\n * @param {string} elementName\n */\nexport function invalidate(elementName){\n  let template = templateMap[elementName];\n  if (template) {\n    invalidateTemplate(template);\n  }\n}\n\n/**\n * This function can be called multiple times to mark a template invalid\n * and signal that the style inside must be regenerated.\n *\n * Use `startValidatingTemplate` to begin an asynchronous validation cycle.\n * During that cycle, call `templateIsValidating` to see if the template must\n * be revalidated\n * @param {HTMLTemplateElement} template\n */\nexport function invalidateTemplate(template) {\n  // default the current version to 0\n  template[CURRENT_VERSION] = template[CURRENT_VERSION] || 0;\n  // ensure the \"validating for\" flag exists\n  template[VALIDATING_VERSION] = template[VALIDATING_VERSION] || 0;\n  // increment the next version\n  template[NEXT_VERSION] = (template[NEXT_VERSION] || 0) + 1;\n}\n\n/**\n * @param {string} elementName\n * @return {boolean}\n */\nexport function isValid(elementName) {\n  let template = templateMap[elementName];\n  if (template) {\n    return templateIsValid(template);\n  }\n  return true;\n}\n\n/**\n * @param {HTMLTemplateElement} template\n * @return {boolean}\n */\nexport function templateIsValid(template) {\n  return template[CURRENT_VERSION] === template[NEXT_VERSION];\n}\n\n/**\n * @param {string} elementName\n * @return {boolean}\n */\nexport function isValidating(elementName) {\n  let template = templateMap[elementName];\n  if (template) {\n    return templateIsValidating(template);\n  }\n  return false;\n}\n\n/**\n * Returns true if the template is currently invalid and `startValidating` has been called since the last invalidation.\n * If false, the template must be validated.\n * @param {HTMLTemplateElement} template\n * @return {boolean}\n */\nexport function templateIsValidating(template) {\n  return !templateIsValid(template) && template[VALIDATING_VERSION] === template[NEXT_VERSION];\n}\n\n/**\n * the template is marked as `validating` for one microtask so that all instances\n * found in the tree crawl of `applyStyle` will update themselves,\n * but the template will only be updated once.\n * @param {string} elementName\n*/\nexport function startValidating(elementName) {\n  let template = templateMap[elementName];\n  startValidatingTemplate(template);\n}\n\n/**\n * Begin an asynchronous invalidation cycle.\n * This should be called after every validation of a template\n *\n * After one microtask, the template will be marked as valid until the next call to `invalidateTemplate`\n * @param {HTMLTemplateElement} template\n */\nexport function startValidatingTemplate(template) {\n  // remember that the current \"next version\" is the reason for this validation cycle\n  template[VALIDATING_VERSION] = template[NEXT_VERSION];\n  // however, there only needs to be one async task to clear the counters\n  if (!template._validating) {\n    template._validating = true;\n    promise.then(function() {\n      // sync the current version to let future invalidations cause a refresh cycle\n      template[CURRENT_VERSION] = template[NEXT_VERSION];\n      template._validating = false;\n    });\n  }\n}\n\n/**\n * @return {boolean}\n */\nexport function elementsAreInvalid() {\n  for (let elementName in templateMap) {\n    let template = templateMap[elementName];\n    if (!templateIsValid(template)) {\n      return true;\n    }\n  }\n  return false;\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'use strict';\n\nimport { MIXIN_MATCH, VAR_ASSIGN } from './common-regex.js';\n\n/**\n * @param {Element} element\n * @param {Object=} properties\n */\nexport function updateNativeProperties(element, properties) {\n  // remove previous properties\n  for (let p in properties) {\n    // NOTE: for bc with shim, don't apply null values.\n    if (p === null) {\n      element.style.removeProperty(p);\n    } else {\n      element.style.setProperty(p, properties[p]);\n    }\n  }\n}\n\n/**\n * @param {Element} element\n * @param {string} property\n * @return {string}\n */\nexport function getComputedStyleValue(element, property) {\n  /**\n   * @const {string}\n   */\n  const value = window.getComputedStyle(element).getPropertyValue(property);\n  if (!value) {\n    return '';\n  } else {\n    return value.trim();\n  }\n}\n\n/**\n * return true if `cssText` contains a mixin definition or consumption\n * @param {string} cssText\n * @return {boolean}\n */\nexport function detectMixin(cssText) {\n  const has = MIXIN_MATCH.test(cssText) || VAR_ASSIGN.test(cssText);\n  // reset state of the regexes\n  MIXIN_MATCH.lastIndex = 0;\n  VAR_ASSIGN.lastIndex = 0;\n  return has;\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'use strict';\n\nimport ScopingShim from '../src/scoping-shim.js';\nimport {nativeCssVariables, nativeShadow, cssBuild, disableRuntime} from '../src/style-settings.js';\n\n/** @const {ScopingShim} */\nconst scopingShim = new ScopingShim();\n\nlet ApplyShim, CustomStyleInterface;\n\nif (window['ShadyCSS']) {\n  ApplyShim = window['ShadyCSS']['ApplyShim'];\n  CustomStyleInterface = window['ShadyCSS']['CustomStyleInterface'];\n}\n\nwindow.ShadyCSS = {\n  ScopingShim: scopingShim,\n  /**\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} elementExtends\n   */\n  prepareTemplate(template, elementName, elementExtends) {\n    scopingShim.flushCustomStyles();\n    scopingShim.prepareTemplate(template, elementName, elementExtends)\n  },\n\n  /**\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   */\n  prepareTemplateDom(template, elementName) {\n    scopingShim.prepareTemplateDom(template, elementName);\n  },\n\n  /**\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} elementExtends\n   */\n  prepareTemplateStyles(template, elementName, elementExtends) {\n    scopingShim.flushCustomStyles();\n    scopingShim.prepareTemplateStyles(template, elementName, elementExtends)\n  },\n  /**\n   * @param {!HTMLElement} element\n   * @param {Object=} properties\n   */\n  styleSubtree(element, properties) {\n    scopingShim.flushCustomStyles();\n    scopingShim.styleSubtree(element, properties);\n  },\n\n  /**\n   * @param {!HTMLElement} element\n   */\n  styleElement(element) {\n    scopingShim.flushCustomStyles();\n    scopingShim.styleElement(element);\n  },\n\n  /**\n   * @param {Object=} properties\n   */\n  styleDocument(properties) {\n    scopingShim.flushCustomStyles();\n    scopingShim.styleDocument(properties);\n  },\n\n  flushCustomStyles() {\n    scopingShim.flushCustomStyles();\n  },\n\n  /**\n   * @param {Element} element\n   * @param {string} property\n   * @return {string}\n   */\n  getComputedStyleValue(element, property) {\n    return scopingShim.getComputedStyleValue(element, property);\n  },\n\n  nativeCss: nativeCssVariables,\n\n  nativeShadow: nativeShadow,\n\n  cssBuild: cssBuild,\n\n  disableRuntime: disableRuntime,\n};\n\nif (ApplyShim) {\n  window.ShadyCSS.ApplyShim = ApplyShim;\n}\n\nif (CustomStyleInterface) {\n  window.ShadyCSS.CustomStyleInterface = CustomStyleInterface;\n}","/**\n * @license\n * Copyright (c) 2014 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\nexport {};\n\nlet customElements = window['customElements'];\nlet HTMLImports = window['HTMLImports'];\nlet Template = window['HTMLTemplateElement'];\n\n// global for (1) existence means `WebComponentsReady` will file,\n// (2) WebComponents.ready == true means event has fired.\nwindow.WebComponents = window.WebComponents || {};\n\nif (customElements && customElements['polyfillWrapFlushCallback']) {\n  // Here we ensure that the public `HTMLImports.whenReady`\n  // always comes *after* custom elements have upgraded.\n  let flushCallback;\n  let runAndClearCallback = function runAndClearCallback() {\n    if (flushCallback) {\n      // make sure to run the HTMLTemplateElement polyfill before custom elements upgrade\n      if (Template.bootstrap) {\n        Template.bootstrap(window.document);\n      }\n      let cb = flushCallback;\n      flushCallback = null;\n      cb();\n      return true;\n    }\n  }\n  let origWhenReady = HTMLImports['whenReady'];\n  customElements['polyfillWrapFlushCallback'](function(cb) {\n    flushCallback = cb;\n    origWhenReady(runAndClearCallback);\n  });\n\n  HTMLImports['whenReady'] = function(cb) {\n    origWhenReady(function() {\n      // custom element code may add dynamic imports\n      // to match processing of native custom elements before\n      // domContentLoaded, we wait for these imports to resolve first.\n      if (runAndClearCallback()) {\n        HTMLImports['whenReady'](cb);\n      } else {\n        cb();\n      }\n    });\n  }\n\n}\n\nHTMLImports['whenReady'](function() {\n  requestAnimationFrame(function() {\n    window.WebComponents.ready = true;\n    document.dispatchEvent(new CustomEvent('WebComponentsReady', {bubbles: true}));\n  });\n});\n","/**\n * @license\n * Copyright (c) 2014 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\nexport {};\n\n// It's desireable to provide a default stylesheet\n// that's convenient for styling unresolved elements, but\n// it's cumbersome to have to include this manually in every page.\n// It would make sense to put inside some HTMLImport but\n// the HTMLImports polyfill does not allow loading of stylesheets\n// that block rendering. Therefore this injection is tolerated here.\n//\n// NOTE: position: relative fixes IE's failure to inherit opacity\n// when a child is not statically positioned.\nlet style = document.createElement('style');\nstyle.textContent = ''\n    + 'body {'\n    + 'transition: opacity ease-in 0.2s;'\n    + ' } \\n'\n    + 'body[unresolved] {'\n    + 'opacity: 0; display: block; overflow: hidden; position: relative;'\n    + ' } \\n'\n    ;\nlet head = document.querySelector('head');\nhead.insertBefore(style, head.firstChild);\n"]}