{"version":3,"sources":["../../shadydom/src/shady-data.js"," [synthetic:util/defineproperty] "," [synthetic:util/global] "," [synthetic:es6/symbol] "," [synthetic:es6/util/makeiterator] "," [synthetic:es6/util/arrayfromiterator] ","../../shadydom/src/utils.js","../../shadydom/src/flush.js","../../shadydom/src/observe-changes.js","../../shadydom/src/native-methods.js","../../shadydom/src/innerHTML.js","../../shadydom/src/native-tree-walker.js","../../shadydom/src/native-tree-accessors.js","../../shadydom/src/native-tree.js","../../shadydom/src/patch-accessors.js","../../shadydom/src/patch-builtins.js","../../shadydom/src/logical-tree.js","../../shadydom/src/logical-mutation.js","../../shadydom/src/attach-shadow.js","../../shadydom/src/patch-events.js","../../shadydom/src/array-splice.js"," [synthetic:es6/util/arrayfromiterable] ","../../shadydom/src/shadydom.js","../../custom-elements/src/Utilities.js","../../custom-elements/src/CustomElementInternals.js","../../custom-elements/src/CustomElementState.js","../../custom-elements/src/DocumentConstructionObserver.js","../../custom-elements/src/CustomElementRegistry.js","../../custom-elements/src/Deferred.js","../../custom-elements/src/Patch/Native.js","../../custom-elements/src/AlreadyConstructedMarker.js","../../custom-elements/src/Patch/HTMLElement.js","../../custom-elements/src/custom-elements.js","../../custom-elements/src/Patch/Interface/ParentNode.js","../../custom-elements/src/Patch/Document.js","../../custom-elements/src/Patch/Node.js","../../custom-elements/src/Patch/Interface/ChildNode.js","../../custom-elements/src/Patch/Element.js","../../custom-elements/src/Patch/DocumentFragment.js","../../shadycss/src/css-parse.js","../../shadycss/src/style-settings.js","../../shadycss/src/common-regex.js","../../shadycss/src/unscoped-style-handler.js","../../shadycss/src/style-util.js","../../shadycss/src/style-transformer.js","../../shadycss/src/scoping-shim.js","../../shadycss/src/document-watcher.js","../../shadycss/src/style-properties.js","../../shadycss/src/style-info.js","../../shadycss/src/style-placeholder.js","../../shadycss/src/style-cache.js","../../shadycss/src/template-map.js","../../shadycss/src/apply-shim-utils.js","../../shadycss/src/common-utils.js","../../shadycss/entrypoints/scoping-shim.js"],"names":["$jscomp.defineProperty","$jscomp.global","$jscomp.initSymbol","$jscomp.Symbol","$jscomp.SYMBOL_PREFIX","$jscomp.arrayIterator","$jscomp.initSymbolIterator","$jscomp.iteratorPrototype","constructor","ShadyData","publicRoot","root","dirty","flattenedNodes","_prevAssignedSlot","_previouslyAssignedNodes","assignedSlot","assignedNodes","observer","childNodes","nextSibling","previousSibling","lastChild","firstChild","parentNode","ownerShadyRoot","undefined","__insideAccessors","__outsideAccessors","__onCallbackListeners","toJSON","ensureShadyDataForNode","node","__shady","shadyDataForNode","settings","window","hasNativeShadowDOM","attachShadow","Element","prototype","getRootNode","Node","desc","Object","getOwnPropertyDescriptor","hasDescriptors","configurable","get","inUse","IS_IE","navigator","userAgent","match","IS_EDGE","useNativeAccessors","isTrackingLogicalChildNodes","nodeData","isShadyRoot","obj","_localName","ownerShadyRootForNode","p","matches","matchesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector","webkitMatchesSelector","extend","target","source","n$","getOwnPropertyNames","i","n","length","pd","name","defineProperty","extendAll","sources","mixin","twiddle","document","createTextNode","content","queue","observe","MutationObserver","shift","e","textContent","characterData","microtask","callback","push","hasDocumentContains","contains","container","createPolyfilledHTMLCollection","nodes","l","getAttribute","isNaN","item","nodes.item","index","namedItem","nodes.namedItem","$jscomp.makeIterator","flushList","scheduled","enqueue","flush","didFlush","AsyncObserver","_scheduled","addedNodes","removedNodes","callbacks","Set","schedule","mutations","takeRecords","forEach","cb","observeChildren","sd","add","_callback","_observer","_node","unobserveChildren","handle","delete","size","filterMutations","targetRootNode","map","mutation","mutationInScope","Array","from","filter","create","value","m","insertBefore","replaceChild","removeChild","setAttribute","removeAttribute","cloneNode","importNode","Document","addEventListener","removeEventListener","windowAddEventListener","Window","windowRemoveEventListener","dispatchEvent","HTMLElement","getElementById","elementQuerySelector","querySelector","fragmentQuerySelector","DocumentFragment","documentQuerySelector","elementQuerySelectorAll","querySelectorAll","fragmentQuerySelectorAll","documentQuerySelectorAll","exports","appendChild","selector","nodeType","ELEMENT_NODE","call","DOCUMENT_NODE","escapeAttrRegExp","escapeDataRegExp","escapeReplace","c","makeSet","arr","set","voidElements","plaintextParents","getInnerHTML","localName","s","c$","child","tagName","attrs","attributes","attr","replace","TEXT_NODE","data","COMMENT_NODE","console","error","Error","nodeWalker","createTreeWalker","NodeFilter","SHOW_ALL","elementWalker","SHOW_ELEMENT","currentNode","parentElement","firstElementChild","lastElementChild","previousElementSibling","nextElementSibling","children","innerHTML","DOCUMENT_FRAGMENT_NODE","textWalker","SHOW_TEXT","nextNode","nodeValue","nativeProtos","findNodeDescriptor","proto","hasOwnProperty","nodeAccessors","fragmentAccessors","documentAccessors","slice","accessors","nativeTreeAccessors","nativeTreeWalker","clearNode","inertDoc","implementation","createHTMLDocument","nativeIsConnectedAccessors","nativeIsConnected","nativeActiveElementDescriptor","OutsideAccessors","nativeTree","ClassNameAccessor","className","InsideAccessors","childNodes.item","childElementCount","tc","cn","join","text","nativeAccessors","containerName","htmlContainer","namespaceURI","createElementNS","createElement","newContent","ShadowRootAccessor","shadowRoot","ActiveElementAccessor","activeElement","active","host","nativeContains","activeRoot","patchAccessorGroup","descriptors","force","objDesc","warn","patchAccessors","patchShadowRootAccessors","ShadyRoot","__proto__","defineProperties","nodeName","prop","patchOutsideElementAccessors","element","patchInsideElementAccessors","recordInsertBefore","ref_node","containerData","linkNode","resetTo","ref_nodeData","psd","nsd","recordRemoveChild","recordChildNodes","doc","preferPerformance","parent","ownerDocument","nativeMethods","refData","slotsAdded","scopingFn","addShadyScoping","ownerRoot","newScopeName","currentScopeForNode","oldScopeName","ShadowRoot","getScopingShim","scopingShim","removeShadyScoping","allowNativeInsert","needsScoping","currentScopeIsCorrect","treeVisitor","_addSlots","_asyncRender","parentData","hasShadowRootWithSlot","firstComposedNode","adoptNode","scheduleObserver","skipUnscoping","preventNativeRemove","removeOwnerShadyRoot","changeSlotContent","removingInsertionPoint","_removeContainedSlots","composed","flattened","_hasInsertionPoint","distributeAttributeChange","_updateSlotName","_slotList","_validateSlots","oldName","__slotName","_nameForSlot","slots","_slotMap","indexOf","splice","list","_sortSlots","addedNode","removedNode","documentElement","query","matcher","halter","queryElements","elements","result","deep","nc","currentScopeName","correctScope","idx","currentScope","visitorFn","eventWrappersName","Date","now","composedGetter","composedProp","Event","ev","alwaysComposed","unpatchedEvents","pathComposer","startNode","composedPath","current","startRoot","retarget","refNode","path","refNodePath","ancestor","lastRoot","rootIdx","eventMixin","__composed","type","isTrusted","__composedPath","currentTarget","relatedTarget","__relatedTarget","__relatedTargetComposedPath","stopPropagation","__propagationStopped","stopImmediatePropagation","__immediatePropagationStopped","mixinComposedFlag","Base","klazz","options","event","nonBubblingEventsToRetarget","hasRetargeted","fireHandlers","phase","hs","__handlers","fn","retargetNonBubblingEvent","AT_TARGET","lastFiredRoot","findListener","wrappers","capture","once","passive","savedType","savedListener","savedCapture","savedOnce","savedPassive","savedNode","fnOrObj","optionsOrCapture","handlerType","handleEvent","ael","__shadyTarget","wrapperFn","patchEvent","lastCurrentTargetDesc","eventPhase","BUBBLING_PHASE","CAPTURING_PHASE","bubbles","ret","rel","activateFocusEventOverrides","getPrototypeOf","patchProto","__sourceProto","PatchedEvent","PatchedCustomEvent","CustomEvent","PatchedMouseEvent","MouseEvent","patchEvents","composedClickFn","cancelable","click","newSplice","addedCount","removed","calcSplices","currentEnd","old","oldEnd","currentStart","oldStart","prefixCount","suffixCount","minLength","Math","min","currentValue","previousValue","index1","index2","count","equals","rowCount","columnCount","distances","j","north","west","edits","EDIT_ADD","EDIT_DELETE","northWest","EDIT_LEAVE","EDIT_UPDATE","reverse","splices","oldIndex","ShadyRootConstructionToken","isRendering","readyState","rootRendered","ancestorList","ancestors","unshift","token","TypeError","SHADYROOT_NAME","_mode","mode","hostData","MODE_CLOSED","rootData","_hasRendered","_renderPending","_pendingSlots","_render","_getRenderRoot","renderRoot","_rendererForHost","_isInsertionPoint","wasRendering","_distribute","slot","_clearSlotAssignedNodes","slotData","_distributeNodeToSlot","slotParentRoot","slotParentData","_addAssignedToFlattenedNodes","prevAssignedNodes","_fireSlotChange","_compose","composeList","_composeNode","_updateChildNodes","d","next","forcedSlot","oldSlot","CATCHALL_NAME","assigned","nestedAssigned","_ensureSlotData","$jscomp.arrayFromIterator","_mapSlots","slotNamesToSort","sort","a","b","listA","listB","nA","nB","x","_removeFlattenedNodes","didRemove","connectMap","Map","clear","__shadydom_connectedCallback","__shadydom_disconnectedCallback","ManageConnect","base","connected","disconnected","counter","connectFlag","connectedCallback","base.prototype.__shadydom_connectedCallback","disconnectedCallback","base.prototype.__shadydom_disconnectedCallback","isConnected","define","getAssignedSlot","windowMixin","bind","nodeMixin","ATTRIBUTE_NODE","IsConnectedAccessor","textMixin","queryMixin","useNative","o","fragmentMixin","slotMixin","flatten","elementMixin","documentMixin","id","nativeBlur","blur","htmlElementMixin","shadowActive","property","substring","shadyData","eventName","shadowRootMixin","patchBuiltin","ShadyDOM","patch","nativeHTMLElement","Text","HTMLSlotElement","reservedTagList","isValidCustomElementName","reserved","has","validForm","test","nativeValue","__CE_isImportDocument","nextSiblingOrAncestorSibling","start","walkDeepDescendantElements","visitedImports","import","__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","newValue","namespace","DocumentConstructionObserver","internals","_internals","_document","_handleMutations","childList","subtree","disconnect","Deferred","_resolve","_value","_promise","Promise","resolve","CustomElementRegistry","_elementDefinitionIsRunning","_whenDefinedDeferred","_flushCallback","this._flushCallback","_flushPending","_pendingDefinitions","_documentConstructionObserver","define.prototype","Function","SyntaxError","getCallback","callbackValue","adoptedCallback","_flush","upgrade.prototype","pendingDefinitions","elementsWithStableDefinitions","elementsWithPendingDefinitions","pendingElements","pendingUpgradableElements","deferred","get.prototype","whenDefined.prototype","CustomElementRegistry$$module$node_modules$$webcomponents$custom_elements$src$CustomElementRegistry_prototype$whenDefined","whenDefined","reject","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","enumerable","builtIn","appendPrependPatch","builtInMethod","connectedElements","apply","prepend","append","clone","$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","parts","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","toLowerCase","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","previous","CLOSE_BRACE","t","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","split","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$","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","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","scope","head","after","compareDocumentPosition","DOCUMENT_POSITION_PRECEDING","findMatchingParen","level","processVariableAndFallback","str","prefix","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","$jscomp.global.Object.defineProperties","StyleInfo","ast","placeholder","ownStylePropertyNames","overrideStyleProperties","customStyle","scopeSelector","styleProperties","styleInfo","_getStyleRules","method","StyleProperties","decorateStyles","props","keyframes","ruleIndex","decorateRule","propertyInfo","collectPropertiesInCssText","exec","onKeyframesRule","_keyframes","names","properties","collectProperties","collectCssText","collectConsumingCssText","assign","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","fetch","ownPropertyNames","entry","_validate","pn","scopeRegExp","getCurrentScope","getOwnerScope","handler","mxns","mxn","unscopedNodes","unscopedNode","scopeForPreviouslyUnscopedNode","delayedStart","body","requestAnimationFrame","module$node_modules$$webcomponents$shadycss$src$document_watcher.flush","templateMap","promise","invalidate","elementName","template","templateIsValid","startValidatingTemplate","_validating","then","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","hasAttribute","scopingAttribute","newStyle","_ensure","hasMixins","_generateStaticStyle","shadowroot","_style","_ownPropertyNames","prepareTemplateDom.prototype","_domPrepared","_ensureCustomStyleInterface","CustomStyleInterface","transformCustomStyleForDocument","flushCustomStyles","_ensureApplyShim","ApplyShim","flushCustomStyles.prototype","customStyles","_revalidateCustomStyleApplyShim","_revalidateApplyShim","_updateProperties","_applyCustomStyles","styleDocument","styleElement.prototype","overrideProps","_prepareHost","styleElementNativeVariables","removeProperty","setProperty","styleElementShimVariables","_applyStyleProperties","cachedStyle","cacheEntry","oldScopeSelector","_generateScopeSelector","applyElementStyle","applyElementScopeSelector","v","_styleOwnerForNode","owner","ownerStyleInfo","hostAndRootProps","propertiesMatchingHost","_mixinOverrideStyles","overrides","reify","styleDocument.prototype","styleSubtree","styleSubtree.prototype","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"],"mappings":"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","file":"webcomponents-sd-ce.js","sourcesContent":["/**\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  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",null,null,null,null,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*/\nimport {shadyDataForNode} from './shady-data.js';\n\nexport let settings = window['ShadyDOM'] || {};\n\nsettings.hasNativeShadowDOM = Boolean(Element.prototype.attachShadow && Node.prototype.getRootNode);\n\nlet desc = Object.getOwnPropertyDescriptor(Node.prototype, 'firstChild');\n\nsettings.hasDescriptors = Boolean(desc && desc.configurable && desc.get);\nsettings.inUse = settings['force'] || !settings.hasNativeShadowDOM;\n\n// Default to using native accessors (instead of treewalker) only for\n// IE/Edge where they are faster.\nconst IS_IE = navigator.userAgent.match('Trident');\nconst IS_EDGE = navigator.userAgent.match('Edge');\nif (settings.useNativeAccessors === undefined) {\n  settings.useNativeAccessors = settings.hasDescriptors && (IS_IE || IS_EDGE);\n}\n\nexport function isTrackingLogicalChildNodes(node) {\n  const nodeData = shadyDataForNode(node);\n  return (nodeData && nodeData.firstChild !== undefined);\n}\n\nexport function isShadyRoot(obj) {\n  return Boolean(obj._localName === 'ShadyRoot');\n}\n\nexport function ownerShadyRootForNode(node) {\n  let root = node.getRootNode();\n  if (isShadyRoot(root)) {\n    return root;\n  }\n}\n\nlet p = Element.prototype;\nlet matches = p.matches || p.matchesSelector ||\n  p.mozMatchesSelector || p.msMatchesSelector ||\n  p.oMatchesSelector || p.webkitMatchesSelector;\n\nexport function matchesSelector(element, selector) {\n  return matches.call(element, selector);\n}\n\nfunction copyOwnProperty(name, source, target) {\n  let pd = Object.getOwnPropertyDescriptor(source, name);\n  if (pd) {\n    Object.defineProperty(target, name, pd);\n  }\n}\n\nexport function extend(target, source) {\n  if (target && source) {\n    let n$ = Object.getOwnPropertyNames(source);\n    for (let i=0, n; (i<n$.length) && (n=n$[i]); i++) {\n      copyOwnProperty(n, source, target);\n    }\n  }\n  return target || source;\n}\n\nexport function extendAll(target, ...sources) {\n  for (let i=0; i < sources.length; i++) {\n    extend(target, sources[i]);\n  }\n  return target;\n}\n\nexport function mixin(target, source) {\n  for (var i in source) {\n    target[i] = source[i];\n  }\n  return target;\n}\n\nexport function patchPrototype(obj, mixin) {\n  let proto = Object.getPrototypeOf(obj);\n  if (!proto.hasOwnProperty('__patchProto')) {\n    let patchProto = Object.create(proto);\n    patchProto.__sourceProto = proto;\n    extend(patchProto, mixin);\n    proto['__patchProto'] = patchProto;\n  }\n  // old browsers don't have setPrototypeOf\n  obj.__proto__ = proto['__patchProto'];\n}\n\n\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 function microtask(callback) {\n  queue.push(callback);\n  twiddle.textContent = content++;\n}\n\nexport const hasDocumentContains = Boolean(document.contains);\n\nexport function contains(container, node) {\n  while (node) {\n    if (node == container) {\n      return true;\n    }\n    node = node.parentNode;\n  }\n  return false;\n}\n\nfunction getNodeHTMLCollectionName(node) {\n  return node.getAttribute('id') || node.getAttribute('name');\n}\n\nfunction isValidHTMLCollectionName(name) {\n  return name !== 'length' && isNaN(name);\n}\n\nexport function 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","/**\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\nexport let appendChild = Element.prototype.appendChild;\nexport let insertBefore = Element.prototype.insertBefore;\nexport let replaceChild = Element.prototype.replaceChild;\nexport let removeChild = Element.prototype.removeChild;\nexport let setAttribute = Element.prototype.setAttribute;\nexport let removeAttribute = Element.prototype.removeAttribute;\nexport let cloneNode = Element.prototype.cloneNode;\nexport let importNode = Document.prototype.importNode;\nexport let addEventListener = Element.prototype.addEventListener;\nexport let removeEventListener = Element.prototype.removeEventListener;\nexport let windowAddEventListener = Window.prototype.addEventListener;\nexport let windowRemoveEventListener = Window.prototype.removeEventListener;\nexport let dispatchEvent = Element.prototype.dispatchEvent;\nexport let contains = Node.prototype.contains || HTMLElement.prototype.contains;\nexport let getElementById = Document.prototype.getElementById;\nexport let elementQuerySelector = Element.prototype.querySelector;\nexport let fragmentQuerySelector = DocumentFragment.prototype.querySelector;\nexport let documentQuerySelector = Document.prototype.querySelector;\nexport let querySelector = /** @this {Element|Document|DocumentFragment} */ function(selector) {\n  switch (this.nodeType) {\n    case Node.ELEMENT_NODE:\n      return elementQuerySelector.call(/** @type {Element} */ (this), selector);\n    case Node.DOCUMENT_NODE:\n      return documentQuerySelector.call(/** @type {Document} */ (this), selector);\n    default:\n      return fragmentQuerySelector.call(this, selector);\n  }\n};\nexport let elementQuerySelectorAll = Element.prototype.querySelectorAll;\nexport let fragmentQuerySelectorAll = DocumentFragment.prototype.querySelectorAll;\nexport let documentQuerySelectorAll = Document.prototype.querySelectorAll;\nexport let querySelectorAll = /** @this {Element|Document|DocumentFragment} */ function(selector) {\n  switch (this.nodeType) {\n    case Node.ELEMENT_NODE:\n      return elementQuerySelectorAll.call(/** @type {Element} */ (this), selector);\n    case Node.DOCUMENT_NODE:\n      return documentQuerySelectorAll.call(/** @type {Document} */ (this), selector);\n    default:\n      return fragmentQuerySelectorAll.call(this, selector);\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\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*/\n\nimport {getInnerHTML} from './innerHTML.js';\nimport * as utils from './utils.js';\n\nlet nodeWalker = document.createTreeWalker(document, NodeFilter.SHOW_ALL,\n  null, false);\n\nlet elementWalker = document.createTreeWalker(document, NodeFilter.SHOW_ELEMENT,\n  null, false);\n\nexport function parentNode(node) {\n  nodeWalker.currentNode = node;\n  return nodeWalker.parentNode();\n}\n\nexport function firstChild(node) {\n  nodeWalker.currentNode = node;\n  return nodeWalker.firstChild();\n}\n\nexport function lastChild(node) {\n  nodeWalker.currentNode = node;\n  return nodeWalker.lastChild();\n}\n\nexport function previousSibling(node) {\n  nodeWalker.currentNode = node;\n  return nodeWalker.previousSibling();\n}\n\nexport function nextSibling(node) {\n  nodeWalker.currentNode = node;\n  return nodeWalker.nextSibling();\n}\n\nexport function childNodes(node) {\n  let nodes = [];\n  nodeWalker.currentNode = node;\n  let n = nodeWalker.firstChild();\n  while (n) {\n    nodes.push(n);\n    n = nodeWalker.nextSibling();\n  }\n  return nodes;\n}\n\nexport function parentElement(node) {\n  elementWalker.currentNode = node;\n  return elementWalker.parentNode();\n}\n\nexport function firstElementChild(node) {\n  elementWalker.currentNode = node;\n  return elementWalker.firstChild();\n}\n\nexport function lastElementChild(node) {\n  elementWalker.currentNode = node;\n  return elementWalker.lastChild();\n}\n\nexport function previousElementSibling(node) {\n  elementWalker.currentNode = node;\n  return elementWalker.previousSibling();\n}\n\nexport function nextElementSibling(node) {\n  elementWalker.currentNode = node;\n  return elementWalker.nextSibling();\n}\n\nexport function children(node) {\n  let nodes = [];\n  elementWalker.currentNode = node;\n  let n = elementWalker.firstChild();\n  while (n) {\n    nodes.push(n);\n    n = elementWalker.nextSibling();\n  }\n  return utils.createPolyfilledHTMLCollection(nodes);\n}\n\nexport function innerHTML(node) {\n  return getInnerHTML(node, (n) => childNodes(n));\n}\n\nexport function textContent(node) {\n  /* eslint-disable no-case-declarations */\n  switch (node.nodeType) {\n    case Node.ELEMENT_NODE:\n    case Node.DOCUMENT_FRAGMENT_NODE:\n      let textWalker = document.createTreeWalker(node, 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 node.nodeValue;\n  }\n  /* eslint-enable */\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';\n\nconst hasDescriptors = utils.settings.hasDescriptors;\n\n// Find descriptor on the \"lowest\" native prototype. Safe as these are not\n// overridden and we call these on nodes.\nconst nativeProtos = [Node.prototype, Element.prototype, HTMLElement.prototype];\n// note, avoid Array.find for IE11 compat.\nfunction findNativeProtoWithDescriptor(name) {\n  for (let i=0; i < nativeProtos.length; i++) {\n    const proto = nativeProtos[i];\n    if (proto.hasOwnProperty(name)) {\n      return proto;\n    }\n  }\n}\nfunction findNodeDescriptor(name) {\n  const proto = findNativeProtoWithDescriptor(name);\n  if (!proto) {\n    throw Error(`Could not find descriptor for ${name}`);\n  }\n  return Object.getOwnPropertyDescriptor(proto, name);\n}\n\nexport const nodeAccessors = hasDescriptors ? {\n  parentNode: findNodeDescriptor('parentNode'),\n  firstChild: findNodeDescriptor('firstChild'),\n  lastChild: findNodeDescriptor('lastChild'),\n  previousSibling: findNodeDescriptor('previousSibling'),\n  nextSibling: findNodeDescriptor('nextSibling'),\n  childNodes: findNodeDescriptor('childNodes'),\n  parentElement: findNodeDescriptor('parentElement'),\n  previousElementSibling: findNodeDescriptor('previousElementSibling'),\n  nextElementSibling: findNodeDescriptor('nextElementSibling'),\n  innerHTML: findNodeDescriptor('innerHTML'),\n  textContent: findNodeDescriptor('textContent'),\n  firstElementChild: findNodeDescriptor('firstElementChild'),\n  lastElementChild: findNodeDescriptor('lastElementChild'),\n  children: findNodeDescriptor('children'),\n} : {};\n\nexport const fragmentAccessors = hasDescriptors ? {\n  firstElementChild: Object.getOwnPropertyDescriptor(\n    DocumentFragment.prototype, 'firstElementChild'),\n  lastElementChild: Object.getOwnPropertyDescriptor(\n    DocumentFragment.prototype, 'lastElementChild'),\n  children: Object.getOwnPropertyDescriptor(\n    DocumentFragment.prototype, 'children')\n} : {};\n\nexport const documentAccessors = hasDescriptors ? {\n  firstElementChild: Object.getOwnPropertyDescriptor(\n    Document.prototype, 'firstElementChild'),\n  lastElementChild: Object.getOwnPropertyDescriptor(\n    Document.prototype, 'lastElementChild'),\n  children: Object.getOwnPropertyDescriptor(\n    Document.prototype, 'children')\n} : {};\n\nexport function parentNode(node) {\n  return nodeAccessors.parentNode.get.call(node);\n}\n\nexport function firstChild(node) {\n  return nodeAccessors.firstChild.get.call(node);\n}\n\nexport function lastChild(node) {\n  return nodeAccessors.lastChild.get.call(node);\n}\n\nexport function previousSibling(node) {\n  return nodeAccessors.previousSibling.get.call(node);\n}\n\nexport function nextSibling(node) {\n  return nodeAccessors.nextSibling.get.call(node);\n}\n\nexport function childNodes(node) {\n  return Array.prototype.slice.call(nodeAccessors.childNodes.get.call(node));\n}\n\nexport function parentElement(node) {\n  return nodeAccessors.parentElement.get.call(node);\n}\n\nexport function previousElementSibling(node) {\n  return nodeAccessors.previousElementSibling.get.call(node);\n}\n\nexport function nextElementSibling(node) {\n  return nodeAccessors.nextElementSibling.get.call(node);\n}\n\nexport function innerHTML(node) {\n  return nodeAccessors.innerHTML.get.call(node);\n}\n\nexport function textContent(node) {\n  return nodeAccessors.textContent.get.call(node);\n}\n\nexport function children(node) {\n  switch (node.nodeType) {\n    case Node.DOCUMENT_FRAGMENT_NODE:\n      return fragmentAccessors.children.get.call(node);\n    case Node.DOCUMENT_NODE:\n      return documentAccessors.children.get.call(node);\n    default:\n      return nodeAccessors.children.get.call(node);\n  }\n}\n\nexport function firstElementChild(node) {\n  switch (node.nodeType) {\n    case Node.DOCUMENT_FRAGMENT_NODE:\n      return fragmentAccessors.firstElementChild.get.call(node);\n    case Node.DOCUMENT_NODE:\n      return documentAccessors.firstElementChild.get.call(node);\n    default:\n      return nodeAccessors.firstElementChild.get.call(node);\n  }\n}\n\nexport function lastElementChild(node) {\n  switch (node.nodeType) {\n    case Node.DOCUMENT_FRAGMENT_NODE:\n      return fragmentAccessors.lastElementChild.get.call(node);\n    case Node.DOCUMENT_NODE:\n      return documentAccessors.lastElementChild.get.call(node);\n    default:\n      return nodeAccessors.lastElementChild.get.call(node);\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 nativeTreeWalker from './native-tree-walker.js';\nimport * as nativeTreeAccessors from './native-tree-accessors.js';\nimport * as utils from './utils.js';\n\nexport const accessors = utils.settings.useNativeAccessors ?\n    nativeTreeAccessors : nativeTreeWalker;","/**\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 {accessors as nativeTree} from './native-tree.js';\nimport {nodeAccessors as nativeAccessors} from './native-tree-accessors.js';\nimport {contains as nativeContains} from './native-methods.js';\nimport {ensureShadyDataForNode, shadyDataForNode} from './shady-data.js';\n\nfunction clearNode(node) {\n  while (node.firstChild) {\n    node.removeChild(node.firstChild);\n  }\n}\n\nconst hasDescriptors = utils.settings.hasDescriptors;\nconst inertDoc = document.implementation.createHTMLDocument('inert');\n\nconst nativeIsConnectedAccessors =\n/** @type {ObjectPropertyDescriptor} */(\n  Object.getOwnPropertyDescriptor(Node.prototype, 'isConnected')\n);\n\nconst nativeIsConnected = nativeIsConnectedAccessors && nativeIsConnectedAccessors.get;\n\nconst nativeActiveElementDescriptor =\n  /** @type {ObjectPropertyDescriptor} */(\n    Object.getOwnPropertyDescriptor(Document.prototype, 'activeElement')\n  );\nfunction getDocumentActiveElement() {\n  if (nativeActiveElementDescriptor && nativeActiveElementDescriptor.get) {\n    return nativeActiveElementDescriptor.get.call(document);\n  } else if (!utils.settings.hasDescriptors) {\n    return document.activeElement;\n  }\n}\n\nfunction activeElementForNode(node) {\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(node));\n  if (node !== 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 (node.host === active ||\n        !nativeContains.call(node.host, 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 = utils.ownerShadyRootForNode(active);\n  while (activeRoot && activeRoot !== node) {\n    active = activeRoot.host;\n    activeRoot = utils.ownerShadyRootForNode(active);\n  }\n  if (node === 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 === node ? active : null;\n  }\n}\n\nlet OutsideAccessors = {\n\n  parentElement: {\n    /** @this {Node} */\n    get() {\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 : nativeTree.parentElement(this);\n    },\n    configurable: true\n  },\n\n  parentNode: {\n    /** @this {Node} */\n    get() {\n      const nodeData = shadyDataForNode(this);\n      const l = nodeData && nodeData.parentNode;\n      return l !== undefined ? l : nativeTree.parentNode(this);\n    },\n    configurable: true\n  },\n\n  nextSibling: {\n    /** @this {Node} */\n    get() {\n      const nodeData = shadyDataForNode(this);\n      const l = nodeData && nodeData.nextSibling;\n      return l !== undefined ? l : nativeTree.nextSibling(this);\n    },\n    configurable: true\n  },\n\n  previousSibling: {\n    /** @this {Node} */\n    get() {\n      const nodeData = shadyDataForNode(this);\n      const l = nodeData && nodeData.previousSibling;\n      return l !== undefined ? l : nativeTree.previousSibling(this);\n    },\n    configurable: true\n  },\n\n  // fragment, element, document\n  nextElementSibling: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      const nodeData = shadyDataForNode(this);\n      if (nodeData && nodeData.nextSibling !== undefined) {\n        let n = this.nextSibling;\n        while (n && n.nodeType !== Node.ELEMENT_NODE) {\n          n = n.nextSibling;\n        }\n        return n;\n      } else {\n        return nativeTree.nextElementSibling(this);\n      }\n    },\n    configurable: true\n  },\n\n  previousElementSibling: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      const nodeData = shadyDataForNode(this);\n      if (nodeData && nodeData.previousSibling !== undefined) {\n        let n = this.previousSibling;\n        while (n && n.nodeType !== Node.ELEMENT_NODE) {\n          n = n.previousSibling;\n        }\n        return n;\n      } else {\n        return nativeTree.previousElementSibling(this);\n      }\n    },\n    configurable: true\n  }\n\n};\n\nexport const ClassNameAccessor = {\n  className: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      return this.getAttribute('class') || '';\n    },\n    /**\n     * @this {HTMLElement}\n     */\n    set(value) {\n      this.setAttribute('class', value);\n    },\n    configurable: true\n  }\n}\n\nexport const IsConnectedAccessor = {\n\n  isConnected: {\n    /**\n     * @this {Node}\n     */\n    get() {\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 (nativeContains.call(ownerDocument, this)) {\n          return true;\n        }\n      } else if (ownerDocument.documentElement &&\n        nativeContains.call(ownerDocument.documentElement, 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.parentNode || (utils.isShadyRoot(node) ? /** @type {ShadowRoot} */(node).host : undefined);\n      }\n      return !!(node && node instanceof Document);\n    },\n    configurable: true\n  }\n};\n\nlet InsideAccessors = {\n\n  childNodes: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\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.firstChild; n; n=n.nextSibling) {\n            nodeData.childNodes.push(n);\n          }\n        }\n        childNodes = nodeData.childNodes;\n      } else {\n        childNodes = nativeTree.childNodes(this);\n      }\n      childNodes.item = function(index) {\n        return childNodes[index];\n      }\n      return childNodes;\n    },\n    configurable: true\n  },\n\n  childElementCount: {\n    /** @this {HTMLElement} */\n    get() {\n      return this.children.length;\n    },\n    configurable: true\n  },\n\n  firstChild: {\n    /** @this {HTMLElement} */\n    get() {\n      const nodeData = shadyDataForNode(this);\n      const l = nodeData && nodeData.firstChild;\n      return l !== undefined ? l : nativeTree.firstChild(this);\n    },\n    configurable: true\n  },\n\n  lastChild: {\n  /** @this {HTMLElement} */\n    get() {\n      const nodeData = shadyDataForNode(this);\n      const l = nodeData && nodeData.lastChild;\n      return l !== undefined ? l : nativeTree.lastChild(this);\n    },\n    configurable: true\n  },\n\n  textContent: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      if (utils.isTrackingLogicalChildNodes(this)) {\n        let tc = [];\n        for (let i = 0, cn = this.childNodes, c; (c = cn[i]); i++) {\n          if (c.nodeType !== Node.COMMENT_NODE) {\n            tc.push(c.textContent);\n          }\n        }\n        return tc.join('');\n      } else {\n        return nativeTree.textContent(this);\n      }\n    },\n    /**\n     * @this {HTMLElement}\n     * @param {string} text\n     */\n    set(text) {\n      if (typeof text === 'undefined' || text === null) {\n        text = ''\n      }\n      switch (this.nodeType) {\n        case Node.ELEMENT_NODE:\n        case Node.DOCUMENT_FRAGMENT_NODE:\n          if (!utils.isTrackingLogicalChildNodes(this) && hasDescriptors) {\n            // may be removing a nested slot but fast path if we know we are not.\n            const firstChild = this.firstChild;\n            if (firstChild != this.lastChild ||\n              (firstChild && firstChild.nodeType != Node.TEXT_NODE)) {\n              clearNode(this);\n            }\n            nativeAccessors.textContent.set.call(this, text);\n          } else {\n            clearNode(this);\n            // Document fragments must have no childnodes if setting a blank string\n            if (text.length > 0 || this.nodeType === Node.ELEMENT_NODE) {\n              this.appendChild(document.createTextNode(text));\n            }\n          }\n          break;\n        default:\n          // TODO(sorvell): can't do this if patch nodeValue.\n          this.nodeValue = text;\n          break;\n      }\n    },\n    configurable: true\n  },\n\n  // fragment, element, document\n  firstElementChild: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      const nodeData = shadyDataForNode(this);\n      if (nodeData && nodeData.firstChild !== undefined) {\n        let n = this.firstChild;\n        while (n && n.nodeType !== Node.ELEMENT_NODE) {\n          n = n.nextSibling;\n        }\n        return n;\n      } else {\n        return nativeTree.firstElementChild(this);\n      }\n    },\n    configurable: true\n  },\n\n  lastElementChild: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      const nodeData = shadyDataForNode(this);\n      if (nodeData && nodeData.lastChild !== undefined) {\n        let n = this.lastChild;\n        while (n && n.nodeType !== Node.ELEMENT_NODE) {\n          n = n.previousSibling;\n        }\n        return n;\n      } else {\n        return nativeTree.lastElementChild(this);\n      }\n    },\n    configurable: true\n  },\n\n  children: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      if (!utils.isTrackingLogicalChildNodes(this)) {\n        return nativeTree.children(this);\n      }\n      return utils.createPolyfilledHTMLCollection(Array.prototype.filter.call(this.childNodes, function(n) {\n        return (n.nodeType === Node.ELEMENT_NODE);\n      }));\n    },\n    configurable: true\n  },\n\n  // element (HTMLElement on IE11)\n  innerHTML: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      if (utils.isTrackingLogicalChildNodes(this)) {\n        const content = this.localName === 'template' ?\n        /** @type {HTMLTemplateElement} */(this).content : this;\n        return getInnerHTML(content);\n      } else {\n        return nativeTree.innerHTML(this);\n      }\n    },\n    /**\n     * @this {HTMLElement}\n     */\n    set(text) {\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      if (hasDescriptors) {\n        nativeAccessors.innerHTML.set.call(htmlContainer, text);\n      } else {\n        htmlContainer.innerHTML = text;\n      }\n      const newContent = this.localName === 'template' ?\n        /** @type {HTMLTemplateElement} */(htmlContainer).content : htmlContainer;\n      while (newContent.firstChild) {\n        content.appendChild(newContent.firstChild);\n      }\n    },\n    configurable: true\n  }\n\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).\nexport let ShadowRootAccessor = {\n\n  shadowRoot: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      const nodeData = shadyDataForNode(this);\n      return nodeData && nodeData.publicRoot || null;\n    },\n    configurable: true\n  }\n};\n\n// Note: Can be patched on document prototype on browsers with builtin accessors.\n// Must be patched separately on simulated ShadowRoot.\n// Must be patched as `_activeElement` on browsers without builtin accessors.\nexport let ActiveElementAccessor = {\n\n  activeElement: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      return activeElementForNode(this);\n    },\n    /**\n     * @this {HTMLElement}\n     */\n    set() {},\n    configurable: true\n  }\n\n};\n\n// patch a group of descriptors on an object only if it exists or if the `force`\n// argument is true.\n/**\n * @param {!Object} obj\n * @param {!Object} descriptors\n * @param {boolean=} force\n */\nfunction patchAccessorGroup(obj, descriptors, force) {\n  for (let p in descriptors) {\n    let objDesc = Object.getOwnPropertyDescriptor(obj, p);\n    if ((objDesc && objDesc.configurable) ||\n      (!objDesc && force)) {\n      Object.defineProperty(obj, p, descriptors[p]);\n    } else if (force) {\n      console.warn('Could not define', p, 'on', obj); // eslint-disable-line no-console\n    }\n  }\n}\n\n// patch dom accessors on proto where they exist\nexport function patchAccessors(proto) {\n  patchAccessorGroup(proto, OutsideAccessors);\n  patchAccessorGroup(proto, ClassNameAccessor);\n  patchAccessorGroup(proto, InsideAccessors);\n  patchAccessorGroup(proto, ActiveElementAccessor);\n}\n\nexport function patchShadowRootAccessors(proto) {\n  proto.__proto__ = DocumentFragment.prototype;\n  // ensure element descriptors (IE/Edge don't have em)\n  patchAccessorGroup(proto, OutsideAccessors, true);\n  patchAccessorGroup(proto, InsideAccessors, true);\n  patchAccessorGroup(proto, ActiveElementAccessor, true);\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  // 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  // defer properties to host\n  [\n    'ownerDocument',\n    'baseURI',\n    'isConnected'\n  ].forEach((prop) => {\n    Object.defineProperty(proto, prop, {\n      get() {\n        return this.host[prop];\n      },\n      configurable: true\n    });\n  });\n}\n\n// ensure an element has patched \"outside\" accessors; no-op when not needed\nexport let patchOutsideElementAccessors = utils.settings.hasDescriptors ?\n  function() {} : function(element) {\n    const sd = ensureShadyDataForNode(element);\n    if (!sd.__outsideAccessors) {\n      sd.__outsideAccessors = true;\n      patchAccessorGroup(element, OutsideAccessors, true);\n      patchAccessorGroup(element, ClassNameAccessor, true);\n    }\n  }\n\n// ensure an element has patched \"inside\" accessors; no-op when not needed\nexport let patchInsideElementAccessors = utils.settings.hasDescriptors ?\n  function() {} : function(element) {\n    const sd = ensureShadyDataForNode(element);\n    if (!sd.__insideAccessors) {\n      patchAccessorGroup(element, InsideAccessors, true);\n      patchAccessorGroup(element, ShadowRootAccessor, true);\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 {flush} from './flush.js';\nimport {dispatchEvent, querySelectorAll} from './native-methods.js';\nimport * as mutation from './logical-mutation.js';\nimport {ActiveElementAccessor, ShadowRootAccessor, patchAccessors, patchShadowRootAccessors, IsConnectedAccessor} from './patch-accessors.js';\nimport {addEventListener, removeEventListener} from './patch-events.js';\nimport {attachShadow, ShadyRoot} from './attach-shadow.js';\nimport {shadyDataForNode, ensureShadyDataForNode} from './shady-data.js';\n\nfunction getAssignedSlot(node) {\n  mutation.renderRootNode(node);\n  const nodeData = shadyDataForNode(node);\n  return nodeData && nodeData.assignedSlot || null;\n}\n\nlet windowMixin = {\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\nlet nodeMixin = {\n\n  addEventListener: addEventListener,\n\n  removeEventListener: removeEventListener,\n\n  appendChild(node) {\n    return mutation.insertBefore(this, node);\n  },\n\n  insertBefore(node, ref_node) {\n    return mutation.insertBefore(this, node, ref_node);\n  },\n\n  removeChild(node) {\n    return mutation.removeChild(this, node);\n  },\n\n  /**\n   * @this {Node}\n   */\n  replaceChild(node, ref_node) {\n    mutation.insertBefore(this, node, ref_node);\n    mutation.removeChild(this, ref_node);\n    return node;\n  },\n\n  /**\n   * @this {Node}\n   */\n  cloneNode(deep) {\n    return mutation.cloneNode(this, deep);\n  },\n\n  /**\n   * @this {Node}\n   */\n  getRootNode(options) {\n    return mutation.getRootNode(this, options);\n  },\n\n  contains(node) {\n    return utils.contains(this, node);\n  },\n\n  /**\n   * @this {Node}\n   */\n  dispatchEvent(event) {\n    flush();\n    return dispatchEvent.call(this, event);\n  }\n\n};\n\n// NOTE: we can do this regardless of the browser supporting native accessors\n// since this is always \"new\" in that case.\nObject.defineProperties(nodeMixin, IsConnectedAccessor);\n\n// NOTE: For some reason 'Text' redefines 'assignedSlot'\nlet textMixin = {\n  /**\n   * @this {Text}\n   */\n  get assignedSlot() {\n    return getAssignedSlot(this);\n  }\n};\n\nlet queryMixin = {\n\n  // TODO(sorvell): consider doing native QSA and filtering results.\n  /**\n   * @this {DocumentFragment}\n   */\n  querySelector(selector) {\n    // match selector and halt on first result.\n    let result = mutation.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 {DocumentFragment}\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(querySelectorAll.call(this, selector));\n      const root = this.getRootNode();\n      return o.filter(e => e.getRootNode() == root);\n    }\n    return mutation.query(this, function(n) {\n      return utils.matchesSelector(n, selector);\n    });\n  }\n\n};\n\nlet fragmentMixin = {};\n\nlet slotMixin = {\n\n  /**\n   * @this {HTMLSlotElement}\n   */\n  assignedNodes(options) {\n    if (this.localName === 'slot') {\n      mutation.renderRootNode(this);\n      const nodeData = shadyDataForNode(this);\n      return nodeData ?\n        ((options && options.flatten ? nodeData.flattenedNodes :\n          nodeData.assignedNodes) || []) :\n        [];\n    }\n  }\n\n};\n\nlet elementMixin = utils.extendAll({\n\n  /**\n   * @this {HTMLElement}\n   */\n  setAttribute(name, value) {\n    mutation.setAttribute(this, name, value);\n  },\n\n  /**\n   * @this {HTMLElement}\n   */\n  removeAttribute(name) {\n    mutation.removeAttribute(this, name);\n  },\n\n  /**\n   * @this {HTMLElement}\n   */\n  attachShadow(options) {\n    return attachShadow(this, options);\n  },\n\n  /**\n   * @this {HTMLElement}\n   */\n  get slot() {\n    return this.getAttribute('slot');\n  },\n\n  /**\n   * @this {HTMLElement}\n   */\n  set slot(value) {\n    mutation.setAttribute(this, 'slot', value);\n  },\n\n  /**\n   * @this {HTMLElement}\n   */\n  get assignedSlot() {\n    return getAssignedSlot(this);\n  }\n\n}, queryMixin, slotMixin);\n\nObject.defineProperties(elementMixin, ShadowRootAccessor);\n\nlet documentMixin = {\n  /**\n   * @this {Document}\n   */\n  importNode(node, deep) {\n    return mutation.importNode(node, deep);\n  },\n\n  /**\n   * @this {Document}\n   */\n  getElementById(id) {\n    let result = mutation.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\nObject.defineProperties(documentMixin, {\n  '_activeElement': ActiveElementAccessor.activeElement\n});\n\nlet nativeBlur = HTMLElement.prototype.blur;\n\nlet htmlElementMixin = {\n  /**\n   * @this {HTMLElement}\n   */\n  blur() {\n    const nodeData = shadyDataForNode(this);\n    let root = nodeData && nodeData.root;\n    let shadowActive = root && root.activeElement;\n    if (shadowActive) {\n      shadowActive.blur();\n    } else {\n      nativeBlur.call(this);\n    }\n  }\n};\n\nfor (const property of Object.getOwnPropertyNames(Document.prototype)) {\n  if (property.substring(0,2) === 'on') {\n    Object.defineProperty(htmlElementMixin, 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.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\nconst shadowRootMixin = utils.extendAll({\n  /**\n   * @this {ShadowRoot}\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.addEventListener(type, fn, optionsOrCapture);\n  },\n\n  /**\n   * @this {ShadowRoot}\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.removeEventListener(type, fn, optionsOrCapture);\n  },\n\n  /**\n   * @this {ShadowRoot}\n   */\n  getElementById(id) {\n    let result = mutation.query(this, function(n) {\n      return n.id == id;\n    }, function(n) {\n      return Boolean(n);\n    })[0];\n    return result || null;\n  }\n}, queryMixin);\n\n// Patch querySelector/All on documents and fragments only if\n// flag is not set.\nif (!utils.settings['preferPerformance']) {\n  utils.extendAll(documentMixin, queryMixin);\n  utils.extendAll(fragmentMixin, queryMixin);\n}\n\nfunction patchBuiltin(proto, obj) {\n  let n$ = Object.getOwnPropertyNames(obj);\n  for (let i=0; i < n$.length; i++) {\n    let n = n$[i];\n    let d = Object.getOwnPropertyDescriptor(obj, n);\n    // NOTE: we prefer writing directly here because some browsers\n    // have descriptors that are writable but not configurable (e.g.\n    // `appendChild` on older browsers)\n    if (d.value) {\n      proto[n] = d.value;\n    } else {\n      Object.defineProperty(proto, n, d);\n    }\n  }\n}\n\n// Apply patches to builtins (e.g. Element.prototype). Some of these patches\n// can be done unconditionally (mostly methods like\n// `Element.prototype.appendChild`) and some can only be done when the browser\n// has proper descriptors on the builtin prototype\n// (e.g. `Element.prototype.firstChild`)`. When descriptors are not available,\n// elements are individually patched when needed (see e.g.\n// `patchInside/OutsideElementAccessors` in `patch-accessors.js`).\nexport function patchBuiltins() {\n  let nativeHTMLElement =\n    (window['customElements'] && window['customElements']['nativeHTMLElement']) ||\n    HTMLElement;\n  // These patches can always be done, for all supported browsers.\n  patchBuiltin(ShadyRoot.prototype, shadowRootMixin);\n  patchBuiltin(window.Node.prototype, nodeMixin);\n  patchBuiltin(window.Window.prototype, windowMixin);\n  patchBuiltin(window.Text.prototype, textMixin);\n  patchBuiltin(window.Element.prototype, elementMixin);\n  patchBuiltin(window.DocumentFragment.prototype, fragmentMixin);\n  patchBuiltin(window.Document.prototype, documentMixin);\n  if (window.HTMLSlotElement) {\n    patchBuiltin(window.HTMLSlotElement.prototype, slotMixin);\n  }\n  patchBuiltin(nativeHTMLElement.prototype, htmlElementMixin);\n  // These patches can *only* be done\n  // on browsers that have proper property descriptors on builtin prototypes.\n  // This includes: IE11, Edge, Chrome >= 4?; Safari >= 10, Firefox\n  // On older browsers (Chrome <= 4?, Safari 9), a per element patching\n  // strategy is used for patching accessors.\n  if (utils.settings.hasDescriptors) {\n    patchAccessors(window.Node.prototype);\n    patchAccessors(window.Text.prototype);\n    patchAccessors(window.DocumentFragment.prototype);\n    patchAccessors(window.Element.prototype);\n    patchAccessors(nativeHTMLElement.prototype);\n    patchAccessors(window.Document.prototype);\n    if (window.HTMLSlotElement) {\n      patchAccessors(window.HTMLSlotElement.prototype);\n    }\n  }\n  patchShadowRootAccessors(ShadyRoot.prototype);\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 {patchInsideElementAccessors, patchOutsideElementAccessors} from './patch-accessors.js';\nimport {accessors} from './native-tree.js';\nimport {ensureShadyDataForNode, shadyDataForNode} from './shady-data.js';\n\nconst {childNodes} = accessors;\n\nexport function 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.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\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.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 function 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 * @param  {Array<Node>=} nodes\n */\nfunction recordChildNodes(node, nodes) {\n  const nodeData = ensureShadyDataForNode(node);\n  if (nodeData.firstChild === undefined) {\n    // remove caching of childNodes\n    nodeData.childNodes = null;\n    const c$ = nodes || childNodes(node);\n    nodeData.firstChild = c$[0] || null;\n    nodeData.lastChild = c$[c$.length-1] || null;\n    patchInsideElementAccessors(node);\n    for (let i=0; i<c$.length; i++) {\n      const n = c$[i];\n      const sd = ensureShadyDataForNode(n);\n      sd.parentNode = node;\n      sd.nextSibling = c$[i+1] || null;\n      sd.previousSibling = c$[i-1] || null;\n      patchOutsideElementAccessors(n);\n    }\n  }\n}\n\nexport {recordChildNodes}\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 * as logicalTree from './logical-tree.js';\nimport * as nativeMethods from './native-methods.js';\nimport {accessors} from './native-tree.js';\nimport {ensureShadyDataForNode, shadyDataForNode} from './shady-data.js';\n\nconst {parentNode} = accessors;\n\nconst doc = window.document;\n\nconst preferPerformance = utils.settings.preferPerformance;\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 * @param {!Node} parent\n * @param {Node} node\n * @param {Node=} ref_node\n */\nexport function insertBefore(parent, node, ref_node) {\n  if (parent.ownerDocument !== doc && node.ownerDocument !== doc) {\n    return nativeMethods.insertBefore.call(parent, node, ref_node);\n  }\n  if (node === parent) {\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 !== parent) ||\n      (p === undefined && parentNode(ref_node) !== parent)) {\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  let slotsAdded = [];\n  /** @type {function(!Node, string): void} */\n  let scopingFn = addShadyScoping;\n  let ownerRoot = utils.ownerShadyRootForNode(parent);\n  /** @type {string} */\n  let newScopeName;\n  if (ownerRoot) {\n    // get scope name from new ShadyRoot host\n    newScopeName = ownerRoot.host.localName;\n  } else {\n    // borrow parent's scope name\n    newScopeName = currentScopeForNode(parent);\n  }\n  // remove from existing location\n  if (node.parentNode) {\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    const oldScopeName = currentScopeForNode(node);\n    removeChild(node.parentNode, node, Boolean(ownerRoot) || !(node.getRootNode() instanceof ShadowRoot));\n    scopingFn = (node, newScopeName) => {\n      replaceShadyScoping(node, newScopeName, oldScopeName);\n    };\n  }\n  // add to new parent\n  let allowNativeInsert = true;\n  const needsScoping = (!preferPerformance || node['__noInsertionPoint'] === undefined)\n    && !currentScopeIsCorrect(node, newScopeName);\n  if (ownerRoot) {\n    // in a shadowroot, only tree walk if new insertion points may have been added, or scoping is needed\n    if (!node['__noInsertionPoint'] || needsScoping) {\n      treeVisitor(node, (node) => {\n        if (node.localName === 'slot') {\n          slotsAdded.push(/** @type {!HTMLSlotElement} */(node));\n        }\n        if (needsScoping) {\n          scopingFn(node, newScopeName);\n        }\n      });\n    }\n  } else if (needsScoping) {\n    // in a document or disconnected tree, replace scoping if necessary\n    const oldScopeName = currentScopeForNode(node);\n    treeVisitor(node, (node) => {\n      replaceShadyScoping(node, newScopeName, oldScopeName);\n    });\n  }\n  if (slotsAdded.length) {\n    ownerRoot._addSlots(slotsAdded);\n  }\n  // if a slot is added, must render containing root.\n  if (parent.localName === 'slot' || slotsAdded.length) {\n    if (ownerRoot) {\n      ownerRoot._asyncRender();\n    }\n  }\n  if (utils.isTrackingLogicalChildNodes(parent)) {\n    logicalTree.recordInsertBefore(node, parent, 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(parent);\n    if (hasShadowRootWithSlot(parent)) {\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(parent) ?\n      /** @type {ShadowRoot} */(parent).host : parent;\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      nativeMethods.insertBefore.call(container, node, ref_node);\n    } else {\n      nativeMethods.appendChild.call(container, node);\n    }\n  // Since ownerDocument is not patched, it can be incorrect afer 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 !== parent.ownerDocument) {\n    parent.ownerDocument.adoptNode(node);\n  }\n  scheduleObserver(parent, node);\n  return 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 * @param {Node} parent\n * @param {Node} node\n * @param {boolean=} skipUnscoping\n*/\nexport function removeChild(parent, node, skipUnscoping = false) {\n  if (parent.ownerDocument !== doc) {\n    return nativeMethods.removeChild.call(parent, node);\n  }\n  if (node.parentNode !== parent) {\n    throw Error('The node to be removed is not a child of this node: ' +\n      node);\n  }\n  let preventNativeRemove;\n  let ownerRoot = utils.ownerShadyRootForNode(node);\n  let removingInsertionPoint;\n  const parentData = shadyDataForNode(parent);\n  if (utils.isTrackingLogicalChildNodes(parent)) {\n    logicalTree.recordRemoveChild(node, parent);\n    if (hasShadowRootWithSlot(parent)) {\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 = parent && parent.localName === 'slot';\n    if (changeSlotContent) {\n      preventNativeRemove = true;\n    }\n    removingInsertionPoint = ownerRoot._removeContainedSlots(node);\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(parent) ?\n      /** @type {ShadowRoot} */(parent).host :\n      parent;\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 === parentNode(node))) {\n      nativeMethods.removeChild.call(container, node);\n    }\n  }\n  scheduleObserver(parent, null, node);\n  return node;\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.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.nextSibling);\n  }\n  return composed;\n}\n\nfunction hasShadowRootWithSlot(node) {\n  const nodeData = shadyDataForNode(node);\n  let root = nodeData && nodeData.root;\n  return (root && root._hasInsertionPoint());\n}\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.parentNode;\n    if (hasShadowRootWithSlot(parent)) {\n      shadyDataForNode(parent).root._asyncRender();\n    }\n  } else if (node.localName === 'slot' && name === 'name') {\n    let root = utils.ownerShadyRootForNode(node);\n    if (root) {\n      root._updateSlotName(node);\n      root._asyncRender();\n    }\n  }\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\n/**\n * @param {Node} node\n * @param {Object=} options\n */\nexport function getRootNode(node, options) { // eslint-disable-line no-unused-vars\n  if (!node || !node.nodeType) {\n    return;\n  }\n  const nodeData = ensureShadyDataForNode(node);\n  let root = nodeData.ownerShadyRoot;\n  if (root === undefined) {\n    if (utils.isShadyRoot(node)) {\n      root = node;\n      nodeData.ownerShadyRoot = root;\n    } else {\n      let parent = node.parentNode;\n      root = parent ? getRootNode(parent) : node;\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 (nativeMethods.contains.call(document.documentElement, node)) {\n        nodeData.ownerShadyRoot = root;\n      }\n    }\n\n  }\n  return root;\n}\n\n// NOTE: `query` is used primarily for ShadyDOM's querySelector impl,\n// but it's also generally useful to recurse through the element tree\n// and is used by Polymer's styling system.\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.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.childNodes, matcher,\n    halter, list);\n}\n\nexport function renderRootNode(element) {\n  var root = element.getRootNode();\n  if (utils.isShadyRoot(root)) {\n    root._render();\n  }\n}\n\nlet scopingShim = null;\n\nfunction getScopingShim() {\n  if (!scopingShim) {\n    scopingShim = window['ShadyCSS'] && window['ShadyCSS']['ScopingShim'];\n  }\n  return scopingShim || null;\n}\n\nexport function setAttribute(node, attr, value) {\n  if (node.ownerDocument !== doc) {\n    nativeMethods.setAttribute.call(node, attr, value);\n  } else {\n    const scopingShim = getScopingShim();\n    if (scopingShim && attr === 'class') {\n      scopingShim['setElementClass'](node, value);\n    } else {\n      nativeMethods.setAttribute.call(node, attr, value);\n      distributeAttributeChange(node, attr);\n    }\n  }\n}\n\nexport function removeAttribute(node, attr) {\n  nativeMethods.removeAttribute.call(node, attr);\n  distributeAttributeChange(node, attr);\n}\n\nexport function cloneNode(node, deep) {\n  if (node.localName == 'template') {\n    return nativeMethods.cloneNode.call(node, deep);\n  } else {\n    let n = nativeMethods.cloneNode.call(node, 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$ = node.childNodes;\n      for (let i=0, nc; i < c$.length; i++) {\n        nc = c$[i].cloneNode(true);\n        n.appendChild(nc);\n      }\n    }\n    return n;\n  }\n}\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.\nexport function 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 !== document || node.localName === 'template') {\n    return nativeMethods.importNode.call(document, node, deep);\n  }\n  let n = nativeMethods.importNode.call(document, node, false);\n  if (deep) {\n    let c$ = node.childNodes;\n    for (let i=0, nc; i < c$.length; i++) {\n      nc = importNode(c$[i], true);\n      n.appendChild(nc);\n    }\n  }\n  return n;\n}\n\n/**\n * @param {!Node} node\n * @param {string} newScopeName\n */\nfunction 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 */\nfunction 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 */\nfunction replaceShadyScoping(node, newScopeName, oldScopeName) {\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return;\n  }\n  removeShadyScoping(node, oldScopeName);\n  addShadyScoping(node, newScopeName);\n}\n\n/**\n * @param {!Node} node\n * @param {string} newScopeName\n * @return {boolean}\n */\nfunction 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    for (let idx = 0; correctScope && (idx < node.childNodes.length); idx++) {\n      correctScope = correctScope &&\n        currentScopeIsCorrect(node.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 */\nfunction 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 */\nfunction 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  for (let idx = 0, n; idx < node.childNodes.length; idx++) {\n    n = node.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 {calculateSplices} from './array-splice.js';\nimport * as utils from './utils.js';\nimport {enqueue} from './flush.js';\nimport {recordChildNodes} from './logical-tree.js';\nimport {removeChild, insertBefore, dispatchEvent} from './native-methods.js';\nimport {accessors} from './native-tree.js';\nimport {ensureShadyDataForNode, shadyDataForNode} from './shady-data.js';\n\nconst {parentNode, childNodes} = accessors;\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.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    this._mode = options && options.mode;\n    const c$ = childNodes(host);\n    recordChildNodes(host, c$);\n    const hostData = ensureShadyDataForNode(host);\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      for (let i=0, l=c$.length; i < l; i++) {\n        removeChild.call(host, c$[i])\n      }\n    } else {\n      this._asyncRender();\n    }\n  }\n\n  // async render\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  _getRenderRoot() {\n    let renderRoot;\n    let root = this;\n    while (root) {\n      if (root._renderPending) {\n        renderRoot = root;\n      }\n      root = root._rendererForHost();\n    }\n    return renderRoot;\n  }\n\n  // Returns the shadyRoot `this.host` if `this.host`\n  // has children that require distribution.\n  _rendererForHost() {\n    let root = this.host.getRootNode();\n    if (utils.isShadyRoot(root)) {\n      let c$ = this.host.childNodes;\n      for (let i=0, c; i < c$.length; i++) {\n        c = c$[i];\n        if (this._isInsertionPoint(c)) {\n          return root;\n        }\n      }\n    }\n  }\n\n  _render() {\n    const root = this._getRenderRoot();\n    if (root) {\n      root['_renderRoot']();\n    }\n  }\n\n  // NOTE: avoid renaming to ease testability.\n  ['_renderRoot']() {\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.childNodes;\n      for (let i=0, l=c$.length; i < l; i++) {\n        const child = c$[i];\n        const data = shadyDataForNode(child);\n        if (parentNode(child) === this.host &&\n            (child.localName === 'slot' || !data.assignedSlot)) {\n          removeChild.call(this.host, 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.firstChild; n; n=n.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.firstChild; n; n=n.nextSibling) {\n          this._distributeNodeToSlot(n, slot);\n        }\n      }\n      const slotParentData = shadyDataForNode(slot.parentNode);\n      const slotParentRoot = slotParentData && slotParentData.root;\n      if (slotParentRoot && (slotParentRoot._hasInsertionPoint() || slotParentRoot._renderPending)) {\n        slotParentRoot['_renderRoot']();\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.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    dispatchEvent.call(slot, 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].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.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 = childNodes(container);\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 (parentNode(n) === container) {\n          removeChild.call(container, 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        insertBefore.call(container, 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      let 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      recordChildNodes(slot.parentNode);\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.parentNode.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      let slots = map[n];\n      for (let i=0; i < slots.length; i++) {\n        let 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          }\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 = parentNode(node);\n        if (parent) {\n          removeChild.call(parent, 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\nexport {ShadyRoot};\n\n/**\n  Implements a pared down version of ShadowDOM's scoping, which is easy to\n  polyfill across browsers.\n*/\nexport function attachShadow(host, options) {\n  if (!host) {\n    throw 'Must provide a host.';\n  }\n  if (!options) {\n    throw '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    const map = Array.from(connectMap);\n    connectMap.clear();\n    for (const [e, value] of map) {\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      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      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@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 * as nativeMethods from './native-methods.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\nfunction pathComposer(startNode, composed) {\n  let composedPath = [];\n  let current = startNode;\n  let startRoot = startNode === window ? window : startNode.getRootNode();\n  while (current) {\n    composedPath.push(current);\n    if (current.assignedSlot) {\n      current = current.assignedSlot;\n    } else if (current.nodeType === Node.DOCUMENT_FRAGMENT_NODE && current.host && (composed || current !== startRoot)) {\n      current = current.host;\n    } else {\n      current = current.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\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 = ancestor === window ? window : ancestor.getRootNode();\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 eventMixin = {\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 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 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'], 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  utils.mixin(klazz, 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.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 {Event}\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  const ael = this instanceof Window ? nativeMethods.windowAddEventListener :\n      nativeMethods.addEventListener;\n\n  if (unpatchedEvents[type]) {\n    return ael.call(this, 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.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  // 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    ael.call(this, type, wrapperFn, optionsOrCapture);\n  }\n}\n\n/**\n * @this {Event}\n */\nexport function removeEventListener(type, fnOrObj, optionsOrCapture) {\n  if (!fnOrObj) {\n    return;\n  }\n  const rel = this instanceof Window ? nativeMethods.windowRemoveEventListener :\n    nativeMethods.removeEventListener;\n  if (unpatchedEvents[type]) {\n    return rel.call(this, 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  rel.call(this, 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.addEventListener(ev, function(e) {\n      if (!e['__target']) {\n        patchEvent(e);\n        retargetNonBubblingEvent(e);\n      }\n    }, true);\n  }\n}\n\nfunction patchEvent(event) {\n  event['__target'] = event.target;\n  event.__relatedTarget = event.relatedTarget;\n  // patch event prototype if we can\n  if (utils.settings.hasDescriptors) {\n    utils.patchPrototype(event, eventMixin);\n  // and fallback to patching instance\n  } else {\n    utils.extend(event, eventMixin);\n  }\n}\n\nlet PatchedEvent = mixinComposedFlag(window.Event);\nlet PatchedCustomEvent = mixinComposedFlag(window.CustomEvent);\nlet PatchedMouseEvent = mixinComposedFlag(window.MouseEvent);\n\nexport function patchEvents() {\n  window.Event = PatchedEvent;\n  window.CustomEvent = PatchedCustomEvent;\n  window.MouseEvent = PatchedMouseEvent;\n  activateFocusEventOverrides();\n\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.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","/**\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",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\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 * as nativeMethods from './native-methods.js';\nimport {accessors as nativeTree} from './native-tree.js';\nimport {patchBuiltins} from './patch-builtins.js';\nimport {patchInsideElementAccessors, patchOutsideElementAccessors} from './patch-accessors.js';\nimport {patchEvents} from './patch-events.js';\nimport {ShadyRoot} from './attach-shadow.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    'settings': utils.settings,\n    'filterMutations': filterMutations,\n    'observeChildren': observeChildren,\n    'unobserveChildren': unobserveChildren,\n    'nativeMethods': nativeMethods,\n    'nativeTree': nativeTree,\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  };\n\n  window['ShadyDOM'] = ShadyDOM;\n\n  // Apply patches to events...\n  patchEvents();\n  // Apply patches to builtins (e.g. Element.prototype) where applicable.\n  patchBuiltins();\n\n  window.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\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 * @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} 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/**\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) {\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);\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   * Prepare template for the given element type\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   */\n  prepareTemplateDom(template, elementName) {\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    let {is, typeExtension} = StyleUtil.getIsExtends(host);\n    let placeholder = getStylePlaceholder(is)\n    let template = templateMap[is];\n    let ast;\n    let ownStylePropertyNames;\n    let cssBuild;\n    if (template) {\n      ast = template['_styleAst'];\n      ownStylePropertyNames = template._ownPropertyNames;\n      cssBuild = StyleUtil.getCssBuild(template);\n    }\n    const styleInfo = new StyleInfo(\n      ast,\n      placeholder,\n      ownStylePropertyNames,\n      is,\n      typeExtension,\n      cssBuild\n    );\n    // only set the style info after this element has registered its template\n    if (template) {\n      StyleInfo.set(host, styleInfo);\n    }\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    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    let styleInfo = StyleInfo.get(host);\n    if (!styleInfo) {\n      styleInfo = this._prepareHost(host);\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      styleInfo.overrideStyleProperties =\n        styleInfo.overrideStyleProperties || {};\n      Object.assign(styleInfo.overrideStyleProperties, overrideProps);\n    }\n    if (!nativeCssVariables) {\n      this.styleElementShimVariables(host, styleInfo);\n    } else {\n      this.styleElementNativeVariables(host, styleInfo);\n    }\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 = node.getRootNode();\n    let host = root.host;\n    if (host) {\n      if (StyleInfo.get(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    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    let root = host.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 = host.children || host.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 = 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;\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} 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 = 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 = 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 {Array<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} 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) {\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} 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\nif (ApplyShim) {\n  window.ShadyCSS.ApplyShim = ApplyShim;\n}\n\nif (CustomStyleInterface) {\n  window.ShadyCSS.CustomStyleInterface = CustomStyleInterface;\n}"]}