{"version":3,"sources":["node_modules/@webcomponents/html-imports/src/html-imports.js"," [synthetic:util/global] "," [synthetic:util/defineproperty] "," [synthetic:es6/symbol] "," [synthetic:es6/util/makeiterator] "," [synthetic:es6/util/arrayfromiterator] ","node_modules/@webcomponents/shadydom/src/shady-data.js","node_modules/@webcomponents/shadydom/src/utils.js","node_modules/@webcomponents/shadydom/src/flush.js","node_modules/@webcomponents/shadydom/src/observe-changes.js","node_modules/@webcomponents/shadydom/src/native-methods.js","node_modules/@webcomponents/shadydom/src/innerHTML.js","node_modules/@webcomponents/shadydom/src/native-tree-walker.js","node_modules/@webcomponents/shadydom/src/native-tree-accessors.js","node_modules/@webcomponents/shadydom/src/native-tree.js","node_modules/@webcomponents/shadydom/src/patch-accessors.js","node_modules/@webcomponents/shadydom/src/attach-shadow.js","node_modules/@webcomponents/shadydom/src/patch-builtins.js","node_modules/@webcomponents/shadydom/src/logical-tree.js","node_modules/@webcomponents/shadydom/src/logical-mutation.js"," [synthetic:es6/util/arrayfromiterable] ","node_modules/@webcomponents/shadydom/src/patch-events.js","node_modules/@webcomponents/shadydom/src/array-splice.js","node_modules/@webcomponents/shadydom/src/shadydom.js","node_modules/@webcomponents/custom-elements/src/Utilities.js","node_modules/@webcomponents/custom-elements/src/CustomElementInternals.js","node_modules/@webcomponents/custom-elements/src/CustomElementState.js","node_modules/@webcomponents/custom-elements/src/DocumentConstructionObserver.js","node_modules/@webcomponents/custom-elements/src/CustomElementRegistry.js","node_modules/@webcomponents/custom-elements/src/Deferred.js","node_modules/@webcomponents/custom-elements/src/Patch/Native.js","node_modules/@webcomponents/custom-elements/src/AlreadyConstructedMarker.js","node_modules/@webcomponents/custom-elements/src/Patch/HTMLElement.js","node_modules/@webcomponents/custom-elements/src/custom-elements.js","node_modules/@webcomponents/custom-elements/src/Patch/Interface/ParentNode.js","node_modules/@webcomponents/custom-elements/src/Patch/Document.js","node_modules/@webcomponents/custom-elements/src/Patch/Node.js","node_modules/@webcomponents/custom-elements/src/Patch/Interface/ChildNode.js","node_modules/@webcomponents/custom-elements/src/Patch/Element.js","node_modules/@webcomponents/custom-elements/src/Patch/DocumentFragment.js","node_modules/@webcomponents/shadycss/src/css-parse.js","node_modules/@webcomponents/shadycss/src/style-settings.js","node_modules/@webcomponents/shadycss/src/common-regex.js","node_modules/@webcomponents/shadycss/src/unscoped-style-handler.js","node_modules/@webcomponents/shadycss/src/style-util.js","node_modules/@webcomponents/shadycss/src/style-transformer.js","node_modules/@webcomponents/shadycss/src/style-info.js","node_modules/@webcomponents/shadycss/src/style-properties.js","node_modules/@webcomponents/shadycss/src/style-placeholder.js","node_modules/@webcomponents/shadycss/src/style-cache.js","node_modules/@webcomponents/shadycss/src/document-watcher.js","node_modules/@webcomponents/shadycss/src/template-map.js","node_modules/@webcomponents/shadycss/src/apply-shim-utils.js","node_modules/@webcomponents/shadycss/src/document-wait.js","node_modules/@webcomponents/shadycss/src/scoping-shim.js","node_modules/@webcomponents/shadycss/src/common-utils.js","node_modules/@webcomponents/shadycss/entrypoints/scoping-shim.js","src/post-polyfill.js","src/unresolved.js"],"names":["$jscomp.global","$jscomp.defineProperty","$jscomp.initSymbol","$jscomp.Symbol","$jscomp.SYMBOL_PREFIX","$jscomp.arrayIterator","$jscomp.initSymbolIterator","$jscomp.iteratorPrototype","scope","newCustomEvent","type","params","window","CustomEvent","event","document","createEvent","initCustomEvent","bubbles","cancelable","detail","importForElement","element","useNative","ownerDocument","doc","parentNode","closest","importSelector","isImportLink","whenImportsReady","callback","imports","QSA","rootImportSelector","pending","length","forEach","imp","whenElementLoaded","whenDocumentReady","stateChanged","readyState","body","removeEventListener","addEventListener","whenReady","localName","src","firstChild","onLoadingDone","isIE","node","nodeType","Node","ELEMENT_NODE","rel","constructor","Importer","documents","inflight","dynamicImportsMO","MutationObserver","m","handleMutations","observe","head","childList","subtree","loadImports","replaceScripts","fragment","template","content","scriptsSelector","script","clone","createElement","attributes","attr","setAttribute","name","value","textContent","replaceChild","selector","childNodes","querySelectorAll","emptyNodeList","list","inverseOrder","increment","i","link","currentScript","Object","defineProperty","get","scripts","configurable","CSS_URL_REGEXP","CSS_IMPORT_REGEXP","STYLESHEET_REGEXP","Path","fixUrls","base","href","resolveUrl","getAttribute","r","replaceUrls","text","linkUrl","regexp","replace","pre","url","post","urlPath","undefined","__workingURL","u","URL","pathname","e","__tempDoc","implementation","createHTMLDocument","__base","appendChild","__anchor","Xhr","async","load","success","fail","match","pieces","split","resource","header","indexOf","atob","decodeURIComponent","request","XMLHttpRequest","open","onload","request.onload","redirectedUrl","responseURL","getResponseHeader","location","origin","protocol","host","response","responseText","status","send","test","navigator","userAgent","links","loadImport","fireEventIfNeeded","makeDocument","processImportsIfLoadingDone","createDocumentFragment","p1","p2","innerHTML","baseEl","querySelector","removeAttribute","n$","importDependenciesSelector","inlineScriptIndex","n","importDependencyAttr","encodeURIComponent","num","disconnect","flatten","scriptsOk","stylesOk","fireEvents","waitForStyles","runScripts","DOCUMENT_FRAGMENT_NODE","cloneScript","l","s","s$","pendingScriptsSelector","pendingStylesSelector","needsMove","disabledLinkSelector","placeholder","insertBefore","nextSibling","newSibling","import","dispatchEvent","eventType","mutations","addedNodes","elem","importer","imps","target","native_baseURI","getOwnPropertyDescriptor","prototype","klass","Element","ownerDoc","call","enumerable","HTMLLinkElement","HTMLImports","ShadyData","publicRoot","root","dirty","flattenedNodes","_prevAssignedSlot","_previouslyAssignedNodes","assignedSlot","assignedNodes","observer","previousSibling","lastChild","ownerShadyRoot","__insideAccessors","__outsideAccessors","ensureShadyDataForNode","__shady","shadyDataForNode","settings","hasNativeShadowDOM","attachShadow","getRootNode","desc","hasDescriptors","inUse","IS_IE","IS_EDGE","useNativeAccessors","isTrackingLogicalChildNodes","nodeData","isShadyRoot","obj","_localName","ownerShadyRootForNode","p","matches","matchesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector","webkitMatchesSelector","extend","source","getOwnPropertyNames","pd","extendAll","sources","mixin","twiddle","createTextNode","queue","shift","characterData","microtask","push","hasDocumentContains","contains","container","flushList","scheduled","enqueue","flush","didFlush","AsyncObserver","_scheduled","removedNodes","callbacks","Set","schedule","takeRecords","cb","observeChildren","sd","add","_callback","_observer","_node","unobserveChildren","handle","delete","size","filterMutations","targetRootNode","map","mutation","mutationInScope","nodes","Array","from","filter","create","removeChild","cloneNode","importNode","Document","windowAddEventListener","Window","windowRemoveEventListener","HTMLElement","elementQuerySelector","fragmentQuerySelector","DocumentFragment","documentQuerySelector","elementQuerySelectorAll","fragmentQuerySelectorAll","documentQuerySelectorAll","DOCUMENT_NODE","escapeAttrRegExp","escapeDataRegExp","escapeReplace","c","makeSet","arr","set","voidElements","plaintextParents","getInnerHTML","c$","child","tagName","attrs","TEXT_NODE","data","COMMENT_NODE","console","error","Error","nodeWalker","createTreeWalker","NodeFilter","SHOW_ALL","elementWalker","SHOW_ELEMENT","currentNode","parentElement","firstElementChild","lastElementChild","previousElementSibling","nextElementSibling","children","textWalker","SHOW_TEXT","nextNode","nodeValue","nativeProtos","findNodeDescriptor","proto","hasOwnProperty","nodeAccessors","fragmentAccessors","documentAccessors","slice","accessors","nativeTreeAccessors","nativeTreeWalker","clearNode","inertDoc","nativeIsConnectedAccessors","nativeIsConnected","nativeActiveElementDescriptor","OutsideAccessors","ClassNameAccessor","className","InsideAccessors","item","childNodes.item","index","childElementCount","tc","cn","join","nativeAccessors","children.item","containerName","htmlContainer","ShadowRootAccessor","shadowRoot","ActiveElementAccessor","activeElement","active","nativeContains","activeRoot","patchAccessorGroup","descriptors","force","objDesc","warn","patchAccessors","patchShadowRootAccessors","ShadyRoot","__proto__","defineProperties","nodeName","prop","patchOutsideElementAccessors","patchInsideElementAccessors","linkNode","ref_node","containerData","ref_nodeData","psd","nsd","recordChildNodes","parent","refData","ownerRoot","slotsAdded","slots","_ensureSlotData","_pendingSlots","_slotList","_slotMap","$jscomp.arrayFromIterator","$jscomp.makeIterator","_asyncRender","resetTo","parentData","hasShadowRootWithSlot","preventNativeInsert","firstComposedNode","nativeMethods","scheduleObserver","preventNativeRemove","removeOwnerShadyRoot","changeSlotContent","_validateSlots","slot","splice","x","didRemove","removingInsertionPoint","composed","flattened","_hasInsertionPoint","distributeAttributeChange","oldName","__slotName","_nameForSlot","_sortSlots","addedNode","removedNode","documentElement","query","matcher","halter","queryElements","elements","result","scopingShim","deep","nc","eventWrappersName","Date","now","alwaysComposed","pathComposer","startNode","composedPath","current","startRoot","retarget","refNode","path","refNodePath","ancestor","lastRoot","rootIdx","eventMixin","isTrusted","__composed","__composedPath","currentTarget","relatedTarget","__relatedTarget","__relatedTargetComposedPath","stopPropagation","Event","__propagationStopped","stopImmediatePropagation","__immediatePropagationStopped","mixinComposedFlag","Base","klazz","options","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","__shadyTarget","wrapperFn","patchEvent","lastCurrentTargetDesc","eventPhase","BUBBLING_PHASE","CAPTURING_PHASE","ret","ael","idx","activateFocusEventOverrides","ev","getPrototypeOf","patchProto","__sourceProto","PatchedEvent","PatchedCustomEvent","PatchedMouseEvent","MouseEvent","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","ancestorList","ancestors","unshift","token","TypeError","SHADYROOT_NAME","_mode","mode","hostData","MODE_CLOSED","rootData","_renderPending","_render","renderRoot","_distribute","slotData","_distributeNodeToSlot","slotParentRoot","slotParentData","_addAssignedToFlattenedNodes","prevAssignedNodes","_fireSlotChange","_compose","composeList","targetNode","distributedNode","d","next","forcedSlot","oldSlot","CATCHALL_NAME","assigned","nestedAssigned","slotNamesToSort","_mapSlots","sort","a","b","listA","listB","nA","nB","getAssignedSlot","windowMixin","bind","nodeMixin","IsConnectedAccessor","isConnected","textMixin","fragmentMixin","o","slotMixin","elementMixin","documentMixin","getElementById","id","nativeBlur","blur","htmlElementMixin","shadowActive","shadowRootMixin","patchBuiltin","ShadyDOM","patch","nativeHTMLElement","Text","HTMLSlotElement","ShadowRoot","reservedTagList","isValidCustomElementName","reserved","has","validForm","nativeValue","__CE_isImportDocument","nextSiblingOrAncestorSibling","start","walkDeepDescendantElements","visitedImports","__CE_shadowRoot","setPropertyUnchecked","destination","CustomElementInternals","_localNameToDefinition","Map","_constructorToDefinition","_patches","_hasPatches","setDefinition","definition","addPatch","listener","patchTree","__CE_patched","connectTree","custom","__CE_state","connectedCallback","upgradeElement","disconnectTree","disconnectedCallback","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","Deferred","_resolve","_value","_promise","Promise","resolve","CustomElementRegistry","_elementDefinitionIsRunning","_whenDefinedDeferred","_flushCallback","this._flushCallback","_flushPending","_pendingDefinitions","_documentConstructionObserver","define","Function","SyntaxError","getCallback","callbackValue","adoptedCallback","_flush","pendingDefinitions","elementsWithStableDefinitions","elementsWithPendingDefinitions","pendingElements","pendingUpgradableElements","deferred","whenDefined","reject","prior","some","polyfillWrapFlushCallback","outer","inner","Document_createElement","Document_createElementNS","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","$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","builtIn","appendPrependPatch","builtInMethod","connectedElements","apply","prepend","append","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Document_importNode.call","NS_HTML","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.Document_createElementNS.call","$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","priorCustomElements","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.DocumentFragment_prepend","$jscompDefaultExport$$module$node_modules$$webcomponents$custom_elements$src$Patch$Native.DocumentFragment_append","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","substring","trim","ss","_expandUnicodeEscapes","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.multipleSpaces","lastIndexOf","AT_START","MEDIA_START","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.MEDIA_RULE","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.keyframesRule","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.KEYFRAMES_RULE","VAR_START","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.MIXIN_RULE","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.STYLE_RULE","r$","code","repeat","stringify","preserveProperties","cssText","rules","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.customProp","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.mixinProp","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.mixinApply","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.varApply","STYLE_RULE","KEYFRAMES_RULE","MEDIA_RULE","MIXIN_RULE","comments","port","customProp","mixinProp","mixinApply","varApply","keyframesRule","multipleSpaces","nativeShadow","nativeCssVariables","calcCssVariables","CSS","supports","ShadyCSS","nativeCss","module$node_modules$$webcomponents$shadycss$src$style_settings.nativeCssVariables","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","compareDocumentPosition","DOCUMENT_POSITION_PRECEDING","processVariableAndFallback","str","level","prefix","suffix","comma","fallback","setElementClassRaw","getIsExtends","typeExtension","is","extends","StyleTransformer","dom","shouldRemoveScope","_transformDom","_content","classList","remove","SCOPE_NAME","CLASS","elementStyles","styleRules","cssBuildType","css","ext","hostScope","_calcHostScope","CSS_CLASS_PREFIX","isScoped","transformedSelector","_transformRuleCss","self","_transformComplexSelector","transformer","p$","COMPLEX_SELECTOR_SEP","_twiddleNthPlus","NTH","inside","stop","isNth","SLOTTED_START","HOST","SIMPLE_SELECTOR_SEP","info","_transformCompoundSelector","combinator","slottedIndex","SLOTTED","_transformHostSelector","_transformSimpleSelector","slotted","SLOTTED_PAREN","paren","DIR_PAREN","before","dir","PSEUDO_PREFIX","HOST_PAREN","SIMPLE_SELECTOR_PREFIX","typeSelector","SELECTOR_NO_MATCH","normalizeRootSelector","ROOT","_transformDocumentSelector","SCOPE_DOC_SELECTOR","$jscomp.global.Object.defineProperties","RegExp","StyleInfo","ast","ownStylePropertyNames","overrideStyleProperties","customStyle","scopeSelector","styleProperties","styleInfo","_getStyleRules","method","StyleProperties","decorateStyles","props","keyframes","ruleIndex","decorateRule","propertyInfo","exec","onKeyframesRule","_keyframes","names","properties","collectProperties","hasProperties","assign","any","valueForProperty","property","valueForProperties","propertyValue","colon","pp","propertyDataFromStyles","selectorToMatch","parseInt","key","whenHostOrRootRule","cssBuild","parsedSelector","isRoot","isHost","hostAndRootPropertiesForScope","hostProps","rootProps","_element","transformStyles","hostSelector","hostRx","HOST_PREFIX","rxHostSelector","HOST_SUFFIX","StyleInfo$$module$node_modules$$webcomponents$shadycss$src$style_info.get","keyframeTransforms","_elementKeyframeTransforms","output","input","hasAnimations","keyframeNamesToTransform","keyframe","transform","keyframesRules","keyframesNameRx","transformedKeyframesName","scopeId","_keyframesRuleTransformer","applyCustomStyle","XSCOPE_NAME","placeholderMap","ce","origDefine","wrappedDefine","clazz","placeHolder","createComment","after","StyleCache","cache","store","tagname","styleElement","typeMax","fetch","ownPropertyNames","entry","pn","handler","mxns","mxn","classes","hasAttribute","currentScope","newScope","unscoped","delayedStart","requestAnimationFrame","module$node_modules$$webcomponents$shadycss$src$document_watcher.flush","templateMap","promise","invalidate","elementName","templateIsValid","startValidatingTemplate","_validating","then","readyPromise","resolveFn","documentWait","styleCache","ScopingShim","_scopeCounter","_documentOwner","_documentOwnerStyleInfo","StyleInfo$$module$node_modules$$webcomponents$shadycss$src$style_info.set","_elementsHaveApplied","_customStyleInterface","_applyShim","_ensure","ScopingShim$$module$node_modules$$webcomponents$shadycss$src$scoping_shim.prototype","?.prototype","ScopingShim$$module$node_modules$$webcomponents$shadycss$src$scoping_shim_prototype$flush","getStyleAst","styleAstToString","prepareTemplate","_prepared","styleTextParts","styles","scopingAttribute","newStyle","__cssBuild","_cssBuild","shadowroot","_style","_ownPropertyNames","_ensureCustomStyleInterface","CustomStyleInterface","transformCustomStyleForDocument","flushCustomStyles","_ensureApplyShim","ApplyShim","customStyles","_revalidateCustomStyleApplyShim","_updateProperties","_applyCustomStyles","styleDocument","overrideProps","_isRootOwner","removeProperty","setProperty","cachedStyle","cacheEntry","oldScopeSelector","cachedScopeSelector","applyElementStyle","v","_styleOwnerForNode","owner","ownerStyleInfo","hostAndRootProps","propertiesMatchingHost","propertyData","overrides","reify","styleSubtree","shadowChildren","documentRule","_transformRule","getComputedStyleValue","getComputedStyle","getPropertyValue","setElementClass","classString","scopeName","classAttr","k$","_styleInfoForNode","elementExtends","Template","WebComponents","flushCallback","runAndClearCallback","bootstrap","origWhenReady","ready"],"mappings":"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","file":"webcomponents-hi-sd-ce.js","sourcesContent":["/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n(scope => {\n\n  /********************* base setup *********************/\n  const link = document.createElement('link');\n  const useNative = Boolean('import' in link);\n  const emptyNodeList = link.querySelectorAll('*');\n\n  // Polyfill `currentScript` for browsers without it.\n  let currentScript = null;\n  if ('currentScript' in document === false) {\n    Object.defineProperty(document, 'currentScript', {\n      get() {\n        return currentScript ||\n          // NOTE: only works when called in synchronously executing code.\n          // readyState should check if `loading` but IE10 is\n          // interactive when scripts run so we cheat. This is not needed by\n          // html-imports polyfill but helps generally polyfill `currentScript`.\n          (document.readyState !== 'complete' ?\n            document.scripts[document.scripts.length - 1] : null);\n      },\n      configurable: true\n    });\n  }\n\n  /**\n   * @param {Array|NodeList|NamedNodeMap} list\n   * @param {!Function} callback\n   * @param {boolean=} inverseOrder\n   */\n  const forEach = (list, callback, inverseOrder) => {\n    const length = list ? list.length : 0;\n    const increment = inverseOrder ? -1 : 1;\n    let i = inverseOrder ? length - 1 : 0;\n    for (; i < length && i >= 0; i = i + increment) {\n      callback(list[i], i);\n    }\n  };\n\n  /**\n   * @param {!Node} node\n   * @param {!string} selector\n   * @return {!NodeList<!Element>}\n   */\n  const QSA = (node, selector) => {\n    // IE 11 throws a SyntaxError if a node with no children is queried with\n    // a selector containing the `:not([type])` syntax.\n    if (!node.childNodes.length) {\n      return emptyNodeList;\n    }\n    return node.querySelectorAll(selector);\n  };\n\n  /**\n   * @param {!DocumentFragment} fragment\n   */\n  const replaceScripts = (fragment) => {\n    forEach(QSA(fragment, 'template'), template => {\n      forEach(QSA(template.content, scriptsSelector), script => {\n        const clone = /** @type {!HTMLScriptElement} */\n          (document.createElement('script'));\n        forEach(script.attributes, attr => clone.setAttribute(attr.name, attr.value));\n        clone.textContent = script.textContent;\n        script.parentNode.replaceChild(clone, script);\n      });\n      replaceScripts(template.content);\n    });\n  };\n\n  /********************* path fixup *********************/\n  const CSS_URL_REGEXP = /(url\\()([^)]*)(\\))/g;\n  const CSS_IMPORT_REGEXP = /(@import[\\s]+(?!url\\())([^;]*)(;)/g;\n  const STYLESHEET_REGEXP = /(<link[^>]*)(rel=['|\"]?stylesheet['|\"]?[^>]*>)/g;\n\n  // path fixup: style elements in imports must be made relative to the main\n  // document. We fixup url's in url() and @import.\n  const Path = {\n\n    fixUrls(element, base) {\n      if (element.href) {\n        element.setAttribute('href',\n          Path.resolveUrl(element.getAttribute('href'), base));\n      }\n      if (element.src) {\n        element.setAttribute('src',\n          Path.resolveUrl(element.getAttribute('src'), base));\n      }\n      if (element.localName === 'style') {\n        const r = Path.replaceUrls(element.textContent, base, CSS_URL_REGEXP);\n        element.textContent = Path.replaceUrls(r, base, CSS_IMPORT_REGEXP);\n      }\n    },\n\n    replaceUrls(text, linkUrl, regexp) {\n      return text.replace(regexp, (m, pre, url, post) => {\n        let urlPath = url.replace(/[\"']/g, '');\n        if (linkUrl) {\n          urlPath = Path.resolveUrl(urlPath, linkUrl);\n        }\n        return pre + '\\'' + urlPath + '\\'' + post;\n      });\n    },\n\n    resolveUrl(url, base) {\n      // Lazy feature detection.\n      if (Path.__workingURL === undefined) {\n        Path.__workingURL = false;\n        try {\n          const u = new URL('b', 'http://a');\n          u.pathname = 'c%20d';\n          Path.__workingURL = (u.href === 'http://a/c%20d');\n        } catch (e) {}\n      }\n\n      if (Path.__workingURL) {\n        return (new URL(url, base)).href;\n      }\n\n      // Fallback to creating an anchor into a disconnected document.\n      let doc = Path.__tempDoc;\n      if (!doc) {\n        doc = document.implementation.createHTMLDocument('temp');\n        Path.__tempDoc = doc;\n        doc.__base = doc.createElement('base');\n        doc.head.appendChild(doc.__base);\n        doc.__anchor = doc.createElement('a');\n      }\n      doc.__base.href = base;\n      doc.__anchor.href = url;\n      return doc.__anchor.href || url;\n    }\n  };\n\n  /********************* Xhr processor *********************/\n  const Xhr = {\n\n    async: true,\n\n    /**\n     * @param {!string} url\n     * @param {!function(!string, string=)} success\n     * @param {!function(!string)} fail\n     */\n    load(url, success, fail) {\n      if (!url) {\n        fail('error: href must be specified');\n      } else if (url.match(/^data:/)) {\n        // Handle Data URI Scheme\n        const pieces = url.split(',');\n        const header = pieces[0];\n        let resource = pieces[1];\n        if (header.indexOf(';base64') > -1) {\n          resource = atob(resource);\n        } else {\n          resource = decodeURIComponent(resource);\n        }\n        success(resource);\n      } else {\n        const request = new XMLHttpRequest();\n        request.open('GET', url, Xhr.async);\n        request.onload = () => {\n          // Servers redirecting an import can add a Location header to help us\n          // polyfill correctly. Handle relative and full paths.\n          // Prefer responseURL which already resolves redirects\n          // https://xhr.spec.whatwg.org/#the-responseurl-attribute\n          let redirectedUrl = request.responseURL || request.getResponseHeader('Location');\n          if (redirectedUrl && redirectedUrl.indexOf('/') === 0) {\n            // In IE location.origin might not work\n            // https://connect.microsoft.com/IE/feedback/details/1763802/location-origin-is-undefined-in-ie-11-on-windows-10-but-works-on-windows-7\n            const origin = (location.origin || location.protocol + '//' + location.host);\n            redirectedUrl = origin + redirectedUrl;\n          }\n          const resource = /** @type {string} */ (request.response || request.responseText);\n          if (request.status === 304 || request.status === 0 ||\n            request.status >= 200 && request.status < 300) {\n            success(resource, redirectedUrl);\n          } else {\n            fail(resource);\n          }\n        };\n        request.send();\n      }\n    }\n  };\n\n  /********************* importer *********************/\n\n  const isIE = /Trident/.test(navigator.userAgent) ||\n    /Edge\\/\\d./i.test(navigator.userAgent);\n\n  const importSelector = 'link[rel=import]';\n\n  // Used to disable loading of resources.\n  const importDisableType = 'import-disable';\n\n  const disabledLinkSelector = `link[rel=stylesheet][href][type=${importDisableType}]`;\n\n  const scriptsSelector = `script:not([type]),script[type=\"application/javascript\"],` +\n    `script[type=\"text/javascript\"]`;\n\n  const importDependenciesSelector = `${importSelector},${disabledLinkSelector},` +\n    `style:not([type]),link[rel=stylesheet][href]:not([type]),` + scriptsSelector;\n\n  const importDependencyAttr = 'import-dependency';\n\n  const rootImportSelector = `${importSelector}:not([${importDependencyAttr}])`;\n\n  const pendingScriptsSelector = `script[${importDependencyAttr}]`;\n\n  const pendingStylesSelector = `style[${importDependencyAttr}],` +\n    `link[rel=stylesheet][${importDependencyAttr}]`;\n\n  /**\n   * Importer will:\n   * - load any linked import documents (with deduping)\n   * - whenever an import is loaded, prompt the parser to try to parse\n   * - observe imported documents for new elements (these are handled via the\n   *   dynamic importer)\n   */\n  class Importer {\n    constructor() {\n      this.documents = {};\n      // Used to keep track of pending loads, so that flattening and firing of\n      // events can be done when all resources are ready.\n      this.inflight = 0;\n      this.dynamicImportsMO = new MutationObserver(m => this.handleMutations(m));\n      // Observe changes on <head>.\n      this.dynamicImportsMO.observe(document.head, {\n        childList: true,\n        subtree: true\n      });\n      // 1. Load imports contents\n      // 2. Assign them to first import links on the document\n      // 3. Wait for import styles & scripts to be done loading/running\n      // 4. Fire load/error events\n      this.loadImports(document);\n    }\n\n    /**\n     * @param {!(HTMLDocument|DocumentFragment|Element)} doc\n     */\n    loadImports(doc) {\n      const links = /** @type {!NodeList<!HTMLLinkElement>} */\n        (QSA(doc, importSelector));\n      forEach(links, link => this.loadImport(link));\n    }\n\n    /**\n     * @param {!HTMLLinkElement} link\n     */\n    loadImport(link) {\n      const url = link.href;\n      // This resource is already being handled by another import.\n      if (this.documents[url] !== undefined) {\n        // If import is already loaded, we can safely associate it to the link\n        // and fire the load/error event.\n        const imp = this.documents[url];\n        if (imp && imp['__loaded']) {\n          link['__import'] = imp;\n          this.fireEventIfNeeded(link);\n        }\n        return;\n      }\n      this.inflight++;\n      // Mark it as pending to notify others this url is being loaded.\n      this.documents[url] = 'pending';\n      Xhr.load(url, (resource, redirectedUrl) => {\n        const doc = this.makeDocument(resource, redirectedUrl || url);\n        this.documents[url] = doc;\n        this.inflight--;\n        // Load subtree.\n        this.loadImports(doc);\n        this.processImportsIfLoadingDone();\n      }, () => {\n        // If load fails, handle error.\n        this.documents[url] = null;\n        this.inflight--;\n        this.processImportsIfLoadingDone();\n      });\n    }\n\n    /**\n     * Creates a new document containing resource and normalizes urls accordingly.\n     * @param {string=} resource\n     * @param {string=} url\n     * @return {!DocumentFragment}\n     */\n    makeDocument(resource, url) {\n      if (!resource) {\n        return document.createDocumentFragment();\n      }\n\n      if (isIE) {\n        // <link rel=stylesheet> should be appended to <head>. Not doing so\n        // in IE/Edge breaks the cascading order. We disable the loading by\n        // setting the type before setting innerHTML to avoid loading\n        // resources twice.\n        resource = resource.replace(STYLESHEET_REGEXP, (match, p1, p2) => {\n          if (match.indexOf('type=') === -1) {\n            return `${p1} type=${importDisableType} ${p2}`;\n          }\n          return match;\n        });\n      }\n\n      let content;\n      const template = /** @type {!HTMLTemplateElement} */\n        (document.createElement('template'));\n      template.innerHTML = resource;\n      if (template.content) {\n        content = template.content;\n        // Clone scripts inside templates since they won't execute when the\n        // hosting template is cloned.\n        replaceScripts(content);\n      } else {\n        // <template> not supported, create fragment and move content into it.\n        content = document.createDocumentFragment();\n        while (template.firstChild) {\n          content.appendChild(template.firstChild);\n        }\n      }\n\n      // Support <base> in imported docs. Resolve url and remove its href.\n      const baseEl = content.querySelector('base');\n      if (baseEl) {\n        url = Path.resolveUrl(baseEl.getAttribute('href'), url);\n        baseEl.removeAttribute('href');\n      }\n\n      const n$ = /** @type {!NodeList<!(HTMLLinkElement|HTMLScriptElement|HTMLStyleElement)>} */\n        (QSA(content, importDependenciesSelector));\n      // For source map hints.\n      let inlineScriptIndex = 0;\n      forEach(n$, n => {\n        // Listen for load/error events, then fix urls.\n        whenElementLoaded(n);\n        Path.fixUrls(n, url);\n        // Mark for easier selectors.\n        n.setAttribute(importDependencyAttr, '');\n        // Generate source map hints for inline scripts.\n        if (n.localName === 'script' && !n.src && n.textContent) {\n          const num = inlineScriptIndex ? `-${inlineScriptIndex}` : '';\n          const content = n.textContent + `\\n//# sourceURL=${url}${num}.js\\n`;\n          // We use the src attribute so it triggers load/error events, and it's\n          // easier to capture errors (e.g. parsing) like this.\n          n.setAttribute('src', 'data:text/javascript;charset=utf-8,' + encodeURIComponent(content));\n          n.textContent = '';\n          inlineScriptIndex++;\n        }\n      });\n      return content;\n    }\n\n    /**\n     * Waits for loaded imports to finish loading scripts and styles, then fires\n     * the load/error events.\n     */\n    processImportsIfLoadingDone() {\n      // Wait until all resources are ready, then load import resources.\n      if (this.inflight) return;\n\n      // Stop observing, flatten & load resource, then restart observing <head>.\n      this.dynamicImportsMO.disconnect();\n      this.flatten(document);\n      // We wait for styles to load, and at the same time we execute the scripts,\n      // then fire the load/error events for imports to have faster whenReady\n      // callback execution.\n      // NOTE: This is different for native behavior where scripts would be\n      // executed after the styles before them are loaded.\n      // To achieve that, we could select pending styles and scripts in the\n      // document and execute them sequentially in their dom order.\n      let scriptsOk = false,\n        stylesOk = false;\n      const onLoadingDone = () => {\n        if (stylesOk && scriptsOk) {\n          // Catch any imports that might have been added while we\n          // weren't looking, wait for them as well.\n          this.loadImports(document);\n          if (this.inflight) return;\n\n          // Restart observing.\n          this.dynamicImportsMO.observe(document.head, {\n            childList: true,\n            subtree: true\n          });\n          this.fireEvents();\n        }\n      }\n      this.waitForStyles(() => {\n        stylesOk = true;\n        onLoadingDone();\n      });\n      this.runScripts(() => {\n        scriptsOk = true;\n        onLoadingDone();\n      });\n    }\n\n    /**\n     * @param {!HTMLDocument} doc\n     */\n    flatten(doc) {\n      const n$ = /** @type {!NodeList<!HTMLLinkElement>} */\n        (QSA(doc, importSelector));\n      forEach(n$, n => {\n        const imp = this.documents[n.href];\n        n['__import'] = /** @type {!Document} */ (imp);\n        if (imp && imp.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n          // We set the .import to be the link itself, and update its readyState.\n          // Other links with the same href will point to this link.\n          this.documents[n.href] = n;\n          n.readyState = 'loading';\n          n['__import'] = n;\n          this.flatten(imp);\n          n.appendChild(imp);\n        }\n      });\n    }\n\n    /**\n     * Replaces all the imported scripts with a clone in order to execute them.\n     * Updates the `currentScript`.\n     * @param {!function()} callback\n     */\n    runScripts(callback) {\n      const s$ = QSA(document, pendingScriptsSelector);\n      const l = s$.length;\n      const cloneScript = i => {\n        if (i < l) {\n          // The pending scripts have been generated through innerHTML and\n          // browsers won't execute them for security reasons. We cannot use\n          // s.cloneNode(true) either, the only way to run the script is manually\n          // creating a new element and copying its attributes.\n          const s = s$[i];\n          const clone = /** @type {!HTMLScriptElement} */\n            (document.createElement('script'));\n          // Remove import-dependency attribute to avoid double cloning.\n          s.removeAttribute(importDependencyAttr);\n          forEach(s.attributes, attr => clone.setAttribute(attr.name, attr.value));\n          // Update currentScript and replace original with clone script.\n          currentScript = clone;\n          s.parentNode.replaceChild(clone, s);\n          whenElementLoaded(clone, () => {\n            currentScript = null;\n            cloneScript(i + 1);\n          });\n        } else {\n          callback();\n        }\n      };\n      cloneScript(0);\n    }\n\n    /**\n     * Waits for all the imported stylesheets/styles to be loaded.\n     * @param {!function()} callback\n     */\n    waitForStyles(callback) {\n      const s$ = /** @type {!NodeList<!(HTMLLinkElement|HTMLStyleElement)>} */\n        (QSA(document, pendingStylesSelector));\n      let pending = s$.length;\n      if (!pending) {\n        callback();\n        return;\n      }\n      // <link rel=stylesheet> should be appended to <head>. Not doing so\n      // in IE/Edge breaks the cascading order\n      // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/10472273/\n      // If there is one <link rel=stylesheet> imported, we must move all imported\n      // links and styles to <head>.\n      const needsMove = isIE && !!document.querySelector(disabledLinkSelector);\n      forEach(s$, s => {\n        // Listen for load/error events, remove selector once is done loading.\n        whenElementLoaded(s, () => {\n          s.removeAttribute(importDependencyAttr);\n          if (--pending === 0) {\n            callback();\n          }\n        });\n        // Check if was already moved to head, to handle the case where the element\n        // has already been moved but it is still loading.\n        if (needsMove && s.parentNode !== document.head) {\n          // Replace the element we're about to move with a placeholder.\n          const placeholder = document.createElement(s.localName);\n          // Add reference of the moved element.\n          placeholder['__appliedElement'] = s;\n          // Disable this from appearing in document.styleSheets.\n          placeholder.setAttribute('type', 'import-placeholder');\n          // Append placeholder next to the sibling, and move original to <head>.\n          s.parentNode.insertBefore(placeholder, s.nextSibling);\n          let newSibling = importForElement(s);\n          while (newSibling && importForElement(newSibling)) {\n            newSibling = importForElement(newSibling);\n          }\n          if (newSibling.parentNode !== document.head) {\n            newSibling = null;\n          }\n          document.head.insertBefore(s, newSibling);\n          // Enable the loading of <link rel=stylesheet>.\n          s.removeAttribute('type');\n        }\n      });\n    }\n\n    /**\n     * Fires load/error events for imports in the right order .\n     */\n    fireEvents() {\n      const n$ = /** @type {!NodeList<!HTMLLinkElement>} */\n        (QSA(document, importSelector));\n      // Inverse order to have events firing bottom-up.\n      forEach(n$, n => this.fireEventIfNeeded(n), true);\n    }\n\n    /**\n     * Fires load/error event for the import if this wasn't done already.\n     * @param {!HTMLLinkElement} link\n     */\n    fireEventIfNeeded(link) {\n      // Don't fire twice same event.\n      if (!link['__loaded']) {\n        link['__loaded'] = true;\n        // Update link's import readyState.\n        link.import && (link.import.readyState = 'complete');\n        const eventType = link.import ? 'load' : 'error';\n        link.dispatchEvent(newCustomEvent(eventType, {\n          bubbles: false,\n          cancelable: false,\n          detail: undefined\n        }));\n      }\n    }\n\n    /**\n     * @param {Array<MutationRecord>} mutations\n     */\n    handleMutations(mutations) {\n      forEach(mutations, m => forEach(m.addedNodes, elem => {\n        if (elem && elem.nodeType === Node.ELEMENT_NODE) {\n          // NOTE: added scripts are not updating currentScript in IE.\n          if (isImportLink(elem)) {\n            this.loadImport( /** @type {!HTMLLinkElement} */ (elem));\n          } else {\n            this.loadImports( /** @type {!Element} */ (elem));\n          }\n        }\n      }));\n    }\n  }\n\n  /**\n   * @param {!Node} node\n   * @return {boolean}\n   */\n  const isImportLink = node => {\n    return node.nodeType === Node.ELEMENT_NODE && node.localName === 'link' &&\n      ( /** @type {!HTMLLinkElement} */ (node).rel === 'import');\n  };\n\n  /**\n   * Waits for an element to finish loading. If already done loading, it will\n   * mark the element accordingly.\n   * @param {!(HTMLLinkElement|HTMLScriptElement|HTMLStyleElement)} element\n   * @param {function()=} callback\n   */\n  const whenElementLoaded = (element, callback) => {\n    if (element['__loaded']) {\n      callback && callback();\n    } else if ((element.localName === 'script' && !element.src) ||\n      (element.localName === 'style' && !element.firstChild)) {\n      // Inline scripts and empty styles don't trigger load/error events,\n      // consider them already loaded.\n      element['__loaded'] = true;\n      callback && callback();\n    } else {\n      const onLoadingDone = event => {\n        element.removeEventListener(event.type, onLoadingDone);\n        element['__loaded'] = true;\n        callback && callback();\n      };\n      element.addEventListener('load', onLoadingDone);\n      // NOTE: We listen only for load events in IE/Edge, because in IE/Edge\n      // <style> with @import will fire error events for each failing @import,\n      // and finally will trigger the load event when all @import are\n      // finished (even if all fail).\n      if (!isIE || element.localName !== 'style') {\n        element.addEventListener('error', onLoadingDone);\n      }\n    }\n  }\n\n  /**\n   * Calls the callback when all imports in the document at call time\n   * (or at least document ready) have loaded. Callback is called synchronously\n   * if imports are already done loading.\n   * @param {function()=} callback\n   */\n  const whenReady = callback => {\n    // 1. ensure the document is in a ready state (has dom), then\n    // 2. watch for loading of imports and call callback when done\n    whenDocumentReady(() => whenImportsReady(() => callback && callback()));\n  }\n\n  /**\n   * Invokes the callback when document is in ready state. Callback is called\n   *  synchronously if document is already done loading.\n   * @param {!function()} callback\n   */\n  const whenDocumentReady = callback => {\n    const stateChanged = () => {\n      // NOTE: Firefox can hit readystate interactive without document.body existing.\n      // This is anti-spec, but we handle it here anyways by waiting for next change.\n      if (document.readyState !== 'loading' && !!document.body) {\n        document.removeEventListener('readystatechange', stateChanged);\n        callback();\n      }\n    }\n    document.addEventListener('readystatechange', stateChanged);\n    stateChanged();\n  }\n\n  /**\n   * Invokes the callback after all imports are loaded. Callback is called\n   * synchronously if imports are already done loading.\n   * @param {!function()} callback\n   */\n  const whenImportsReady = callback => {\n    let imports = /** @type {!NodeList<!HTMLLinkElement>} */\n      (QSA(document, rootImportSelector));\n    let pending = imports.length;\n    if (!pending) {\n      callback();\n      return;\n    }\n    forEach(imports, imp => whenElementLoaded(imp, () => {\n      if (--pending === 0) {\n        callback();\n      }\n    }));\n  }\n\n  /**\n   * Returns the import document containing the element.\n   * @param {!Node} element\n   * @return {HTMLLinkElement|Document|undefined}\n   */\n  const importForElement = element => {\n    if (useNative) {\n      // Return only if not in the main doc!\n      return element.ownerDocument !== document ? element.ownerDocument : null;\n    }\n    let doc = element['__importDoc'];\n    if (!doc && element.parentNode) {\n      doc = /** @type {!Element} */ (element.parentNode);\n      if (typeof doc.closest === 'function') {\n        // Element.closest returns the element itself if it matches the selector,\n        // so we search the closest import starting from the parent.\n        doc = doc.closest(importSelector);\n      } else {\n        // Walk up the parent tree until we find an import.\n        while (!isImportLink(doc) && (doc = doc.parentNode)) {}\n      }\n      element['__importDoc'] = doc;\n    }\n    return doc;\n  }\n\n  let importer = null;\n  /**\n   * Ensures imports contained in the element are imported.\n   * Use this to handle dynamic imports attached to body.\n   * @param {!(HTMLDocument|Element)} doc\n   */\n  const loadImports = (doc) => {\n    if (importer) {\n      importer.loadImports(doc);\n    }\n  };\n\n  const newCustomEvent = (type, params) => {\n    if (typeof window.CustomEvent === 'function') {\n      return new CustomEvent(type, params);\n    }\n    const event = /** @type {!CustomEvent} */ (document.createEvent('CustomEvent'));\n    event.initCustomEvent(type, Boolean(params.bubbles), Boolean(params.cancelable), params.detail);\n    return event;\n  };\n\n  if (useNative) {\n    // Check for imports that might already be done loading by the time this\n    // script is actually executed. Native imports are blocking, so the ones\n    // available in the document by this time should already have failed\n    // or have .import defined.\n    const imps = /** @type {!NodeList<!HTMLLinkElement>} */\n      (QSA(document, importSelector));\n    forEach(imps, imp => {\n      if (!imp.import || imp.import.readyState !== 'loading') {\n        imp['__loaded'] = true;\n      }\n    });\n    // Listen for load/error events to capture dynamically added scripts.\n    /**\n     * @type {!function(!Event)}\n     */\n    const onLoadingDone = event => {\n      const elem = /** @type {!Element} */ (event.target);\n      if (isImportLink(elem)) {\n        elem['__loaded'] = true;\n      }\n    };\n    document.addEventListener('load', onLoadingDone, true /* useCapture */ );\n    document.addEventListener('error', onLoadingDone, true /* useCapture */ );\n  } else {\n    // Override baseURI so that imported elements' baseURI can be used seemlessly\n    // on native or polyfilled html-imports.\n    // NOTE: a <link rel=import> will have `link.baseURI === link.href`, as the link\n    // itself is used as the `import` document.\n    /** @type {Object|undefined} */\n    const native_baseURI = Object.getOwnPropertyDescriptor(Node.prototype, 'baseURI');\n    // NOTE: if not configurable (e.g. safari9), set it on the Element prototype. \n    const klass = !native_baseURI || native_baseURI.configurable ? Node : Element;\n    Object.defineProperty(klass.prototype, 'baseURI', {\n      get() {\n        const ownerDoc = /** @type {HTMLLinkElement} */ (isImportLink(this) ? this : importForElement(this));\n        if (ownerDoc) return ownerDoc.href;\n        // Use native baseURI if possible.\n        if (native_baseURI && native_baseURI.get) return native_baseURI.get.call(this);\n        // Polyfill it if not available.\n        const base = /** @type {HTMLBaseElement} */ (document.querySelector('base'));\n        return (base || window.location).href;\n      },\n      configurable: true,\n      enumerable: true\n    });\n\n    // Define 'import' read-only property.\n    Object.defineProperty(HTMLLinkElement.prototype, 'import', {\n      get() {\n        return /** @type {HTMLLinkElement} */ (this)['__import'] || null;\n      },\n      configurable: true,\n      enumerable: true\n    });\n\n    whenDocumentReady(() => {\n      importer = new Importer()\n    });\n  }\n\n  /**\n    Add support for the `HTMLImportsLoaded` event and the `HTMLImports.whenReady`\n    method. This api is necessary because unlike the native implementation,\n    script elements do not force imports to resolve. Instead, users should wrap\n    code in either an `HTMLImportsLoaded` handler or after load time in an\n    `HTMLImports.whenReady(callback)` call.\n\n    NOTE: This module also supports these apis under the native implementation.\n    Therefore, if this file is loaded, the same code can be used under both\n    the polyfill and native implementation.\n   */\n  whenReady(() => document.dispatchEvent(newCustomEvent('HTMLImportsLoaded', {\n    cancelable: true,\n    bubbles: true,\n    detail: undefined\n  })));\n\n  // exports\n  scope.useNative = useNative;\n  scope.whenReady = whenReady;\n  scope.importForElement = importForElement;\n  scope.loadImports = loadImports;\n\n})(window.HTMLImports = (window.HTMLImports || {}));",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*/\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  }\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@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","/**\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 elementQuerySelector = Element.prototype.querySelector;\nexport let fragmentQuerySelector = DocumentFragment.prototype.querySelector;\nexport let documentQuerySelector = Document.prototype.querySelector;\nexport let querySelector = function(selector) {\n  switch (this.nodeType) {\n    case Node.ELEMENT_NODE:\n      return elementQuerySelector.call(this, selector);\n    case Node.DOCUMENT_NODE:\n      return documentQuerySelector.call(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 = function(selector) {\n  switch (this.nodeType) {\n    case Node.ELEMENT_NODE:\n      return elementQuerySelectorAll.call(this, selector);\n    case Node.DOCUMENT_NODE:\n      return documentQuerySelectorAll.call(this, selector);\n    default:\n      return fragmentQuerySelectorAll.call(this, selector);\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';\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 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  let children;\n  switch (node.nodeType) {\n    case Node.DOCUMENT_FRAGMENT_NODE:\n      children = fragmentAccessors.children.get.call(node);\n      break;\n    case Node.DOCUMENT_NODE:\n      children = documentAccessors.children.get.call(node);\n      break;\n    default:\n      children = nodeAccessors.children.get.call(node);\n      break;\n  }\n  return Array.prototype.slice.call(children);\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@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      let children;\n      if (utils.isTrackingLogicalChildNodes(this)) {\n        children = Array.prototype.filter.call(this.childNodes, function(n) {\n          return (n.nodeType === Node.ELEMENT_NODE);\n        });\n      } else {\n        children = nativeTree.children(this);\n      }\n      children.item = function(index) {\n        return children[index];\n      }\n      return children;\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      let containerName = this.localName;\n      // avoid creating a template so we don't have to pull nodes form `.content`\n      if (!containerName || containerName === 'template') {\n        containerName = 'div';\n      }\n      const htmlContainer = inertDoc.createElement(containerName);\n      if (hasDescriptors) {\n        nativeAccessors.innerHTML.set.call(htmlContainer, text);\n      } else {\n        htmlContainer.innerHTML = text;\n      }\n      while (htmlContainer.firstChild) {\n        content.appendChild(htmlContainer.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 {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\nfunction ancestorList(node) {\n  let ancestors = [];\n  do {\n    ancestors.unshift(node);\n  } while ((node = node.parentNode));\n  return ancestors;\n}\n\n/**\n * @constructor\n * @extends {ShadowRoot}\n */\nexport class 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    const c$ = childNodes(host);\n    // root <=> host\n    this.host = host;\n    this._mode = options && options.mode;\n    // logical dom setup\n    recordChildNodes(host, c$);\n    const hostData = shadyDataForNode(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    this._slotMap = null;\n    this._pendingSlots = null;\n    // fast path initial render: remove existing physical dom.\n    for (let i=0, l=c$.length; i < l; i++) {\n      removeChild.call(host, c$[i])\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    this._renderPending = false;\n    if (this._slotList) {\n      this._distribute();\n      this._compose();\n    }\n    this._hasRendered = true;\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()) {\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    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\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@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} 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 fragmentMixin = {\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(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 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}, fragmentMixin, slotMixin);\n\nObject.defineProperties(elementMixin, ShadowRootAccessor);\n\nlet documentMixin = utils.extendAll({\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}, fragmentMixin);\n\nObject.defineProperties(documentMixin, {\n  '_activeElement': ActiveElementAccessor.activeElement\n});\n\nlet nativeBlur = HTMLElement.prototype.blur;\n\nlet htmlElementMixin = utils.extendAll({\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\nconst shadowRootMixin = {\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  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  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\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.DocumentFragment.prototype, fragmentMixin);\n  patchBuiltin(window.Element.prototype, elementMixin);\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\nexport let recordChildNodes = function(node, nodes) {\n  const nodeData = ensureShadyDataForNode(node);\n  if (nodeData.firstChild === undefined) {\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@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\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 (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  // 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    removeChild(node.parentNode, node);\n  }\n  // add to new parent\n  let preventNativeInsert;\n  let ownerRoot;\n  let slotsAdded;\n  if (!node['__noInsertionPoint']) {\n    ownerRoot = utils.ownerShadyRootForNode(parent);\n    slotsAdded = ownerRoot && findContainedSlots(node);\n    if (slotsAdded) {\n      ownerRoot._addSlots(slotsAdded);\n    }\n  }\n  // if a slot is added, must render containing root.\n  if (parent.localName === 'slot' || slotsAdded) {\n    ownerRoot = ownerRoot || utils.ownerShadyRootForNode(parent);\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      preventNativeInsert = true;\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      preventNativeInsert = true;\n    }\n  }\n  if (!preventNativeInsert) {\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  }\n  scheduleObserver(parent, node);\n  return node;\n}\n\nfunction findContainedSlots(node) {\n  let slots;\n  if (node.localName === 'slot') {\n    slots = [node];\n  } else if (node.querySelectorAll) {\n    slots = node.querySelectorAll('slot');\n  }\n  if (slots && slots.length) {\n    return slots;\n  }\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*/\nexport function removeChild(parent, node) {\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  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 form 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\nexport function setAttribute(node, attr, value) {\n  if (!scopingShim) {\n    scopingShim = window['ShadyCSS'] && window['ShadyCSS']['ScopingShim'];\n  }\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\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    if (deep) {\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  if (node.ownerDocument !== document) {\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}",null,"/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\nimport * 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// https://github.com/w3c/webcomponents/issues/513#issuecomment-224183937\nlet 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\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    // isTrusted may not exist in this browser, so just check if isTrusted is explicitly false\n    if (this.isTrusted !== false && this.__composed === undefined) {\n      this.__composed = alwaysComposed[this.type];\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.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.__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  // 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    // 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    let ael = this instanceof Window ? nativeMethods.windowAddEventListener :\n      nativeMethods.addEventListener;\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\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  let rel = this instanceof Window ? nativeMethods.windowRemoveEventListener :\n    nativeMethods.removeEventListener;\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","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nfunction newSplice(index, removed, addedCount) {\n  return {\n    index: index,\n    removed: removed,\n    addedCount: addedCount\n  };\n}\n\nconst EDIT_LEAVE = 0;\nconst EDIT_UPDATE = 1;\nconst EDIT_ADD = 2;\nconst EDIT_DELETE = 3;\n\n// Note: This function is *based* on the computation of the Levenshtein\n// \"edit\" distance. The one change is that \"updates\" are treated as two\n// edits - not one. With Array splices, an update is really a delete\n// followed by an add. By retaining this, we optimize for \"keeping\" the\n// maximum array items in the original array. For example:\n//\n//   'xxxx123' -> '123yyyy'\n//\n// With 1-edit updates, the shortest path would be just to update all seven\n// characters. With 2-edit updates, we delete 4, leave 3, and add 4. This\n// leaves the substring '123' intact.\nfunction calcEditDistances(current, currentStart, currentEnd,\n                            old, oldStart, oldEnd) {\n  // \"Deletion\" columns\n  let rowCount = oldEnd - oldStart + 1;\n  let columnCount = currentEnd - currentStart + 1;\n  let distances = new Array(rowCount);\n\n  // \"Addition\" rows. Initialize null column.\n  for (let i = 0; i < rowCount; i++) {\n    distances[i] = new Array(columnCount);\n    distances[i][0] = i;\n  }\n\n  // Initialize null row\n  for (let j = 0; j < columnCount; j++)\n    distances[0][j] = j;\n\n  for (let i = 1; i < rowCount; i++) {\n    for (let j = 1; j < columnCount; j++) {\n      if (equals(current[currentStart + j - 1], old[oldStart + i - 1]))\n        distances[i][j] = distances[i - 1][j - 1];\n      else {\n        let north = distances[i - 1][j] + 1;\n        let west = distances[i][j - 1] + 1;\n        distances[i][j] = north < west ? north : west;\n      }\n    }\n  }\n\n  return distances;\n}\n\n// This starts at the final weight, and walks \"backward\" by finding\n// the minimum previous weight recursively until the origin of the weight\n// matrix.\nfunction spliceOperationsFromEditDistances(distances) {\n  let i = distances.length - 1;\n  let j = distances[0].length - 1;\n  let current = distances[i][j];\n  let edits = [];\n  while (i > 0 || j > 0) {\n    if (i == 0) {\n      edits.push(EDIT_ADD);\n      j--;\n      continue;\n    }\n    if (j == 0) {\n      edits.push(EDIT_DELETE);\n      i--;\n      continue;\n    }\n    let northWest = distances[i - 1][j - 1];\n    let west = distances[i - 1][j];\n    let north = distances[i][j - 1];\n\n    let min;\n    if (west < north)\n      min = west < northWest ? west : northWest;\n    else\n      min = north < northWest ? north : northWest;\n\n    if (min == northWest) {\n      if (northWest == current) {\n        edits.push(EDIT_LEAVE);\n      } else {\n        edits.push(EDIT_UPDATE);\n        current = northWest;\n      }\n      i--;\n      j--;\n    } else if (min == west) {\n      edits.push(EDIT_DELETE);\n      i--;\n      current = west;\n    } else {\n      edits.push(EDIT_ADD);\n      j--;\n      current = north;\n    }\n  }\n\n  edits.reverse();\n  return edits;\n}\n\n/**\n * Splice Projection functions:\n *\n * A splice map is a representation of how a previous array of items\n * was transformed into a new array of items. Conceptually it is a list of\n * tuples of\n *\n *   <index, removed, addedCount>\n *\n * which are kept in ascending index order of. The tuple represents that at\n * the |index|, |removed| sequence of items were removed, and counting forward\n * from |index|, |addedCount| items were added.\n */\n\n/**\n * Lacking individual splice mutation information, the minimal set of\n * splices can be synthesized given the previous state and final state of an\n * array. The basic approach is to calculate the edit distance matrix and\n * choose the shortest path through it.\n *\n * Complexity: O(l * p)\n *   l: The length of the current array\n *   p: The length of the old array\n */\nfunction calcSplices(current, currentStart, currentEnd,\n                      old, oldStart, oldEnd) {\n  let prefixCount = 0;\n  let suffixCount = 0;\n  let splice;\n\n  let minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart);\n  if (currentStart == 0 && oldStart == 0)\n    prefixCount = sharedPrefix(current, old, minLength);\n\n  if (currentEnd == current.length && oldEnd == old.length)\n    suffixCount = sharedSuffix(current, old, minLength - prefixCount);\n\n  currentStart += prefixCount;\n  oldStart += prefixCount;\n  currentEnd -= suffixCount;\n  oldEnd -= suffixCount;\n\n  if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0)\n    return [];\n\n  if (currentStart == currentEnd) {\n    splice = newSplice(currentStart, [], 0);\n    while (oldStart < oldEnd)\n      splice.removed.push(old[oldStart++]);\n\n    return [ splice ];\n  } else if (oldStart == oldEnd)\n    return [ newSplice(currentStart, [], currentEnd - currentStart) ];\n\n  let ops = spliceOperationsFromEditDistances(\n      calcEditDistances(current, currentStart, currentEnd,\n                             old, oldStart, oldEnd));\n\n  splice = undefined;\n  let splices = [];\n  let index = currentStart;\n  let oldIndex = oldStart;\n  for (let i = 0; i < ops.length; i++) {\n    switch(ops[i]) {\n      case EDIT_LEAVE:\n        if (splice) {\n          splices.push(splice);\n          splice = undefined;\n        }\n\n        index++;\n        oldIndex++;\n        break;\n      case EDIT_UPDATE:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.addedCount++;\n        index++;\n\n        splice.removed.push(old[oldIndex]);\n        oldIndex++;\n        break;\n      case EDIT_ADD:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.addedCount++;\n        index++;\n        break;\n      case EDIT_DELETE:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.removed.push(old[oldIndex]);\n        oldIndex++;\n        break;\n    }\n  }\n\n  if (splice) {\n    splices.push(splice);\n  }\n  return splices;\n}\n\nfunction sharedPrefix(current, old, searchLength) {\n  for (let i = 0; i < searchLength; i++)\n    if (!equals(current[i], old[i]))\n      return i;\n  return searchLength;\n}\n\nfunction sharedSuffix(current, old, searchLength) {\n  let index1 = current.length;\n  let index2 = old.length;\n  let count = 0;\n  while (count < searchLength && equals(current[--index1], old[--index2]))\n    count++;\n\n  return count;\n}\n\nfunction equals(currentValue, previousValue) {\n  return currentValue === previousValue;\n}\n\nexport function calculateSplices(current, previous) {\n  return calcSplices(current, 0, current.length, previous, 0,\n                          previous.length);\n}\n\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\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  };\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}","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.constructor, 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 {!Element} 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.constructor;\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      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  _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<!Element>}\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<!Element>>}\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.constructor;\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['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 */\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      /** @type {!Function} */\n      const constructor = 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 = 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      constructionStack[lastIndex] = AlreadyConstructedMarker;\n\n      Object.setPrototypeOf(element, constructor.prototype);\n      internals.patch(/** @type {!HTMLElement} */ (element));\n\n      return element;\n    }\n\n    HTMLElement.prototype = Native.HTMLElement.prototype;\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.constructor)();\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 = 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.constructor)();\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>}\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_createElement.call(document,\n            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(\n            /** @type {!Node} */ (marker || 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 || 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 let nativeShadow = !(window['ShadyDOM'] && window['ShadyDOM']['inUse']);\nexport let 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\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@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} 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 * @param {Element} element\n * @return {?string}\n */\nexport function getCssBuildType(element) {\n  return element.getAttribute('css-build');\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 */\nfunction 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@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  // 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  dom(node, scope, shouldRemoveScope) {\n    // one time optimization to skip scoping...\n    if (node['__styleScoped']) {\n      node['__styleScoped'] = null;\n    } else {\n      this._transformDom(node, scope || '', shouldRemoveScope);\n    }\n  }\n\n  _transformDom(node, selector, shouldRemoveScope) {\n    if (node.nodeType === Node.ELEMENT_NODE) {\n      this.element(node, selector, shouldRemoveScope);\n    }\n    let c$ = (node.localName === 'template') ?\n      (node.content || node._content).childNodes :\n      node.children || node.childNodes;\n    if (c$) {\n      for (let i=0; i<c$.length; i++) {\n        this._transformDom(c$[i], selector, shouldRemoveScope);\n      }\n    }\n  }\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  elementStyles(element, styleRules, callback) {\n    let cssBuildType = element['__cssBuild'];\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    let cssText = '';\n    if (nativeShadow || cssBuildType === '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    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$ = rule['selector'].split(COMPLEX_SELECTOR_SEP);\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$.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 * @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    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    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    let p$ = selector.split(PSEUDO_PREFIX);\n    p$[0] += scope;\n    return p$.join(PSEUDO_PREFIX);\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    return selector.match(SLOTTED) ?\n      this._transformComplexSelector(selector, SCOPE_DOC_SELECTOR) :\n      this._transformSimpleSelector(selector.trim(), SCOPE_DOC_SELECTOR);\n  }\n}\n\nlet NTH = /:(nth[-\\w]+)\\(([^)]+)\\)/;\nlet SCOPE_DOC_SELECTOR = `:not(.${SCOPE_NAME})`;\nlet COMPLEX_SELECTOR_SEP = ',';\nlet SIMPLE_SELECTOR_SEP = /(^|[\\s>+~]+)((?:\\[.+?\\]|[^\\s>+~=[])+)/g;\nlet SIMPLE_SELECTOR_PREFIX = /[[.:#*]/;\nlet HOST = ':host';\nlet ROOT = ':root';\nlet SLOTTED = '::slotted';\nlet 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\nlet HOST_PAREN = /(:host)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))/;\n// similar to HOST_PAREN\nlet SLOTTED_PAREN = /(?:::slotted)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))/;\nlet DIR_PAREN = /(.*):dir\\((?:(ltr|rtl))\\)/;\nlet CSS_CLASS_PREFIX = '.';\nlet PSEUDO_PREFIX = ':';\nlet CLASS = 'class';\nlet SELECTOR_NO_MATCH = 'should_not_match';\n\nexport default new StyleTransformer()","/**\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\nStyleInfo.prototype['_getStyleRules'] = StyleInfo.prototype._getStyleRules;","/**\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 = {}, self = this;\n    // generates a unique key for these matches\n    let o = [];\n    // note: active rules excludes non-matching @media rules\n    StyleUtil.forEachRule(rules, function(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        self.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          self.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|undefined} 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 (cssBuild === 'shadow') {\n      isRoot = parsedSelector === ':host > *' || parsedSelector === 'html';\n      isHost = isHost && !isRoot;\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 * @return {Object}\n */\n  hostAndRootPropertiesForScope(scope, rules) {\n    let hostProps = {}, rootProps = {}, self = this;\n    // note: active rules excludes non-matching @media rules\n    let cssBuild = rules && rules['__cssBuild'];\n    StyleUtil.forEachRule(rules, function(rule) {\n      // if scope is StyleDefaults, use _element for matchesSelector\n      self.whenHostOrRootRule(scope, rule, cssBuild, function(info) {\n        let element = scope._element || scope;\n        if (matchesSelector.call(element, info.selector)) {\n          if (info.isHost) {\n            self.collectProperties(rule, hostProps);\n          } else {\n            self.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 rules = StyleInfo.get(element).styleRules;\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    });\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 = selector.split(',');\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 {applyStylePlaceHolder} from './style-util.js';\nimport {nativeShadow} from './style-settings.js';\n\n/** @type {Object<string, !Node>} */\nlet placeholderMap = {};\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   * @return {function(new:HTMLElement)}\n   */\n  const wrappedDefine = (name, clazz, options) => {\n    placeholderMap[name] = applyStylePlaceHolder(name);\n    return origDefine.call(/** @type {!CustomElementRegistry} */(ce), name, clazz, options);\n  }\n  ce['define'] = wrappedDefine;\n}\n\nexport default placeholderMap;\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    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\nimport {nativeShadow} from './style-settings.js';\nimport StyleTransformer from './style-transformer.js';\nimport {getIsExtends} from './style-util.js';\n\nexport let flush = function() {};\n\n/**\n * @param {HTMLElement} element\n * @return {!Array<string>}\n */\nfunction getClasses(element) {\n  let classes = [];\n  if (element.classList) {\n    classes = Array.from(element.classList);\n  } else if (element instanceof window['SVGElement'] && element.hasAttribute('class')) {\n    classes = element.getAttribute('class').split(/\\s+/);\n  }\n  return classes;\n}\n\n/**\n * @param {HTMLElement} element\n * @return {string}\n */\nfunction getCurrentScope(element) {\n  let classes = getClasses(element);\n  let idx = classes.indexOf(StyleTransformer.SCOPE_NAME);\n  if (idx > -1) {\n    return classes[idx + 1];\n  }\n  return '';\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 (currentScope && root === n.ownerDocument) {\n        StyleTransformer.dom(n, currentScope, true);\n      } else if (root.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n        let newScope;\n        let host = /** @type {ShadowRoot} */(root).host;\n        // element may no longer be in a shadowroot\n        if (!host) {\n          continue;\n        }\n        newScope = getIsExtends(host).is;\n        if (currentScope === newScope) {\n          // make sure all the subtree elements are scoped correctly\n          let unscoped = window['ShadyDOM']['nativeMethods']['querySelectorAll'].call(\n            n, `:not(.${StyleTransformer.SCOPE_NAME})`);\n          for (let j = 0; j < unscoped.length; j++) {\n            StyleTransformer.element(unscoped[j], currentScope);\n          }\n          continue;\n        }\n        if (currentScope) {\n          StyleTransformer.dom(n, currentScope, true);\n        }\n        StyleTransformer.dom(n, newScope);\n      }\n    }\n  }\n}\n\nif (!nativeShadow) {\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\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@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 {Promise<void>} */\nlet readyPromise = null;\n\n/** @type {?function(?function())} */\nlet whenReady = window['HTMLImports'] && window['HTMLImports']['whenReady'] || null;\n\n/** @type {function()} */\nlet resolveFn;\n\n/**\n * @param {?function()} callback\n */\nexport default function documentWait(callback) {\n  requestAnimationFrame(function() {\n    if (whenReady) {\n      whenReady(callback)\n    } else {\n      if (!readyPromise) {\n        readyPromise = new Promise((resolve) => {resolveFn = resolve});\n        if (document.readyState === 'complete') {\n          resolveFn();\n        } else {\n          document.addEventListener('readystatechange', () => {\n            if (document.readyState === 'complete') {\n              resolveFn();\n            }\n          });\n        }\n      }\n      readyPromise.then(function(){ callback && callback(); });\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 {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 placeholderMap from './style-placeholder.js';\nimport StyleInfo from './style-info.js';\nimport StyleCache from './style-cache.js';\nimport {flush as watcherFlush} from './document-watcher.js';\nimport templateMap from './template-map.js';\nimport * as ApplyShimUtils from './apply-shim-utils.js';\nimport documentWait from './document-wait.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 = 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    this._applyShim = null;\n    /** @type {?CustomStyleInterfaceInterface} */\n    this._customStyleInterface = null;\n    documentWait(() => {\n      this._ensure();\n    });\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  _getCssBuild(template) {\n    let style = template.content.querySelector('style');\n    if (!style) {\n      return '';\n    }\n    return style.getAttribute('css-build') || '';\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    if (template._prepared) {\n      return;\n    }\n    template._prepared = true;\n    template.name = elementName;\n    template.extends = typeExtension;\n    templateMap[elementName] = template;\n    let cssBuild = this._getCssBuild(template);\n    let cssText = this._gatherStyles(template);\n    let info = {\n      is: elementName,\n      extends: typeExtension,\n      __cssBuild: cssBuild,\n    };\n    if (!nativeShadow) {\n      StyleTransformer.dom(template.content, elementName);\n    }\n    // check if the styling has mixin definitions or uses\n    this._ensure();\n    let hasMixins = 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    template._cssBuild = cssBuild;\n\n    let ownPropertyNames = [];\n    if (!nativeCssVariables) {\n      ownPropertyNames = StyleProperties.decorateStyles(template['_styleAst'], info);\n    }\n    if (!ownPropertyNames.length || nativeCssVariables) {\n      let root = nativeShadow ? template.content : null;\n      let placeholder = placeholderMap[elementName];\n      let style = this._generateStaticStyle(info, template['_styleAst'], root, placeholder);\n      template._style = style;\n    }\n    template._ownPropertyNames = ownPropertyNames;\n  }\n  _generateStaticStyle(info, rules, shadowroot, placeholder) {\n    let cssText = StyleTransformer.elementStyles(info, rules);\n    if (cssText.length) {\n      return StyleUtil.applyCss(cssText, info.is, shadowroot, placeholder);\n    }\n  }\n  _prepareHost(host) {\n    let {is, typeExtension} = StyleUtil.getIsExtends(host);\n    let placeholder = placeholderMap[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 = template._cssBuild;\n    }\n    return StyleInfo.set(host,\n      new StyleInfo(\n        ast,\n        placeholder,\n        ownStylePropertyNames,\n        is,\n        typeExtension,\n        cssBuild\n      )\n    );\n  }\n  _ensureApplyShim() {\n    if (this._applyShim) {\n      return;\n    } else if (window.ShadyCSS && window.ShadyCSS.ApplyShim) {\n      this._applyShim = 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    if (!nativeCssVariables) {\n      this._updateProperties(this._documentOwner, this._documentOwnerStyleInfo);\n      this._applyCustomStyles(customStyles);\n    } else {\n      this._revalidateCustomStyleApplyShim(customStyles);\n    }\n    this._customStyleInterface['enqueued'] = false;\n    // if custom elements have upgraded and there are no native css variables, we must recalculate the whole tree\n    if (this._elementsHaveApplied && !nativeCssVariables) {\n      this.styleDocument();\n    }\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 {is} = StyleUtil.getIsExtends(host);\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._updateProperties(host, styleInfo);\n      if (styleInfo.ownStylePropertyNames && styleInfo.ownStylePropertyNames.length) {\n        this._applyStyleProperties(host, styleInfo);\n      }\n    } else {\n      if (styleInfo.overrideStyleProperties) {\n        updateNativeProperties(host, styleInfo.overrideStyleProperties);\n      }\n      let template = templateMap[is];\n      // bail early if there is no shadowroot for this element\n      if (!template && !this._isRootOwner(host)) {\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            style.textContent = StyleTransformer.elementStyles(host, styleInfo.styleRules);\n          }\n        }\n        styleInfo.styleRules = template['_styleAst'];\n      }\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);\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 = root && (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    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) {\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\n/* exports */\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;\nObject.defineProperties(ScopingShim.prototype, {\n  'nativeShadow': {\n    get() {\n      return nativeShadow;\n    }\n  },\n  'nativeCss': {\n    get() {\n      return nativeCssVariables;\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 { 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} 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 {!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  /**\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\nif (ApplyShim) {\n  window.ShadyCSS.ApplyShim = ApplyShim;\n}\n\nif (CustomStyleInterface) {\n  window.ShadyCSS.CustomStyleInterface = CustomStyleInterface;\n}","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n'use strict';\n\nlet customElements = window['customElements'];\nlet HTMLImports = window['HTMLImports'];\nlet Template = window['HTMLTemplateElement'];\n\n// global for (1) existence means `WebComponentsReady` will file,\n// (2) WebComponents.ready == true means event has fired.\nwindow.WebComponents = window.WebComponents || {};\n\nif (customElements && customElements['polyfillWrapFlushCallback']) {\n  // Here we ensure that the public `HTMLImports.whenReady`\n  // always comes *after* custom elements have upgraded.\n  let flushCallback;\n  let runAndClearCallback = function runAndClearCallback() {\n    if (flushCallback) {\n      // make sure to run the HTMLTemplateElement polyfill before custom elements upgrade\n      if (Template.bootstrap) {\n        Template.bootstrap(window.document);\n      }\n      let cb = flushCallback;\n      flushCallback = null;\n      cb();\n      return true;\n    }\n  }\n  let origWhenReady = HTMLImports['whenReady'];\n  customElements['polyfillWrapFlushCallback'](function(cb) {\n    flushCallback = cb;\n    origWhenReady(runAndClearCallback);\n  });\n\n  HTMLImports['whenReady'] = function(cb) {\n    origWhenReady(function() {\n      // custom element code may add dynamic imports\n      // to match processing of native custom elements before\n      // domContentLoaded, we wait for these imports to resolve first.\n      if (runAndClearCallback()) {\n        HTMLImports['whenReady'](cb);\n      } else {\n        cb();\n      }\n    });\n  }\n\n}\n\nHTMLImports['whenReady'](function() {\n  requestAnimationFrame(function() {\n    window.WebComponents.ready = true;\n    document.dispatchEvent(new CustomEvent('WebComponentsReady', {bubbles: true}));\n  });\n});","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n'use strict';\n// It's desireable to provide a default stylesheet\n// that's convenient for styling unresolved elements, but\n// it's cumbersome to have to include this manually in every page.\n// It would make sense to put inside some HTMLImport but\n// the HTMLImports polyfill does not allow loading of stylesheets\n// that block rendering. Therefore this injection is tolerated here.\n//\n// NOTE: position: relative fixes IE's failure to inherit opacity\n// when a child is not statically positioned.\nlet style = document.createElement('style');\nstyle.textContent = ''\n    + 'body {'\n    + 'transition: opacity ease-in 0.2s;'\n    + ' } \\n'\n    + 'body[unresolved] {'\n    + 'opacity: 0; display: block; overflow: hidden; position: relative;'\n    + ' } \\n'\n    ;\nlet head = document.querySelector('head');\nhead.insertBefore(style, head.firstChild);"]}