{"version":3,"sources":["../../shadydom/src/shady-data.js"," [synthetic:es6/util/arrayiterator] "," [synthetic:es6/util/makeiterator] "," [synthetic:es6/util/arrayfromiterator] "," [synthetic:util/global] ","../../shadydom/src/utils.js","../../shadydom/src/flush.js","../../shadydom/src/observe-changes.js","../../shadydom/src/innerHTML.js","../../shadydom/src/patch-native.js","../../shadydom/src/patch-instances.js","../../shadydom/src/patch-events.js","../../shadydom/src/array-splice.js","../../shadydom/src/patches/EventTarget.js","../../shadydom/src/style-scoping.js","../../shadydom/src/patches/Node.js","../../shadydom/src/attach-shadow.js"," [synthetic:es6/util/arrayfromiterable] ","../../shadydom/src/patches/Slotable.js","../../shadydom/src/patches/ParentNode.js","../../shadydom/src/patches/Element.js","../../shadydom/src/patches/ElementOrShadowRoot.js","../../shadydom/src/patches/HTMLElement.js","../../shadydom/src/patches/Slot.js","../../shadydom/src/patches/DocumentOrFragment.js","../../shadydom/src/patches/DocumentOrShadowRoot.js","../../shadydom/src/patches/Document.js","../../shadydom/src/patches/Window.js","../../shadydom/src/patch-prototypes.js","../../shadydom/src/link-nodes.js","../../shadydom/src/patches/ShadowRoot.js","../../shadydom/src/patch-shadyRoot.js","../../shadydom/src/wrapper.js","../../shadydom/src/shadydom.js","../../custom-elements/ts_src/Patch/Native.ts","../../custom-elements/ts_src/Utilities.ts","../../custom-elements/ts_src/CustomElementInternals.ts","../../custom-elements/ts_src/custom-elements.ts","../../custom-elements/ts_src/CustomElementState.ts","../../custom-elements/ts_src/Deferred.ts","../../custom-elements/ts_src/DocumentConstructionObserver.ts","../../custom-elements/ts_src/CustomElementRegistry.ts","../../custom-elements/ts_src/Patch/Interface/ParentNode.ts","../../custom-elements/ts_src/Patch/Document.ts","../../custom-elements/ts_src/Patch/Interface/ChildNode.ts","../../custom-elements/ts_src/Patch/Element.ts","../../custom-elements/ts_src/AlreadyConstructedMarker.ts","../../custom-elements/ts_src/Patch/HTMLElement.ts","../../custom-elements/ts_src/Patch/Node.ts","../../custom-elements/ts_src/Patch/DocumentFragment.ts","../../shadycss/src/css-parse.js","../../shadycss/src/style-settings.js","../../shadycss/src/common-regex.js","../../shadycss/src/unscoped-style-handler.js","../../shadycss/src/style-util.js","../../shadycss/src/style-transformer.js","../../shadycss/src/scoping-shim.js","../../shadycss/src/document-watcher.js","../../shadycss/src/style-properties.js","../../shadycss/src/style-info.js","../../shadycss/src/style-placeholder.js","../../shadycss/src/style-cache.js","../../shadycss/src/template-map.js","../../shadycss/src/apply-shim-utils.js","../../shadycss/src/common-utils.js","../../shadycss/entrypoints/scoping-shim.js"],"names":["$jscomp.arrayIteratorImpl","$jscomp.global","ShadyData","toJSON","ensureShadyDataForNode","node","__shady","shadyDataForNode","settings","window","hasNativeShadowDOM","attachShadow","Element","prototype","getRootNode","Node","desc","Object","getOwnPropertyDescriptor","hasDescriptors","configurable","get","inUse","noPatch","preferPerformance","patchOnDemand","IS_IE","navigator","userAgent","match","isTrackingLogicalChildNodes","nodeData","undefined","firstChild","isShadyRoot","obj","ShadowRoot","hasShadowRootWithSlot","root","_hasInsertionPoint","p","matches","matchesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector","webkitMatchesSelector","twiddle","document","createTextNode","content","queue","observe","MutationObserver","length","shift","e","textContent","characterData","microtask","callback","push","documentContains","contains","doc","documentElement","container","createPolyfilledHTMLCollection","nodes","l","name","getAttribute","isNaN","item","nodes.item","index","namedItem","nodes.namedItem","$jscomp.makeIterator","nativeChildNodesArray","parent","result","n","childNodesArray","patchProperty","proto","descriptor","value","defineProperty","patchProperties","descriptors","prefix","disallowedPatches","indexOf","patchExistingProperties","getOwnPropertyDescriptors","getOwnPropertyNames","forEach","assign","target","source","names","i","flushList","scheduled","enqueue","flush","didFlush","constructor","AsyncObserver","_scheduled","addedNodes","removedNodes","callbacks","Set","schedule","mutations","takeRecords","cb","observeChildren","sd","observer","add","_callback","_observer","_node","unobserveChildren","handle","delete","size","filterMutations","targetRootNode","map","mutation","mutationInScope","slice","call","filter","create","m","escapeAttrRegExp","escapeDataRegExp","escapeReplace","c","makeSet","arr","set","voidElements","plaintextParents","getInnerHTML","localName","s","c$","childNodes","child","nodeType","ELEMENT_NODE","tagName","attrs","attributes","attr","replace","TEXT_NODE","data","parentNode","COMMENT_NODE","console","error","Error","nativeMethods","querySelector","selector","querySelectorAll","nativeTree","installNativeAccessor","NATIVE_PREFIX","defineNativeAccessors","prop","copyProperties","list","nodeWalker","createTreeWalker","NodeFilter","SHOW_ALL","elementWalker","SHOW_ELEMENT","inertDoc","implementation","createHTMLDocument","clearNode","ParentNodeAccessors","ParentNodeMethods","addNativePrefixedProperties","eventProps","EventTarget","Window","currentNode","lastChild","previousSibling","nextSibling","parentElement","DOCUMENT_FRAGMENT_NODE","textWalker","SHOW_TEXT","nextNode","nodeValue","HTMLElement","ParentNodeWalkerDescriptors","firstElementChild","lastElementChild","children","childElementCount","previousElementSibling","nextElementSibling","innerHTML","containerName","htmlContainer","namespaceURI","createElementNS","createElement","newContent","className","setAttribute","HTMLTemplateElement","DocumentFragment","Document","InsideDescriptors","shadowRoot","TextContentInnerHTMLDescriptors","OutsideDescriptors","makeNonEnumerable","enumerable","noInstancePatching","patchOutsideElementAccessors","element","__outsideAccessors","patchInsideElementAccessors","__insideAccessors","customElements","eventWrappersName","Date","now","composedGetter","composedProp","Event","ev","supportsEventOptions","listener","supported","eventOptions","capture","addEventListener","removeEventListener","parseEventOptions","optionsOrCapture","once","passive","shadyTarget","__shadyTarget","nativeEventOptions","alwaysComposed","unpatchedEvents","getRootNodeWithFallback","eventTarget","pathComposer","startNode","composed","composedPath","current","startRoot","host","event","__composedPath","retarget","refNode","path","refNodePath","ancestor","lastRoot","rootIdx","mixinComposedFlag","Base","klazz","type","options","__composed","__proto__","nonBubblingEventsToRetarget","hasRetargeted","__relatedTarget","relatedTarget","fireHandlers","phase","hs","__handlers","fn","__immediatePropagationStopped","shadyDispatchEvent","retargetedPath","bubbles","currentTarget","eventPhase","CAPTURING_PHASE","AT_TARGET","__propagationStopped","atTarget","BUBBLING_PHASE","findListener","wrappers","savedType","savedListener","savedCapture","savedOnce","savedPassive","savedNode","dispatchEvent","patchEvent","fnOrObj","handlerType","handleEvent","wrapperFn","lastCurrentTargetDesc","lastEventPhaseDesc","stopImmediatePropagation","ret","idx","splice","activateFocusEventOverrides","EventPatchesDescriptors","EventPatches","isTrusted","__relatedTargetComposedPath","stopPropagation","getPrototypeOf","hasOwnProperty","SHADY_PROTO","patchedProto","PatchedEvent","PatchedCustomEvent","CustomEvent","PatchedMouseEvent","MouseEvent","patchClick","composedClickFn","cancelable","click","eventPropertyNamesForElement","substring","eventPropertyNamesForHTMLElement","wrappedDescriptorForEventProperty","property","shadyData","eventName","__onCallbackListeners","newSplice","addedCount","removed","calcSplices","currentEnd","old","oldEnd","currentStart","oldStart","prefixCount","suffixCount","minLength","Math","min","currentValue","previousValue","index1","index2","count","equals","rowCount","columnCount","distances","Array","j","north","west","edits","EDIT_ADD","EDIT_DELETE","northWest","EDIT_LEAVE","EDIT_UPDATE","reverse","splices","oldIndex","EventTargetPatches","scopingShim","getScopingShim","scopeClassAttribute","removeShadyScoping","currentScopeName","currentScopeIsCorrect","newScopeName","correctScope","currentScope","currentScopeForNode","treeVisitor","visitorFn","nativeIsConnectedAccessors","nativeIsConnected","removeOwnerShadyRoot","ownerShadyRoot","firstComposedNode","flattened","flattenedNodes","scheduleObserver","addedNode","removedNode","NodePatches","childNodes.item","isConnected","ownerDocument","tc","join","insertBefore","ref_node","refData","slotsAdded","ownerRoot","ownerShadyRootForNode","oldScopeName","skipUnscoping","allowNativeInsert","needsScoping","needsSlotFinding","_ensureSlotData","_pendingSlots","$jscomp.arrayFromIterator","_asyncRender","recordInsertBefore","parentData","adoptNode","appendChild","removeChild","removingInsertionPoint","_removeContainedSlots","recordRemoveChild","preventNativeRemove","changeSlotContent","replaceChild","cloneNode","deep","ATTRIBUTE_NODE","nc","SlotablePatches","assignedSlot","_render","query","matcher","halter","queryChildNodes","ParentNodePatches","QueryPatches","useNative","o","ParentNodeDocumentOrFragmentPatches","distributeAttributeChange","_slotList","_validateSlots","oldName","__slotName","_nameForSlot","slots","_slotMap","_sortSlots","ElementPatches","slot","removeAttribute","ElementShadowPatches","_init","recordChildNodes","ShadyRoot","ShadyRootConstructionToken","publicRoot","ElementOrShadowRootPatches","HTMLElementPatches","blur","shadowActive","activeElement","SlotPatches","assignedNodes","flatten","DocumentOrFragmentPatches","getElementById","id","DocumentOrShadowRootPatches","active","activeRoot","DocumentPatches","importNode","WindowPatches","bind","NonStandardHTMLElement","patchMap","Text","Comment","CDATASection","ProcessingInstruction","HTMLSlotElement","disallowedNativePatches","applyPatchList","disallowed","patch","applyPatches","ctor","patchElementProto","patchNode","nativeProto","PATCHED_PROTO","setPrototypeOf","OutsideAccessors","InsideAcccessors","linkNode","containerData","ref_nodeData","psd","nsd","first","adoptedParent","previous","ShadowRootPatches","patchShadyAccessors","isRendering","readyState","rootRendered","ancestorList","ancestors","unshift","token","TypeError","mode","hostData","MODE_CLOSED","rootData","_renderPending","renderRoot","__childSlotCount","_renderSelf","wasRendering","_distribute","slotData","n$","_previouslyAssignedNodes","_prevAssignedSlot","_distributeNodeToSlot","slotParentRoot","slotParentData","_addAssignedToFlattenedNodes","prevAssignedNodes","dirty","_fireSlotChange","_compose","composeList","targetNode","distributedNode","d","next","_hasRendered","forcedSlot","oldSlot","CATCHALL_NAME","assigned","nestedAssigned","slotNamesToSort","slotParent","_mapSlots","sort","a","b","listA","listB","nA","nB","x","didRemove","patchShadyRoot","SHADY_PREFIX","defineProperties","nodeName","define","connectMap","Map","r","v","k","clear","ManageConnect","base","connected","disconnected","counter","connectFlag","connectedCallback","disconnectedCallback","originalDefine","Wrapper","?.prototype","focus","DOCUMENT_NODE","$jscomp.global.Object.defineProperties","_activeElement","addEventPropertyWrapper","wrapperMap","WeakMap","wrap","wrapper","ShadyDOM","flushInitial","Document_createElement","Document_createElementNS","Document_importNode","Document_prepend","Document_append","DocumentFragment_prepend","DocumentFragment_append","Node_cloneNode","Node_appendChild","Node_insertBefore","Node_removeChild","Node_replaceChild","Node_textContent","Element_attachShadow","Element_innerHTML","Element_getAttribute","Element_setAttribute","Element_removeAttribute","Element_getAttributeNS","getAttributeNS","Element_setAttributeNS","setAttributeNS","Element_removeAttributeNS","removeAttributeNS","Element_insertAdjacentElement","Element_insertAdjacentHTML","Element_prepend","Element_append","Element_before","Element_after","Element_replaceWith","Element_remove","HTMLElement_innerHTML","HTMLElement_insertAdjacentElement","HTMLElement_insertAdjacentHTML","reservedElementNameSet","isValidCustomElementName","reserved","has","validForm","test","nativeContains","nativeValue","__CE_isImportDocument","childrenFromFragment","fragment","nativeChildren","nextSiblingOrAncestorSibling","start","walkDeepDescendantElements","visitedImports","import","__CE_shadowRoot","CustomElementInternals","noDocumentConstructionObserver","priorCustomElements","shadyDomFastWalk","_patchesNode","_patchesElement","_hasPatches","useDocumentConstructionObserver","forEachElement","elements","addNodePatch","addElementPatch","patchTree","patchElement","__CE_patched","connectTree","custom","__CE_state","upgradeReaction","disconnectTree","patchAndUpgradeTree","upgrade","gatherElements","__CE_registry","__CE_documentLoadHandled","clonedVisitedImports","registry","defaultView","internal_localNameToDefinition","definition","constructionStack","constructorFunction","pop","failed","__CE_definition","attributeChangedCallback","hasAttributes","observedAttributes","_upgradeAnElement","reportTheException","oldValue","newValue","namespace","createAnElement","NS_HTML","HTMLUnknownElement","message","filename","sourceURL","fileName","lineno","line","lineNumber","colno","column","columnNumber","ErrorEvent","initErrorEvent","createEvent","preventDefault","event.preventDefault","defaultPrevented","Deferred","_value","_promise","Promise","resolve","_resolve","DocumentConstructionObserver","internals","_internals","_document","_handleMutations","childList","subtree","disconnect","CustomElementRegistry","_localNameToConstructorGetter","_localNameToDefinition","_constructorToDefinition","_elementDefinitionIsRunning","_whenDefinedDeferred","_flushCallback","this._flushCallback","_flushPending","_unflushedLocalNames","_documentConstructionObserver","polyfillDefineLazy","constructorGetter","Function","internal_assertCanDefineLocalName","_flush","internal_reifyDefinition","SyntaxError","getCallback","callbackValue","adoptedCallback","elementsWithStableDefinitions","unflushedLocalNames","elementsWithPendingDefinitions","pendingElements","pendingUpgradableElements","deferred","whenDefined","reject","prior","anyDefinitionExists","definitionHasFlushed","polyfillWrapFlushCallback","outer","inner","existingDefinition","destination","builtIn","appendPrependPatch","builtInMethod","connectedElements","apply","prepend","append","Document.prototype.createElement","Document.prototype.importNode","clone","Document.prototype.createElementNS","PatchParentNode","beforeAfterPatch","before","after","replaceWith","destination.replaceWith","wasConnected","remove","destination.remove","patch_innerHTML","baseDescriptor","htmlString","removedElements","patch_insertAdjacentElement","baseMethod","insertAdjacentElement","destination.insertAdjacentElement","position","insertedElement","patch_insertAdjacentHTML","upgradeNodesInRange","end","insertAdjacentHTML","destination.insertAdjacentHTML","text","strPosition","toLowerCase","marker","String","Element.prototype.attachShadow","init","assignedValue","isTemplate","rawElement","Element.prototype.setAttribute","Element.prototype.setAttributeNS","Element.prototype.removeAttribute","Element.prototype.removeAttributeNS","PatchChildNode","alreadyConstructedMarker","PatchedHTMLElement","lastIndex","writable","patch_textContent","childNodesLength","Node.prototype.insertBefore","insertedNodes","nativeResult","nodeWasConnectedElement","Node.prototype.appendChild","Node.prototype.cloneNode","Node.prototype.removeChild","Node.prototype.replaceChild","nodeToInsert","nodeToRemove","nodeToInsertWasConnectedElement","thisIsConnected","parts","installPolyfill","PatchHTMLElement","PatchDocument","PatchNode","PatchElement","StyleNode","parse","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.comments","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.port","OPEN_BRACE","CLOSE_BRACE","parseCss","t","trim","ss","_expandUnicodeEscapes","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.multipleSpaces","lastIndexOf","AT_START","MEDIA_START","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.MEDIA_RULE","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.keyframesRule","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.KEYFRAMES_RULE","split","VAR_START","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.MIXIN_RULE","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.STYLE_RULE","r$","code","repeat","stringify","preserveProperties","cssText","rules","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.customProp","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.mixinProp","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.mixinApply","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.varApply","STYLE_RULE","KEYFRAMES_RULE","MEDIA_RULE","MIXIN_RULE","comments","port","customProp","mixinProp","mixinApply","varApply","keyframesRule","multipleSpaces","nativeShadow","nativeCssVariables_","calcCssVariables","CSS","supports","cssBuild","ShadyCSS","disableRuntime","nativeCss","nativeCssVariables","VAR_ASSIGN","MIXIN_MATCH","VAR_CONSUMED","ANIMATION_MATCH","MEDIA_MATCH","BRACKETED","styleTextSet","toCssText","forEachRule","rulesForStyle","style","isKeyframesSelector","rule","styleRuleCallback","keyframesRuleCallback","onlyActiveRules","skipRules","matchMedia","applyCss","moniker","contextNode","applyStyle","lastHeadApplyNode","applyStylePlaceHolder","placeHolder","createComment","scope","head","compareDocumentPosition","DOCUMENT_POSITION_PRECEDING","findMatchingParen","level","processVariableAndFallback","str","suffix","comma","fallback","setElementClassRaw","getIsExtends","typeExtension","is","extends","splitSelectorList","part","getCssBuild","__cssBuild","attrValue","CSS_BUILD_ATTR","buildComment","commentParts","isOptimalCssBuild","StyleTransformer","domAddScope","_transformDom","transformer","_content","shouldRemoveScope","classList","SCOPE_NAME","CLASS","domReplaceScope","oldScope","newScope","domRemoveScope","elementStyles","styleRules","css","ext","hostScope","_calcHostScope","CSS_CLASS_PREFIX","isScoped","transformedSelector","_transformRuleCss","self","_transformComplexSelector","p$","COMPLEX_SELECTOR_SEP","_twiddleNthPlus","NTH","inside","_preserveMatchesPseudo","MATCHES","input","MATCHES_REPLACEMENT","_replaceMatchesPseudo","reduce","acc","cur","stop","isNth","isMatches","SLOTTED_START","SIMPLE_SELECTOR_SEP","info","_transformCompoundSelector","combinator","DIR_PAREN","dir","slottedIndex","SLOTTED","HOST","_transformHostSelector","_transformSimpleSelector","slotted","SLOTTED_PAREN","paren","output","PSEUDO_PREFIX","HOST_PAREN","SIMPLE_SELECTOR_PREFIX","typeSelector","SELECTOR_NO_MATCH","normalizeRootSelector","ROOT","_transformDocumentSelector","SCOPE_DOC_SELECTOR","$jscompDefaultExport","StyleInfo","ast","placeholder","ownStylePropertyNames","overrideStyleProperties","customStyle","scopeSelector","styleProperties","styleInfo","_getStyleRules","method","rootSelector","StyleProperties","decorateStyles","props","keyframes","ruleIndex","decorateRule","propertyInfo","exec","onKeyframesRule","_keyframes","properties","collectProperties","hasProperties","any","valueForProperty","valueForProperties","propertyValue","colon","pp","propertyDataFromStyles","selectorToMatch","parseInt","key","whenHostOrRootRule","parsedSelector","isHost","isRoot","hostAndRootPropertiesForScope","hostProps","rootProps","_element","transformStyles","hostSelector","hostRx","RegExp","HOST_PREFIX","rxHostSelector","HOST_SUFFIX","StyleInfo$$module$node_modules$$webcomponents$shadycss$src$style_info.get","keyframeTransforms","_elementKeyframeTransforms","hasAnimations","keyframeNamesToTransform","keyframe","transform","keyframesRules","keyframesNameRx","transformedKeyframesName","scopeId","_keyframesRuleTransformer","applyCustomStyle","XSCOPE_NAME","placeholderMap","ce","origDefine","wrappedDefine","clazz","StyleCache","cache","store","tagname","styleElement","typeMax","scopeRegExp","getCurrentScope","getOwnerScope","handler","mxns","mxn","unscopedNodes","unscopedNode","scopeForPreviouslyUnscopedNode","delayedStart","body","requestAnimationFrame","templateMap","promise","invalidate","elementName","template","templateIsValid","startValidatingTemplate","_validating","then","adoptedCssTextMap","styleCache","ScopingShim","_scopeCounter","_documentOwner","_documentOwnerStyleInfo","StyleInfo$$module$node_modules$$webcomponents$shadycss$src$style_info.set","_elementsHaveApplied","_customStyleInterface","_applyShim","watcherFlush","getStyleAst","styleAstToString","prepareTemplate","prepareTemplateDom","prepareTemplateStyles","_prepared","optimalBuild","styleTextParts","styles","hasAttribute","scopingAttribute","newStyle","_ensure","hasMixins","ownPropertyNames","shadowroot","_style","_ownPropertyNames","prepareAdoptedCssText","cssTextArray","_domPrepared","_prepareHost","_ensureCustomStyleInterface","CustomStyleInterface","transformCustomStyleForDocument","flushCustomStyles","_ensureApplyShim","ApplyShim","needsApplyShimUpdate","customStyles","_revalidateCustomStyleApplyShim","_reorderCustomStylesRules","_updateProperties","_applyCustomStyles","styleDocument","DOCUMENT_POSITION_FOLLOWING","overrideProps","styleElementNativeVariables","_isRootOwner","styleElementShimVariables","cacheEntry","entry","pn","cachedStyle","oldScopeSelector","cachedScopeSelector","applyElementStyle","removeProperty","setProperty","_styleOwnerForNode","owner","ownerStyleInfo","ownerProperties","hostAndRootProps","propertiesMatchingHost","propertyData","overrides","reify","styleSubtree","wrappedHost","isRootOwner","descendantRoot","descendantHosts","from","documentRule","_transformRule","getComputedStyleValue","getComputedStyle","getPropertyValue","setElementClass","classString","classes","definitelyString","scopeName","classAttr","k$","_styleInfoForNode","scopeNode","unscopeNode","scopeForNode","elementExtends"],"mappings":"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","file":"webcomponents-sd-ce.js","sourcesContent":["/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n\nexport class ShadyData {\n\n  /** @override */\n  toJSON() {\n    return {};\n  }\n}\n\nexport function ensureShadyDataForNode(node) {\n  if (!node.__shady) {\n    node.__shady = new ShadyData();\n  }\n  return node.__shady;\n}\n\nexport function shadyDataForNode(node) {\n  return node && node.__shady;\n}\n",null,null,null,null,"/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport {shadyDataForNode} from './shady-data.js';\n\n/** @type {!Object} */\nexport const settings = window['ShadyDOM'] || {};\n\nsettings.hasNativeShadowDOM = Boolean(Element.prototype.attachShadow && Node.prototype.getRootNode);\n\n// The user might need to pass the custom elements polyfill a flag by setting an\n// object to `customElements`, so check for `customElements.define` also.\nexport const hasCustomElements =\n    () => Boolean(window.customElements && window.customElements.define);\n// The custom elements polyfill is typically loaded after Shady DOM, so this\n// check isn't reliable during initial evaluation. However, because the\n// polyfills are loaded immediately after one another, it works at runtime.\nexport const hasPolyfilledCustomElements =\n    () => Boolean(window.customElements && window.customElements['polyfillWrapFlushCallback']);\n\nconst desc = Object.getOwnPropertyDescriptor(Node.prototype, 'firstChild');\n\n/* eslint-disable */\nsettings.hasDescriptors = Boolean(desc && desc.configurable && desc.get);\nsettings.inUse = settings['force'] || !settings.hasNativeShadowDOM;\nsettings.noPatch = /** @type {string|boolean} */(settings['noPatch'] || false);\nsettings.preferPerformance = settings['preferPerformance'];\nsettings.patchOnDemand = (settings.noPatch === 'on-demand');\n/* eslint-enable */\n\nconst IS_IE = navigator.userAgent.match('Trident');\nsettings.IS_IE = IS_IE;\n\nexport const canUpgrade = () => !settings.IS_IE;\n\nexport const isTrackingLogicalChildNodes = (node) => {\n  const nodeData = shadyDataForNode(node);\n  return (nodeData && nodeData.firstChild !== undefined);\n}\n\nexport const isShadyRoot = obj => obj instanceof ShadowRoot;\n\nexport const hasShadowRootWithSlot = (node) => {\n  const nodeData = shadyDataForNode(node);\n  let root = nodeData && nodeData.root;\n  return (root && root._hasInsertionPoint());\n}\n\nlet p = Element.prototype;\nlet matches = p.matches || p.matchesSelector ||\n  p.mozMatchesSelector || p.msMatchesSelector ||\n  p.oMatchesSelector || p.webkitMatchesSelector;\n\nexport const matchesSelector = (element, selector) => {\n  return matches.call(element, selector);\n}\n\nexport const mixin = (target, source) => {\n  for (var i in source) {\n    target[i] = source[i];\n  }\n  return target;\n}\n\n// NOTE, prefer MutationObserver over Promise for microtask timing\n// for consistency x-platform.\nlet twiddle = document.createTextNode('');\nlet content = 0;\nlet queue = [];\nnew MutationObserver(() => {\n  while (queue.length) {\n    // catch errors in user code...\n    try {\n      queue.shift()();\n    } catch(e) {\n      // enqueue another record and throw\n      twiddle.textContent = content++;\n      throw(e);\n    }\n  }\n}).observe(twiddle, {characterData: true});\n\n// use MutationObserver to get microtask async timing.\nexport const microtask = (callback) => {\n  queue.push(callback);\n  twiddle.textContent = content++;\n}\n\n/** @type {function(!Document, !Node): boolean} */\nexport const documentContains = (() => {\n  if (document.contains) {\n    return (doc, node) => doc[NATIVE_PREFIX + 'contains'](node);\n  } else {\n    return (doc, node) => (\n      doc === node ||\n      (doc.documentElement && doc.documentElement[NATIVE_PREFIX + 'contains'](node))\n    );\n  }\n})();\n\nexport const contains = (container, node) => {\n  while (node) {\n    if (node == container) {\n      return true;\n    }\n    node = node[SHADY_PREFIX + 'parentNode'];\n  }\n  return false;\n}\n\nconst getNodeHTMLCollectionName = (node) =>\n    node.getAttribute('id') || node.getAttribute('name');\n\nconst isValidHTMLCollectionName = (name) => name !== 'length' && isNaN(name);\n\nexport const createPolyfilledHTMLCollection = (nodes) => {\n  // Note: loop in reverse so that the first named item matches the named property\n  for (let l = nodes.length - 1; l >= 0; l--) {\n    const node = nodes[l];\n    const name = getNodeHTMLCollectionName(node);\n\n    if (name && isValidHTMLCollectionName(name)) {\n      nodes[name] = node;\n    }\n  }\n  nodes.item = function(index) {\n    return nodes[index];\n  }\n  nodes.namedItem = function(name) {\n    if (isValidHTMLCollectionName(name) && nodes[name]) {\n      return nodes[name];\n    }\n\n    for (const node of nodes) {\n      const nodeName = getNodeHTMLCollectionName(node);\n\n      if (nodeName == name) {\n        return node;\n      }\n    }\n\n    return null;\n  };\n  return nodes;\n}\n\nexport const NATIVE_PREFIX = '__shady_native_';\nexport const SHADY_PREFIX = '__shady_';\n\nexport const nativeChildNodesArray = (parent) => {\n  const result = [];\n  for (let n=parent[NATIVE_PREFIX + 'firstChild']; n; n = n[NATIVE_PREFIX + 'nextSibling']) {\n    result.push(n);\n  }\n  return result;\n}\n\nexport const childNodesArray = (parent) => {\n  const result = [];\n  for (let n=parent[SHADY_PREFIX + 'firstChild']; n; n = n[SHADY_PREFIX + 'nextSibling']) {\n    result.push(n);\n  }\n  return result;\n}\n\nconst patchProperty = (proto, name, descriptor) => {\n  descriptor.configurable = true;\n  // NOTE: we prefer writing directly because some browsers\n  // have descriptors that are writable but not configurable (e.g.\n  // `appendChild` on older browsers)\n  if (descriptor.value) {\n    proto[name] = descriptor.value;\n  } else {\n    try {\n      Object.defineProperty(proto, name, descriptor);\n    } catch(e) {\n      // this error is harmless so we just trap it.\n    }\n  }\n}\n\n/**\n * Patch a group of accessors on an object. By default this overrides\n * @param {!Object} proto\n * @param {!Object} descriptors\n * @param {string=} prefix\n * @param {Array=} disallowedPatches\n */\nexport const patchProperties = (proto, descriptors, prefix = '', disallowedPatches) => {\n  for (let name in descriptors) {\n    if (disallowedPatches && disallowedPatches.indexOf(name) >= 0) {\n      continue;\n    }\n    patchProperty(proto,  prefix + name, descriptors[name]);\n  }\n}\n\nexport const patchExistingProperties = (proto, descriptors) => {\n  for (let name in descriptors) {\n    if (name in proto) {\n      patchProperty(proto,  name, descriptors[name]);\n    }\n  }\n}\n\n// note, this is not a perfect polyfill since it doesn't include symbols\n/** @return {!Object<!ObjectPropertyDescriptor>} */\nexport const getOwnPropertyDescriptors = (obj) => {\n  const descriptors = {};\n  Object.getOwnPropertyNames(obj).forEach((name) => {\n    descriptors[name] = Object.getOwnPropertyDescriptor(obj, name);\n  });\n  return descriptors;\n};\n\nexport const assign = (target, source) => {\n  const names = Object.getOwnPropertyNames(source);\n  for (let i = 0, p; i < names.length; i++) {\n    p = names[i];\n    target[p] = source[p];\n  }\n};\n\nexport const arrayFrom = (object) => {\n  return [].slice.call(/** @type {IArrayLike} */(object));\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 = utils.arrayFrom(mutation.addedNodes).filter(function(n) {\n        return (targetRootNode === n.getRootNode());\n      });\n      if (nodes.length) {\n        mutation = Object.create(mutation);\n        Object.defineProperty(mutation, 'addedNodes', {\n          value: nodes,\n          configurable: true\n        });\n        return mutation;\n      }\n    } else if (mutationInScope) {\n      return mutation;\n    }\n  }).filter(function(m) { return m});\n}\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n// Cribbed from ShadowDOM polyfill\n// https://github.com/webcomponents/webcomponentsjs/blob/master/src/ShadowDOM/wrappers/HTMLElement.js#L28\n/////////////////////////////////////////////////////////////////////////////\n// innerHTML and outerHTML\n\n// http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#escapingString\nlet escapeAttrRegExp = /[&\\u00A0\"]/g;\nlet escapeDataRegExp = /[&\\u00A0<>]/g;\n\nfunction escapeReplace(c) {\n  switch (c) {\n    case '&':\n      return '&amp;';\n    case '<':\n      return '&lt;';\n    case '>':\n      return '&gt;';\n    case '\"':\n      return '&quot;';\n    case '\\u00A0':\n      return '&nbsp;';\n  }\n}\n\nfunction escapeAttr(s) {\n  return s.replace(escapeAttrRegExp, escapeReplace);\n}\n\nfunction escapeData(s) {\n  return s.replace(escapeDataRegExp, escapeReplace);\n}\n\nfunction makeSet(arr) {\n  let set = {};\n  for (let i = 0; i < arr.length; i++) {\n    set[arr[i]] = true;\n  }\n  return set;\n}\n\n// http://www.whatwg.org/specs/web-apps/current-work/#void-elements\nlet voidElements = makeSet([\n  'area',\n  'base',\n  'br',\n  'col',\n  'command',\n  'embed',\n  'hr',\n  'img',\n  'input',\n  'keygen',\n  'link',\n  'meta',\n  'param',\n  'source',\n  'track',\n  'wbr'\n]);\n\nlet plaintextParents = makeSet([\n  'style',\n  'script',\n  'xmp',\n  'iframe',\n  'noembed',\n  'noframes',\n  'plaintext',\n  'noscript'\n]);\n\n/**\n * @param {Node} node\n * @param {Node} parentNode\n * @param {Function=} callback\n */\nexport function getOuterHTML(node, parentNode, callback) {\n  switch (node.nodeType) {\n    case Node.ELEMENT_NODE: {\n      let tagName = node.localName;\n      let s = '<' + tagName;\n      let attrs = node.attributes;\n      for (let i = 0, attr; (attr = attrs[i]); i++) {\n        s += ' ' + attr.name + '=\"' + escapeAttr(attr.value) + '\"';\n      }\n      s += '>';\n      if (voidElements[tagName]) {\n        return s;\n      }\n      return s + getInnerHTML(node, callback) + '</' + tagName + '>';\n    }\n    case Node.TEXT_NODE: {\n      let data = /** @type {Text} */ (node).data;\n      if (parentNode && plaintextParents[parentNode.localName]) {\n        return data;\n      }\n      return escapeData(data);\n    }\n    case Node.COMMENT_NODE: {\n      return '<!--' + /** @type {Comment} */ (node).data + '-->';\n    }\n    default: {\n      window.console.error(node);\n      throw new Error('not implemented');\n    }\n  }\n}\n\n/**\n * @param {Node} node\n * @param {Function=} callback\n */\nexport function getInnerHTML(node, callback) {\n  if (node.localName === 'template') {\n    node =  /** @type {HTMLTemplateElement} */ (node).content;\n  }\n  let s = '';\n  let c$ = callback ? callback(node) : node.childNodes;\n  for (let i=0, l=c$.length, child; (i<l) && (child=c$[i]); i++) {\n    s += getOuterHTML(child, node, callback);\n  }\n  return s;\n}\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport * as utils from './utils.js';\nimport {patchProperties} from './utils.js';\nimport {getInnerHTML} from './innerHTML.js';\n\nconst hasDescriptors = utils.settings.hasDescriptors;\nexport const NATIVE_PREFIX = utils.NATIVE_PREFIX;\n\n// Object on which raw native methods are stored.\n// e.g. `nativeMethods.querySelector.call(node, selector)`\n// same as `node.querySelector(selector)`\nexport const nativeMethods = {\n  /** @this {Element} */\n  querySelector(selector) {\n    return this[NATIVE_PREFIX + 'querySelector'](selector);\n  },\n  /** @this {Element} */\n  querySelectorAll(selector) {\n    return this[NATIVE_PREFIX + 'querySelectorAll'](selector);\n  }\n};\n// Object on which raw native accessors are available via `accessorName(node)`.\n// e.g. `nativeTree.firstChild(node)`\n// same as `node.firstChild`\nexport const nativeTree = {};\n\nconst installNativeAccessor = (name) => {\n  nativeTree[name] = (node) => node[NATIVE_PREFIX + name];\n}\n\nconst installNativeMethod = (name, fn) => {\n  if (!nativeMethods[name]) {\n    nativeMethods[name] = fn;\n  }\n}\n\n\nconst defineNativeAccessors = (proto, descriptors) => {\n  patchProperties(proto, descriptors, NATIVE_PREFIX);\n  // make native accessors available to users\n  for (let prop in descriptors) {\n    installNativeAccessor(prop);\n  }\n}\n\nconst copyProperties = (proto, list = []) => {\n  for (let i = 0; i < list.length; i++) {\n    const name = list[i];\n    const descriptor = Object.getOwnPropertyDescriptor(proto, name);\n    if (descriptor) {\n      Object.defineProperty(proto, NATIVE_PREFIX + name, descriptor);\n      // make native methods/accessors available to users\n      if (descriptor.value) {\n        installNativeMethod(name, descriptor.value);\n      } else {\n        installNativeAccessor(name);\n      }\n    }\n  }\n}\n\n/** @type {!TreeWalker} */\nconst nodeWalker = document.createTreeWalker(document, NodeFilter.SHOW_ALL,\n  null, false);\n\n/** @type {!TreeWalker} */\nconst elementWalker = document.createTreeWalker(document, NodeFilter.SHOW_ELEMENT,\n  null, false);\n\n/** @type {!Document} */\nconst inertDoc = document.implementation.createHTMLDocument('inert');\n\nconst clearNode = node => {\n  let firstChild;\n  while ((firstChild = node[NATIVE_PREFIX + 'firstChild'])) {\n    node[NATIVE_PREFIX + 'removeChild'](firstChild);\n  }\n}\n\nconst ParentNodeAccessors = [\n  'firstElementChild',\n  'lastElementChild',\n  'children',\n  'childElementCount',\n];\n\nconst ParentNodeMethods = [\n  'querySelector',\n  'querySelectorAll'\n  // 'append', 'prepend'\n];\n\nexport const addNativePrefixedProperties = () => {\n\n  // EventTarget\n  const eventProps = [\n    'dispatchEvent',\n    'addEventListener',\n    'removeEventListener'\n  ];\n  if (window.EventTarget) {\n    copyProperties(window.EventTarget.prototype, eventProps);\n  } else {\n    copyProperties(Node.prototype, eventProps);\n    copyProperties(Window.prototype, eventProps);\n  }\n\n\n  // Node\n  if (hasDescriptors) {\n    copyProperties(Node.prototype, [\n      'parentNode',\n      'firstChild',\n      'lastChild',\n      'previousSibling',\n      'nextSibling',\n      'childNodes',\n      'parentElement',\n      'textContent',\n    ]);\n  } else {\n    defineNativeAccessors(Node.prototype, {\n      parentNode: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.parentNode();\n        }\n      },\n      firstChild: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.firstChild();\n        }\n      },\n      lastChild: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.lastChild();\n        }\n\n      },\n      previousSibling: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.previousSibling();\n        }\n      },\n      nextSibling: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.nextSibling();\n        }\n      },\n      // TODO(sorvell): make this a NodeList or whatever\n      childNodes: {\n        /** @this {Node} */\n        get() {\n          const nodes = [];\n          nodeWalker.currentNode = this;\n          let n = nodeWalker.firstChild();\n          while (n) {\n            nodes.push(n);\n            n = nodeWalker.nextSibling();\n          }\n          return nodes;\n        }\n      },\n      parentElement: {\n        /** @this {Node} */\n        get() {\n          elementWalker.currentNode = this;\n          return elementWalker.parentNode();\n        }\n      },\n      textContent: {\n        /** @this {Node} */\n        get() {\n          /* eslint-disable no-case-declarations */\n          switch (this.nodeType) {\n            case Node.ELEMENT_NODE:\n            case Node.DOCUMENT_FRAGMENT_NODE:\n              // TODO(sorvell): This cannot be a single TreeWalker that's reused\n              // at least for Safari 9, but it's unclear why.\n              const textWalker = document.createTreeWalker(this, NodeFilter.SHOW_TEXT,\n                null, false);\n              let content = '', n;\n              while ( (n = textWalker.nextNode()) ) {\n                // TODO(sorvell): can't use textContent since we patch it on Node.prototype!\n                // However, should probably patch it only on element.\n                content += n.nodeValue;\n              }\n              return content;\n            default:\n              return this.nodeValue;\n          }\n        },\n        // Needed on browsers that do not proper accessors (e.g. old versions of Chrome)\n        /** @this {Node} */\n        set(value) {\n          if (typeof value === 'undefined' || value === null) {\n            value = ''\n          }\n          switch (this.nodeType) {\n            case Node.ELEMENT_NODE:\n            case Node.DOCUMENT_FRAGMENT_NODE:\n              clearNode(this);\n              // Document fragments must have no childnodes if setting a blank string\n              if (value.length > 0 || this.nodeType === Node.ELEMENT_NODE) {\n                // Note: old Chrome versions require 2nd argument here\n                this[NATIVE_PREFIX + 'insertBefore'](document.createTextNode(value), undefined);\n              }\n              break;\n            default:\n              // TODO(sorvell): can't do this if patch nodeValue.\n              this.nodeValue = value;\n              break;\n          }\n        }\n      }\n    });\n  }\n\n  copyProperties(Node.prototype, [\n    'appendChild',\n    'insertBefore',\n    'removeChild',\n    'replaceChild',\n    'cloneNode',\n    'contains'\n  ]);\n\n  // NOTE, on some browsers IE 11 / Edge 15 some properties are incorrectly on HTMLElement\n  copyProperties(HTMLElement.prototype, [\n    'parentElement',\n    'contains'\n  ]);\n\n  const ParentNodeWalkerDescriptors = {\n    firstElementChild: {\n      /** @this {ParentNode} */\n      get() {\n        elementWalker.currentNode = this;\n        return elementWalker.firstChild();\n      }\n    },\n    lastElementChild: {\n      /** @this {ParentNode} */\n      get() {\n        elementWalker.currentNode = this;\n        return elementWalker.lastChild();\n      }\n    },\n    children: {\n      /** @this {ParentNode} */\n      get() {\n        let nodes = [];\n        elementWalker.currentNode = this;\n        let n = elementWalker.firstChild();\n        while (n) {\n          nodes.push(n);\n          n = elementWalker.nextSibling();\n        }\n        return utils.createPolyfilledHTMLCollection(nodes);\n      }\n    },\n    childElementCount: {\n      /** @this {ParentNode} */\n      get() {\n        if (this.children) {\n          return this.children.length;\n        }\n        return 0;\n      }\n    }\n  };\n\n  // Element\n  if (hasDescriptors) {\n    copyProperties(Element.prototype, ParentNodeAccessors);\n\n    copyProperties(Element.prototype, [\n      'previousElementSibling',\n      'nextElementSibling',\n      'innerHTML',\n      'className'\n    ]);\n\n    // NOTE, on some browsers IE 11 / Edge 15 some properties are incorrectly on HTMLElement\n    copyProperties(HTMLElement.prototype, [\n      'children',\n      'innerHTML',\n      'className'\n    ]);\n  } else {\n    defineNativeAccessors(Element.prototype, ParentNodeWalkerDescriptors);\n    defineNativeAccessors(Element.prototype, {\n      previousElementSibling: {\n        /** @this {Element} */\n        get() {\n          elementWalker.currentNode = this;\n          return elementWalker.previousSibling();\n        }\n      },\n      nextElementSibling: {\n        /** @this {Element} */\n        get() {\n          elementWalker.currentNode = this;\n          return elementWalker.nextSibling();\n        }\n      },\n      innerHTML: {\n        /** @this {Element} */\n        get() {\n          return getInnerHTML(this, utils.nativeChildNodesArray);\n        },\n        // Needed on browsers that do not proper accessors (e.g. old versions of Chrome)\n        /** @this {Element} */\n        set(value) {\n          const content = this.localName === 'template' ?\n          /** @type {HTMLTemplateElement} */(this).content : this;\n          clearNode(content);\n          const containerName = this.localName || 'div';\n          let htmlContainer;\n          if (!this.namespaceURI || this.namespaceURI === inertDoc.namespaceURI) {\n            htmlContainer = inertDoc.createElement(containerName);\n          } else {\n            htmlContainer = inertDoc.createElementNS(this.namespaceURI, containerName);\n          }\n          htmlContainer.innerHTML = value;\n          const newContent = this.localName === 'template' ?\n            /** @type {HTMLTemplateElement} */(htmlContainer).content : htmlContainer;\n          let firstChild;\n          while ((firstChild = newContent[NATIVE_PREFIX + 'firstChild'])) {\n            // Note: old Chrome versions require 2nd argument here\n            content[NATIVE_PREFIX + 'insertBefore'](firstChild, undefined);\n          }\n        }\n      },\n      className: {\n        /** @this {Element} */\n        get() {\n          return this.getAttribute('class') || '';\n        },\n        /** @this {Element} */\n        set(value) {\n          this.setAttribute('class', value);\n        }\n      }\n    });\n  }\n\n  copyProperties(Element.prototype, [\n    'setAttribute',\n    'getAttribute',\n    'hasAttribute',\n    'removeAttribute',\n    // on older Safari, these are on Element.\n    'focus',\n    'blur',\n  ]);\n  copyProperties(Element.prototype, ParentNodeMethods);\n\n  // HTMLElement\n  copyProperties(HTMLElement.prototype, [\n    'focus',\n    'blur'\n  ]);\n\n  // HTMLTemplateElement\n  if (window.HTMLTemplateElement) {\n    copyProperties(window.HTMLTemplateElement.prototype, ['innerHTML']);\n  }\n\n  // DocumentFragment\n  if (hasDescriptors) {\n    // NOTE, IE 11 does not have on DocumentFragment\n    // firstElementChild\n    // lastElementChild\n    copyProperties(DocumentFragment.prototype, ParentNodeAccessors);\n  } else {\n    defineNativeAccessors(DocumentFragment.prototype, ParentNodeWalkerDescriptors);\n  }\n\n  copyProperties(DocumentFragment.prototype, ParentNodeMethods);\n\n  // Document\n  if (hasDescriptors) {\n    copyProperties(Document.prototype, ParentNodeAccessors);\n    copyProperties(Document.prototype, [\n      'activeElement'\n    ]);\n  } else {\n    defineNativeAccessors(Document.prototype, ParentNodeWalkerDescriptors);\n  }\n\n  copyProperties(Document.prototype, [\n    'importNode',\n    'getElementById'\n  ]);\n  copyProperties(Document.prototype, ParentNodeMethods);\n\n};\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\nimport {ensureShadyDataForNode} from './shady-data.js';\n\nexport const InsideDescriptors = utils.getOwnPropertyDescriptors({\n\n  /** @this {Node} */\n  get childNodes() {\n    return this[utils.SHADY_PREFIX + 'childNodes'];\n  },\n\n  /** @this {Node} */\n  get firstChild() {\n    return this[utils.SHADY_PREFIX + 'firstChild'];\n  },\n\n  /** @this {Node} */\n  get lastChild() {\n    return this[utils.SHADY_PREFIX + 'lastChild'];\n  },\n\n  /** @this {Node} */\n  get childElementCount() {\n    return this[utils.SHADY_PREFIX + 'childElementCount'];\n  },\n\n  /** @this {Node} */\n  get children() {\n    return this[utils.SHADY_PREFIX + 'children'];\n  },\n\n  /** @this {Node} */\n  get firstElementChild() {\n    return this[utils.SHADY_PREFIX + 'firstElementChild'];\n  },\n\n  /** @this {Node} */\n  get lastElementChild() {\n    return this[utils.SHADY_PREFIX + 'lastElementChild'];\n  },\n\n  /** @this {Node} */\n  get shadowRoot() {\n    return this[utils.SHADY_PREFIX + 'shadowRoot'];\n  },\n\n});\n\nexport const TextContentInnerHTMLDescriptors = utils.getOwnPropertyDescriptors({\n  /** @this {Node} */\n  get textContent() {\n    return this[utils.SHADY_PREFIX + 'textContent'];\n  },\n\n  /** @this {Node} */\n  set textContent(value) {\n    this[utils.SHADY_PREFIX + 'textContent'] = value;\n  },\n\n  /** @this {Node} */\n  get innerHTML() {\n    return this[utils.SHADY_PREFIX + 'innerHTML'];\n  },\n\n  /** @this {Node} */\n  set innerHTML(value) {\n    return this[utils.SHADY_PREFIX + 'innerHTML'] = value;\n  },\n});\n\nexport const OutsideDescriptors = utils.getOwnPropertyDescriptors({\n\n  /** @this {Node} */\n  get parentElement() {\n    return this[utils.SHADY_PREFIX + 'parentElement'];\n  },\n\n  /** @this {Node} */\n  get parentNode() {\n    return this[utils.SHADY_PREFIX + 'parentNode'];\n  },\n\n  /** @this {Node} */\n  get nextSibling() {\n    return this[utils.SHADY_PREFIX + 'nextSibling'];\n  },\n\n  /** @this {Node} */\n  get previousSibling() {\n    return this[utils.SHADY_PREFIX + 'previousSibling'];\n  },\n\n  /** @this {Node} */\n  get nextElementSibling() {\n    return this[utils.SHADY_PREFIX + 'nextElementSibling'];\n  },\n\n  /** @this {Node} */\n  get previousElementSibling() {\n    return this[utils.SHADY_PREFIX + 'previousElementSibling'];\n  },\n\n  /** @this {Node} */\n  get className() {\n    return this[utils.SHADY_PREFIX + 'className'];\n  },\n\n  /** @this {Node} */\n  set className(value) {\n    return this[utils.SHADY_PREFIX + 'className'] = value;\n  }\n\n});\n\nconst makeNonEnumerable = (descriptors) => {\n  for (let prop in descriptors) {\n    const descriptor = descriptors[prop];\n    // NOTE, the only known reason the descriptor wouldn't exist here is\n    // if someone has patched `Object.getOwnPropertyNames`, but we've seen this\n    // so this is just to be extra safe.\n    if (descriptor) {\n      descriptor.enumerable = false;\n    }\n  }\n}\n\nmakeNonEnumerable(InsideDescriptors);\nmakeNonEnumerable(TextContentInnerHTMLDescriptors);\nmakeNonEnumerable(OutsideDescriptors);\n\nconst noInstancePatching = utils.settings.hasDescriptors || (utils.settings.noPatch === true);\n\n// ensure an element has patched \"outside\" accessors; no-op when not needed\nexport let patchOutsideElementAccessors = noInstancePatching ?\n  function() {} : function(element) {\n    const sd = ensureShadyDataForNode(element);\n    if (!sd.__outsideAccessors) {\n      sd.__outsideAccessors = true;\n      utils.patchExistingProperties(element, OutsideDescriptors);\n    }\n  }\n\n// ensure an element has patched \"inside\" accessors; no-op when not needed\nexport let patchInsideElementAccessors = noInstancePatching ?\n  function() {} : function(element) {\n    const sd = ensureShadyDataForNode(element);\n    if (!sd.__insideAccessors) {\n      sd.__insideAccessors = true;\n      utils.patchExistingProperties(element, InsideDescriptors);\n      // NOTE: There are compatibility issues with patches for `textContent`\n      // and `innerHTML` between CE and SD. Since SD patches are applied\n      // via `ShadyDOM.patch` and CE patches are applied as the tree is walked,\n      // SD patches overwrite CE patches.\n      // * When SD is in patching mode, SD calls through to native\n      // methods not patched by CE (since SD is at the bottom) and CE does not\n      // upgrade, connect, or disconnect elements. Therefore do *not patch*\n      // these accessors in this case.\n      // * When SD is in `noPatch` mode, the SD patches call through to\n      // \"native\" methods that are patched by CE (since CE is at the bottom).\n      // Therefore continue to patch in this case.\n      // If the custom elements polyfill is not loaded, then these accessors\n      // should be patched so they work correctly.\n      if (!utils.hasPolyfilledCustomElements() || utils.settings.noPatch) {\n        utils.patchExistingProperties(element, TextContentInnerHTMLDescriptors);\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 {flush} from './flush.js';\nimport {shadyDataForNode, ensureShadyDataForNode} from './shady-data.js';\n\n/*\nMake this name unique so it is unlikely to conflict with properties on objects passed to `addEventListener`\nhttps://github.com/webcomponents/shadydom/issues/173\n*/\nconst /** string */ eventWrappersName = `__eventWrappers${Date.now()}`;\n\n/** @type {?function(!Event): boolean} */\nconst composedGetter = (() => {\n  const composedProp = Object.getOwnPropertyDescriptor(Event.prototype, 'composed');\n  return composedProp ? (ev) => composedProp.get.call(ev) : null;\n})();\n\nconst supportsEventOptions = (() => {\n  let supported = false;\n  let eventOptions = {\n    get capture() {\n      supported = true;\n      return false;\n    }\n  }\n  const listener = () => {}\n  // NOTE: These will be unpatched at this point.\n  window.addEventListener('test', listener, eventOptions);\n  window.removeEventListener('test', listener, eventOptions);\n  return supported;\n})();\n\nconst parseEventOptions = (optionsOrCapture) => {\n  let capture, once, passive, shadyTarget;\n  if (optionsOrCapture && typeof optionsOrCapture === 'object') {\n    capture = Boolean(optionsOrCapture.capture);\n    once = Boolean(optionsOrCapture.once);\n    passive = Boolean(optionsOrCapture.passive);\n    shadyTarget = optionsOrCapture.__shadyTarget;\n  } else {\n    capture = Boolean(optionsOrCapture);\n    once = false;\n    passive = false;\n  }\n  return {\n    shadyTarget,\n    capture,\n    once,\n    passive,\n    nativeEventOptions: supportsEventOptions ? optionsOrCapture : capture\n  }\n}\n\n// https://github.com/w3c/webcomponents/issues/513#issuecomment-224183937\nconst alwaysComposed = {\n  'blur': true,\n  'focus': true,\n  'focusin': true,\n  'focusout': true,\n  'click': true,\n  'dblclick': true,\n  'mousedown': true,\n  'mouseenter': true,\n  'mouseleave': true,\n  'mousemove': true,\n  'mouseout': true,\n  'mouseover': true,\n  'mouseup': true,\n  'wheel': true,\n  'beforeinput': true,\n  'input': true,\n  'keydown': true,\n  'keyup': true,\n  'compositionstart': true,\n  'compositionupdate': true,\n  'compositionend': true,\n  'touchstart': true,\n  'touchend': true,\n  'touchmove': true,\n  'touchcancel': true,\n  'pointerover': true,\n  'pointerenter': true,\n  'pointerdown': true,\n  'pointermove': true,\n  'pointerup': true,\n  'pointercancel': true,\n  'pointerout': true,\n  'pointerleave': true,\n  'gotpointercapture': true,\n  'lostpointercapture': true,\n  'dragstart': true,\n  'drag': true,\n  'dragenter': true,\n  'dragleave': true,\n  'dragover': true,\n  'drop': true,\n  'dragend': true,\n  'DOMActivate': true,\n  'DOMFocusIn': true,\n  'DOMFocusOut': true,\n  'keypress': true\n};\n\nconst unpatchedEvents = {\n  'DOMAttrModified': true,\n  'DOMAttributeNameChanged': true,\n  'DOMCharacterDataModified': true,\n  'DOMElementNameChanged': true,\n  'DOMNodeInserted': true,\n  'DOMNodeInsertedIntoDocument': true,\n  'DOMNodeRemoved': true,\n  'DOMNodeRemovedFromDocument': true,\n  'DOMSubtreeModified': true\n}\n\n/**\n * Some EventTarget subclasses are not Node subclasses, and you cannot call\n * `getRootNode()` on them.\n *\n * @param {!(Node|EventTarget)} eventTarget\n * @return {!(Node|EventTarget)}\n */\nfunction getRootNodeWithFallback(eventTarget) {\n  if (eventTarget instanceof Node) {\n    return eventTarget[utils.SHADY_PREFIX + 'getRootNode']();\n  } else {\n    return eventTarget;\n  }\n}\n\nfunction pathComposer(startNode, composed) {\n  let composedPath = [];\n  let current = startNode;\n  let startRoot = getRootNodeWithFallback(startNode);\n  while (current) {\n    composedPath.push(current);\n    if (current[utils.SHADY_PREFIX + 'assignedSlot']) {\n      current = current[utils.SHADY_PREFIX + 'assignedSlot'];\n    } else if (current.nodeType === Node.DOCUMENT_FRAGMENT_NODE && current.host && (composed || current !== startRoot)) {\n      current = current.host;\n    } else {\n      current = current[utils.SHADY_PREFIX + 'parentNode'];\n    }\n  }\n  // event composedPath includes window when startNode's ownerRoot is document\n  if (composedPath[composedPath.length - 1] === document) {\n    composedPath.push(window);\n  }\n  return composedPath;\n}\n\nexport const composedPath = (event) => {\n  if (!event.__composedPath) {\n    event.__composedPath = pathComposer(event.target, true);\n  }\n  return event.__composedPath;\n}\n\nfunction retarget(refNode, path) {\n  if (!utils.isShadyRoot) {\n    return refNode;\n  }\n  // If ANCESTOR's root is not a shadow root or ANCESTOR's root is BASE's\n  // shadow-including inclusive ancestor, return ANCESTOR.\n  let refNodePath = pathComposer(refNode, true);\n  let p$ = path;\n  for (let i=0, ancestor, lastRoot, root, rootIdx; i < p$.length; i++) {\n    ancestor = p$[i];\n    root = getRootNodeWithFallback(ancestor);\n    if (root !== lastRoot) {\n      rootIdx = refNodePath.indexOf(root);\n      lastRoot = root;\n    }\n    if (!utils.isShadyRoot(root) || rootIdx > -1) {\n      return ancestor;\n    }\n  }\n}\n\nlet EventPatches = {\n\n  /**\n   * @this {Event}\n   */\n  get composed() {\n    if (this.__composed === undefined) {\n      // if there's an original `composed` getter on the Event prototype, use that\n      if (composedGetter) {\n        // TODO(web-padawan): see https://github.com/webcomponents/shadydom/issues/275\n        this.__composed = this.type === 'focusin' || this.type === 'focusout' || composedGetter(this);\n      // If the event is trusted, or `isTrusted` is not supported, check the list of always composed events\n      } else if (this.isTrusted !== false) {\n        this.__composed = alwaysComposed[this.type];\n      }\n    }\n    return /** @type {!Event} */(this).__composed || false;\n  },\n\n  /**\n   * @this {Event}\n   */\n  composedPath() {\n    if (!this.__composedPath) {\n      this.__composedPath = pathComposer(this['__target'], this.composed);\n    }\n    return /** @type {!Event} */(this).__composedPath;\n  },\n\n  /**\n   * @this {Event}\n   */\n  get target() {\n    return retarget(this.currentTarget || this['__previousCurrentTarget'], this.composedPath());\n  },\n\n  // http://w3c.github.io/webcomponents/spec/shadow/#event-relatedtarget-retargeting\n  /**\n   * @this {Event}\n   */\n  get relatedTarget() {\n    if (!this.__relatedTarget) {\n      return null;\n    }\n    if (!this.__relatedTargetComposedPath) {\n      this.__relatedTargetComposedPath = pathComposer(this.__relatedTarget, true);\n    }\n    // find the deepest node in relatedTarget composed path that is in the same root with the currentTarget\n    return retarget(this.currentTarget || this['__previousCurrentTarget'], /** @type {!Event} */(this).__relatedTargetComposedPath);\n  },\n  /**\n   * @this {Event}\n   */\n  stopPropagation() {\n    Event.prototype.stopPropagation.call(this);\n    this.__propagationStopped = true;\n  },\n  /**\n   * @this {Event}\n   */\n  stopImmediatePropagation() {\n    Event.prototype.stopImmediatePropagation.call(this);\n    this.__immediatePropagationStopped = true;\n    this.__propagationStopped = true;\n  }\n\n};\n\nfunction mixinComposedFlag(Base) {\n  // NOTE: avoiding use of `class` here so that transpiled output does not\n  // try to do `Base.call` with a dom construtor.\n  let klazz = function(type, options) {\n    let event = new Base(type, options);\n    event.__composed = options && Boolean(options['composed']);\n    return event;\n  }\n  // put constructor properties on subclass\n  klazz.__proto__ = Base;\n  klazz.prototype = Base.prototype;\n  return klazz;\n}\n\nlet nonBubblingEventsToRetarget = {\n  'focus': true,\n  'blur': true\n};\n\n\n/**\n * Check if the event has been retargeted by comparing original `target`, and calculated `target`\n * @param {Event} event\n * @return {boolean} True if the original target and calculated target are the same\n */\nfunction hasRetargeted(event) {\n  return event['__target'] !== event.target || event.__relatedTarget !== event.relatedTarget;\n}\n\n/**\n *\n * @param {Event} event\n * @param {Node} node\n * @param {string} phase\n */\nfunction fireHandlers(event, node, phase) {\n  let hs = node.__handlers && node.__handlers[event.type] &&\n    node.__handlers[event.type][phase];\n  if (hs) {\n    for (let i = 0, fn; (fn = hs[i]); i++) {\n      if (hasRetargeted(event) && event.target === event.relatedTarget) {\n        return;\n      }\n      fn.call(node, event);\n      if (event.__immediatePropagationStopped) {\n        return;\n      }\n    }\n  }\n}\n\nfunction shadyDispatchEvent(e) {\n  const path = e.composedPath();\n  const retargetedPath = path.map(node => retarget(node, path));\n  const bubbles = e.bubbles;\n\n  let currentTarget;\n  // override `currentTarget` to let patched `target` calculate correctly\n  Object.defineProperty(e, 'currentTarget', {\n    configurable: true,\n    enumerable: true,\n    get: function() {\n      return currentTarget;\n    },\n  });\n\n  let eventPhase = Event.CAPTURING_PHASE;\n  Object.defineProperty(e, 'eventPhase', {\n    configurable: true,\n    enumerable: true,\n    get: function() {\n      return eventPhase;\n    },\n  });\n\n  for (let i = path.length - 1; i >= 0; i--) {\n    currentTarget = path[i];\n    eventPhase = currentTarget === retargetedPath[i] ? Event.AT_TARGET : Event.CAPTURING_PHASE;\n    // capture phase fires all capture handlers\n    fireHandlers(e, currentTarget, 'capture');\n    if (e.__propagationStopped) {\n      return;\n    }\n  }\n\n  for (let i = 0; i < path.length; i++) {\n    currentTarget = path[i];\n    const atTarget = currentTarget === retargetedPath[i];\n    if (atTarget || bubbles) {\n      eventPhase = atTarget ? Event.AT_TARGET : Event.BUBBLING_PHASE;\n      fireHandlers(e, currentTarget, 'bubble');\n      if (e.__propagationStopped) {\n        return;\n      }\n    }\n  }\n\n  eventPhase = 0; // `Event.NONE` is not available in IE11.\n  currentTarget = null;\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\nfunction targetNeedsPathCheck(node) {\n  return utils.isShadyRoot(node) || node.localName === 'slot';\n}\n\n/** @this {Node} */\nexport function dispatchEvent(event) {\n  flush();\n  // If the target is disconnected from the real document, it might still be\n  // connected in the user-facing tree. To allow its path to potentially\n  // include both connected and disconnected parts, dispatch it manually.\n  if (!utils.settings.preferPerformance && this instanceof Node &&\n      !utils.documentContains(document, this)) {\n    if (!event['__target']) {\n      patchEvent(event, this);\n    }\n    return shadyDispatchEvent(event);\n  } else {\n    return this[utils.NATIVE_PREFIX + 'dispatchEvent'](event);\n  }\n}\n\n/**\n * @this {EventTarget}\n */\nexport function addEventListener(type, fnOrObj, optionsOrCapture) {\n  const {capture, once, passive, shadyTarget, nativeEventOptions} =\n    parseEventOptions(optionsOrCapture);\n  if (!fnOrObj) {\n    return;\n  }\n\n  const handlerType = typeof fnOrObj;\n\n  // bail if `fnOrObj` is not a function, not an object\n  if (handlerType !== 'function' && handlerType !== 'object') {\n    return;\n  }\n\n  // bail if `fnOrObj` is an object without a `handleEvent` method\n  if (handlerType === 'object' && (!fnOrObj.handleEvent || typeof fnOrObj.handleEvent !== 'function')) {\n    return;\n  }\n\n  if (unpatchedEvents[type]) {\n    return this[utils.NATIVE_PREFIX + 'addEventListener'](type, fnOrObj, nativeEventOptions);\n  }\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 = shadyTarget || this;\n\n  let wrappers = fnOrObj[eventWrappersName];\n  if (wrappers) {\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    // Stop if the wrapper function has already been created.\n    if (findListener(wrappers, target, type, capture, once, passive) > -1) {\n      return;\n    }\n  } else {\n    fnOrObj[eventWrappersName] = [];\n  }\n\n  /**\n   * @this {HTMLElement}\n   * @param {Event} e\n   */\n  const wrapperFn = function(e) {\n    // Support `once` option.\n    if (once) {\n      this[utils.SHADY_PREFIX + 'removeEventListener'](type, fnOrObj, optionsOrCapture);\n    }\n    if (!e['__target']) {\n      patchEvent(e);\n    }\n    let lastCurrentTargetDesc;\n    let lastEventPhaseDesc;\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      lastEventPhaseDesc = Object.getOwnPropertyDescriptor(e, 'eventPhase');\n      Object.defineProperty(e, 'eventPhase', {\n        configurable: true,\n        enumerable: true,\n        get() {\n          // Shady DOM doesn't support dispatching to a shadow root as the\n          // target, so we don't need to handle Event.AT_TARGET.\n          return capture ? Event.CAPTURING_PHASE : Event.BUBBLING_PHASE;\n        },\n      });\n    }\n    e['__previousCurrentTarget'] = e['currentTarget'];\n    // Always check if a shadowRoot or slot is in the current event path.\n    // If it is not, the event was generated on either the host of the shadowRoot\n    // or a children of the host.\n    if (targetNeedsPathCheck(target) && e.composedPath().indexOf(target) == -1) {\n      return;\n    }\n    // There are two critera that should stop events from firing on this node\n    // 1. the event is not composed and the current node is not in the same root as the target\n    // 2. when bubbling, if after retargeting, relatedTarget and target point to the same node\n    if (e.composed || e.composedPath().indexOf(target) > -1) {\n      if (hasRetargeted(e) && e.target === e.relatedTarget) {\n        if (e.eventPhase === Event.BUBBLING_PHASE) {\n          e.stopImmediatePropagation();\n        }\n        return;\n      }\n      // prevent non-bubbling events from triggering bubbling handlers on shadowroot, but only if not in capture phase\n      if (e.eventPhase !== Event.CAPTURING_PHASE && !e.bubbles && e.target !== target && !(target instanceof Window)) {\n        return;\n      }\n      let ret = handlerType === 'function' ?\n        fnOrObj.call(target, e) :\n        (fnOrObj.handleEvent && fnOrObj.handleEvent(e));\n      if (target !== this) {\n        // Replace the original descriptors for `currentTarget` and `eventPhase`.\n        if (lastCurrentTargetDesc) {\n          Object.defineProperty(e, 'currentTarget', lastCurrentTargetDesc);\n          lastCurrentTargetDesc = null;\n        } else {\n          delete e['currentTarget'];\n        }\n        if (lastEventPhaseDesc) {\n          Object.defineProperty(e, 'eventPhase', lastEventPhaseDesc);\n          lastEventPhaseDesc = null;\n        } else {\n          delete e['eventPhase'];\n        }\n      }\n      return ret;\n    }\n  };\n\n  // Store the wrapper information.\n  fnOrObj[eventWrappersName].push({\n    // note: use target here which is either a shadowRoot\n    // (when the host element is proxy'ing the event) or this element\n    node: target,\n    type: type,\n    capture: capture,\n    once: once,\n    passive: passive,\n    wrapperFn: wrapperFn\n  });\n\n  this.__handlers = this.__handlers || {};\n  this.__handlers[type] = this.__handlers[type] ||\n    {'capture': [], 'bubble': []};\n  this.__handlers[type][capture ? 'capture' : 'bubble'].push(wrapperFn);\n\n  if (!nonBubblingEventsToRetarget[type]) {\n    this[utils.NATIVE_PREFIX + 'addEventListener'](type, wrapperFn, nativeEventOptions);\n  }\n}\n\n/**\n * @this {EventTarget}\n */\nexport function removeEventListener(type, fnOrObj, optionsOrCapture) {\n  if (!fnOrObj) {\n    return;\n  }\n  const {capture, once, passive, shadyTarget, nativeEventOptions} =\n    parseEventOptions(optionsOrCapture);\n  if (unpatchedEvents[type]) {\n    return this[utils.NATIVE_PREFIX + 'removeEventListener'](type, fnOrObj, nativeEventOptions);\n  }\n  let target = shadyTarget || this;\n  // Search the wrapped function.\n  let wrapperFn = undefined;\n  let wrappers = getEventWrappers(fnOrObj);\n  if (wrappers) {\n    let idx = findListener(wrappers, target, type, capture, once, passive);\n    if (idx > -1) {\n      wrapperFn = wrappers.splice(idx, 1)[0].wrapperFn;\n      // Cleanup.\n      if (!wrappers.length) {\n        fnOrObj[eventWrappersName] = undefined;\n      }\n    }\n  }\n  this[utils.NATIVE_PREFIX + 'removeEventListener'](type, wrapperFn || fnOrObj,\n    nativeEventOptions);\n  if (wrapperFn && this.__handlers && this.__handlers[type]) {\n    const arr = this.__handlers[type][capture ? 'capture' : 'bubble'];\n    const idx = arr.indexOf(wrapperFn);\n    if (idx > -1) {\n      arr.splice(idx, 1);\n    }\n  }\n}\n\nfunction activateFocusEventOverrides() {\n  for (let ev in nonBubblingEventsToRetarget) {\n    window[utils.NATIVE_PREFIX + 'addEventListener'](ev, function(e) {\n      if (!e['__target']) {\n        patchEvent(e);\n        shadyDispatchEvent(e);\n      }\n    }, true);\n  }\n}\n\nconst EventPatchesDescriptors = utils.getOwnPropertyDescriptors(EventPatches);\n\nconst SHADY_PROTO = '__shady_patchedProto';\nconst SHADY_SOURCE_PROTO = '__shady_sourceProto';\n\nfunction patchEvent(event, target = event.target) {\n  event['__target'] = target;\n  event.__relatedTarget = event.relatedTarget;\n  // attempt to patch prototype (via cache)\n  if (utils.settings.hasDescriptors) {\n    const proto = Object.getPrototypeOf(event);\n    // eslint-disable-next-line no-prototype-builtins\n    if (!proto.hasOwnProperty(SHADY_PROTO)) {\n      const patchedProto = Object.create(proto);\n      patchedProto[SHADY_SOURCE_PROTO] = proto;\n      utils.patchProperties(patchedProto, EventPatchesDescriptors);\n      proto[SHADY_PROTO] = patchedProto;\n    }\n    event.__proto__ = proto[SHADY_PROTO];\n  // and fallback to patching instance\n  } else {\n    utils.patchProperties(event, EventPatchesDescriptors);\n  }\n}\n\nlet PatchedEvent = mixinComposedFlag(Event);\nlet PatchedCustomEvent = mixinComposedFlag(CustomEvent);\nlet PatchedMouseEvent = mixinComposedFlag(MouseEvent);\n\n\nexport function patchEvents() {\n  activateFocusEventOverrides();\n  window.Event = PatchedEvent;\n  window.CustomEvent = PatchedCustomEvent;\n  window.MouseEvent = PatchedMouseEvent;\n}\n\nexport function patchClick() {\n  // Fix up `Element.prototype.click()` if `isTrusted` is supported, but `composed` isn't\n  if (!composedGetter && Object.getOwnPropertyDescriptor(Event.prototype, 'isTrusted')) {\n    /** @this {Element} */\n    const composedClickFn = function() {\n      const ev = new MouseEvent('click', {\n        bubbles: true,\n        cancelable: true,\n        composed: true\n      });\n      this[utils.SHADY_PREFIX + 'dispatchEvent'](ev);\n    };\n    if (Element.prototype.click) {\n      Element.prototype.click = composedClickFn;\n    } else if (HTMLElement.prototype.click) {\n      HTMLElement.prototype.click = composedClickFn;\n    }\n  }\n}\n\nexport const eventPropertyNamesForElement =\n    Object.getOwnPropertyNames(Element.prototype)\n    .filter(name => name.substring(0,2) === 'on');\n\nexport const eventPropertyNamesForHTMLElement =\n    Object.getOwnPropertyNames(HTMLElement.prototype)\n    .filter(name => name.substring(0,2) === 'on');\n\n/**\n * @param {string} property\n * @return {!ObjectPropertyDescriptor<Element>}\n */\nexport const wrappedDescriptorForEventProperty = (property) => {\n  return {\n    /** @this {Element} */\n    set: function(fn) {\n      const shadyData = ensureShadyDataForNode(this);\n      const eventName = property.substring(2);\n      if (!shadyData.__onCallbackListeners) {\n        shadyData.__onCallbackListeners = {};\n      }\n      shadyData.__onCallbackListeners[property] && this.removeEventListener(eventName, shadyData.__onCallbackListeners[property]);\n      this[utils.SHADY_PREFIX + 'addEventListener'](eventName, fn);\n      shadyData.__onCallbackListeners[property] = fn;\n    },\n    /** @this {Element} */\n    get() {\n      const shadyData = shadyDataForNode(this);\n      return shadyData && shadyData.__onCallbackListeners && shadyData.__onCallbackListeners[property];\n    },\n    configurable: 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\nfunction newSplice(index, removed, addedCount) {\n  return {\n    index: index,\n    removed: removed,\n    addedCount: addedCount\n  };\n}\n\nconst EDIT_LEAVE = 0;\nconst EDIT_UPDATE = 1;\nconst EDIT_ADD = 2;\nconst EDIT_DELETE = 3;\n\n// Note: This function is *based* on the computation of the Levenshtein\n// \"edit\" distance. The one change is that \"updates\" are treated as two\n// edits - not one. With Array splices, an update is really a delete\n// followed by an add. By retaining this, we optimize for \"keeping\" the\n// maximum array items in the original array. For example:\n//\n//   'xxxx123' -> '123yyyy'\n//\n// With 1-edit updates, the shortest path would be just to update all seven\n// characters. With 2-edit updates, we delete 4, leave 3, and add 4. This\n// leaves the substring '123' intact.\nfunction calcEditDistances(current, currentStart, currentEnd,\n                            old, oldStart, oldEnd) {\n  // \"Deletion\" columns\n  let rowCount = oldEnd - oldStart + 1;\n  let columnCount = currentEnd - currentStart + 1;\n  let distances = new Array(rowCount);\n\n  // \"Addition\" rows. Initialize null column.\n  for (let i = 0; i < rowCount; i++) {\n    distances[i] = new Array(columnCount);\n    distances[i][0] = i;\n  }\n\n  // Initialize null row\n  for (let j = 0; j < columnCount; j++)\n    distances[0][j] = j;\n\n  for (let i = 1; i < rowCount; i++) {\n    for (let j = 1; j < columnCount; j++) {\n      if (equals(current[currentStart + j - 1], old[oldStart + i - 1]))\n        distances[i][j] = distances[i - 1][j - 1];\n      else {\n        let north = distances[i - 1][j] + 1;\n        let west = distances[i][j - 1] + 1;\n        distances[i][j] = north < west ? north : west;\n      }\n    }\n  }\n\n  return distances;\n}\n\n// This starts at the final weight, and walks \"backward\" by finding\n// the minimum previous weight recursively until the origin of the weight\n// matrix.\nfunction spliceOperationsFromEditDistances(distances) {\n  let i = distances.length - 1;\n  let j = distances[0].length - 1;\n  let current = distances[i][j];\n  let edits = [];\n  while (i > 0 || j > 0) {\n    if (i == 0) {\n      edits.push(EDIT_ADD);\n      j--;\n      continue;\n    }\n    if (j == 0) {\n      edits.push(EDIT_DELETE);\n      i--;\n      continue;\n    }\n    let northWest = distances[i - 1][j - 1];\n    let west = distances[i - 1][j];\n    let north = distances[i][j - 1];\n\n    let min;\n    if (west < north)\n      min = west < northWest ? west : northWest;\n    else\n      min = north < northWest ? north : northWest;\n\n    if (min == northWest) {\n      if (northWest == current) {\n        edits.push(EDIT_LEAVE);\n      } else {\n        edits.push(EDIT_UPDATE);\n        current = northWest;\n      }\n      i--;\n      j--;\n    } else if (min == west) {\n      edits.push(EDIT_DELETE);\n      i--;\n      current = west;\n    } else {\n      edits.push(EDIT_ADD);\n      j--;\n      current = north;\n    }\n  }\n\n  edits.reverse();\n  return edits;\n}\n\n/**\n * Splice Projection functions:\n *\n * A splice map is a representation of how a previous array of items\n * was transformed into a new array of items. Conceptually it is a list of\n * tuples of\n *\n *   <index, removed, addedCount>\n *\n * which are kept in ascending index order of. The tuple represents that at\n * the |index|, |removed| sequence of items were removed, and counting forward\n * from |index|, |addedCount| items were added.\n */\n\n/**\n * Lacking individual splice mutation information, the minimal set of\n * splices can be synthesized given the previous state and final state of an\n * array. The basic approach is to calculate the edit distance matrix and\n * choose the shortest path through it.\n *\n * Complexity: O(l * p)\n *   l: The length of the current array\n *   p: The length of the old array\n */\nfunction calcSplices(current, currentStart, currentEnd,\n                      old, oldStart, oldEnd) {\n  let prefixCount = 0;\n  let suffixCount = 0;\n  let splice;\n\n  let minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart);\n  if (currentStart == 0 && oldStart == 0)\n    prefixCount = sharedPrefix(current, old, minLength);\n\n  if (currentEnd == current.length && oldEnd == old.length)\n    suffixCount = sharedSuffix(current, old, minLength - prefixCount);\n\n  currentStart += prefixCount;\n  oldStart += prefixCount;\n  currentEnd -= suffixCount;\n  oldEnd -= suffixCount;\n\n  if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0)\n    return [];\n\n  if (currentStart == currentEnd) {\n    splice = newSplice(currentStart, [], 0);\n    while (oldStart < oldEnd)\n      splice.removed.push(old[oldStart++]);\n\n    return [ splice ];\n  } else if (oldStart == oldEnd)\n    return [ newSplice(currentStart, [], currentEnd - currentStart) ];\n\n  let ops = spliceOperationsFromEditDistances(\n      calcEditDistances(current, currentStart, currentEnd,\n                             old, oldStart, oldEnd));\n\n  splice = undefined;\n  let splices = [];\n  let index = currentStart;\n  let oldIndex = oldStart;\n  for (let i = 0; i < ops.length; i++) {\n    switch(ops[i]) {\n      case EDIT_LEAVE:\n        if (splice) {\n          splices.push(splice);\n          splice = undefined;\n        }\n\n        index++;\n        oldIndex++;\n        break;\n      case EDIT_UPDATE:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.addedCount++;\n        index++;\n\n        splice.removed.push(old[oldIndex]);\n        oldIndex++;\n        break;\n      case EDIT_ADD:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.addedCount++;\n        index++;\n        break;\n      case EDIT_DELETE:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.removed.push(old[oldIndex]);\n        oldIndex++;\n        break;\n    }\n  }\n\n  if (splice) {\n    splices.push(splice);\n  }\n  return splices;\n}\n\nfunction sharedPrefix(current, old, searchLength) {\n  for (let i = 0; i < searchLength; i++)\n    if (!equals(current[i], old[i]))\n      return i;\n  return searchLength;\n}\n\nfunction sharedSuffix(current, old, searchLength) {\n  let index1 = current.length;\n  let index2 = old.length;\n  let count = 0;\n  while (count < searchLength && equals(current[--index1], old[--index2]))\n    count++;\n\n  return count;\n}\n\nfunction equals(currentValue, previousValue) {\n  return currentValue === previousValue;\n}\n\nexport function calculateSplices(current, previous) {\n  return calcSplices(current, 0, current.length, previous, 0,\n                          previous.length);\n}\n\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {addEventListener, removeEventListener, dispatchEvent} from '../patch-events.js';\n\nexport const EventTargetPatches = utils.getOwnPropertyDescriptors({\n\n  dispatchEvent,\n\n  addEventListener,\n\n  removeEventListener\n\n});","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\n\nlet scopingShim = null;\n\nexport function getScopingShim() {\n  if (!scopingShim) {\n    scopingShim = window['ShadyCSS'] && window['ShadyCSS']['ScopingShim'];\n  }\n  return scopingShim || null;\n}\n\n/**\n * @param {!Node} node\n * @param {string} attr\n * @param {string} value\n */\nexport function scopeClassAttribute(node, attr, value) {\n  const scopingShim = getScopingShim();\n  if (scopingShim && attr === 'class') {\n    scopingShim['setElementClass'](node, value);\n    return true;\n  }\n  return false;\n}\n\n/**\n * @param {!Node} node\n * @param {string} newScopeName\n */\nexport function addShadyScoping(node, newScopeName) {\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return;\n  }\n  scopingShim['scopeNode'](node, newScopeName);\n}\n\n/**\n * @param {!Node} node\n * @param {string} currentScopeName\n */\nexport function removeShadyScoping(node, currentScopeName) {\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return;\n  }\n  scopingShim['unscopeNode'](node, currentScopeName);\n}\n\n/**\n * @param {!Node} node\n * @param {string} newScopeName\n * @param {string} oldScopeName\n */\nexport function replaceShadyScoping(node, newScopeName, oldScopeName) {\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return;\n  }\n  if (oldScopeName) {\n    removeShadyScoping(node, oldScopeName);\n  }\n  addShadyScoping(node, newScopeName);\n}\n\n/**\n * @param {!Node} node\n * @param {string} newScopeName\n * @return {boolean}\n */\nexport function currentScopeIsCorrect(node, newScopeName) {\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return true;\n  }\n  if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n    // NOTE: as an optimization, only check that all the top-level children\n    // have the correct scope.\n    let correctScope = true;\n    for (let n=node[utils.SHADY_PREFIX + 'firstChild']; n; n = n[utils.SHADY_PREFIX + 'nextSibling']) {\n      correctScope = correctScope &&\n        currentScopeIsCorrect(n, newScopeName);\n    }\n    return correctScope;\n  }\n  if (node.nodeType !== Node.ELEMENT_NODE) {\n    return true;\n  }\n  const currentScope = scopingShim['currentScopeForNode'](node);\n  return currentScope === newScopeName;\n}\n\n/**\n * @param {!Node} node\n * @return {string}\n */\nexport function currentScopeForNode(node) {\n  if (node.nodeType !== Node.ELEMENT_NODE) {\n    return '';\n  }\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return '';\n  }\n  return scopingShim['currentScopeForNode'](node);\n}\n\n/**\n * Walk over a node's tree and apply visitorFn to each element node\n *\n * @param {Node} node\n * @param {function(!Node):void} visitorFn\n */\nexport function treeVisitor(node, visitorFn) {\n  if (!node) {\n    return;\n  }\n  // this check is necessary if `node` is a Document Fragment\n  if (node.nodeType === Node.ELEMENT_NODE) {\n    visitorFn(node);\n  }\n  for (let n = node[utils.SHADY_PREFIX + 'firstChild']; n; (n = n[utils.SHADY_PREFIX + 'nextSibling'])) {\n    if (n.nodeType === Node.ELEMENT_NODE) {\n      treeVisitor(n, visitorFn);\n    }\n  }\n}","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {getScopingShim, removeShadyScoping, replaceShadyScoping,\n  treeVisitor, currentScopeForNode, currentScopeIsCorrect } from '../style-scoping.js';\nimport {shadyDataForNode, ensureShadyDataForNode} from '../shady-data.js';\nimport {recordInsertBefore, recordRemoveChild} from '../link-nodes.js';\nimport {ownerShadyRootForNode} from '../attach-shadow.js';\n\nconst doc = window.document;\n\nconst preferPerformance = utils.settings.preferPerformance;\n\nconst nativeIsConnectedAccessors =\n/** @type {ObjectPropertyDescriptor} */(\n  Object.getOwnPropertyDescriptor(Node.prototype, 'isConnected')\n);\n\nconst nativeIsConnected = nativeIsConnectedAccessors && nativeIsConnectedAccessors.get;\n\nexport function clearNode(node) {\n  let firstChild;\n  while ((firstChild = node[utils.SHADY_PREFIX + 'firstChild'])) {\n    node[utils.SHADY_PREFIX + 'removeChild'](firstChild);\n  }\n}\n\nfunction removeOwnerShadyRoot(node) {\n  // optimization: only reset the tree if node is actually in a root\n  if (hasCachedOwnerRoot(node)) {\n    for (let n=node[utils.SHADY_PREFIX + 'firstChild']; n; n = n[utils.SHADY_PREFIX + 'nextSibling']) {\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    // Note, if `flattened` is falsey, it means that the containing shadowRoot\n    // has not rendered and therefore the `<slot>` is still in the composed\n    // DOM. If that's the case the `<slot>` is the first composed node.\n    if (flattened) {\n      composed = flattened.length ? flattened[0] :\n        firstComposedNode(node[utils.SHADY_PREFIX + 'nextSibling']);\n    }\n  }\n  return composed;\n}\n\n/**\n * @param {Node} node\n * @param {Node=} addedNode\n * @param {Node=} removedNode\n */\nfunction scheduleObserver(node, addedNode, removedNode) {\n  const nodeData = shadyDataForNode(node);\n  const observer = nodeData && nodeData.observer;\n  if (observer) {\n    if (addedNode) {\n      if (addedNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n        for (let i = 0, l = addedNode.childNodes.length; i < l; i++) {\n          observer.addedNodes.push(addedNode.childNodes[i]);\n        }\n      } else {\n        observer.addedNodes.push(addedNode);\n      }\n    }\n    if (removedNode) {\n      observer.removedNodes.push(removedNode);\n    }\n    observer.schedule();\n  }\n}\n\nexport const NodePatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Node} */\n  get parentNode() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.parentNode;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'parentNode'];\n  },\n\n  /** @this {Node} */\n  get firstChild() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.firstChild;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'firstChild'];\n  },\n\n  /** @this {Node} */\n  get lastChild() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.lastChild;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'lastChild'];\n  },\n\n  /** @this {Node} */\n  get nextSibling() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.nextSibling;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'nextSibling'];\n  },\n\n  /** @this {Node} */\n  get previousSibling() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.previousSibling;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'previousSibling'];\n  },\n\n  /** @this {Node} */\n  get childNodes() {\n    let childNodes;\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      const nodeData = shadyDataForNode(this);\n      if (!nodeData.childNodes) {\n        nodeData.childNodes = [];\n        for (let n=this[utils.SHADY_PREFIX + 'firstChild']; n; n=n[utils.SHADY_PREFIX + 'nextSibling']) {\n          nodeData.childNodes.push(n);\n        }\n      }\n      childNodes = nodeData.childNodes;\n    } else {\n      childNodes = this[utils.NATIVE_PREFIX + 'childNodes'];\n    }\n    childNodes.item = function(index) {\n      return childNodes[index];\n    }\n    return childNodes;\n  },\n\n  /** @this {Node} */\n  get parentElement() {\n    const nodeData = shadyDataForNode(this);\n    let l = nodeData && nodeData.parentNode;\n    if (l && l.nodeType !== Node.ELEMENT_NODE) {\n      l = null;\n    }\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'parentElement'];\n  },\n\n  /** @this {Node} */\n  get isConnected() {\n    if (nativeIsConnected && nativeIsConnected.call(this)) {\n      return true;\n    }\n    if (this.nodeType == Node.DOCUMENT_FRAGMENT_NODE) {\n      return false;\n    }\n    // Fast path for distributed nodes.\n    const ownerDocument = this.ownerDocument;\n    if (ownerDocument === null || utils.documentContains(ownerDocument, this)) {\n      return true;\n    }\n    // Slow path for non-distributed nodes.\n    let node = this;\n    while (node && !(node instanceof Document)) {\n      node = node[utils.SHADY_PREFIX + 'parentNode'] || (utils.isShadyRoot(node) ? /** @type {ShadowRoot} */(node).host : undefined);\n    }\n    return !!(node && node instanceof Document);\n  },\n\n  /** @this {Node} */\n  get textContent() {\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      let tc = [];\n      for (let n=this[utils.SHADY_PREFIX + 'firstChild']; n; n = n[utils.SHADY_PREFIX + 'nextSibling']) {\n        if (n.nodeType !== Node.COMMENT_NODE) {\n          tc.push(n[utils.SHADY_PREFIX + 'textContent']);\n        }\n      }\n      return tc.join('');\n    } else {\n      return this[utils.NATIVE_PREFIX + 'textContent'];\n    }\n  },\n\n  /**\n   * @this {Node}\n   * @param {string} value\n   */\n  set textContent(value) {\n    if (typeof value === 'undefined' || value === null) {\n      value = ''\n    }\n    switch (this.nodeType) {\n      case Node.ELEMENT_NODE:\n      case Node.DOCUMENT_FRAGMENT_NODE:\n        if (!utils.isTrackingLogicalChildNodes(this) && utils.settings.hasDescriptors) {\n          // may be removing a nested slot but fast path if we know we are not.\n          const firstChild = this[utils.SHADY_PREFIX + 'firstChild'];\n          if (firstChild != this[utils.SHADY_PREFIX + 'lastChild'] ||\n            (firstChild && firstChild.nodeType != Node.TEXT_NODE)) {\n            clearNode(this);\n          }\n          this[utils.NATIVE_PREFIX + 'textContent'] = value;\n        } else {\n          clearNode(this);\n          // Document fragments must have no childNodes if setting a blank string\n          if (value.length > 0 || this.nodeType === Node.ELEMENT_NODE) {\n            this[utils.SHADY_PREFIX + 'insertBefore'](document.createTextNode(value))\n          }\n        }\n        break;\n      default:\n        // Note, be wary of patching `nodeValue`.\n        this.nodeValue = value;\n        break;\n    }\n  },\n\n  // Patched `insertBefore`. Note that all mutations that add nodes are routed\n  // here. When a <slot> is added or a node is added to a host with a shadowRoot\n  // with a slot, a standard dom `insert` call is aborted and `_asyncRender`\n  // is called on the relevant shadowRoot. In all other cases, a standard dom\n  // `insert` can be made, but the location and ref_node may need to be changed.\n  /**\n   * @this {Node}\n   * @param {Node} node\n   * @param {Node=} ref_node\n   */\n  insertBefore(node, ref_node) {\n    // optimization: assume native insertBefore is ok if the nodes are not in the document.\n    if (this.ownerDocument !== doc && node.ownerDocument !== doc) {\n      this[utils.NATIVE_PREFIX + 'insertBefore'](node, ref_node);\n      return node;\n    }\n    if (node === this) {\n      throw Error(`Failed to execute 'appendChild' on 'Node': The new child element contains the parent.`);\n    }\n    if (ref_node) {\n      const refData = shadyDataForNode(ref_node);\n      const p = refData && refData.parentNode;\n      if ((p !== undefined && p !== this) ||\n        (p === undefined && ref_node[utils.NATIVE_PREFIX + 'parentNode'] !== this)) {\n        throw Error(`Failed to execute 'insertBefore' on 'Node': The node ` +\n        `before which the new node is to be inserted is not a child of this node.`);\n      }\n    }\n    if (ref_node === node) {\n      return node;\n    }\n    scheduleObserver(this, node);\n    /** @type {!Array<!HTMLSlotElement>} */\n    const slotsAdded = [];\n    const ownerRoot = ownerShadyRootForNode(this);\n    /** @type {string} */\n    const newScopeName = ownerRoot ? ownerRoot.host.localName : currentScopeForNode(this);\n    /** @type {string} */\n    let oldScopeName;\n    // remove from existing location\n    const parentNode = node[utils.SHADY_PREFIX + 'parentNode'];\n    if (parentNode) {\n      oldScopeName = currentScopeForNode(node);\n      const skipUnscoping =\n        // Don't remove scoping if we're inserting into another shadowRoot;\n        // this would be unnecessary since it will be re-scoped below\n        Boolean(ownerRoot) ||\n        // Don't remove scoping if we're being moved between non-shadowRoot\n        // locations (the likely case is when moving pre-scoped nodes in a template)\n        !ownerShadyRootForNode(node) ||\n        // Under preferPerformance, don't remove scoping when moving back into\n        // a document fragment that was previously scoped; the assumption is\n        // that the user should only move correctly-scoped DOM back into it\n        (preferPerformance && this['__noInsertionPoint'] !== undefined);\n      parentNode[utils.SHADY_PREFIX + 'removeChild'](node, skipUnscoping);\n    }\n    // add to new parent\n    let allowNativeInsert = true;\n    const needsScoping = (!preferPerformance ||\n        // Under preferPerformance, only re-scope if we're not coming from a\n        // pre-scoped doc fragment or back into a pre-scoped doc fragment\n        (node['__noInsertionPoint'] === undefined &&\n         this['__noInsertionPoint'] === undefined)) &&\n        !currentScopeIsCorrect(node, newScopeName);\n    const needsSlotFinding = ownerRoot && !node['__noInsertionPoint'] &&\n        (!preferPerformance || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE);\n    if (needsSlotFinding || needsScoping) {\n      // NOTE: avoid node.removeChild as this *can* trigger another patched\n      // method (e.g. custom elements) and we want only the shady method to run.\n      // The following table describes what style scoping actions should happen as a result of this insertion.\n      // document -> shadowRoot: replace\n      // shadowRoot -> shadowRoot: replace\n      // shadowRoot -> shadowRoot of same type: do nothing\n      // shadowRoot -> document: allow unscoping\n      // document -> document: do nothing\n      // The \"same type of shadowRoot\" and \"document to document cases rely on `currentScopeIsCorrect` returning true\n      if (needsScoping) {\n        // in a document or disconnected tree, replace scoping if necessary\n        oldScopeName = oldScopeName || currentScopeForNode(node);\n      }\n      treeVisitor(node, (node) => {\n        if (needsSlotFinding && node.localName === 'slot') {\n          slotsAdded.push(/** @type {!HTMLSlotElement} */(node));\n        }\n        if (needsScoping) {\n          replaceShadyScoping(node, newScopeName, oldScopeName);\n        }\n      });\n    }\n    // if a slot is added, must render containing root.\n    if (slotsAdded.length) {\n      ownerRoot._addSlots(slotsAdded);\n      ownerRoot._asyncRender();\n    }\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      recordInsertBefore(node, this, ref_node);\n      const parentData = shadyDataForNode(this);\n      // if the node being inserted into has a shadowRoot, do not perform\n      // a native insertion\n      if (parentData.root) {\n        allowNativeInsert = false;\n        // when inserting into a host with a shadowRoot with slot, use\n        // `shadowRoot._asyncRender()` via `attach-shadow` module\n        // when inserting into a host with shadowRoot with NO slot, do nothing\n        // as the node should not be added to composed DOM anywhere.\n        if (utils.hasShadowRootWithSlot(this)) {\n          parentData.root._asyncRender();\n        }\n      // when inserting into a slot inside a shadowRoot, render the\n      // containing shadowRoot to update fallback content.\n      } else if (ownerRoot && this.localName === 'slot') {\n        allowNativeInsert = false;\n        ownerRoot._asyncRender();\n      }\n    }\n    if (allowNativeInsert) {\n      // if adding to a shadyRoot, add to host instead\n      let container = utils.isShadyRoot(this) ?\n        /** @type {ShadowRoot} */(this).host : this;\n      // if ref_node, get the ref_node that's actually in composed dom.\n      if (ref_node) {\n        ref_node = firstComposedNode(ref_node);\n        container[utils.NATIVE_PREFIX + 'insertBefore'](node, ref_node);\n      } else {\n        container[utils.NATIVE_PREFIX + 'appendChild'](node);\n      }\n    // Since ownerDocument is not patched, it can be incorrect after this call\n    // if the node is physically appended via distribution. This can result\n    // in the custom elements polyfill not upgrading the node if it's in an inert doc.\n    // We correct this by calling `adoptNode`.\n    } else if (node.ownerDocument !== this.ownerDocument) {\n      this.ownerDocument.adoptNode(node);\n    }\n    return node;\n  },\n\n  /**\n   * @this {Node}\n   * @param {Node} node\n   */\n  appendChild(node) {\n    // if this is a shadowRoot and the shadowRoot is passed as `node`\n    // then an optimized append has already been performed, so do nothing.\n    if (!(this == node && utils.isShadyRoot(node))) {\n      return this[utils.SHADY_PREFIX + 'insertBefore'](node);\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   * @this {Node}\n   * @param {Node} node\n   * @param {boolean=} skipUnscoping\n   */\n  removeChild(node, skipUnscoping = false) {\n    if (this.ownerDocument !== doc) {\n      return this[utils.NATIVE_PREFIX + 'removeChild'](node);\n    }\n    if (node[utils.SHADY_PREFIX + 'parentNode'] !== this) {\n      throw Error('The node to be removed is not a child of this node: ' +\n        node);\n    }\n    scheduleObserver(this, null, node);\n    let preventNativeRemove;\n    let ownerRoot = ownerShadyRootForNode(node);\n    const removingInsertionPoint = ownerRoot && ownerRoot._removeContainedSlots(node);\n    const parentData = shadyDataForNode(this);\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      recordRemoveChild(node, this);\n      if (utils.hasShadowRootWithSlot(this)) {\n        parentData.root._asyncRender();\n        preventNativeRemove = true;\n      }\n    }\n    // unscope a node leaving a ShadowRoot if ShadyCSS is present, and this node\n    // is not going to be rescoped in `insertBefore`\n    if (getScopingShim() && !skipUnscoping && ownerRoot\n      && node.nodeType !== Node.TEXT_NODE) {\n      const oldScopeName = currentScopeForNode(node);\n      treeVisitor(node, (node) => {\n        removeShadyScoping(node, oldScopeName);\n      });\n    }\n    removeOwnerShadyRoot(node);\n    // if removing slot, must render containing root\n    if (ownerRoot) {\n      let changeSlotContent = this.localName === 'slot';\n      if (changeSlotContent) {\n        preventNativeRemove = true;\n      }\n      if (removingInsertionPoint || changeSlotContent) {\n        ownerRoot._asyncRender();\n      }\n    }\n    if (!preventNativeRemove) {\n      // if removing from a shadyRoot, remove from host instead\n      let container = utils.isShadyRoot(this) ?\n        /** @type {ShadowRoot} */(this).host :\n        this;\n      // not guaranteed to physically be in container; e.g.\n      // (1) if parent has a shadyRoot, element may or may not at distributed\n      // location (could be undistributed)\n      // (2) if parent is a slot, element may not ben in composed dom\n      if (!(parentData.root || node.localName === 'slot') ||\n        (container === node[utils.NATIVE_PREFIX + 'parentNode'])) {\n        container[utils.NATIVE_PREFIX + 'removeChild'](node);\n      }\n    }\n    return node;\n  },\n\n  /**\n   * @this {Node}\n   * @param {Node} node\n   * @param {Node=} ref_node\n   */\n  replaceChild(node, ref_node) {\n    this[utils.SHADY_PREFIX + 'insertBefore'](node, ref_node);\n    this[utils.SHADY_PREFIX + 'removeChild'](ref_node);\n    return node;\n  },\n\n  /**\n   * @this {Node}\n   * @param {boolean=} deep\n   */\n  cloneNode(deep) {\n    if (this.localName == 'template') {\n      return this[utils.NATIVE_PREFIX + 'cloneNode'](deep);\n    } else {\n      const n = this[utils.NATIVE_PREFIX + 'cloneNode'](false);\n      // Attribute nodes historically had childNodes, but they have later\n      // been removed from the spec.\n      // Make sure we do not do a deep clone on them for old browsers (IE11)\n      if (deep && n.nodeType !== Node.ATTRIBUTE_NODE) {\n        for (let c=this[utils.SHADY_PREFIX + 'firstChild'], nc; c; c = c[utils.SHADY_PREFIX + 'nextSibling']) {\n          nc = c[utils.SHADY_PREFIX + 'cloneNode'](true);\n          n[utils.SHADY_PREFIX + 'appendChild'](nc);\n        }\n      }\n      return n;\n    }\n  },\n\n  /**\n   * @this {Node}\n   * @param {Object=} options\n   */\n  // TODO(sorvell): implement `options` e.g. `{ composed: boolean }`\n  getRootNode(options) { // eslint-disable-line no-unused-vars\n    if (!this || !this.nodeType) {\n      return;\n    }\n    const nodeData = ensureShadyDataForNode(this);\n    let root = nodeData.ownerShadyRoot;\n    if (root === undefined) {\n      if (utils.isShadyRoot(this)) {\n        root = this;\n        nodeData.ownerShadyRoot = root;\n      } else {\n        let parent = this[utils.SHADY_PREFIX + 'parentNode'];\n        root = parent ? parent[utils.SHADY_PREFIX + 'getRootNode'](options) : this;\n        // memo-ize result for performance but only memo-ize\n        // result if node is in the document. This avoids a problem where a root\n        // can be cached while an element is inside a fragment.\n        // If this happens and we cache the result, the value can become stale\n        // because for perf we avoid processing the subtree of added fragments.\n        if (document.documentElement[utils.NATIVE_PREFIX + 'contains'](this)) {\n          nodeData.ownerShadyRoot = root;\n        }\n      }\n\n    }\n    return root;\n  },\n\n  /** @this {Node} */\n  contains(node) {\n    return utils.contains(this, node);\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport {calculateSplices} from './array-splice.js';\nimport * as utils from './utils.js';\nimport {enqueue} from './flush.js';\nimport {ensureShadyDataForNode, shadyDataForNode} from './shady-data.js';\nimport {recordChildNodes} from './link-nodes.js';\nimport {patchShadyRoot} from './patch-shadyRoot.js';\n\n// Do not export this object. It must be passed as the first argument to the\n// ShadyRoot constructor in `attachShadow` to prevent the constructor from\n// throwing. This prevents the user from being able to manually construct a\n// ShadyRoot (i.e. `new ShadowRoot()`).\nconst ShadyRootConstructionToken = {};\n\nconst CATCHALL_NAME = '__catchall';\n\nconst MODE_CLOSED = 'closed';\n\nlet isRendering = utils.settings['deferConnectionCallbacks'] && document.readyState === 'loading';\nlet rootRendered;\n\nfunction ancestorList(node) {\n  let ancestors = [];\n  do {\n    ancestors.unshift(node);\n  } while ((node = node[utils.SHADY_PREFIX + 'parentNode']));\n  return ancestors;\n}\n\n/**\n * @extends {ShadowRoot}\n */\nclass ShadyRoot {\n\n  constructor(token, host, options) {\n    if (token !== ShadyRootConstructionToken) {\n      throw new TypeError('Illegal constructor');\n    }\n    /** @type {boolean} */\n    this._renderPending;\n    /** @type {boolean} */\n    this._hasRendered;\n    /** @type {?Array<HTMLSlotElement>} */\n    this._slotList = null;\n    /** @type {?Object<string, Array<HTMLSlotElement>>} */\n    this._slotMap;\n    /** @type {?Array<HTMLSlotElement>} */\n    this._pendingSlots;\n    this._init(host, options);\n  }\n\n  _init(host, options) {\n    // root <=> host\n    this.host = host;\n    /** @type {!string|undefined} */\n    this.mode = options && options.mode;\n    recordChildNodes(this.host);\n    const hostData = ensureShadyDataForNode(this.host);\n    /** @type {!ShadyRoot} */\n    hostData.root = this;\n    hostData.publicRoot = this.mode !== MODE_CLOSED ? this : null;\n    // setup root\n    const rootData = ensureShadyDataForNode(this);\n    rootData.firstChild = rootData.lastChild =\n        rootData.parentNode = rootData.nextSibling =\n        rootData.previousSibling = null;\n    // NOTE: optimization flag, only require an asynchronous render\n    // to record parsed children if flag is not set.\n    if (utils.settings['preferPerformance']) {\n      let n;\n      while ((n = this.host[utils.NATIVE_PREFIX + 'firstChild'])) {\n        this.host[utils.NATIVE_PREFIX + 'removeChild'](n);\n      }\n    } else {\n      this._asyncRender();\n    }\n  }\n\n  _asyncRender() {\n    if (!this._renderPending) {\n      this._renderPending = true;\n      enqueue(() => this._render());\n    }\n  }\n\n  // returns the oldest renderPending ancestor root.\n  _getPendingDistributionRoot() {\n    let renderRoot;\n    let root = this;\n    while (root) {\n      if (root._renderPending) {\n        renderRoot = root;\n      }\n      root = root._getDistributionParent();\n    }\n    return renderRoot;\n  }\n\n  // Returns the shadyRoot `this.host` if `this.host`\n  // has children that require distribution.\n  _getDistributionParent() {\n    let root = this.host[utils.SHADY_PREFIX + 'getRootNode']();\n    if (!utils.isShadyRoot(root)) {\n      return;\n    }\n    const nodeData = shadyDataForNode(this.host);\n    if (nodeData && nodeData.__childSlotCount > 0) {\n      return root;\n    }\n  }\n\n  // Renders the top most render pending shadowRoot in the distribution tree.\n  // This is safe because when a distribution parent renders, all children render.\n  _render() {\n    // If this root is not pending, it needs no rendering work. Any pending\n    // parent that needs to render wll cause this root to render.\n    const root = this._renderPending && this._getPendingDistributionRoot();\n    if (root) {\n      root._renderSelf();\n    }\n  }\n\n  _flushInitial() {\n    if (!this._hasRendered && this._renderPending) {\n      this._render();\n    }\n  }\n\n  /** @override */\n  _renderSelf() {\n    // track rendering state.\n    const wasRendering = isRendering;\n    isRendering = true;\n    this._renderPending = false;\n    if (this._slotList) {\n      this._distribute();\n      this._compose();\n    }\n    // NOTE: optimization flag, only process parsed children\n    // if optimization flag is not set.\n    // on initial render remove any undistributed children.\n    if (!utils.settings['preferPerformance'] && !this._hasRendered) {\n      for (let n=this.host[utils.SHADY_PREFIX + 'firstChild']; n; n = n[utils.SHADY_PREFIX + 'nextSibling']) {\n        const data = shadyDataForNode(n);\n        if (n[utils.NATIVE_PREFIX + 'parentNode'] === this.host &&\n            (n.localName === 'slot' || !data.assignedSlot)) {\n          this.host[utils.NATIVE_PREFIX + 'removeChild'](n);\n        }\n      }\n    }\n    this._hasRendered = true;\n    isRendering = wasRendering;\n    if (rootRendered) {\n      rootRendered();\n    }\n  }\n\n  _distribute() {\n    this._validateSlots();\n    // capture # of previously assigned nodes to help determine if dirty.\n    for (let i=0, slot; i < this._slotList.length; i++) {\n      slot = this._slotList[i];\n      this._clearSlotAssignedNodes(slot);\n    }\n    // distribute host children.\n    for (let n=this.host[utils.SHADY_PREFIX + 'firstChild']; n; n=n[utils.SHADY_PREFIX + 'nextSibling']) {\n      this._distributeNodeToSlot(n);\n    }\n    // fallback content, slotchange, and dirty roots\n    for (let i=0; i < this._slotList.length; i++) {\n      const slot = this._slotList[i];\n      const slotData = shadyDataForNode(slot);\n      // distribute fallback content\n      if (!slotData.assignedNodes.length) {\n        for (let n=slot[utils.SHADY_PREFIX + 'firstChild']; n; n=n[utils.SHADY_PREFIX + 'nextSibling']) {\n          this._distributeNodeToSlot(n, slot);\n        }\n      }\n      const slotParentData = shadyDataForNode(slot[utils.SHADY_PREFIX + 'parentNode']);\n      const slotParentRoot = slotParentData && slotParentData.root;\n      if (slotParentRoot && (slotParentRoot._hasInsertionPoint() || slotParentRoot._renderPending)) {\n        slotParentRoot._renderSelf();\n      }\n      this._addAssignedToFlattenedNodes(slotData.flattenedNodes,\n        slotData.assignedNodes);\n      let prevAssignedNodes = slotData._previouslyAssignedNodes;\n      if (prevAssignedNodes) {\n        for (let i=0; i < prevAssignedNodes.length; i++) {\n          shadyDataForNode(prevAssignedNodes[i])._prevAssignedSlot = null;\n        }\n        slotData._previouslyAssignedNodes = null;\n        // dirty if previously less assigned nodes than previously assigned.\n        if (prevAssignedNodes.length > slotData.assignedNodes.length) {\n          slotData.dirty = true;\n        }\n      }\n      /* Note: A slot is marked dirty whenever a node is newly assigned to it\n      or a node is assigned to a different slot (done in `_distributeNodeToSlot`)\n      or if the number of nodes assigned to the slot has decreased (done above);\n      */\n      if (slotData.dirty) {\n        slotData.dirty = false;\n        this._fireSlotChange(slot);\n      }\n    }\n  }\n\n  /**\n   * Distributes given `node` to the appropriate slot based on its `slot`\n   * attribute. If `forcedSlot` is given, then the node is distributed to the\n   * `forcedSlot`.\n   * Note: slot to which the node is assigned will be marked dirty for firing\n   * `slotchange`.\n   * @param {Node} node\n   * @param {Node=} forcedSlot\n   *\n   */\n  _distributeNodeToSlot(node, forcedSlot) {\n    const nodeData = ensureShadyDataForNode(node);\n    let oldSlot = nodeData._prevAssignedSlot;\n    nodeData._prevAssignedSlot = null;\n    let slot = forcedSlot;\n    if (!slot) {\n      let name = node[utils.SHADY_PREFIX + 'slot'] || CATCHALL_NAME;\n      const list = this._slotMap[name];\n      slot = list && list[0];\n    }\n    if (slot) {\n      const slotData = ensureShadyDataForNode(slot);\n      slotData.assignedNodes.push(node);\n      nodeData.assignedSlot = slot;\n    } else {\n      nodeData.assignedSlot = undefined;\n    }\n    if (oldSlot !== nodeData.assignedSlot) {\n      if (nodeData.assignedSlot) {\n        ensureShadyDataForNode(nodeData.assignedSlot).dirty = true;\n      }\n    }\n  }\n\n  /**\n   * Clears the assignedNodes tracking data for a given `slot`. Note, the current\n   * assigned node data is tracked (via _previouslyAssignedNodes and\n   * _prevAssignedSlot) to see if `slotchange` should fire. This data may be out\n   *  of date at this time because the assigned nodes may have already been\n   * distributed to another root. This is ok since this data is only used to\n   * track changes.\n   * @param {HTMLSlotElement} slot\n   */\n  _clearSlotAssignedNodes(slot) {\n    const slotData = shadyDataForNode(slot);\n    let n$ = slotData.assignedNodes;\n    slotData.assignedNodes = [];\n    slotData.flattenedNodes = [];\n    slotData._previouslyAssignedNodes = n$;\n    if (n$) {\n      for (let i=0; i < n$.length; i++) {\n        let n = shadyDataForNode(n$[i]);\n        n._prevAssignedSlot = n.assignedSlot;\n        // only clear if it was previously set to this slot;\n        // this helps ensure that if the node has otherwise been distributed\n        // ignore it.\n        if (n.assignedSlot === slot) {\n          n.assignedSlot = null;\n        }\n      }\n    }\n  }\n\n  _addAssignedToFlattenedNodes(flattened, assigned) {\n    for (let i=0, n; (i<assigned.length) && (n=assigned[i]); i++) {\n      if (n.localName == 'slot') {\n        const nestedAssigned = shadyDataForNode(n).assignedNodes;\n        if (nestedAssigned && nestedAssigned.length) {\n          this._addAssignedToFlattenedNodes(flattened, nestedAssigned);\n        }\n      } else {\n        flattened.push(assigned[i]);\n      }\n    }\n  }\n\n  _fireSlotChange(slot) {\n    // NOTE: cannot bubble correctly here so not setting bubbles: true\n    // Safari tech preview does not bubble but chrome does\n    // Spec says it bubbles (https://dom.spec.whatwg.org/#mutation-observers)\n    slot[utils.NATIVE_PREFIX + 'dispatchEvent'](new Event('slotchange'));\n    const slotData = shadyDataForNode(slot);\n    if (slotData.assignedSlot) {\n      this._fireSlotChange(slotData.assignedSlot);\n    }\n  }\n\n  // Reify dom such that it is at its correct rendering position\n  // based on logical distribution.\n  // NOTE: here we only compose parents of <slot> elements and not the\n  // shadowRoot into the host. The latter is performend via a fast path\n  // in the `logical-mutation`.insertBefore.\n  _compose() {\n    const slots = this._slotList;\n    let composeList = [];\n    for (let i=0; i < slots.length; i++) {\n      const parent = slots[i][utils.SHADY_PREFIX + 'parentNode'];\n      /* compose node only if:\n        (1) parent does not have a shadowRoot since shadowRoot has already\n        composed into the host\n        (2) we're not already composing it\n        [consider (n^2) but rare better than Set]\n      */\n      const parentData = shadyDataForNode(parent);\n      if (!(parentData && parentData.root) &&\n        composeList.indexOf(parent) < 0) {\n        composeList.push(parent);\n      }\n    }\n    for (let i=0; i < composeList.length; i++) {\n      const node = composeList[i];\n      const targetNode = node === this ? this.host : node;\n      this._updateChildNodes(targetNode, this._composeNode(node));\n    }\n  }\n\n  // Returns the list of nodes which should be rendered inside `node`.\n  _composeNode(node) {\n    let children = [];\n    for (let n=node[utils.SHADY_PREFIX + 'firstChild']; n; n = n[utils.SHADY_PREFIX + 'nextSibling']) {\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(n)) {\n        let flattenedNodes = shadyDataForNode(n).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(n);\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 = utils.nativeChildNodesArray(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 (n[utils.NATIVE_PREFIX + 'parentNode'] === container) {\n          container[utils.NATIVE_PREFIX + 'removeChild'](n);\n        }\n        // TODO(sorvell): avoid the need for splicing here.\n        composed.splice(s.index + d, 1);\n      }\n      d -= s.addedCount;\n    }\n    // process adds\n    for (let i=0, s, next; (i<splices.length) && (s=splices[i]); i++) { //eslint-disable-line no-redeclare\n      next = composed[s.index];\n      for (let j=s.index, n; j < s.index + s.addedCount; j++) {\n        n = children[j];\n        container[utils.NATIVE_PREFIX + 'insertBefore'](n, next);\n        composed.splice(j, 0, n);\n      }\n    }\n  }\n\n  _ensureSlotData() {\n    this._pendingSlots = this._pendingSlots || [];\n    this._slotList = this._slotList || [];\n    this._slotMap = this._slotMap || {};\n  }\n\n  _addSlots(slots) {\n    this._ensureSlotData();\n    this._pendingSlots.push(...slots);\n  }\n\n  _validateSlots() {\n    if (this._pendingSlots && this._pendingSlots.length) {\n      this._mapSlots(this._pendingSlots);\n      this._pendingSlots = [];\n    }\n  }\n\n  /**\n   * Adds the given slots. Slots are maintained in an dom-ordered list.\n   * In addition a map of name to slot is updated.\n   */\n  _mapSlots(slots) {\n    let slotNamesToSort;\n    for (let i=0; i < slots.length; i++) {\n      const slot = slots[i];\n      // ensure insertionPoints's and their parents have logical dom info.\n      // save logical tree info\n      // a. for shadyRoot\n      // b. for insertion points (fallback)\n      // c. for parents of insertion points\n      recordChildNodes(slot);\n      const slotParent = slot[utils.SHADY_PREFIX + 'parentNode'];\n      recordChildNodes(slotParent);\n      const slotParentData = shadyDataForNode(slotParent);\n      slotParentData.__childSlotCount = (slotParentData.__childSlotCount || 0) + 1;\n      let name = this._nameForSlot(slot);\n      if (this._slotMap[name]) {\n        slotNamesToSort = slotNamesToSort || {};\n        slotNamesToSort[name] = true;\n        this._slotMap[name].push(slot);\n      } else {\n        this._slotMap[name] = [slot];\n      }\n      this._slotList.push(slot);\n    }\n    if (slotNamesToSort) {\n      for (let n in slotNamesToSort) {\n        this._slotMap[n] = this._sortSlots(this._slotMap[n]);\n      }\n    }\n  }\n\n  _nameForSlot(slot) {\n    const name = slot['name'] || slot.getAttribute('name') || CATCHALL_NAME;\n    slot.__slotName = name;\n    return name;\n  }\n\n  /**\n   * Slots are kept in an ordered list. Slots with the same name\n   * are sorted here by tree order.\n   */\n  _sortSlots(slots) {\n    // NOTE: Cannot use `compareDocumentPosition` because it's not polyfilled,\n    // but the code here could be used to polyfill the preceeding/following info\n    // in `compareDocumentPosition`.\n    return slots.sort((a, b) => {\n      let listA = ancestorList(a);\n      let listB = ancestorList(b);\n      for (var i=0; i < listA.length; i++) {\n        let nA = listA[i];\n        let nB = listB[i];\n        if (nA !== nB) {\n          let c$ = utils.childNodesArray(nA[utils.SHADY_PREFIX + 'parentNode']);\n          return c$.indexOf(nA) - c$.indexOf(nB);\n        }\n      }\n    });\n  }\n\n  /**\n   * Removes from tracked slot data any slots contained within `container` and\n   * then updates the tracked data (_slotList and _slotMap).\n   * Any removed slots also have their `assignedNodes` removed from comopsed dom.\n   */\n  _removeContainedSlots(container) {\n    if (!this._slotList) {\n      return;\n    }\n    this._validateSlots();\n    let didRemove;\n    const map = this._slotMap;\n    for (let n in map) {\n      const slots = map[n];\n      for (let i=0; i < slots.length; i++) {\n        const slot = slots[i];\n        if (utils.contains(container, slot)) {\n          slots.splice(i, 1);\n          const x = this._slotList.indexOf(slot);\n          if (x >= 0) {\n            this._slotList.splice(x, 1);\n            const slotParentData = shadyDataForNode(slot[utils.SHADY_PREFIX + 'parentNode']);\n            if (slotParentData && slotParentData.__childSlotCount) {\n              slotParentData.__childSlotCount--;\n            }\n          }\n          i--;\n          this._removeFlattenedNodes(slot);\n          didRemove = true;\n        }\n      }\n    }\n    return didRemove;\n  }\n\n  _updateSlotName(slot) {\n    if (!this._slotList) {\n      return;\n    }\n    // make sure slotMap is initialized with this slot\n    this._validateSlots();\n    const oldName = slot.__slotName;\n    const name = this._nameForSlot(slot);\n    if (name === oldName) {\n      return;\n    }\n    // remove from existing tracking\n    let slots = this._slotMap[oldName];\n    const i = slots.indexOf(slot);\n    if (i >= 0) {\n      slots.splice(i, 1);\n    }\n    // add to new location and sort if nedessary\n    let list = this._slotMap[name] || (this._slotMap[name] = []);\n    list.push(slot);\n    if (list.length > 1) {\n      this._slotMap[name] = this._sortSlots(list);\n    }\n  }\n\n  _removeFlattenedNodes(slot) {\n    const data = shadyDataForNode(slot);\n    let n$ = data.flattenedNodes;\n    if (n$) {\n      for (let i=0; i<n$.length; i++) {\n        let node = n$[i];\n        let parent = node[utils.NATIVE_PREFIX + 'parentNode'];\n        if (parent) {\n          parent[utils.NATIVE_PREFIX + 'removeChild'](node);\n        }\n      }\n    }\n    data.flattenedNodes = [];\n    data.assignedNodes = [];\n  }\n\n  _hasInsertionPoint() {\n    this._validateSlots();\n    return Boolean(this._slotList && this._slotList.length);\n  }\n}\n\npatchShadyRoot(ShadyRoot.prototype);\nexport {ShadyRoot};\n\n/**\n  Implements a pared down version of ShadowDOM's scoping, which is easy to\n  polyfill across browsers.\n*/\nexport const attachShadow = (host, options) => {\n  if (!host) {\n    throw new Error('Must provide a host.');\n  }\n  if (!options) {\n    throw new Error('Not enough arguments.');\n  }\n  let root;\n  // Optimization for booting up a shadowRoot from a fragment rather than\n  // creating one.\n  if (options['shadyUpgradeFragment'] && utils.canUpgrade()) {\n    root = options['shadyUpgradeFragment'];\n    root.__proto__ = ShadowRoot.prototype;\n    root._init(host, options);\n    recordChildNodes(root, root);\n    // Note: qsa is native when used with noPatch.\n    /** @type {?NodeList<Element>} */\n    const slotsAdded = root['__noInsertionPoint'] ? null : root.querySelectorAll('slot');\n    // Reset scoping information so normal scoing rules apply after this.\n    root['__noInsertionPoint'] = undefined;\n    // if a slot is added, must render containing root.\n    if (slotsAdded && slotsAdded.length) {\n      root._addSlots(slotsAdded);\n      root._asyncRender();\n    }\n    /** @type {ShadowRoot} */(root).host[utils.NATIVE_PREFIX + 'appendChild'](root);\n  } else {\n    root = new ShadyRoot(ShadyRootConstructionToken, host, options);\n  }\n  return root;\n}\n\n// Mitigate connect/disconnect spam by wrapping custom element classes. This\n// should happen if custom elements are available in any capacity, polyfilled or\n// not.\nif (utils.hasCustomElements() && utils.settings.inUse && !utils.settings['preferPerformance']) {\n\n  // process connect/disconnect after roots have rendered to avoid\n  // issues with reaction stack.\n  let connectMap = new Map();\n  rootRendered = function() {\n    // allow elements to connect\n    // save map state (without needing polyfills on IE11)\n    const r = [];\n    connectMap.forEach((v, k) => {\n      r.push([k, v]);\n    });\n    connectMap.clear();\n    for (let i=0; i < r.length; i++) {\n      const e = r[i][0], value = r[i][1];\n      if (value) {\n        e['__shadydom_connectedCallback']();\n      } else {\n        e['__shadydom_disconnectedCallback']();\n      }\n    }\n  }\n\n  // Document is in loading state and flag is set (deferConnectionCallbacks)\n  // so process connection stack when `readystatechange` fires.\n  if (isRendering) {\n    document.addEventListener('readystatechange', () => {\n      isRendering = false;\n      rootRendered();\n    }, {once: true});\n  }\n\n  /*\n   * (1) elements can only be connected/disconnected if they are in the expected\n   * state.\n   * (2) never run connect/disconnect during rendering to avoid reaction stack issues.\n   */\n  const ManageConnect = (base, connected, disconnected) => {\n    let counter = 0;\n    const connectFlag = `__isConnected${counter++}`;\n    if (connected || disconnected) {\n\n      /** @this {!HTMLElement} */\n      base.prototype.connectedCallback = base.prototype['__shadydom_connectedCallback'] = function() {\n        // if rendering defer connected\n        // otherwise connect only if we haven't already\n        if (isRendering) {\n          connectMap.set(this, true);\n        } else if (!this[connectFlag]) {\n          this[connectFlag] = true;\n          if (connected) {\n            connected.call(this);\n          }\n        }\n      }\n\n      /** @this {!HTMLElement} */\n      base.prototype.disconnectedCallback = base.prototype['__shadydom_disconnectedCallback'] = function() {\n        // if rendering, cancel a pending connection and queue disconnect,\n        // otherwise disconnect only if a connection has been allowed\n        if (isRendering) {\n          // This is necessary only because calling removeChild\n          // on a node that requires distribution leaves it in the DOM tree\n          // until distribution.\n          // NOTE: remember this is checking the patched isConnected to determine\n          // if the node is in the logical tree.\n          if (!this.isConnected) {\n            connectMap.set(this, false);\n          }\n        } else if (this[connectFlag]) {\n          this[connectFlag] = false;\n          if (disconnected) {\n            disconnected.call(this);\n          }\n        }\n      }\n    }\n\n    return base;\n  }\n\n  const originalDefine = window['customElements']['define'];\n  const define = function(name, constructor) {\n    const connected = constructor.prototype.connectedCallback;\n    const disconnected = constructor.prototype.disconnectedCallback;\n    originalDefine.call(window['customElements'], name,\n        ManageConnect(constructor, connected, disconnected));\n    // unpatch connected/disconnected on class; custom elements tears this off\n    // so the patch is maintained, but if the user calls these methods for\n    // e.g. testing, they will be as expected.\n    constructor.prototype.connectedCallback = connected;\n    constructor.prototype.disconnectedCallback = disconnected;\n  }\n  // Note, it would be better to only patch the CustomElementRegistry.prototype,\n  // but ShadyCSS patches define directly.\n  window.customElements.define = define;\n  // Still patch the registry directly since Safari 10 loses the patch\n  // unless this is done.\n  Object.defineProperty(window['CustomElementRegistry'].prototype, 'define', {\n    value: define,\n    configurable: true\n  });\n}\n\n/** @return {!ShadyRoot|undefined} */\nexport const ownerShadyRootForNode = (node) => {\n  let root = node[utils.SHADY_PREFIX + 'getRootNode']();\n  if (utils.isShadyRoot(root)) {\n    return root;\n  }\n}\n",null,"/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {shadyDataForNode} from '../shady-data.js';\n\nexport const SlotablePatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Node} */\n  get assignedSlot() {\n    // Force any parent's shadowRoot to flush so that distribution occurs\n    // and this node has an assignedSlot.\n    const parent = this[utils.SHADY_PREFIX + 'parentNode'];\n    const ownerRoot = parent && parent[utils.SHADY_PREFIX + 'shadowRoot'];\n    if (ownerRoot) {\n      ownerRoot._render();\n    }\n    const nodeData = shadyDataForNode(this);\n    return nodeData && nodeData.assignedSlot || null;\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {shadyDataForNode} from '../shady-data.js';\n\n/**\n * @param {Node} node\n * @param {Function} matcher\n * @param {Function=} halter\n */\nexport function query(node, matcher, halter) {\n  let list = [];\n  queryChildNodes(node, matcher,\n    halter, list);\n  return list;\n}\n\nfunction queryChildNodes(parent, matcher, halter, list) {\n  for (let n = parent[utils.SHADY_PREFIX + 'firstChild']; n; n = n[utils.SHADY_PREFIX + 'nextSibling']) {\n    if (n.nodeType === Node.ELEMENT_NODE &&\n        queryElement(n, 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  queryChildNodes(node, matcher,\n    halter, list);\n}\n\n// Needed on Element, DocumentFragment, Document\nexport const ParentNodePatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Element} */\n  get firstElementChild() {\n    const nodeData = shadyDataForNode(this);\n    if (nodeData && nodeData.firstChild !== undefined) {\n      let n = this[utils.SHADY_PREFIX + 'firstChild'];\n      while (n && n.nodeType !== Node.ELEMENT_NODE) {\n        n = n[utils.SHADY_PREFIX + 'nextSibling'];\n      }\n      return n;\n    } else {\n      return this[utils.NATIVE_PREFIX + 'firstElementChild'];\n    }\n  },\n\n  /** @this {Element} */\n  get lastElementChild() {\n    const nodeData = shadyDataForNode(this);\n    if (nodeData && nodeData.lastChild !== undefined) {\n      let n = this[utils.SHADY_PREFIX + 'lastChild'];\n      while (n && n.nodeType !== Node.ELEMENT_NODE) {\n        n = n[utils.SHADY_PREFIX + 'previousSibling'];\n      }\n      return n;\n    } else {\n      return this[utils.NATIVE_PREFIX + 'lastElementChild'];\n    }\n  },\n\n  /** @this {Element} */\n  get children() {\n    if (!utils.isTrackingLogicalChildNodes(this)) {\n      return this[utils.NATIVE_PREFIX + 'children'];\n    }\n    return utils.createPolyfilledHTMLCollection(Array.prototype.filter.call(\n        utils.childNodesArray(this), (n) => {\n      return (n.nodeType === Node.ELEMENT_NODE);\n    }));\n  },\n\n  /** @this {Element} */\n  get childElementCount() {\n    let children = this[utils.SHADY_PREFIX + 'children'];\n    if(children) {\n      return children.length;\n    }\n    return 0;\n  }\n\n});\n\nexport const QueryPatches = utils.getOwnPropertyDescriptors({\n  // TODO(sorvell): consider doing native QSA and filtering results.\n  /**\n   * @this {Element}\n   * @param  {string} selector\n   */\n  querySelector(selector) {\n    // match selector and halt on first result.\n    let result = query(this, function(n) {\n      return utils.matchesSelector(n, selector);\n    }, function(n) {\n      return Boolean(n);\n    })[0];\n    return result || null;\n  },\n\n  /**\n   * @this {Element}\n   * @param  {string} selector\n   * @param  {boolean} useNative\n   */\n  // TODO(sorvell): `useNative` option relies on native querySelectorAll and\n  // misses distributed nodes, see\n  // https://github.com/webcomponents/shadydom/pull/210#issuecomment-361435503\n  querySelectorAll(selector, useNative) {\n    if (useNative) {\n      const o = Array.prototype.slice.call(this[utils.NATIVE_PREFIX + 'querySelectorAll'](selector));\n      const root = this[utils.SHADY_PREFIX + 'getRootNode']();\n      return utils.createPolyfilledHTMLCollection(o.filter(e => e[utils.SHADY_PREFIX + 'getRootNode']() == root));\n    }\n    return utils.createPolyfilledHTMLCollection(query(this, function(n) {\n      return utils.matchesSelector(n, selector);\n    }));\n  }\n\n});\n\n// In preferPerformance mode, create a custom `ParentNodeDocumentOrFragment`\n// that optionally does not mixin querySelector/All; this is a performance\n// optimization. In noPatch, we need to keep the query patches here in order to\n// ensure the query API is available on the wrapper\nexport const ParentNodeDocumentOrFragmentPatches =\n  (utils.settings.preferPerformance && !utils.settings.noPatch) ?\n  utils.assign({}, ParentNodePatches) : ParentNodePatches;\n\nutils.assign(ParentNodePatches, QueryPatches);\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {scopeClassAttribute} from '../style-scoping.js';\nimport {shadyDataForNode} from '../shady-data.js';\nimport {attachShadow, ownerShadyRootForNode} from '../attach-shadow.js';\nimport {eventPropertyNamesForElement, wrappedDescriptorForEventProperty} from '../patch-events.js';\n\nconst doc = window.document;\n\n/**\n * Should be called whenever an attribute changes. If the `slot` attribute\n * changes, provokes rendering if necessary. If a `<slot>` element's `name`\n * attribute changes, updates the root's slot map and renders.\n * @param {Node} node\n * @param {string} name\n */\nfunction distributeAttributeChange(node, name) {\n  if (name === 'slot') {\n    const parent = node[utils.SHADY_PREFIX + 'parentNode'];\n    if (utils.hasShadowRootWithSlot(parent)) {\n      shadyDataForNode(parent).root._asyncRender();\n    }\n  } else if (node.localName === 'slot' && name === 'name') {\n    let root = ownerShadyRootForNode(node);\n    if (root) {\n      root._updateSlotName(node);\n      root._asyncRender();\n    }\n  }\n}\n\nexport const ElementPatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Element} */\n  get previousElementSibling() {\n    const nodeData = shadyDataForNode(this);\n    if (nodeData && nodeData.previousSibling !== undefined) {\n      let n = this[utils.SHADY_PREFIX + 'previousSibling'];\n      while (n && n.nodeType !== Node.ELEMENT_NODE) {\n        n = n[utils.SHADY_PREFIX + 'previousSibling'];\n      }\n      return n;\n    } else {\n      return this[utils.NATIVE_PREFIX + 'previousElementSibling'];\n    }\n  },\n\n  /** @this {Element} */\n  get nextElementSibling() {\n    const nodeData = shadyDataForNode(this);\n    if (nodeData && nodeData.nextSibling !== undefined) {\n      let n = this[utils.SHADY_PREFIX + 'nextSibling'];\n      while (n && n.nodeType !== Node.ELEMENT_NODE) {\n        n = n[utils.SHADY_PREFIX + 'nextSibling'];\n      }\n      return n;\n    } else {\n      return this[utils.NATIVE_PREFIX + 'nextElementSibling'];\n    }\n  },\n\n  /** @this {Element} */\n  get slot() {\n    return this.getAttribute('slot');\n  },\n\n  /** @this {Element} */\n  set slot(value) {\n    this[utils.SHADY_PREFIX + 'setAttribute']('slot', value);\n  },\n\n  /** @this {Element} */\n  get className() {\n    return this.getAttribute('class') || '';\n  },\n\n  /**\n   * @this {Element}\n   * @param {string} value\n   */\n  set className(value) {\n    this[utils.SHADY_PREFIX + 'setAttribute']('class', value);\n  },\n\n  /**\n   * @this {Element}\n   * @param {string} attr\n   * @param {string} value\n   */\n  setAttribute(attr, value) {\n    if (this.ownerDocument !== doc) {\n      this[utils.NATIVE_PREFIX + 'setAttribute'](attr, value);\n    } else if (!scopeClassAttribute(this, attr, value)) {\n      this[utils.NATIVE_PREFIX + 'setAttribute'](attr, value);\n      distributeAttributeChange(this, attr);\n    }\n  },\n\n  /**\n   * @this {Element}\n   * @param {string} attr\n   */\n  removeAttribute(attr) {\n    if (this.ownerDocument !== doc) {\n      this[utils.NATIVE_PREFIX + 'removeAttribute'](attr);\n    } else if (!scopeClassAttribute(this, attr, '')) {\n      this[utils.NATIVE_PREFIX + 'removeAttribute'](attr);\n      distributeAttributeChange(this, attr);\n    } else if (this.getAttribute(attr) === '') {\n      // ensure that \"class\" attribute is fully removed if ShadyCSS does not keep scoping\n      this[utils.NATIVE_PREFIX + 'removeAttribute'](attr);\n    }\n  }\n\n});\n\nif (!utils.settings.preferPerformance) {\n  eventPropertyNamesForElement.forEach(property => {\n    ElementPatches[property] = wrappedDescriptorForEventProperty(property);\n  });\n}\n\nexport const ElementShadowPatches = utils.getOwnPropertyDescriptors({\n  /**\n   * @this {Element}\n   * @param {!{mode: string}} options\n   */\n  attachShadow(options) {\n    const root = attachShadow(this, options);\n    // TODO(sorvell): Workaround for CE not seeing shadowRoot in `on-demand`\n    // noPatch mode. CE's attachShadow patch is overwritten by this patch\n    // and cannot set its own special tracking for shadowRoot. It does this\n    // to be able to see closed shadowRoots.\n    // This is necessary so that the CE polyfill can traverse into nodes\n    // with shadowRoot that will under `on-demand` have their childNodes patched.\n    this['__CE_shadowRoot'] = root;\n    return root;\n  },\n\n  // Note: Can be patched on element prototype on all browsers.\n  // Must be patched on instance on browsers that support native Shadow DOM\n  // but do not have builtin accessors (old Chrome).\n  /** @this {Element} */\n  get shadowRoot() {\n    const nodeData = shadyDataForNode(this);\n    return nodeData && nodeData.publicRoot || null;\n  },\n});\n\nutils.assign(ElementPatches, ElementShadowPatches);\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {getInnerHTML} from '../innerHTML.js';\nimport {clearNode} from './Node.js';\n\n/** @type {!Document} */\nconst inertDoc = document.implementation.createHTMLDocument('inert');\n\nexport const ElementOrShadowRootPatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Element} */\n  get innerHTML() {\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      const content = this.localName === 'template' ?\n      /** @type {HTMLTemplateElement} */(this).content : this;\n      return getInnerHTML(content, utils.childNodesArray);\n    } else {\n      return this[utils.NATIVE_PREFIX + 'innerHTML'];\n    }\n  },\n\n  /**\n   * @this {Element}\n   * @param {string} value\n   */\n  set innerHTML(value) {\n    if (this.localName === 'template') {\n      this[utils.NATIVE_PREFIX + 'innerHTML'] = value;\n    } else {\n      clearNode(this);\n      const containerName = this.localName || 'div';\n      let htmlContainer;\n      if (!this.namespaceURI || this.namespaceURI === inertDoc.namespaceURI) {\n        htmlContainer = inertDoc.createElement(containerName);\n      } else {\n        htmlContainer = inertDoc.createElementNS(this.namespaceURI, containerName);\n      }\n      if (utils.settings.hasDescriptors) {\n        htmlContainer[utils.NATIVE_PREFIX + 'innerHTML'] = value;\n      } else {\n        htmlContainer.innerHTML = value;\n      }\n      let firstChild;\n      while ((firstChild = htmlContainer[utils.SHADY_PREFIX + 'firstChild'])) {\n        this[utils.SHADY_PREFIX + 'insertBefore'](firstChild);\n      }\n    }\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {eventPropertyNamesForHTMLElement, wrappedDescriptorForEventProperty} from '../patch-events.js';\nimport {shadyDataForNode} from '../shady-data.js';\n\nexport const HTMLElementPatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {HTMLElement} */\n  blur() {\n    const nodeData = shadyDataForNode(this);\n    let root = nodeData && nodeData.root;\n    let shadowActive = root && root.activeElement;\n    if (shadowActive) {\n      shadowActive[utils.SHADY_PREFIX + 'blur']();\n    } else {\n      this[utils.NATIVE_PREFIX + 'blur']();\n    }\n  }\n\n});\n\nif (!utils.settings.preferPerformance) {\n  eventPropertyNamesForHTMLElement.forEach(property => {\n    HTMLElementPatches[property] = wrappedDescriptorForEventProperty(property);\n  });\n}\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {shadyDataForNode} from '../shady-data.js';\nimport {addEventListener, removeEventListener} from '../patch-events.js';\n\nexport const SlotPatches = utils.getOwnPropertyDescriptors({\n\n  /**\n   * @this {HTMLSlotElement}\n   * @param {Object=} options\n   */\n  assignedNodes(options) {\n    if (this.localName === 'slot') {\n      // Force any containing shadowRoot to flush so that distribution occurs\n      // and this node has assignedNodes.\n      const root = this[utils.SHADY_PREFIX + 'getRootNode']();\n      if (root && utils.isShadyRoot(root)) {\n        root._render();\n      }\n      const nodeData = shadyDataForNode(this);\n      return nodeData ?\n        ((options && options.flatten ? nodeData.flattenedNodes :\n          nodeData.assignedNodes) || []) :\n        [];\n    }\n  },\n\n  /**\n   * @this {HTMLSlotElement}\n   * @param {string} type\n   * @param {Function} fn\n   * @param {Object|boolean=} optionsOrCapture\n   */\n  addEventListener(type, fn, optionsOrCapture) {\n    // NOTE, check if this is a `slot` because these patches are installed on\n    // Element where browsers don't have `<slot>`\n    if (this.localName !== 'slot' || type === 'slotchange') {\n      addEventListener.call(this, type, fn, optionsOrCapture);\n    } else {\n      if (typeof optionsOrCapture !== 'object') {\n        optionsOrCapture = {\n          capture: Boolean(optionsOrCapture)\n        }\n      }\n      const parent = this[utils.SHADY_PREFIX + 'parentNode'];\n      if (!parent) {\n        throw new Error('ShadyDOM cannot attach event to slot unless it has a `parentNode`');\n      }\n      optionsOrCapture.__shadyTarget = this;\n      parent[utils.SHADY_PREFIX + 'addEventListener'](type, fn, optionsOrCapture);\n    }\n  },\n\n  /**\n   * @this {HTMLSlotElement}\n   * @param {string} type\n   * @param {Function} fn\n   * @param {Object|boolean=} optionsOrCapture\n   */\n  removeEventListener(type, fn, optionsOrCapture) {\n    // NOTE, check if this is a `slot` because these patches are installed on\n    // Element where browsers don't have `<slot>`\n    if (this.localName !== 'slot' || type === 'slotchange') {\n      removeEventListener.call(this, type, fn, optionsOrCapture);\n    } else {\n      if (typeof optionsOrCapture !== 'object') {\n        optionsOrCapture = {\n          capture: Boolean(optionsOrCapture)\n        }\n      }\n      const parent = this[utils.SHADY_PREFIX + 'parentNode'];\n      if (!parent) {\n        throw new Error('ShadyDOM cannot attach event to slot unless it has a `parentNode`');\n      }\n      optionsOrCapture.__shadyTarget = this;\n      parent[utils.SHADY_PREFIX + 'removeEventListener'](type, fn, optionsOrCapture);\n    }\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport * as utils from '../utils.js';\nimport { query } from './ParentNode.js';\n\nexport const DocumentOrFragmentPatches = utils.getOwnPropertyDescriptors({\n\n  /**\n   * @this {Element}\n   * @param {string} id\n   */\n  getElementById(id) {\n    if (id === '') {\n      return null;\n    }\n    let result = query(this, function(n) {\n      return n.id == id;\n    }, function(n) {\n      return Boolean(n);\n    })[0];\n    return result || null;\n  }\n\n});","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {ownerShadyRootForNode} from '../attach-shadow.js';\n\nfunction getDocumentActiveElement() {\n  if (utils.settings.hasDescriptors) {\n    return document[utils.NATIVE_PREFIX + 'activeElement'];\n  } else {\n    return document.activeElement;\n  }\n}\n\nexport const DocumentOrShadowRootPatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Document|ShadowRoot} */\n  get activeElement() {\n    let active = getDocumentActiveElement();\n    // In IE11, activeElement might be an empty object if the document is\n    // contained in an iframe.\n    // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/10998788/\n    if (!active || !active.nodeType) {\n      return null;\n    }\n    let isShadyRoot = !!(utils.isShadyRoot(this));\n    if (this !== document) {\n      // If this node isn't a document or shady root, then it doesn't have\n      // an active element.\n      if (!isShadyRoot) {\n        return null;\n      }\n      // If this shady root's host is the active element or the active\n      // element is not a descendant of the host (in the composed tree),\n      // then it doesn't have an active element.\n      if (this.host === active ||\n          !this.host[utils.NATIVE_PREFIX + 'contains'](active)) {\n        return null;\n      }\n    }\n    // This node is either the document or a shady root of which the active\n    // element is a (composed) descendant of its host; iterate upwards to\n    // find the active element's most shallow host within it.\n    let activeRoot = ownerShadyRootForNode(active);\n    while (activeRoot && activeRoot !== this) {\n      active = activeRoot.host;\n      activeRoot = ownerShadyRootForNode(active);\n    }\n    if (this === document) {\n      // This node is the document, so activeRoot should be null.\n      return activeRoot ? null : active;\n    } else {\n      // This node is a non-document shady root, and it should be\n      // activeRoot.\n      return activeRoot === this ? active : null;\n    }\n  }\n});\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\n\nconst doc = window.document;\n\nexport const DocumentPatches = utils.getOwnPropertyDescriptors({\n\n  // note: Though not technically correct, we fast path `importNode`\n  // when called on a node not owned by the main document.\n  // This allows, for example, elements that cannot\n  // contain custom elements and are therefore not likely to contain shadowRoots\n  // to cloned natively. This is a fairly significant performance win.\n  /**\n   * @this {Document}\n   * @param {Node} node\n   * @param {boolean} deep\n   */\n  importNode(node, deep) {\n    // A template element normally has no children with shadowRoots, so make\n    // sure we always make a deep copy to correctly construct the template.content\n    if (node.ownerDocument !== doc || node.localName === 'template') {\n      return this[utils.NATIVE_PREFIX + 'importNode'](node, deep);\n    }\n    let n = this[utils.NATIVE_PREFIX + 'importNode'](node, false);\n    if (deep) {\n      for (let c=node[utils.SHADY_PREFIX + 'firstChild'], nc; c; c = c[utils.SHADY_PREFIX + 'nextSibling']) {\n        nc = this[utils.SHADY_PREFIX + 'importNode'](c, true);\n        n[utils.SHADY_PREFIX + 'appendChild'](nc);\n      }\n    }\n    return n;\n  }\n\n});","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport * as utils from '../utils.js';\nimport {addEventListener, removeEventListener, dispatchEvent} from '../patch-events.js';\n\nexport const WindowPatches = utils.getOwnPropertyDescriptors({\n\n  // Ensure that `dispatchEvent` is patched directly on Window since on\n  // IE11, Window does not descend from EventTarget.\n  dispatchEvent,\n\n  // NOTE: ensure these methods are bound to `window` so that `this` is correct\n  // when called directly from global context without a receiver; e.g.\n  // `addEventListener(...)`.\n  addEventListener: addEventListener.bind(window),\n\n  removeEventListener: removeEventListener.bind(window)\n\n});","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\nimport {EventTargetPatches} from './patches/EventTarget.js';\nimport {NodePatches} from './patches/Node.js';\nimport {SlotablePatches} from './patches/Slotable.js';\nimport {ParentNodePatches, ParentNodeDocumentOrFragmentPatches} from './patches/ParentNode.js';\nimport {ElementPatches, ElementShadowPatches} from './patches/Element.js';\nimport {ElementOrShadowRootPatches} from './patches/ElementOrShadowRoot.js';\nimport {HTMLElementPatches} from './patches/HTMLElement.js';\nimport {SlotPatches} from './patches/Slot.js';\nimport {DocumentOrFragmentPatches} from './patches/DocumentOrFragment.js';\nimport {DocumentOrShadowRootPatches} from './patches/DocumentOrShadowRoot.js';\nimport {DocumentPatches} from './patches/Document.js';\nimport {WindowPatches} from './patches/Window.js';\n\n// Some browsers (IE/Edge) have non-standard HTMLElement accessors.\nconst NonStandardHTMLElement = {};\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'parentElement')) {\n  NonStandardHTMLElement.parentElement = NodePatches.parentElement;\n}\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'contains')) {\n  NonStandardHTMLElement.contains = NodePatches.contains;\n}\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'children')) {\n  NonStandardHTMLElement.children = ParentNodePatches.children;\n}\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'innerHTML')) {\n  NonStandardHTMLElement.innerHTML = ElementOrShadowRootPatches.innerHTML;\n}\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'className')) {\n  NonStandardHTMLElement.className = ElementPatches.className;\n}\n\n// Avoid patching `innerHTML` if it does not exist on Element (IE)\n// and we can patch accessors (hasDescriptors).\nconst ElementShouldHaveInnerHTML = !utils.settings.hasDescriptors || 'innerHTML' in Element.prototype;\n\n// setup patching\nconst patchMap = {\n  EventTarget: [EventTargetPatches],\n  Node: [NodePatches, !window.EventTarget ? EventTargetPatches : null],\n  Text: [SlotablePatches],\n  Comment: [SlotablePatches],\n  CDATASection: [SlotablePatches],\n  ProcessingInstruction: [SlotablePatches],\n  Element: [ElementPatches, ParentNodePatches, SlotablePatches,\n    ElementShouldHaveInnerHTML ? ElementOrShadowRootPatches : null,\n    !window.HTMLSlotElement ? SlotPatches : null],\n  HTMLElement: [HTMLElementPatches, NonStandardHTMLElement],\n  HTMLSlotElement: [SlotPatches],\n  DocumentFragment: [ParentNodeDocumentOrFragmentPatches, DocumentOrFragmentPatches],\n  Document: [DocumentPatches, ParentNodeDocumentOrFragmentPatches, DocumentOrFragmentPatches, DocumentOrShadowRootPatches],\n  Window: [WindowPatches]\n}\n\nconst getPatchPrototype = (name) => window[name] && window[name].prototype;\n\n// Note, must avoid patching accessors on prototypes when descriptors are not correct\n// because the CustomElements polyfill checks if these exist before patching instances.\n// CustomElements polyfill *only* cares about these accessors.\nconst disallowedNativePatches = utils.settings.hasDescriptors ? null : ['innerHTML', 'textContent'];\n\n/**\n * Patch a group of accessors on an object.\n * @param {!Object} proto\n * @param {!Array<Object>} list\n * @param {string=} prefix\n * @param {Array=} disallowed\n */\nfunction applyPatchList(proto, list, prefix, disallowed) {\n  list.forEach(patch => proto && patch &&\n    utils.patchProperties(proto, patch, prefix, disallowed));\n}\n\n/** @param {string=} prefix */\nexport const applyPatches = (prefix) => {\n  const disallowed = prefix ? null : disallowedNativePatches;\n  for (let p in patchMap) {\n    const proto = getPatchPrototype(p);\n    applyPatchList(proto, patchMap[p], prefix, disallowed);\n  }\n}\n\nconst PROTO_IS_PATCHED = utils.SHADY_PREFIX + 'protoIsPatched';\n\n// This property is stored directly on these objects, rather than in a local\n// Map, because IE11 has a bug around `defineProperty`/`hasOwnProperty` which\n// breaks Closure Compiler's WeakMap polyfill when using both certain native\n// prototypes (e.g. of CDATASection) and their instances as keys - even if\n// they're isolated to different WeakMaps. Closure's WeakMap polyfill is used\n// transitively by its own Map and Set polyfills, so this bug applies to any\n// situation where either of Map or Set are polyfilled also.\nconst PATCHED_PROTO = utils.SHADY_PREFIX + 'patchedProto';\n\n// Patch non-element prototypes up front so that we don't have to check\n// the type of Node when patching an can always assume we're patching an element.\n['Text', 'Comment', 'CDATASection', 'ProcessingInstruction'].forEach(name => {\n  const ctor = window[name];\n  const patchedProto = Object.create(ctor.prototype);\n  patchedProto[PROTO_IS_PATCHED] = true;\n  applyPatchList(patchedProto, patchMap.EventTarget);\n  applyPatchList(patchedProto, patchMap.Node);\n  if (patchMap[name]) {\n    applyPatchList(patchedProto, patchMap[name]);\n  }\n  ctor.prototype[PATCHED_PROTO] = patchedProto;\n});\n\nexport const patchElementProto = (proto) => {\n  proto[PROTO_IS_PATCHED] = true;\n  applyPatchList(proto, patchMap.EventTarget);\n  applyPatchList(proto, patchMap.Node);\n  applyPatchList(proto, patchMap.Element);\n  applyPatchList(proto, patchMap.HTMLElement);\n  applyPatchList(proto, patchMap.HTMLSlotElement);\n  return proto;\n}\n\nexport const patchNodeProto = (node) => {\n  if (node[PROTO_IS_PATCHED] || utils.isShadyRoot(node)) {\n    return;\n  }\n  const nativeProto = Object.getPrototypeOf(node);\n  // Note, this hasOwnProperty check is critical to avoid seeing a patched\n  // prototype lower in the prototype chain, e.g. if an <s> element has been\n  // patched, without this check, an <input> element would get the wrong patch.\n  let proto = nativeProto.hasOwnProperty(PATCHED_PROTO) && nativeProto[PATCHED_PROTO];\n  if (!proto) {\n    proto = Object.create(nativeProto);\n    patchElementProto(proto);\n    nativeProto[PATCHED_PROTO] = proto;\n  }\n  Object.setPrototypeOf(node, proto);\n}\n\nexport const patchShadowOnElement = () => {\n  utils.patchProperties(Element.prototype, ElementShadowPatches);\n}\n\nexport const addShadyPrefixedProperties = () => {\n  // perform shady patches\n  applyPatches(utils.SHADY_PREFIX);\n\n  // install `_activeElement` because some browsers (older Chrome/Safari) do not have\n  // a 'configurable' `activeElement` accesssor.\n  const descriptor = DocumentOrShadowRootPatches.activeElement;\n  Object.defineProperty(document, '_activeElement', descriptor);\n\n  // On Window, we're patching `addEventListener` which is a weird auto-bound\n  // property that is not directly on the Window prototype.\n  utils.patchProperties(Window.prototype, WindowPatches, utils.SHADY_PREFIX);\n};\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\nimport {shadyDataForNode, ensureShadyDataForNode} from './shady-data.js';\nimport {patchInsideElementAccessors, patchOutsideElementAccessors} from './patch-instances.js';\nimport {patchNodeProto} from './patch-prototypes.js';\n\nconst OutsideAccessors = 1;\nconst InsideAcccessors = 2;\n\nconst patchOnDemand = utils.settings.patchOnDemand;\nconst hasDescriptors = utils.settings.hasDescriptors;\n\nfunction patchNode(node, type) {\n  if (patchOnDemand) {\n    patchNodeProto(node);\n  }\n  if (!hasDescriptors) {\n    if (type === OutsideAccessors) {\n      patchOutsideElementAccessors(node);\n    } else if (type === InsideAcccessors) {\n      patchInsideElementAccessors(node);\n    }\n  }\n}\n\nfunction linkNode(node, container, containerData, ref_node) {\n  patchNode(node, OutsideAccessors);\n  ref_node = ref_node || null;\n  const nodeData = ensureShadyDataForNode(node);\n  const ref_nodeData = ref_node ? ensureShadyDataForNode(ref_node) : null;\n  // update ref_node.previousSibling <-> node\n  nodeData.previousSibling = ref_node ? ref_nodeData.previousSibling :\n    container[utils.SHADY_PREFIX + 'lastChild'];\n  let psd = shadyDataForNode(nodeData.previousSibling);\n  if (psd) {\n    psd.nextSibling = node;\n  }\n  // update node <-> ref_node\n  let nsd = shadyDataForNode(nodeData.nextSibling = ref_node);\n  if (nsd) {\n    nsd.previousSibling = node;\n  }\n  // update node <-> container\n  nodeData.parentNode = container;\n  if (ref_node) {\n    if (ref_node === containerData.firstChild) {\n      containerData.firstChild = node;\n    }\n  } else {\n    containerData.lastChild = node;\n    if (!containerData.firstChild) {\n      containerData.firstChild = node;\n    }\n  }\n  // remove caching of childNodes\n  containerData.childNodes = null;\n}\n\nexport const recordInsertBefore = (node, container, ref_node) => {\n  patchNode(container, InsideAcccessors);\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    // Note, documentFragments should not have logical DOM so there's\n    // no need update that. It is possible to append a ShadowRoot, but we're\n    // choosing not to support that.\n    const first = node[utils.NATIVE_PREFIX + 'firstChild'];\n    for (let n = first; n; (n = n[utils.NATIVE_PREFIX + 'nextSibling'])) {\n      linkNode(n, container, containerData, ref_node);\n    }\n  } else {\n    linkNode(node, container, containerData, ref_node);\n  }\n}\n\nexport const recordRemoveChild = (node, container) => {\n  const nodeData = ensureShadyDataForNode(node);\n  const containerData = ensureShadyDataForNode(container);\n  if (node === containerData.firstChild) {\n    containerData.firstChild = nodeData.nextSibling;\n  }\n  if (node === containerData.lastChild) {\n    containerData.lastChild = nodeData.previousSibling;\n  }\n  let p = nodeData.previousSibling;\n  let n = nodeData.nextSibling;\n  if (p) {\n    ensureShadyDataForNode(p).nextSibling = n;\n  }\n  if (n) {\n    ensureShadyDataForNode(n).previousSibling = p;\n  }\n  // When an element is removed, logical data is no longer tracked.\n  // Explicitly set `undefined` here to indicate this. This is disginguished\n  // from `null` which is set if info is null.\n  nodeData.parentNode = nodeData.previousSibling =\n  nodeData.nextSibling = undefined;\n  if (containerData.childNodes !== undefined) {\n    // remove caching of childNodes\n    containerData.childNodes = null;\n  }\n}\n\n/**\n * @param  {!Node|DocumentFragment} node\n * @param  {!Node|DocumentFragment=} adoptedParent\n */\nexport const recordChildNodes = (node, adoptedParent) => {\n  const nodeData = ensureShadyDataForNode(node);\n  if (!adoptedParent && nodeData.firstChild !== undefined) {\n    return;\n  }\n  // remove caching of childNodes\n  nodeData.childNodes = null;\n  const first = nodeData.firstChild = node[utils.NATIVE_PREFIX + 'firstChild'];\n  nodeData.lastChild = node[utils.NATIVE_PREFIX + 'lastChild'];\n  patchNode(node, InsideAcccessors);\n  for (let n = first, previous; n; (n = n[utils.NATIVE_PREFIX + 'nextSibling'])) {\n    const sd = ensureShadyDataForNode(n);\n    sd.parentNode = adoptedParent || node;\n    sd.nextSibling = n[utils.NATIVE_PREFIX + 'nextSibling'];\n    sd.previousSibling = previous || null;\n    previous = n;\n    patchNode(n, OutsideAccessors);\n  }\n}\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\n\nexport const ShadowRootPatches = utils.getOwnPropertyDescriptors({\n\n  /**\n   * @this {ShadowRoot}\n   * @param {string} type\n   * @param {Function} fn\n   * @param {Object|boolean=} optionsOrCapture\n   */\n  addEventListener(type, fn, optionsOrCapture) {\n    if (typeof optionsOrCapture !== 'object') {\n      optionsOrCapture = {\n        capture: Boolean(optionsOrCapture)\n      }\n    }\n    // Note, `__shadyTarget` may already be set if an event was added on a <slot> child\n    optionsOrCapture.__shadyTarget = optionsOrCapture.__shadyTarget || this;\n    this.host[utils.SHADY_PREFIX + 'addEventListener'](type, fn, optionsOrCapture);\n  },\n\n  /**\n   * @this {ShadowRoot}\n   * @param {string} type\n   * @param {Function} fn\n   * @param {Object|boolean=} optionsOrCapture\n   */\n  removeEventListener(type, fn, optionsOrCapture) {\n    if (typeof optionsOrCapture !== 'object') {\n      optionsOrCapture = {\n        capture: Boolean(optionsOrCapture)\n      }\n    }\n    // Note, `__shadyTarget` may already be set if an event was added on a <slot> child\n    optionsOrCapture.__shadyTarget = optionsOrCapture.__shadyTarget || this;\n    this.host[utils.SHADY_PREFIX + 'removeEventListener'](type, fn, optionsOrCapture);\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\nimport {NodePatches} from './patches/Node.js';\nimport {OutsideDescriptors, InsideDescriptors, TextContentInnerHTMLDescriptors} from './patch-instances.js';\nimport {ParentNodePatches} from './patches/ParentNode.js';\nimport {DocumentOrFragmentPatches} from './patches/DocumentOrFragment.js';\nimport {DocumentOrShadowRootPatches} from './patches/DocumentOrShadowRoot.js';\nimport {ElementOrShadowRootPatches} from './patches/ElementOrShadowRoot.js';\nimport {ShadowRootPatches} from './patches/ShadowRoot.js';\n\n/**\n * @param {!Object} proto\n * @param {string=} prefix\n */\nconst patchShadyAccessors = (proto, prefix) => {\n  utils.patchProperties(proto, ShadowRootPatches, prefix);\n  utils.patchProperties(proto, DocumentOrShadowRootPatches, prefix);\n  utils.patchProperties(proto, ElementOrShadowRootPatches, prefix);\n  // We ensure ParentNode accessors since these do not exist in Edge/IE on DocumentFragments.\n  utils.patchProperties(proto, ParentNodePatches, prefix);\n  // Ensure `shadowRoot` has basic descriptors when we cannot rely\n  // on them coming from DocumentFragment.\n  //\n  // Case 1, noPatching: Because we want noPatch ShadyRoots to have native property\n  // names so that they do not have to be wrapped...\n  // When we do *not* patch Node/DocumentFragment.prototype\n  // we must manually install those properties on ShadyRoot's prototype.\n  // Note, it's important to only install these in this mode so as not to stomp\n  // over CustomElements polyfill's patches on Node/DocumentFragment methods.\n  if (utils.settings.noPatch && !prefix) {\n    utils.patchProperties(proto, NodePatches, prefix);\n    utils.patchProperties(proto, DocumentOrFragmentPatches, prefix);\n  // Case 2, bad descriptors: Ensure accessors are on ShadowRoot.\n  // These descriptors are normally used for instance patching but because\n  // ShadyRoot can always be patched, just do it to the prototype.\n  } else if (!utils.settings.hasDescriptors) {\n    utils.patchProperties(proto, OutsideDescriptors);\n    utils.patchProperties(proto, InsideDescriptors);\n    utils.patchProperties(proto, TextContentInnerHTMLDescriptors);\n  }\n}\n\nexport const patchShadyRoot = (proto) => {\n  proto.__proto__ = DocumentFragment.prototype;\n\n  // patch both prefixed and not, even when noPatch == true.\n  patchShadyAccessors(proto, utils.SHADY_PREFIX);\n  patchShadyAccessors(proto);\n\n  // Ensure native properties are all safely wrapped since ShadowRoot is not an\n  // actual DocumentFragment instance.\n  Object.defineProperties(proto, {\n    nodeType: {\n      value: Node.DOCUMENT_FRAGMENT_NODE,\n      configurable: true\n    },\n    nodeName: {\n      value: '#document-fragment',\n      configurable: true\n    },\n    nodeValue: {\n      value: null,\n      configurable: true\n    }\n  });\n\n  // make undefined\n  [\n    'localName',\n    'namespaceURI',\n    'prefix'\n  ].forEach((prop) => {\n    Object.defineProperty(proto, prop, {\n      value: undefined,\n      configurable: true\n    });\n  });\n\n  // defer properties to host\n  [\n    'ownerDocument',\n    'baseURI',\n    'isConnected'\n  ].forEach((prop) => {\n    Object.defineProperty(proto, prop, {\n      /** @this {ShadowRoot} */\n      get() {\n        return this.host[prop];\n      },\n      configurable: true\n    });\n  });\n}\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\nimport {eventPropertyNamesForElement, eventPropertyNamesForHTMLElement} from './patch-events.js';\n\n/** @implements {IWrapper} */\nclass Wrapper {\n\n  /** @param {!Node} node */\n  constructor(node) {\n    this.node = node;\n  }\n\n  // node\n  addEventListener(name, fn, options) {\n    return this.node[utils.SHADY_PREFIX + 'addEventListener'](name, fn, options);\n  }\n\n  removeEventListener(name, fn, options) {\n    return this.node[utils.SHADY_PREFIX + 'removeEventListener'](name, fn, options);\n  }\n\n  appendChild(node) {\n    return this.node[utils.SHADY_PREFIX + 'appendChild'](node);\n  }\n\n  insertBefore(node, ref_node) {\n    return this.node[utils.SHADY_PREFIX + 'insertBefore'](node, ref_node);\n  }\n\n  removeChild(node) {\n    return this.node[utils.SHADY_PREFIX + 'removeChild'](node);\n  }\n\n  replaceChild(node, ref_node) {\n    return this.node[utils.SHADY_PREFIX + 'replaceChild'](node, ref_node);\n  }\n\n  cloneNode(deep) {\n    return this.node[utils.SHADY_PREFIX + 'cloneNode'](deep);\n  }\n\n  getRootNode(options) {\n    return this.node[utils.SHADY_PREFIX + 'getRootNode'](options);\n  }\n\n  contains(node) {\n    return this.node[utils.SHADY_PREFIX + 'contains'](node);\n  }\n\n  dispatchEvent(event) {\n    return this.node[utils.SHADY_PREFIX + 'dispatchEvent'](event);\n  }\n\n  // element\n  setAttribute(name, value) {\n    this.node[utils.SHADY_PREFIX + 'setAttribute'](name, value);\n  }\n\n  // NOTE: not needed, just here for balance\n  getAttribute(name) {\n    return this.node[utils.NATIVE_PREFIX + 'getAttribute'](name);\n  }\n\n  // NOTE: not needed, just here for balance\n  hasAttribute(name) {\n    return this.node[utils.NATIVE_PREFIX + 'hasAttribute'](name);\n  }\n\n  removeAttribute(name) {\n    this.node[utils.SHADY_PREFIX + 'removeAttribute'](name);\n  }\n\n  attachShadow(options) {\n    return this.node[utils.SHADY_PREFIX + 'attachShadow'](options);\n  }\n\n  /** @return {!Node|undefined} */\n  get activeElement() {\n    if (utils.isShadyRoot(this.node) || this.node.nodeType === Node.DOCUMENT_NODE) {\n      const e = this.node[utils.SHADY_PREFIX + 'activeElement'];\n      return e;\n    }\n    return undefined;\n  }\n\n  /**\n   * Installed for compatibility with browsers (older Chrome/Safari) that do\n   * not have a configurable `activeElement` accessor. Enables noPatch and\n   * patch mode both to consistently use ShadyDOM.wrap(document)._activeElement.\n   * @override\n   * @return {!Node|undefined}\n   */\n  get _activeElement() {\n    return this.activeElement;\n  }\n\n  // NOTE: not needed, just here for balance\n  /** @override */\n  focus() {\n    this.node[utils.NATIVE_PREFIX + 'focus']();\n  }\n\n  blur() {\n    this.node[utils.SHADY_PREFIX + 'blur']();\n  }\n\n  // document\n  importNode(node, deep) {\n    if (this.node.nodeType === Node.DOCUMENT_NODE) {\n      return this.node[utils.SHADY_PREFIX + 'importNode'](node, deep);\n    }\n  }\n\n  getElementById(id) {\n    if (this.node.nodeType === Node.DOCUMENT_NODE) {\n      return this.node[utils.SHADY_PREFIX + 'getElementById'](id);\n    }\n  }\n\n  // query\n  querySelector(selector) {\n    return this.node[utils.SHADY_PREFIX + 'querySelector'](selector);\n  }\n\n  querySelectorAll(selector, useNative) {\n    return this.node[utils.SHADY_PREFIX + 'querySelectorAll'](selector, useNative);\n  }\n\n  // slot\n  assignedNodes(options) {\n    if (this.node.localName === 'slot') {\n      return this.node[utils.SHADY_PREFIX + 'assignedNodes'](options);\n    }\n  }\n\n  get host() {\n    if (utils.isShadyRoot(this.node)) {\n      return /** @type {!ShadowRoot} */(this.node).host;\n    }\n    return undefined;\n  }\n\n  get parentNode() {\n    return this.node[utils.SHADY_PREFIX + 'parentNode'];\n  }\n\n  get firstChild() {\n    return this.node[utils.SHADY_PREFIX + 'firstChild'];\n  }\n\n  get lastChild() {\n    return this.node[utils.SHADY_PREFIX + 'lastChild'];\n  }\n\n  get nextSibling() {\n    return this.node[utils.SHADY_PREFIX + 'nextSibling'];\n  }\n\n  get previousSibling() {\n    return this.node[utils.SHADY_PREFIX + 'previousSibling'];\n  }\n\n  get childNodes() {\n    return this.node[utils.SHADY_PREFIX + 'childNodes'];\n  }\n\n  get parentElement() {\n    return this.node[utils.SHADY_PREFIX + 'parentElement'];\n  }\n\n  get firstElementChild() {\n    return this.node[utils.SHADY_PREFIX + 'firstElementChild'];\n  }\n\n  get lastElementChild() {\n    return this.node[utils.SHADY_PREFIX + 'lastElementChild'];\n  }\n\n  get nextElementSibling() {\n    return this.node[utils.SHADY_PREFIX + 'nextElementSibling'];\n  }\n\n  get previousElementSibling() {\n    return this.node[utils.SHADY_PREFIX + 'previousElementSibling'];\n  }\n\n  get children() {\n    return this.node[utils.SHADY_PREFIX + 'children'];\n  }\n\n  get childElementCount() {\n    return this.node[utils.SHADY_PREFIX + 'childElementCount'];\n  }\n\n  get shadowRoot() {\n    return this.node[utils.SHADY_PREFIX + 'shadowRoot'];\n  }\n\n  get assignedSlot() {\n    return this.node[utils.SHADY_PREFIX + 'assignedSlot'];\n  }\n\n  get isConnected() {\n    return this.node[utils.SHADY_PREFIX + 'isConnected'];\n  }\n\n  get innerHTML() {\n    return this.node[utils.SHADY_PREFIX + 'innerHTML'];\n  }\n\n  set innerHTML(value) {\n    this.node[utils.SHADY_PREFIX + 'innerHTML'] = value;\n  }\n\n  get textContent() {\n    return this.node[utils.SHADY_PREFIX + 'textContent'];\n  }\n\n  set textContent(value) {\n    this.node[utils.SHADY_PREFIX + 'textContent'] = value;\n  }\n\n  get slot() {\n    return this.node[utils.SHADY_PREFIX + 'slot'];\n  }\n\n  set slot(value) {\n    this.node[utils.SHADY_PREFIX + 'slot'] = value;\n  }\n\n  get className() {\n    return this.node[utils.SHADY_PREFIX + 'className'];\n  }\n\n  set className(value) {\n    return this.node[utils.SHADY_PREFIX + 'className'] = value;\n  }\n\n}\n\nconst addEventPropertyWrapper = (name) => {\n  Object.defineProperty(Wrapper.prototype, name, {\n    /** @this {Wrapper} */\n    get() {\n      return this.node[utils.SHADY_PREFIX + name];\n    },\n    /** @this {Wrapper} */\n    set(value) {\n      this.node[utils.SHADY_PREFIX + name] = value;\n    },\n    configurable: true\n  });\n};\n\neventPropertyNamesForElement.forEach(name => addEventPropertyWrapper(name));\neventPropertyNamesForHTMLElement.forEach(name => addEventPropertyWrapper(name));\n\nexport {Wrapper};\n\nconst wrapperMap = new WeakMap();\n\nexport function wrap(obj) {\n  if (utils.isShadyRoot(obj) || obj instanceof Wrapper) {\n    return obj;\n  }\n  let wrapper = wrapperMap.get(obj)\n  if (!wrapper) {\n    wrapper = new Wrapper(obj);\n    wrapperMap.set(obj, wrapper);\n  }\n  return wrapper;\n}\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n/**\n * Patches elements that interacts with ShadyDOM\n * such that tree traversal and mutation apis act like they would under\n * ShadowDOM.\n *\n * This import enables seemless interaction with ShadyDOM powered\n * custom elements, enabling better interoperation with 3rd party code,\n * libraries, and frameworks that use DOM tree manipulation apis.\n */\n\nimport * as utils from './utils.js';\nimport {flush, enqueue} from './flush.js';\nimport {observeChildren, unobserveChildren, filterMutations} from './observe-changes.js';\nimport {addNativePrefixedProperties, nativeMethods, nativeTree} from './patch-native.js';\nimport {patchInsideElementAccessors, patchOutsideElementAccessors} from './patch-instances.js';\nimport {patchEvents, patchClick, composedPath} from './patch-events.js';\nimport {ShadyRoot} from './attach-shadow.js';\nimport {wrap, Wrapper} from './wrapper.js';\nimport {addShadyPrefixedProperties, applyPatches, patchShadowOnElement, patchElementProto} from './patch-prototypes.js';\n\n\nif (utils.settings.inUse) {\n\n  const patch = utils.settings.hasDescriptors ? n => n : (node) => {\n    patchInsideElementAccessors(node);\n    patchOutsideElementAccessors(node);\n    return node;\n  };\n\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': patch,\n    'isShadyRoot': utils.isShadyRoot,\n    'enqueue': enqueue,\n    'flush': flush,\n    'flushInitial': (root) => {\n      root._flushInitial();\n    },\n    'settings': utils.settings,\n    'filterMutations': filterMutations,\n    'observeChildren': observeChildren,\n    'unobserveChildren': unobserveChildren,\n    // Set to true to defer native custom elements connection until the\n    // document has fully parsed. This enables custom elements that create\n    // shadowRoots to be defined while the document is loading. Elements\n    // customized as they are created by the parser will successfully\n    // render with this flag on.\n    'deferConnectionCallbacks': utils.settings['deferConnectionCallbacks'],\n    // Set to true to speed up the polyfill slightly at the cost of correctness\n    // * does not patch querySelector/All on Document or DocumentFragment\n    // * does not wrap connected/disconnected callbacks to de-dup these\n    // when using native customElements\n    // * does not wait to process children of elements with shadowRoots\n    // meaning shadowRoots should not be created while an element is parsing\n    // (e.g. if a custom element that creates a shadowRoot is defined before\n    // a candidate element in the document below it.\n    'preferPerformance': utils.settings['preferPerformance'],\n    // Integration point with ShadyCSS to disable styling MutationObserver,\n    // as ShadyDOM will now handle dynamic scoping.\n    'handlesDynamicScoping': true,\n    // Ensure the node is wrapped. This should be used when `noPatch` is set\n    // to ensure Shadow DOM compatible DOM operation.\n    // Note, wrap falls back to patch so that it ensures API \"always just works\"\n    'wrap': utils.settings.noPatch ? wrap : patch,\n    // When code should be compatible with `noPatch` `true` and `on-demand`\n    // settings, `wrapIfNeeded` can be used for optimal performance (v. `wrap`)\n    // for all DOM operations except the following: `appendChild` and\n    // `insertBefore` (when the node is being moved from a location where it\n    // was logically positioned in the DOM); when setting `className`/`class`;\n    // when calling `querySelector|All`; when setting `textContent` or\n    // `innerHTML`; `addEventListener`, `removeEventListener` and\n    // `dispatchEvent`; and all scope specific API's like `getRootNode`,\n    // `isConnected`, `slot`, `assignedSlot`, `assignedNodes`. Note,\n    // `wrapIfNeeded` falls back to a pass through to preserve optimal\n    // performance.\n    'wrapIfNeeded': utils.settings.noPatch === true ? wrap : n => n,\n    'Wrapper': Wrapper,\n    'composedPath': composedPath,\n    // Set to true to avoid patching regular platform property names. When set,\n    // Shadow DOM compatible behavior is only available when accessing DOM\n    // API using `ShadyDOM.wrap`, e.g. `ShadyDOM.wrap(element).shadowRoot`.\n    // This setting provides a small performance boost, but requires all DOM API\n    // access that requires Shadow DOM behavior to be proxied via `ShadyDOM.wrap`.\n    //\n    // WARNING: When `noPatch` is set and the Custom Elements polyfill is\n    // needed, the Custom Elements polyfill must be loaded before this\n    // polyfill; however, when `noPatch` is not used, this polyfill should be\n    // loaded before the Custom Elements polyfill. This is because\n    // ShadyDOM captures DOM mutation methods and when `noPatch` is used,\n    // ShadyDOM must call the mutation methods patched by the Custom Elements\n    // polyfill or custom elements will not function as expected. When `noPatch`\n    // is not used, the Custom Elements polyfill patches call through to the\n    // ShadyDOM patches so ShadyDOM should be loaded first.\n    'noPatch': utils.settings.noPatch,\n    'patchOnDemand': utils.settings.patchOnDemand,\n    'nativeMethods': nativeMethods,\n    'nativeTree': nativeTree,\n    'patchElementProto': patchElementProto\n  };\n\n  window['ShadyDOM'] = ShadyDOM;\n\n  // Modifies native prototypes for Node, Element, etc. to\n  // make native platform behavior available at prefixed names, e.g.\n  // `utils.NATIVE_PREFIX + 'firstChild'` or `__shady_native_firstChild`.\n  // This allows the standard names to be safely patched while retaining the\n  // ability for native behavior to be used. This polyfill manipulates DOM\n  // by using this saved native behavior.\n  // Note, some browsers do not have proper element descriptors for\n  // accessors; in this case, native behavior for these accessors is simulated\n  // via a TreeWalker.\n  addNativePrefixedProperties();\n\n  // Modifies native prototypes for Node, Element, etc. to make ShadowDOM\n  // behavior available at prefixed names, e.g.\n  // `utils.SHADY_PREFIX + 'firstChild` or `__shady_firstChild`. This is done\n  // so this polyfill can perform Shadow DOM style DOM manipulation.\n  // Because patching normal platform property names is optional, these prefixed\n  // names are used internally.\n  addShadyPrefixedProperties();\n\n  // Modifies native prototypes for Node, Element, etc. to patch\n  // regular platform property names to have Shadow DOM compatible API behavior.\n  // This applies the utils.SHADY_PREFIX behavior to normal names. For example,\n  // if `noPatch` is not set, then `el.__shady_firstChild` is equivalent to\n  // `el.firstChild`.\n  // NOTE, on older browsers (old Chrome/Safari) native accessors cannot be\n  // patched on prototypes (e.g. Node.prototype.firstChild cannot be modified).\n  // On these browsers, instance level patching is performed where needed; this\n  // instance patching is only done when `noPatch` is *not* set.\n  if (!utils.settings.noPatch) {\n    applyPatches();\n    // Patch click event behavior only if we're patching\n    patchClick()\n  } else if (utils.settings.patchOnDemand) {\n    // In `on-demand` patching, do patch `attachShadow` and `shadowRoot`.\n    // These are the only patched properties in `on-demand` mode and these\n    // patches kick off patching \"on-demand\" for other nodes.\n    patchShadowOnElement();\n  }\n\n  // For simplicity, patch events unconditionally.\n  // Patches the event system to have Shadow DOM compatible behavior (e.g.\n  // event retargeting). When `noPatch` is set, retargeting is only available\n  // when adding event listeners and dispatching events via `ShadyDOM.wrap`\n  // (e.g. `ShadyDOM.wrap(element).addEventListener(...)`).\n  patchEvents();\n\n  window.ShadowRoot = /** @type {function(new:ShadowRoot)} */(ShadyRoot);\n}\n","/**\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nexport const Document_createElement = window.Document.prototype.createElement;\nexport const Document_createElementNS =\n    window.Document.prototype.createElementNS;\nexport const Document_importNode = window.Document.prototype.importNode;\n\nexport const Document_prepend = window.Document.prototype['prepend'];\nexport const Document_append = window.Document.prototype['append'];\nexport const DocumentFragment_prepend =\n    window.DocumentFragment.prototype['prepend'];\nexport const DocumentFragment_append =\n    window.DocumentFragment.prototype['append'];\nexport const Node_cloneNode = window.Node.prototype.cloneNode;\nexport const Node_appendChild = window.Node.prototype.appendChild;\nexport const Node_insertBefore = window.Node.prototype.insertBefore;\nexport const Node_removeChild = window.Node.prototype.removeChild;\nexport const Node_replaceChild = window.Node.prototype.replaceChild;\nexport const Node_textContent =\n    Object.getOwnPropertyDescriptor(window.Node.prototype, 'textContent');\nexport const Element_attachShadow = window.Element.prototype['attachShadow'];\nexport const Element_innerHTML =\n    Object.getOwnPropertyDescriptor(window.Element.prototype, 'innerHTML');\nexport const Element_getAttribute = window.Element.prototype.getAttribute;\nexport const Element_setAttribute = window.Element.prototype.setAttribute;\nexport const Element_removeAttribute = window.Element.prototype.removeAttribute;\nexport const Element_getAttributeNS = window.Element.prototype.getAttributeNS;\nexport const Element_setAttributeNS = window.Element.prototype.setAttributeNS;\nexport const Element_removeAttributeNS =\n    window.Element.prototype.removeAttributeNS;\nexport const Element_insertAdjacentElement =\n    window.Element.prototype['insertAdjacentElement'];\nexport const Element_insertAdjacentHTML =\n    window.Element.prototype['insertAdjacentHTML'];\nexport const Element_prepend = window.Element.prototype['prepend'];\nexport const Element_append = window.Element.prototype['append'];\nexport const Element_before = window.Element.prototype['before'];\nexport const Element_after = window.Element.prototype['after'];\nexport const Element_replaceWith = window.Element.prototype['replaceWith'];\nexport const Element_remove = window.Element.prototype['remove'];\nexport const HTMLElement = window.HTMLElement;\nexport const HTMLElement_innerHTML =\n    Object.getOwnPropertyDescriptor(window.HTMLElement.prototype, 'innerHTML');\nexport const HTMLElement_insertAdjacentElement =\n    window.HTMLElement.prototype['insertAdjacentElement'];\nexport const HTMLElement_insertAdjacentHTML =\n    window.HTMLElement.prototype['insertAdjacentHTML'];\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport {HTMLImportElement} from './Externs.js';\n\nconst reservedElementNameSet = new Set<string>();\n// IE11 does not support constructing a set using an iterable.\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].forEach(item => reservedElementNameSet.add(item));\n\nexport function isValidCustomElementName(localName: string) {\n  const reserved = reservedElementNameSet.has(localName);\n  const validForm = /^[a-z][.0-9_a-z]*-[-.0-9_a-z]*$/.test(localName);\n  return !reserved && validForm;\n}\n\n// Note, IE11 doesn't have `document.contains`.\nconst nativeContains = document.contains ?\n    document.contains.bind(document) :\n    document.documentElement.contains.bind(document.documentElement);\n\nexport function isConnected(node: Node) {\n  // Use `Node#isConnected`, if defined.\n  const nativeValue = node.isConnected;\n  if (nativeValue !== undefined) {\n    return nativeValue;\n  }\n  // Optimization: It's significantly faster here to try to use `contains`,\n  // especially on Edge/IE/\n  if (nativeContains(node)) {\n    return true;\n  }\n\n  let current: Node|undefined = node;\n  while (current &&\n         !(current.__CE_isImportDocument || current instanceof Document)) {\n    current = current.parentNode ||\n        (window.ShadowRoot && current instanceof ShadowRoot ? current.host :\n                                                              undefined);\n  }\n  return !!(\n      current &&\n      (current.__CE_isImportDocument || current instanceof Document));\n}\n\nexport function childrenFromFragment(fragment: DocumentFragment): Array<Element> {\n  // Note, IE doesn't have `children` on document fragments.\n  const nativeChildren = fragment.children;\n  if (nativeChildren) {\n    return Array.prototype.slice.call(nativeChildren);\n  }\n  const children: Array<Element> = [];\n  for (let n = fragment.firstChild; n; n = n.nextSibling) {\n    if (n.nodeType === Node.ELEMENT_NODE) {\n      children.push(n as Element);\n    }\n  }\n  return children;\n}\n\nfunction nextSiblingOrAncestorSibling(root: Node, start: Node) {\n  let node: Node|null = start;\n  while (node && node !== root && !node.nextSibling) {\n    node = node.parentNode;\n  }\n  return (!node || node === root) ? null : node.nextSibling;\n}\n\n\nfunction nextNode(root: Node, start: Node) {\n  return start.firstChild ? start.firstChild :\n                            nextSiblingOrAncestorSibling(root, start);\n}\n\nexport function walkDeepDescendantElements(\n    root: Node, callback: (elem: Element) => void, visitedImports?: Set<Node>) {\n  let node: Node|null = root;\n  while (node) {\n    if (node.nodeType === Node.ELEMENT_NODE) {\n      const element = node as Element;\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 its root node available,\n        // walk it.\n        const importNode = (element as HTMLImportElement).import;\n        if (visitedImports === undefined) {\n          visitedImports = new Set();\n        }\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;\n               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;\n             child = child.nextSibling) {\n          walkDeepDescendantElements(child, callback, visitedImports);\n        }\n      }\n    }\n\n    node = nextNode(root, node);\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport './Externs.js';\nimport {CustomElementState as CEState} from './CustomElementState.js';\nimport {CustomElementDefinition, HTMLImportElement} from './Externs.js';\nimport * as Native from './Patch/Native.js';\nimport * as Utilities from './Utilities.js';\n\nconst NS_HTML = 'http://www.w3.org/1999/xhtml';\n\nexport default class CustomElementInternals {\n  private readonly _patchesNode: Array<(node: Node) => void> = [];\n  private readonly _patchesElement: Array<(elem: Element) => void> = [];\n  private _hasPatches = false;\n  public readonly shadyDomFastWalk: boolean;\n  public readonly useDocumentConstructionObserver: boolean;\n\n  constructor(options: {\n    shadyDomFastWalk: boolean,\n    noDocumentConstructionObserver: boolean\n  }) {\n    this.shadyDomFastWalk = options.shadyDomFastWalk;\n    this.useDocumentConstructionObserver =\n        !options.noDocumentConstructionObserver;\n  }\n\n  forEachElement(\n      node: Node, callback: (elem: Element) => void,\n      visitedImports?: Set<Node>) {\n    const sd = window['ShadyDom'];\n    if (this.shadyDomFastWalk && sd && sd['inUse']) {\n      if (node.nodeType === Node.ELEMENT_NODE) {\n        const element = node as Element;\n        callback(element);\n      }\n      // most easily gets to document, element, documentFragment\n      if ((node as Element).querySelectorAll!) {\n        const elements = sd['nativeMethods'].querySelectorAll.call(node, '*');\n        for (let i = 0; i < elements.length; i++) {\n          callback(elements[i]);\n        }\n      }\n    } else {\n      Utilities.walkDeepDescendantElements(node, callback, visitedImports);\n    }\n  }\n\n  addNodePatch(patch: (node: Node) => void) {\n    this._hasPatches = true;\n    this._patchesNode.push(patch);\n  }\n\n  addElementPatch(patch: (element: Element) => void) {\n    this._hasPatches = true;\n    this._patchesElement.push(patch);\n  }\n\n  patchTree(node: Node) {\n    if (!this._hasPatches) {\n      return;\n    }\n\n    this.forEachElement(node, element => this.patchElement(element));\n  }\n\n  patchNode(node: Node) {\n    if (!this._hasPatches) {\n      return;\n    }\n\n    if (node.__CE_patched) {\n      return;\n    }\n    node.__CE_patched = true;\n\n    for (let i = 0; i < this._patchesNode.length; i++) {\n      this._patchesNode[i](node);\n    }\n  }\n\n  patchElement(element: Element) {\n    if (!this._hasPatches) {\n      return;\n    }\n\n    if (element.__CE_patched) {\n      return;\n    }\n    element.__CE_patched = true;\n\n    for (let i = 0; i < this._patchesNode.length; i++) {\n      this._patchesNode[i](element);\n    }\n\n    for (let i = 0; i < this._patchesElement.length; i++) {\n      this._patchesElement[i](element);\n    }\n  }\n\n  connectTree(root: Node) {\n    const elements: Array<Element> = [];\n\n    this.forEachElement(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.upgradeReaction(element as HTMLElement);\n      }\n    }\n  }\n\n  disconnectTree(root: Node) {\n    const elements: Array<Element> = [];\n\n    this.forEachElement(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\n   * that is already created but not customized (i.e. by the parser), does\n   * *not* prevent the element from reading the 'final' (true) state of the\n   * tree. For example, the element, during truly synchronous parsing /\n   * construction would see that it contains no children as they have not yet\n   * been inserted. However, this function does not modify the tree, the\n   * element will (incorrectly) have children. Additionally, self-modification\n   * restrictions for custom element constructors imposed by the DOM spec are\n   * *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\n   * and 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  patchAndUpgradeTree(root: Node, options: {\n    visitedImports?: Set<Node>,\n    upgrade?: (elem: HTMLElement) => void\n  } = {}) {\n    const visitedImports = options.visitedImports;\n    const upgrade =\n        options.upgrade || (element => this.upgradeReaction(element));\n\n    const elements: Array<Element> = [];\n\n    const gatherElements = (element: Element) => {\n      if (this._hasPatches) {\n        this.patchElement(element);\n      }\n      if (element.localName === 'link' &&\n          element.getAttribute('rel') === 'import') {\n        const importElem = element as HTMLImportElement;\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 = importElem.import;\n\n        if (importNode instanceof Node) {\n          importNode.__CE_isImportDocument = true;\n          // Connected links are associated with the global registry.\n          importNode.__CE_registry = document.__CE_registry;\n        }\n\n\n\n        if (importNode &&\n            (importNode as HTMLImportDocument).readyState === 'complete') {\n          importNode.__CE_documentLoadHandled = true;\n        } else {\n          // If this link's import root is not available, its contents can't\n          // be walked. Wait for 'load' and walk it when it's ready.\n          element.addEventListener('load', () => {\n            const importNode = importElem.import!;\n\n            if (importNode.__CE_documentLoadHandled) {\n              return;\n            }\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\n            // to be added. Then, remove *this* link's import node so that we\n            // can walk that import again, even if it was partially walked\n            // later during the same `patchAndUpgradeTree` call.\n            const clonedVisitedImports = new Set<Node>();\n            if (visitedImports) {\n              // IE11 does not support constructing a set using an iterable.\n              visitedImports.forEach(item => clonedVisitedImports.add(item));\n              clonedVisitedImports.delete(importNode);\n            }\n            this.patchAndUpgradeTree(\n                importNode, {visitedImports: clonedVisitedImports, upgrade});\n          });\n        }\n      } else {\n        elements.push(element);\n      }\n    };\n\n    // `forEachElement` populates (and internally checks against)\n    // `visitedImports` when traversing a loaded import.\n    this.forEachElement(root, gatherElements, visitedImports);\n\n    for (let i = 0; i < elements.length; i++) {\n      upgrade(elements[i] as HTMLElement);\n    }\n  }\n\n  upgradeReaction(element: HTMLElement) {\n    try {\n      const definition = this._lookupACustomElementDefinition(\n          element.ownerDocument!, element.localName);\n      if (definition) {\n        this._upgradeAnElement(element, definition);\n      }\n    } catch (e) {\n      this.reportTheException(e);\n    }\n  }\n\n  /**\n   * @see https://html.spec.whatwg.org/multipage/custom-elements.html#concept-upgrade-an-element\n   */\n  private _upgradeAnElement(\n      element: HTMLElement, definition: CustomElementDefinition) {\n    const currentState = element.__CE_state;\n    if (currentState !== undefined) {\n      return;\n    }\n\n    definition.constructionStack.push(element);\n\n    try {\n      try {\n        const result = new (definition.constructorFunction)();\n        if (result !== element) {\n          throw new Error(\n              '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    // Check `hasAttributes` here to avoid iterating when it's not necessary.\n    if (definition.attributeChangedCallback && element.hasAttributes()) {\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  connectedCallback(element: Element) {\n    const definition = element.__CE_definition!;\n    if (definition.connectedCallback) {\n      try {\n        definition.connectedCallback.call(element);\n      } catch (e) {\n        this.reportTheException(e);\n      }\n    }\n  }\n\n  disconnectedCallback(element: Element) {\n    const definition = element.__CE_definition!;\n    if (definition.disconnectedCallback) {\n      try {\n        definition.disconnectedCallback.call(element);\n      } catch (e) {\n        this.reportTheException(e);\n      }\n    }\n  }\n\n  attributeChangedCallback(\n      element: Element, name: string, oldValue?: string|null,\n      newValue?: string|null, namespace?: string|null) {\n    const definition = element.__CE_definition!;\n    if (definition.attributeChangedCallback &&\n        definition.observedAttributes.indexOf(name) > -1) {\n      try {\n        definition.attributeChangedCallback.call(\n            element, name, oldValue, newValue, namespace);\n      } catch (e) {\n        this.reportTheException(e);\n      }\n    }\n  }\n\n  /**\n   * Runs HTML's 'look up a custom element definition', excluding the namespace\n   * check.\n   *\n   * @see https://html.spec.whatwg.org/multipage/custom-elements.html#look-up-a-custom-element-definition\n   */\n  private _lookupACustomElementDefinition(doc: Document, localName: string):\n      CustomElementDefinition|undefined {\n    // The document must be associated with a registry.\n    const registry = doc.__CE_registry;\n    if (!registry) {\n      return;\n    }\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    if (!doc.defaultView && !doc.__CE_isImportDocument) {\n      return;\n    }\n\n    return registry.internal_localNameToDefinition(localName);\n  }\n\n  /**\n   * Runs the DOM's 'create an element'. If namespace is not null, then the\n   * native `createElementNS` is used. Otherwise, `createElement` is used.\n   *\n   * Note, the template polyfill only wraps `createElement`, preventing this\n   * function from using `createElementNS` in all cases.\n   *\n   * @see https://dom.spec.whatwg.org/#concept-create-element\n   */\n  createAnElement(doc: Document, localName: string, namespace: string|null):\n      Element {\n    const registry = doc.__CE_registry;\n    // Only create custom elements if the document is associated with a\n    // registry.\n    if (registry && (namespace === null || namespace === NS_HTML)) {\n      const definition = registry.internal_localNameToDefinition(localName);\n      if (definition) {\n        try {\n          const result = new (definition.constructorFunction)();\n\n          // These conformance checks can't be performed when the user calls\n          // the element's constructor themselves. However, this also true in\n          // native implementations.\n\n          if (result.__CE_state === undefined ||\n              result.__CE_definition === undefined) {\n            throw new Error(\n                'Failed to construct \\'' + localName + '\\': ' +\n                'The returned value was not constructed with the HTMLElement ' +\n                'constructor.');\n          }\n\n          if (result.namespaceURI !== NS_HTML) {\n            throw new Error(\n                'Failed to construct \\'' + localName + '\\': ' +\n                'The constructed element\\'s namespace must be the HTML ' +\n                'namespace.');\n          }\n\n          // The following Errors should be DOMExceptions but DOMException\n          // isn't constructible in all browsers.\n\n          if (result.hasAttributes()) {\n            throw new Error(\n                'Failed to construct \\'' + localName + '\\': ' +\n                'The constructed element must not have any attributes.');\n          }\n\n          // ShadyDOM doesn't wrap `#hasChildNodes`, so we check `#firstChild`\n          // instead.\n          if (result.firstChild !== null) {\n            throw new Error(\n                'Failed to construct \\'' + localName + '\\': ' +\n                'The constructed element must not have any children.');\n          }\n\n          if (result.parentNode !== null) {\n            throw new Error(\n                'Failed to construct \\'' + localName + '\\': ' +\n                'The constructed element must not have a parent node.');\n          }\n\n          if (result.ownerDocument !== doc) {\n            throw new Error(\n                'Failed to construct \\'' + localName + '\\': ' +\n                'The constructed element\\'s owner document is incorrect.');\n          }\n\n          if (result.localName !== localName) {\n            throw new Error(\n                'Failed to construct \\'' + localName + '\\': ' +\n                'The constructed element\\'s local name is incorrect.');\n          }\n\n          return result;\n        } catch (e) {\n          this.reportTheException(e);\n\n          // When construction fails, a new HTMLUnknownElement is produced.\n          // However, there's no direct way to create one, so we create a\n          // regular HTMLElement and replace its prototype.\n          const result = namespace === null ?\n              Native.Document_createElement.call(doc, localName) :\n              Native.Document_createElementNS.call(doc, namespace, localName);\n          Object.setPrototypeOf(result, HTMLUnknownElement.prototype);\n          result.__CE_state = CEState.failed;\n          result.__CE_definition = undefined;\n          this.patchElement(result);\n          return result;\n        }\n      }\n    }\n\n    const result = namespace === null ?\n        Native.Document_createElement.call(doc, localName) :\n        Native.Document_createElementNS.call(doc, namespace, localName);\n    this.patchElement(result);\n    return result;\n  }\n\n  /**\n   * Runs the DOM's 'report the exception' algorithm.\n   *\n   * @see https://html.spec.whatwg.org/multipage/webappapis.html#report-the-exception\n   */\n  reportTheException(error: Error) {\n    const message = error.message;\n    const filename =\n        /* Safari */ error.sourceURL || /* Firefox */ error.fileName || '';\n    const lineno =\n        /* Safari */ error.line || /* Firefox */ error.lineNumber || 0;\n    const colno =\n        /* Safari */ error.column || /* Firefox */ error.columnNumber || 0;\n\n    let event: ErrorEvent|undefined = undefined;\n    if (ErrorEvent.prototype.initErrorEvent === undefined) {\n      event = new ErrorEvent(\n          'error', {cancelable: true, message, filename, lineno, colno, error});\n    } else {\n      event = document.createEvent('ErrorEvent') as ErrorEvent;\n      // initErrorEvent(type, bubbles, cancelable, message, filename, line)\n      event.initErrorEvent!('error', false, true, message, filename, lineno);\n      // Hack for IE, where ErrorEvent#preventDefault does not set\n      // #defaultPrevented to true.\n      event.preventDefault = function(this: ErrorEvent) {\n        Object.defineProperty(this, 'defaultPrevented', {\n          configurable: true,\n          get: function(this: ErrorEvent) {\n            return true;\n          },\n        });\n      };\n    }\n\n    if (event.error === undefined) {\n      Object.defineProperty(event, 'error', {\n        configurable: true,\n        enumerable: true,\n        get: function() {\n          return error;\n        },\n      });\n    }\n\n    window.dispatchEvent(event);\n    if (!event.defaultPrevented) {\n      // In 'report the exception', UAs may optionally write errors to the\n      // console if their associated ErrorEvent isn't handled during dispatch\n      // (indicated by calling `preventDefault`). In practice, these errors are\n      // always displayed.\n      console.error(error);\n    }\n  }\n}\n\ndeclare interface HTMLImportDocument extends Node {\n  readyState: 'complete'|string;\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from './CustomElementInternals.js';\nimport CustomElementRegistry from './CustomElementRegistry.js';\nimport PatchDocument from './Patch/Document.js';\nimport PatchDocumentFragment from './Patch/DocumentFragment.js';\nimport PatchElement from './Patch/Element.js';\nimport PatchHTMLElement from './Patch/HTMLElement.js';\nimport PatchNode from './Patch/Node.js';\n\nconst priorCustomElements = window['customElements'];\n\nfunction installPolyfill() {\n  const noDocumentConstructionObserver =\n      !!(priorCustomElements?.['noDocumentConstructionObserver']);\n  const shadyDomFastWalk = !!(priorCustomElements?.['shadyDomFastWalk']);\n\n  const internals = new CustomElementInternals(\n      {noDocumentConstructionObserver, shadyDomFastWalk});\n\n  PatchHTMLElement(internals);\n  PatchDocument(internals);\n  PatchDocumentFragment(internals);\n  PatchNode(internals);\n  PatchElement(internals);\n\n  const customElements = new CustomElementRegistry(internals);\n\n  // The main document is associated with the global registry.\n  document.__CE_registry = customElements;\n\n  Object.defineProperty(window, 'customElements', {\n    configurable: true,\n    enumerable: true,\n    value: customElements,\n  });\n}\n\nif (!priorCustomElements || priorCustomElements['forcePolyfill'] ||\n    (typeof priorCustomElements['define'] != 'function') ||\n    (typeof priorCustomElements['get'] != 'function')) {\n  installPolyfill();\n}\n\n// This is NOT public API and is only meant to work around a GC bug in older\n// versions of Safari that randomly removes the polyfill during tests.\n(window as any)['__CE_installPolyfill'] = installPolyfill;\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nexport const CustomElementState = {\n  custom: 1,\n  failed: 2,\n} as const;\nexport type CustomElementState =\n    typeof CustomElementState.custom|typeof CustomElementState.failed;\n\nexport default CustomElementState;\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nexport default class Deferred<T> {\n  private _value: T|undefined = undefined;\n\n  private _resolve!: (val: T) => void;\n\n  private readonly _promise: Promise<T>;\n  constructor() {\n    this._promise = new Promise(resolve => {\n      this._resolve = resolve;\n    });\n  }\n\n  resolve(value: T) {\n    if (this._value) {\n      throw new Error('Already resolved.');\n    }\n\n    this._value = value;\n    this._resolve(value);\n  }\n\n  toPromise() {\n    return this._promise;\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from './CustomElementInternals.js';\n\nexport default class DocumentConstructionObserver {\n  private readonly _internals: CustomElementInternals;\n  private readonly _document: Document;\n  private _observer: MutationObserver|undefined = undefined;\n  constructor(internals: CustomElementInternals, doc: Document) {\n    this._internals = internals;\n    this._document = doc;\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\n      // inline 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  private _handleMutations(mutations: ReadonlyArray<MutationRecord>) {\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","/**\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport {AlreadyConstructedMarkerType} from './AlreadyConstructedMarker.js';\nimport CustomElementInternals from './CustomElementInternals.js';\nimport Deferred from './Deferred.js';\nimport DocumentConstructionObserver from './DocumentConstructionObserver.js';\nimport {Constructor, CustomElementDefinition} from './Externs.js';\nimport * as Utilities from './Utilities.js';\n\ninterface ElementConstructor {\n  new(): HTMLElement;\n  observedAttributes?: Array<string>;\n}\ntype ConstructorGetter = () => ElementConstructor;\n\n\n/**\n * @unrestricted\n */\nexport default class CustomElementRegistry {\n  private readonly _localNameToConstructorGetter =\n      new Map<string, ConstructorGetter>();\n  private readonly _localNameToDefinition =\n      new Map<string, CustomElementDefinition>();\n  private readonly _constructorToDefinition =\n      new Map<Constructor<HTMLElement>, CustomElementDefinition>();\n  private _elementDefinitionIsRunning = false;\n  private readonly _internals: CustomElementInternals;\n  private readonly _whenDefinedDeferred =\n      new Map<string, Deferred<undefined>>();\n\n  /**\n   * The default flush callback triggers the document walk synchronously.\n   */\n  private _flushCallback: (fn: () => void) => void = (fn) => fn();\n  private _flushPending = false;\n\n  /**\n   * A map from `localName`s of definitions that were defined *after* the\n   * last flush to unupgraded elements matching that definition, in document\n   * order. Entries are added to this map when a definition is registered,\n   * but the list of elements is only populated during a flush after which\n   * all of the entries are removed. DO NOT edit outside of `#_flush`.\n   */\n  private readonly _unflushedLocalNames: Array<string> = [];\n\n  private readonly _documentConstructionObserver: DocumentConstructionObserver|\n      undefined;\n\n  constructor(internals: CustomElementInternals) {\n    this._internals = internals;\n    this._documentConstructionObserver =\n        internals.useDocumentConstructionObserver ?\n        new DocumentConstructionObserver(internals, document) :\n        undefined;\n  }\n\n  polyfillDefineLazy(localName: string, constructorGetter: ConstructorGetter) {\n    if (!(constructorGetter instanceof Function)) {\n      throw new TypeError(\n          'Custom element constructor getters must be functions.');\n    }\n    this.internal_assertCanDefineLocalName(localName);\n    this._localNameToConstructorGetter.set(localName, constructorGetter);\n    this._unflushedLocalNames.push(localName);\n    // If we've already called the flush callback and it hasn't called back\n    // yet, don't call it again.\n    if (!this._flushPending) {\n      this._flushPending = true;\n      this._flushCallback(() => this._flush());\n    }\n  }\n\n  define(localName: string, constructor: Function) {\n    if (!(constructor instanceof Function)) {\n      throw new TypeError('Custom element constructors must be functions.');\n    }\n\n    this.internal_assertCanDefineLocalName(localName);\n\n    this.internal_reifyDefinition(localName, constructor as ElementConstructor);\n    this._unflushedLocalNames.push(localName);\n    // If we've already called the flush callback and it hasn't called back\n    // yet, don't call it again.\n    if (!this._flushPending) {\n      this._flushPending = true;\n      this._flushCallback(() => this._flush());\n    }\n  }\n\n  internal_assertCanDefineLocalName(localName: string) {\n    if (!Utilities.isValidCustomElementName(localName)) {\n      throw new SyntaxError(`The element name '${localName}' is not valid.`);\n    }\n\n    if (this.internal_localNameToDefinition(localName)) {\n      throw new Error(\n          `A custom element with name ` +\n          `'${localName}' has already been defined.`);\n    }\n\n    if (this._elementDefinitionIsRunning) {\n      throw new Error('A custom element is already being defined.');\n    }\n  }\n\n  internal_reifyDefinition(localName: string, constructor: ElementConstructor) {\n    this._elementDefinitionIsRunning = true;\n\n    let connectedCallback: CustomElementDefinition['connectedCallback'];\n    let disconnectedCallback: CustomElementDefinition['disconnectedCallback'];\n    let adoptedCallback: CustomElementDefinition['adoptedCallback'];\n    let attributeChangedCallback:\n        CustomElementDefinition['attributeChangedCallback'];\n    let observedAttributes: CustomElementDefinition['observedAttributes'];\n    try {\n      const prototype = constructor.prototype;\n      if (!(prototype instanceof Object)) {\n        throw new TypeError(\n            'The custom element constructor\\'s prototype is not an object.');\n      }\n\n      type CEReactionCallback = 'connectedCallback'|'disconnectedCallback'|\n          'adoptedCallback'|'attributeChangedCallback';\n      const getCallback =\n          function getCallback(name: CEReactionCallback) {\n        const callbackValue = prototype[name];\n        if (callbackValue !== undefined &&\n            !(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` should not be read unless an\n      // `attributesChangedCallback` exists\n      observedAttributes =\n          (attributeChangedCallback && constructor['observedAttributes']) || [];\n    } catch (e) {\n      throw e;\n    } finally {\n      this._elementDefinitionIsRunning = false;\n    }\n\n    const definition = {\n      localName,\n      constructorFunction: constructor,\n      connectedCallback,\n      disconnectedCallback,\n      adoptedCallback,\n      attributeChangedCallback,\n      observedAttributes,\n      constructionStack: [] as Array<HTMLElement|AlreadyConstructedMarkerType>,\n    };\n\n    this._localNameToDefinition.set(localName, definition);\n    this._constructorToDefinition.set(\n        definition.constructorFunction, definition);\n\n    return definition;\n  }\n\n  upgrade(node: Node): void {\n    this._internals.patchAndUpgradeTree(node);\n  }\n\n  private _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) {\n      return;\n    }\n    this._flushPending = false;\n\n    /**\n     * Unupgraded elements with definitions that were defined *before* the last\n     * flush, in document order.\n     */\n    const elementsWithStableDefinitions: Array<HTMLElement> = [];\n\n    const unflushedLocalNames = this._unflushedLocalNames;\n    const elementsWithPendingDefinitions =\n        new Map<string, Array<HTMLElement>>();\n    for (let i = 0; i < unflushedLocalNames.length; i++) {\n      elementsWithPendingDefinitions.set(unflushedLocalNames[i], []);\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) {\n          return;\n        }\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\n          // it to the list of elements with stable definitions that need to be\n          // upgraded.\n        } else if (this._localNameToDefinition.has(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.upgradeReaction(elementsWithStableDefinitions[i]);\n    }\n\n    // Upgrade elements with 'pending' definitions in the order they were\n    // defined.\n    for (let i = 0; i < unflushedLocalNames.length; i++) {\n      const localName = unflushedLocalNames[i];\n      const pendingUpgradableElements =\n          elementsWithPendingDefinitions.get(localName)!;\n\n      // Attempt to upgrade all applicable elements.\n      for (let i = 0; i < pendingUpgradableElements.length; i++) {\n        this._internals.upgradeReaction(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    unflushedLocalNames.length = 0;\n  }\n\n  get(localName: string): undefined|{new(): HTMLElement} {\n    const definition = this.internal_localNameToDefinition(localName);\n    if (definition) {\n      return definition.constructorFunction;\n    }\n\n    return undefined;\n  }\n\n  whenDefined(localName: string): Promise<void> {\n    if (!Utilities.isValidCustomElementName(localName)) {\n      return Promise.reject(new SyntaxError(\n          `'${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<undefined>();\n    this._whenDefinedDeferred.set(localName, deferred);\n\n    // Resolve immediately if the given local name has a regular or lazy\n    // definition *and* the full document walk to upgrade elements with that\n    // local name has already happened.\n    //\n    // The behavior of the returned promise differs between the lazy and the\n    // non-lazy cases if the definition fails. Normally, the definition would\n    // fail synchronously and no pending promises would resolve. However, if\n    // the definition is lazy but has not yet been reified, the promise is\n    // resolved early here even though it might fail later when reified.\n    const anyDefinitionExists = this._localNameToDefinition.has(localName) ||\n        this._localNameToConstructorGetter.has(localName);\n    const definitionHasFlushed =\n        this._unflushedLocalNames.indexOf(localName) === -1;\n    if (anyDefinitionExists && definitionHasFlushed) {\n      deferred.resolve(undefined);\n    }\n\n    return deferred.toPromise();\n  }\n\n  polyfillWrapFlushCallback(outer: (fn: () => void) => void) {\n    if (this._documentConstructionObserver) {\n      this._documentConstructionObserver.disconnect();\n    }\n    const inner = this._flushCallback;\n    this._flushCallback = flush => outer(() => inner(flush));\n  }\n\n  internal_localNameToDefinition(localName: string): CustomElementDefinition\n      |undefined {\n    const existingDefinition = this._localNameToDefinition.get(localName);\n    if (existingDefinition) {\n      return existingDefinition;\n    }\n\n    const constructorGetter = this._localNameToConstructorGetter.get(localName);\n    if (constructorGetter) {\n      this._localNameToConstructorGetter.delete(localName);\n      try {\n        return this.internal_reifyDefinition(localName, constructorGetter());\n      } catch (e) {\n        this._internals.reportTheException(e);\n      }\n    }\n\n    return undefined;\n  }\n\n  internal_constructorToDefinition(constructor: ElementConstructor):\n      CustomElementDefinition|undefined {\n    return this._constructorToDefinition.get(constructor);\n  }\n}\n\n// Closure compiler exports.\nwindow['CustomElementRegistry'] =\n    CustomElementRegistry as unknown as typeof window['CustomElementRegistry'];\nCustomElementRegistry.prototype['define'] =\n    CustomElementRegistry.prototype.define;\nCustomElementRegistry.prototype['upgrade'] =\n    CustomElementRegistry.prototype.upgrade;\nCustomElementRegistry.prototype['get'] = CustomElementRegistry.prototype.get;\nCustomElementRegistry.prototype['whenDefined'] =\n    CustomElementRegistry.prototype.whenDefined;\nCustomElementRegistry.prototype['polyfillDefineLazy'] =\n    CustomElementRegistry.prototype.polyfillDefineLazy;\nCustomElementRegistry.prototype['polyfillWrapFlushCallback'] =\n    CustomElementRegistry.prototype.polyfillWrapFlushCallback;\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from '../../CustomElementInternals.js';\nimport * as Utilities from '../../Utilities.js';\n\ntype NativeMethod = (this: Node, ...args: Array<Node|string>) => void;\n\ninterface ParentNodeNativeMethods {\n  prepend: NativeMethod;\n  append: NativeMethod;\n}\n\nexport default function(\n    internals: CustomElementInternals,\n    destination: ParentNode,\n    builtIn: ParentNodeNativeMethods) {\n  function appendPrependPatch(builtInMethod: NativeMethod): NativeMethod {\n    return function(this: Node, ...nodes) {\n      /**\n       * A copy of `nodes`, with any DocumentFragment replaced by its children.\n       */\n      const flattenedNodes: Array<Node|string> = [];\n\n      /**\n       * Elements in `nodes` that were connected before this call.\n       */\n      const connectedElements: Array<Node> = [];\n\n      for (let 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    destination.prepend = appendPrependPatch(builtIn.prepend);\n  }\n\n  if (builtIn.append !== undefined) {\n    destination.append = appendPrependPatch(builtIn.append);\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from '../CustomElementInternals.js';\n\nimport PatchParentNode from './Interface/ParentNode.js';\nimport * as Native from './Native.js';\n\nexport default function(internals: CustomElementInternals) {\n  Document.prototype.createElement = function(\n                                         this: Document, localName: string) {\n    return internals.createAnElement(this, localName, null);\n  } as typeof Document.prototype.createElement;\n\n  Document.prototype.importNode = function<T extends Node>(\n      this: Document, node: T, deep?: boolean): T {\n    const clone = Native.Document_importNode.call(this, node, !!deep) as T;\n    // Only create custom elements if this document is associated with the\n    // registry.\n    if (!this.__CE_registry) {\n      internals.patchTree(clone);\n    } else {\n      internals.patchAndUpgradeTree(clone);\n    }\n    return clone;\n  };\n\n  Document.prototype.createElementNS =\n      function(this: Document, namespace: string|null, localName: string) {\n    return internals.createAnElement(this, localName, namespace);\n  } as typeof Document.prototype.createElementNS;\n\n  PatchParentNode(internals, Document.prototype, {\n    prepend: Native.Document_prepend,\n    append: Native.Document_append,\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from '../../CustomElementInternals.js';\nimport * as Utilities from '../../Utilities.js';\n\ntype NativeMethod = (this: ChildNode, ...args: Array<Node|string>) => void;\n\ninterface ChildNodeNativeMethods {\n  before: NativeMethod;\n  after: NativeMethod;\n  replaceWith: NativeMethod;\n  remove: (this: ChildNode) => void;\n}\n\nexport default function(\n    internals: CustomElementInternals,\n    destination: ChildNode,\n    builtIn: ChildNodeNativeMethods) {\n  function beforeAfterPatch(builtInMethod: NativeMethod): NativeMethod {\n    return function(this: ChildNode, ...nodes) {\n      const flattenedNodes: Array<string|Node> = [];\n      const connectedElements: Array<Node> = [];\n\n      for (let 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    destination.before = beforeAfterPatch(builtIn.before);\n  }\n\n  if (builtIn.after !== undefined) {\n    destination.after = beforeAfterPatch(builtIn.after);\n  }\n\n  if (builtIn.replaceWith !== undefined) {\n    destination.replaceWith = function(\n        this: ChildNode, ...nodes: Array<Node|string>) {\n      /**\n       * A copy of `nodes`, with any DocumentFragment replaced by its children.\n       */\n      const flattenedNodes: Array<Node|string> = [];\n\n      /**\n       * Elements in `nodes` that were connected before this call.\n       */\n      const connectedElements: Array<Node> = [];\n\n      for (let 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    destination.remove = function(this: ChildNode) {\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","/**\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport CEState from '../CustomElementState.js';\nimport * as Utilities from '../Utilities.js';\n\nimport PatchChildNode from './Interface/ChildNode.js';\nimport PatchParentNode from './Interface/ParentNode.js';\nimport * as Native from './Native.js';\n\nexport default function(internals: CustomElementInternals) {\n  if (Native.Element_attachShadow) {\n    Element.prototype.attachShadow = function(\n        this: Element, init: ShadowRootInit) {\n      const shadowRoot = Native.Element_attachShadow.call(this, init);\n      internals.patchNode(shadowRoot);\n      this.__CE_shadowRoot = shadowRoot;\n      return shadowRoot;\n    };\n  }\n\n\n  function patch_innerHTML(\n      destination: Element, baseDescriptor: PropertyDescriptor) {\n    Object.defineProperty(destination, 'innerHTML', {\n      enumerable: baseDescriptor.enumerable,\n      configurable: true,\n      get: baseDescriptor.get,\n      set: function(this: Element, 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        let removedElements: undefined|Array<Element> = undefined;\n        if (isConnected) {\n          removedElements = [];\n          internals.forEachElement(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_registry) {\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    internals.addElementPatch(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: function(this: Element) {\n          return (Native.Node_cloneNode.call(this, true) as Element).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: function(this: Element, 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          const content =\n              isTemplate ? ((this) as HTMLTemplateElement).content : this;\n          const rawElement = Native.Document_createElementNS.call(\n              document, this.namespaceURI, this.localName);\n          rawElement.innerHTML = assignedValue;\n\n          while (content.childNodes.length > 0) {\n            Native.Node_removeChild.call(content, content.childNodes[0]);\n          }\n          const container = isTemplate ?\n              (rawElement as HTMLTemplateElement).content :\n              rawElement;\n          while (container.childNodes.length > 0) {\n            Native.Node_appendChild.call(content, container.childNodes[0]);\n          }\n        },\n      });\n    });\n  }\n\n\n  Element.prototype.setAttribute = function(this: Element, 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  Element.prototype.setAttributeNS = function(\n      this: Element, namespace, name, newValue) {\n    // Fast path for non-custom elements.\n    if (this.__CE_state !== CEState.custom) {\n      return Native.Element_setAttributeNS.call(\n          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(\n        this, name, oldValue, newValue, namespace);\n  };\n\n  Element.prototype.removeAttribute = function(this: Element, 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  Element.prototype.removeAttributeNS = function(\n      this: Element, 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(\n          this, name, oldValue, newValue, namespace);\n    }\n  };\n\n\n  function patch_insertAdjacentElement(\n      destination: Element, baseMethod: Element['insertAdjacentElement']) {\n    destination.insertAdjacentElement = function(\n        this: Element, position, element) {\n      const wasConnected = Utilities.isConnected(element);\n      const insertedElement = 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(\n        HTMLElement.prototype, Native.HTMLElement_insertAdjacentElement);\n  } else if (Native.Element_insertAdjacentElement) {\n    patch_insertAdjacentElement(\n        Element.prototype, Native.Element_insertAdjacentElement);\n  }\n\n\n  function patch_insertAdjacentHTML(\n      destination: Element, baseMethod: Element['insertAdjacentHTML']) {\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     */\n    function upgradeNodesInRange(start: Node, end: Node|null) {\n      const nodes = [];\n      for (let node: 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    destination.insertAdjacentHTML = function(this: Element, position, text) {\n      const strPosition = position.toLowerCase();\n\n      if (strPosition === 'beforebegin') {\n        const marker = this.previousSibling;\n        baseMethod.call(this, strPosition, text);\n        upgradeNodesInRange(marker || this.parentNode!.firstChild!, this);\n      } else if (strPosition === 'afterbegin') {\n        const marker = this.firstChild;\n        baseMethod.call(this, strPosition, text);\n        upgradeNodesInRange(this.firstChild!, marker);\n      } else if (strPosition === 'beforeend') {\n        const marker = this.lastChild;\n        baseMethod.call(this, strPosition, text);\n        upgradeNodesInRange(marker || this.firstChild!, null);\n      } else if (strPosition === 'afterend') {\n        const marker = this.nextSibling;\n        baseMethod.call(this, strPosition, text);\n        upgradeNodesInRange(this.nextSibling!, marker);\n      } else {\n        throw new SyntaxError(\n            `The value provided (${String(strPosition)}) is ` +\n            'not one of \\'beforebegin\\', \\'afterbegin\\', \\'beforeend\\', or \\'afterend\\'.');\n      }\n    };\n  }\n\n  if (Native.HTMLElement_insertAdjacentHTML) {\n    patch_insertAdjacentHTML(\n        HTMLElement.prototype, Native.HTMLElement_insertAdjacentHTML);\n  } else if (Native.Element_insertAdjacentHTML) {\n    patch_insertAdjacentHTML(\n        Element.prototype, Native.Element_insertAdjacentHTML);\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","/**\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n/**\n * Represents the 'already constructed marker' used in custom\n * element construction stacks.\n *\n * https://html.spec.whatwg.org/#concept-already-constructed-marker\n */\nconst alreadyConstructedMarker = {} as {_alreadyConstructedMarker: never};\n\nexport default alreadyConstructedMarker;\nexport type AlreadyConstructedMarkerType = typeof alreadyConstructedMarker;\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport AlreadyConstructedMarker from '../AlreadyConstructedMarker.js';\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport CEState from '../CustomElementState.js';\nimport {Constructor} from '../Externs.js';\nimport * as Native from './Native.js';\n\nexport default function(internals: CustomElementInternals) {\n  const PatchedHTMLElement = function HTMLElement(this: HTMLElement) {\n    // This should really be `new.target` but `new.target` can't be\n    // emulated in ES5. Assuming the user keeps the default value of the\n    // constructor's prototype's `constructor` property, this is\n    // equivalent.\n    const constructor = this.constructor as Constructor<HTMLElement>;\n\n    // Always look up the definition from the global registry.\n    const registry = document.__CE_registry!;\n    const definition = registry.internal_constructorToDefinition(constructor);\n    if (!definition) {\n      throw new Error(\n          'Failed to construct a custom element: ' +\n          'The constructor 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(\n                          document, definition.localName)) as HTMLElement;\n      Object.setPrototypeOf(element, constructor.prototype as typeof element);\n      element.__CE_state = CEState.custom;\n      element.__CE_definition = definition;\n      internals.patchElement(element);\n      return element;\n    }\n\n    const lastIndex = constructionStack.length - 1;\n    const element = constructionStack[lastIndex];\n    if (element === AlreadyConstructedMarker) {\n      const localName = definition.localName;\n      throw new Error(\n          'Failed to construct \\'' + localName + '\\': ' +\n          'This element was already constructed.');\n    }\n    const toConstructElement = element as HTMLElement;\n    constructionStack[lastIndex] = AlreadyConstructedMarker;\n\n    Object.setPrototypeOf(\n        toConstructElement, constructor.prototype as typeof toConstructElement);\n    internals.patchElement(toConstructElement);\n\n    return toConstructElement;\n  };\n\n  PatchedHTMLElement.prototype = Native.HTMLElement.prototype;\n  // Safari 9 has `writable: false` on the propertyDescriptor\n  // Make it writable so that TypeScript can patch up the\n  // constructor in the ES5 compiled code.\n  Object.defineProperty(HTMLElement.prototype, 'constructor', {\n    writable: true,\n    configurable: true,\n    enumerable: false,\n    value: PatchedHTMLElement\n  });\n\n  window['HTMLElement'] = PatchedHTMLElement as unknown as typeof HTMLElement;\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport * as Utilities from '../Utilities.js';\n\nimport * as Native from './Native.js';\n\nexport default function(internals: CustomElementInternals) {\n  // `Node#nodeValue` is implemented on `Attr`.\n  // `Node#textContent` is implemented on `Attr`, `Element`.\n\n  Node.prototype.insertBefore = function<T extends Node>(\n      this: Node, node: T, refNode: Node|null) {\n    if (node instanceof DocumentFragment) {\n      const insertedNodes = Utilities.childrenFromFragment(node);\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 as T;\n    }\n\n    const nodeWasConnectedElement =\n        node instanceof Element && Utilities.isConnected(node);\n    const nativeResult =\n        Native.Node_insertBefore.call(this, node, refNode) as T;\n\n    if (nodeWasConnectedElement) {\n      internals.disconnectTree(node);\n    }\n\n    if (Utilities.isConnected(this)) {\n      internals.connectTree(node);\n    }\n\n    return nativeResult;\n  };\n\n  Node.prototype.appendChild = function<T extends Node>(this: Node, node: T) {\n    if (node instanceof DocumentFragment) {\n      const insertedNodes = Utilities.childrenFromFragment(node);\n      const nativeResult = Native.Node_appendChild.call(this, node) as T;\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 nodeWasConnectedElement =\n        node instanceof Element && Utilities.isConnected(node);\n    const nativeResult = Native.Node_appendChild.call(this, node) as T;\n\n    if (nodeWasConnectedElement) {\n      internals.disconnectTree(node);\n    }\n\n    if (Utilities.isConnected(this)) {\n      internals.connectTree(node);\n    }\n\n    return nativeResult;\n  };\n\n  Node.prototype.cloneNode = function(this: Node, 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_registry) {\n      internals.patchTree(clone);\n    } else {\n      internals.patchAndUpgradeTree(clone);\n    }\n    return clone;\n  };\n\n  Node.prototype.removeChild = function<T extends Node>(this: Node, node: T) {\n    const nodeWasConnectedElement =\n        node instanceof Element && Utilities.isConnected(node);\n    const nativeResult = Native.Node_removeChild.call(this, node) as T;\n\n    if (nodeWasConnectedElement) {\n      internals.disconnectTree(node);\n    }\n\n    return nativeResult;\n  };\n\n  Node.prototype.replaceChild = function<T extends Node>(\n      this: Node, nodeToInsert: Node, nodeToRemove: T) {\n    if (nodeToInsert instanceof DocumentFragment) {\n      const insertedNodes = Utilities.childrenFromFragment(nodeToInsert);\n      const nativeResult =\n          Native.Node_replaceChild.call(this, nodeToInsert, nodeToRemove) as T;\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 nodeToInsertWasConnectedElement =\n        nodeToInsert instanceof Element && Utilities.isConnected(nodeToInsert);\n    const nativeResult =\n        Native.Node_replaceChild.call(this, nodeToInsert, nodeToRemove) as T;\n    const thisIsConnected = Utilities.isConnected(this);\n\n    if (thisIsConnected) {\n      internals.disconnectTree(nodeToRemove);\n    }\n\n    if (nodeToInsertWasConnectedElement) {\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(\n      destination: Node, baseDescriptor: PropertyDescriptor) {\n    Object.defineProperty(destination, 'textContent', {\n      enumerable: baseDescriptor.enumerable,\n      configurable: true,\n      get: baseDescriptor.get,\n      set: function(this: Node, 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.addNodePatch(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: function(this: Node) {\n          const parts: Array<string|null> = [];\n\n          for (let n = this.firstChild; n; n = n.nextSibling) {\n            if (n.nodeType === Node.COMMENT_NODE) {\n              continue;\n            }\n            parts.push(n.textContent);\n          }\n\n          return parts.join('');\n        },\n        set: function(this: Node, assignedValue) {\n          while (this.firstChild) {\n            Native.Node_removeChild.call(this, this.firstChild);\n          }\n          // `textContent = null | undefined | ''` does not result in\n          // a TextNode childNode\n          if (assignedValue != null && assignedValue !== '') {\n            Native.Node_appendChild.call(\n                this, document.createTextNode(assignedValue));\n          }\n        },\n      });\n    });\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\n * http://polymer.github.io/LICENSE.txt The complete set of authors may be found\n * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may\n * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by\n * Google as part of the polymer project is also subject to an additional IP\n * rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from '../CustomElementInternals.js';\n\nimport PatchParentNode from './Interface/ParentNode.js';\nimport * as Native from './Native.js';\n\nexport default function(internals: CustomElementInternals) {\n  PatchParentNode(internals, DocumentFragment.prototype, {\n    prepend: Native.DocumentFragment_prepend,\n    append: Native.DocumentFragment_append,\n  });\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n/*\nExtremely simple css parser. Intended to be not more than what we need\nand definitely not necessarily correct =).\n*/\n\n'use strict';\n\n/** @unrestricted */\nclass StyleNode {\n  constructor() {\n    /** @type {number} */\n    this['start'] = 0;\n    /** @type {number} */\n    this['end'] = 0;\n    /** @type {StyleNode} */\n    this['previous'] = null;\n    /** @type {StyleNode} */\n    this['parent'] = null;\n    /** @type {Array<StyleNode>} */\n    this['rules'] = null;\n    /** @type {string} */\n    this['parsedCssText'] = '';\n    /** @type {string} */\n    this['cssText'] = '';\n    /** @type {boolean} */\n    this['atRule'] = false;\n    /** @type {number} */\n    this['type'] = 0;\n    /** @type {string} */\n    this['keyframesName'] = '';\n    /** @type {string} */\n    this['selector'] = '';\n    /** @type {string} */\n    this['parsedSelector'] = '';\n  }\n}\n\nexport {StyleNode}\n\n// given a string of css, return a simple rule tree\n/**\n * @param {string} text\n * @return {StyleNode}\n */\nexport function parse(text) {\n  text = clean(text);\n  return parseCss(lex(text), text);\n}\n\n// remove stuff we don't care about that may hinder parsing\n/**\n * @param {string} cssText\n * @return {string}\n */\nfunction clean(cssText) {\n  return cssText.replace(RX.comments, '').replace(RX.port, '');\n}\n\n// super simple {...} lexer that returns a node tree\n/**\n * @param {string} text\n * @return {!StyleNode}\n */\nfunction lex(text) {\n  let root = new StyleNode();\n  root['start'] = 0;\n  root['end'] = text.length\n  let n = root;\n  for (let i = 0, l = text.length; i < l; i++) {\n    if (text[i] === OPEN_BRACE) {\n      if (!n['rules']) {\n        n['rules'] = [];\n      }\n      let p = n;\n      let previous = p['rules'][p['rules'].length - 1] || null;\n      n = new StyleNode();\n      n['start'] = i + 1;\n      n['parent'] = p;\n      n['previous'] = previous;\n      p['rules'].push(n);\n    } else if (text[i] === CLOSE_BRACE) {\n      n['end'] = i + 1;\n      n = n['parent'] || root;\n    }\n  }\n  return root;\n}\n\n// add selectors/cssText to node tree\n/**\n * @param {StyleNode} node\n * @param {string} text\n * @return {!StyleNode}\n */\nfunction parseCss(node, text) {\n  let t = text.substring(node['start'], node['end'] - 1);\n  node['parsedCssText'] = node['cssText'] = t.trim();\n  if (node['parent']) {\n    let ss = node['previous'] ? node['previous']['end'] : node['parent']['start'];\n    t = text.substring(ss, node['start'] - 1);\n    t = _expandUnicodeEscapes(t);\n    t = t.replace(RX.multipleSpaces, ' ');\n    // TODO(sorvell): ad hoc; make selector include only after last ;\n    // helps with mixin syntax\n    t = t.substring(t.lastIndexOf(';') + 1);\n    let s = node['parsedSelector'] = node['selector'] = t.trim();\n    node['atRule'] = (s.indexOf(AT_START) === 0);\n    // note, support a subset of rule types...\n    if (node['atRule']) {\n      if (s.indexOf(MEDIA_START) === 0) {\n        node['type'] = types.MEDIA_RULE;\n      } else if (s.match(RX.keyframesRule)) {\n        node['type'] = types.KEYFRAMES_RULE;\n        node['keyframesName'] =\n          node['selector'].split(RX.multipleSpaces).pop();\n      }\n    } else {\n      if (s.indexOf(VAR_START) === 0) {\n        node['type'] = types.MIXIN_RULE;\n      } else {\n        node['type'] = types.STYLE_RULE;\n      }\n    }\n  }\n  let r$ = node['rules'];\n  if (r$) {\n    for (let i = 0, l = r$.length, r;\n      (i < l) && (r = r$[i]); i++) {\n      parseCss(r, text);\n    }\n  }\n  return node;\n}\n\n/**\n * conversion of sort unicode escapes with spaces like `\\33 ` (and longer) into\n * expanded form that doesn't require trailing space `\\000033`\n * @param {string} s\n * @return {string}\n */\nfunction _expandUnicodeEscapes(s) {\n  return s.replace(/\\\\([0-9a-f]{1,6})\\s/gi, function() {\n    let code = arguments[1],\n      repeat = 6 - code.length;\n    while (repeat--) {\n      code = '0' + code;\n    }\n    return '\\\\' + code;\n  });\n}\n\n/**\n * stringify parsed css.\n * @param {StyleNode} node\n * @param {boolean=} preserveProperties\n * @param {string=} text\n * @return {string}\n */\nexport function stringify(node, preserveProperties, text = '') {\n  // calc rule cssText\n  let cssText = '';\n  if (node['cssText'] || node['rules']) {\n    let r$ = node['rules'];\n    if (r$ && !_hasMixinRules(r$)) {\n      for (let i = 0, l = r$.length, r;\n        (i < l) && (r = r$[i]); i++) {\n        cssText = stringify(r, preserveProperties, cssText);\n      }\n    } else {\n      cssText = preserveProperties ? node['cssText'] :\n        removeCustomProps(node['cssText']);\n      cssText = cssText.trim();\n      if (cssText) {\n        cssText = '  ' + cssText + '\\n';\n      }\n    }\n  }\n  // emit rule if there is cssText\n  if (cssText) {\n    if (node['selector']) {\n      text += node['selector'] + ' ' + OPEN_BRACE + '\\n';\n    }\n    text += cssText;\n    if (node['selector']) {\n      text += CLOSE_BRACE + '\\n\\n';\n    }\n  }\n  return text;\n}\n\n/**\n * @param {Array<StyleNode>} rules\n * @return {boolean}\n */\nfunction _hasMixinRules(rules) {\n  let r = rules[0];\n  return Boolean(r) && Boolean(r['selector']) && r['selector'].indexOf(VAR_START) === 0;\n}\n\n/**\n * @param {string} cssText\n * @return {string}\n */\nfunction removeCustomProps(cssText) {\n  cssText = removeCustomPropAssignment(cssText);\n  return removeCustomPropApply(cssText);\n}\n\n/**\n * @param {string} cssText\n * @return {string}\n */\nexport function removeCustomPropAssignment(cssText) {\n  return cssText\n    .replace(RX.customProp, '')\n    .replace(RX.mixinProp, '');\n}\n\n/**\n * @param {string} cssText\n * @return {string}\n */\nfunction removeCustomPropApply(cssText) {\n  return cssText\n    .replace(RX.mixinApply, '')\n    .replace(RX.varApply, '');\n}\n\n/** @enum {number} */\nexport const types = {\n  STYLE_RULE: 1,\n  KEYFRAMES_RULE: 7,\n  MEDIA_RULE: 4,\n  MIXIN_RULE: 1000\n}\n\nconst OPEN_BRACE = '{';\nconst CLOSE_BRACE = '}';\n\n// helper regexp's\nconst RX = {\n  comments: /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//gim,\n  port: /@import[^;]*;/gim,\n  customProp: /(?:^[^;\\-\\s}]+)?--[^;{}]*?:[^{};]*?(?:[;\\n]|$)/gim,\n  mixinProp: /(?:^[^;\\-\\s}]+)?--[^;{}]*?:[^{};]*?{[^}]*?}(?:[;\\n]|$)?/gim,\n  mixinApply: /@apply\\s*\\(?[^);]*\\)?\\s*(?:[;\\n]|$)?/gim,\n  varApply: /[^;:]*?:[^;]*?var\\([^;]*\\)(?:[;\\n]|$)?/gim,\n  keyframesRule: /^@[^\\s]*keyframes/,\n  multipleSpaces: /\\s+/g\n}\n\nconst VAR_START = '--';\nconst MEDIA_START = '@media';\nconst AT_START = '@';\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nexport const nativeShadow = !(window['ShadyDOM'] && window['ShadyDOM']['inUse']);\nlet nativeCssVariables_;\n\n/**\n * @param {(ShadyCSSOptions | ShadyCSSInterface)=} settings\n */\nfunction calcCssVariables(settings) {\n  if (settings && settings['shimcssproperties']) {\n    nativeCssVariables_ = false;\n  } else {\n    // chrome 49 has semi-working css vars, check if box-shadow works\n    // safari 9.1 has a recalc bug: https://bugs.webkit.org/show_bug.cgi?id=155782\n    // However, shim css custom properties are only supported with ShadyDOM enabled,\n    // so fall back on native if we do not detect ShadyDOM\n    // Edge 15: custom properties used in ::before and ::after will also be used in the parent element\n    // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12414257/\n    nativeCssVariables_ = nativeShadow || Boolean(!navigator.userAgent.match(/AppleWebKit\\/601|Edge\\/15/) &&\n      window.CSS && CSS.supports && CSS.supports('box-shadow', '0 0 0 var(--foo)'));\n  }\n}\n\n/** @type {string | undefined} */\nexport let cssBuild;\nif (window.ShadyCSS && window.ShadyCSS.cssBuild !== undefined) {\n  cssBuild = window.ShadyCSS.cssBuild;\n}\n\n/** @type {boolean} */\nexport const disableRuntime = Boolean(window.ShadyCSS && window.ShadyCSS.disableRuntime);\n\nif (window.ShadyCSS && window.ShadyCSS.nativeCss !== undefined) {\n  nativeCssVariables_ = window.ShadyCSS.nativeCss;\n} else if (window.ShadyCSS) {\n  calcCssVariables(window.ShadyCSS);\n  // reset window variable to let ShadyCSS API take its place\n  window.ShadyCSS = undefined;\n} else {\n  calcCssVariables(window['WebComponents'] && window['WebComponents']['flags']);\n}\n\n// Hack for type error under new type inference which doesn't like that\n// nativeCssVariables is updated in a function and assigns the type\n// `function(): ?` instead of `boolean`.\nexport const nativeCssVariables = /** @type {boolean} */(nativeCssVariables_);","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nexport const VAR_ASSIGN = /(?:^|[;\\s{]\\s*)(--[\\w-]*?)\\s*:\\s*(?:((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^)]*?\\)|[^};{])+)|\\{([^}]*)\\}(?:(?=[;\\s}])|$))/gi;\nexport const MIXIN_MATCH = /(?:^|\\W+)@apply\\s*\\(?([^);\\n]*)\\)?/gi;\nexport const VAR_CONSUMED = /(--[\\w-]+)\\s*([:,;)]|$)/gi;\nexport const ANIMATION_MATCH = /(animation\\s*:)|(animation-name\\s*:)/;\nexport const MEDIA_MATCH = /@media\\s(.*)/;\nexport const IS_VAR = /^--/;\nexport const BRACKETED = /\\{[^}]*\\}/g;\nexport const HOST_PREFIX = '(?:^|[^.#[:])';\nexport const HOST_SUFFIX = '($|[.:[\\\\s>+~])';\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\n/** @type {!Set<string>} */\nconst styleTextSet = new Set();\n\nexport const scopingAttribute = 'shady-unscoped';\n\n/**\n * Add a specifically-marked style to the document directly, and only one copy of that style.\n *\n * @param {!HTMLStyleElement} style\n * @return {undefined}\n */\nexport function processUnscopedStyle(style) {\n  const text = style.textContent;\n  if (!styleTextSet.has(text)) {\n    styleTextSet.add(text);\n    const newStyle = document.createElement('style');\n    newStyle.setAttribute('shady-unscoped', '');\n    newStyle.textContent = text;\n    document.head.appendChild(newStyle);\n  }\n}\n\n/**\n * Check if a style is supposed to be unscoped\n * @param {!HTMLStyleElement} style\n * @return {boolean} true if the style has the unscoping attribute\n */\nexport function isUnscopedStyle(style) {\n  return style.hasAttribute(scopingAttribute);\n}","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {nativeShadow, nativeCssVariables, cssBuild} from './style-settings.js';\nimport {parse, stringify, types, StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\nimport {MEDIA_MATCH} from './common-regex.js';\nimport {processUnscopedStyle, isUnscopedStyle} from './unscoped-style-handler.js';\n\n/**\n * @param {string|StyleNode} rules\n * @param {function(StyleNode)=} callback\n * @return {string}\n */\nexport function toCssText (rules, callback) {\n  if (!rules) {\n    return '';\n  }\n  if (typeof rules === 'string') {\n    rules = parse(rules);\n  }\n  if (callback) {\n    forEachRule(rules, callback);\n  }\n  return stringify(rules, nativeCssVariables);\n}\n\n/**\n * @param {HTMLStyleElement} style\n * @return {StyleNode}\n */\nexport function rulesForStyle(style) {\n  if (!style['__cssRules'] && style.textContent) {\n    style['__cssRules'] = parse(style.textContent);\n  }\n  return style['__cssRules'] || null;\n}\n\n// Tests if a rule is a keyframes selector, which looks almost exactly\n// like a normal selector but is not (it has nothing to do with scoping\n// for example).\n/**\n * @param {StyleNode} rule\n * @return {boolean}\n */\nexport function isKeyframesSelector(rule) {\n  return Boolean(rule['parent']) &&\n  rule['parent']['type'] === types.KEYFRAMES_RULE;\n}\n\n/**\n * @param {StyleNode} node\n * @param {Function=} styleRuleCallback\n * @param {Function=} keyframesRuleCallback\n * @param {boolean=} onlyActiveRules\n */\nexport function forEachRule(node, styleRuleCallback, keyframesRuleCallback, onlyActiveRules) {\n  if (!node) {\n    return;\n  }\n  let skipRules = false;\n  let type = node['type'];\n  if (onlyActiveRules) {\n    if (type === types.MEDIA_RULE) {\n      let matchMedia = node['selector'].match(MEDIA_MATCH);\n      if (matchMedia) {\n        // if rule is a non matching @media rule, skip subrules\n        if (!window.matchMedia(matchMedia[1]).matches) {\n          skipRules = true;\n        }\n      }\n    }\n  }\n  if (type === types.STYLE_RULE) {\n    styleRuleCallback(node);\n  } else if (keyframesRuleCallback &&\n    type === types.KEYFRAMES_RULE) {\n    keyframesRuleCallback(node);\n  } else if (type === types.MIXIN_RULE) {\n    skipRules = true;\n  }\n  let r$ = node['rules'];\n  if (r$ && !skipRules) {\n    for (let i=0, l=r$.length, r; (i<l) && (r=r$[i]); i++) {\n      forEachRule(r, styleRuleCallback, keyframesRuleCallback, onlyActiveRules);\n    }\n  }\n}\n\n// add a string of cssText to the document.\n/**\n * @param {string} cssText\n * @param {string} moniker\n * @param {Node} target\n * @param {Node} contextNode\n * @return {HTMLStyleElement}\n */\nexport function applyCss(cssText, moniker, target, contextNode) {\n  let style = createScopeStyle(cssText, moniker);\n  applyStyle(style, target, contextNode);\n  return style;\n}\n\n/**\n * @param {string} cssText\n * @param {string} moniker\n * @return {!HTMLStyleElement}\n */\nexport function createScopeStyle(cssText, moniker) {\n  let style = /** @type {HTMLStyleElement} */(document.createElement('style'));\n  if (moniker) {\n    style.setAttribute('scope', moniker);\n  }\n  style.textContent = cssText;\n  return style;\n}\n\n/**\n * Track the position of the last added style for placing placeholders\n * @type {Node}\n */\nlet lastHeadApplyNode = null;\n\n// insert a comment node as a styling position placeholder.\n/**\n * @param {string} moniker\n * @return {!Comment}\n */\nexport function applyStylePlaceHolder(moniker) {\n  let placeHolder = document.createComment(' Shady DOM styles for ' +\n    moniker + ' ');\n  let after = lastHeadApplyNode ?\n    lastHeadApplyNode['nextSibling'] : null;\n  let scope = document.head;\n  scope.insertBefore(placeHolder, after || scope.firstChild);\n  lastHeadApplyNode = placeHolder;\n  return placeHolder;\n}\n\n/**\n * @param {HTMLStyleElement} style\n * @param {?Node} target\n * @param {?Node} contextNode\n */\nexport function applyStyle(style, target, contextNode) {\n  target = target || document.head;\n  let after = (contextNode && contextNode.nextSibling) ||\n    target.firstChild;\n  target.insertBefore(style, after);\n  if (!lastHeadApplyNode) {\n    lastHeadApplyNode = style;\n  } else {\n    // only update lastHeadApplyNode if the new style is inserted after the old lastHeadApplyNode\n    let position = style.compareDocumentPosition(lastHeadApplyNode);\n    if (position === Node.DOCUMENT_POSITION_PRECEDING) {\n      lastHeadApplyNode = style;\n    }\n  }\n}\n\n/**\n * @param {string} buildType\n * @return {boolean}\n */\nexport function isTargetedBuild(buildType) {\n  return nativeShadow ? buildType === 'shadow' : buildType === 'shady';\n}\n\n/**\n * Walk from text[start] matching parens and\n * returns position of the outer end paren\n * @param {string} text\n * @param {number} start\n * @return {number}\n */\nexport function findMatchingParen(text, start) {\n  let level = 0;\n  for (let i=start, l=text.length; i < l; i++) {\n    if (text[i] === '(') {\n      level++;\n    } else if (text[i] === ')') {\n      if (--level === 0) {\n        return i;\n      }\n    }\n  }\n  return -1;\n}\n\n/**\n * @param {string} str\n * @param {function(string, string, string, string)} callback\n */\nexport function processVariableAndFallback(str, callback) {\n  // find 'var('\n  let start = str.indexOf('var(');\n  if (start === -1) {\n    // no var?, everything is prefix\n    return callback(str, '', '', '');\n  }\n  //${prefix}var(${inner})${suffix}\n  let end = findMatchingParen(str, start + 3);\n  let inner = str.substring(start + 4, end);\n  let prefix = str.substring(0, start);\n  // suffix may have other variables\n  let suffix = processVariableAndFallback(str.substring(end + 1), callback);\n  let comma = inner.indexOf(',');\n  // value and fallback args should be trimmed to match in property lookup\n  if (comma === -1) {\n    // variable, no fallback\n    return callback(prefix, inner.trim(), '', suffix);\n  }\n  // var(${value},${fallback})\n  let value = inner.substring(0, comma).trim();\n  let fallback = inner.substring(comma + 1).trim();\n  return callback(prefix, value, fallback, suffix);\n}\n\n/**\n * @param {Element} element\n * @param {string} value\n */\nexport function setElementClassRaw(element, value) {\n  // use native setAttribute provided by ShadyDOM when setAttribute is patched\n  if (nativeShadow) {\n    element.setAttribute('class', value);\n  } else {\n    window['ShadyDOM']['nativeMethods']['setAttribute'].call(element, 'class', value);\n  }\n}\n\n/**\n * @type {function(*):*}\n */\nexport const wrap = window['ShadyDOM'] && window['ShadyDOM']['wrap'] || ((node) => node);\n\n/**\n * @param {Element | {is: string, extends: string}} element\n * @return {{is: string, typeExtension: string}}\n */\nexport function getIsExtends(element) {\n  let localName = element['localName'];\n  let is = '', typeExtension = '';\n  /*\n  NOTE: technically, this can be wrong for certain svg elements\n  with `-` in the name like `<font-face>`\n  */\n  if (localName) {\n    if (localName.indexOf('-') > -1) {\n      is = localName;\n    } else {\n      typeExtension = localName;\n      is = (element.getAttribute && element.getAttribute('is')) || '';\n    }\n  } else {\n    is = /** @type {?} */(element).is;\n    typeExtension = /** @type {?} */(element).extends;\n  }\n  return {is, typeExtension};\n}\n\n/**\n * @param {Element|DocumentFragment} element\n * @return {string}\n */\nexport function gatherStyleText(element) {\n  /** @type {!Array<string>} */\n  const styleTextParts = [];\n  const styles = /** @type {!NodeList<!HTMLStyleElement>} */(element.querySelectorAll('style'));\n  for (let i = 0; i < styles.length; i++) {\n    const style = styles[i];\n    if (isUnscopedStyle(style)) {\n      if (!nativeShadow) {\n        processUnscopedStyle(style);\n        style.parentNode.removeChild(style);\n      }\n    } else {\n      styleTextParts.push(style.textContent);\n      style.parentNode.removeChild(style);\n    }\n  }\n  return styleTextParts.join('').trim();\n}\n\n/**\n * Split a selector separated by commas into an array in a smart way\n * @param {string} selector\n * @return {!Array<string>}\n */\nexport function splitSelectorList(selector) {\n  const parts = [];\n  let part = '';\n  for (let i = 0; i >= 0 && i < selector.length; i++) {\n    // A selector with parentheses will be one complete part\n    if (selector[i] === '(') {\n      // find the matching paren\n      const end = findMatchingParen(selector, i);\n      // push the paren block into the part\n      part += selector.slice(i, end + 1);\n      // move the index to after the paren block\n      i = end;\n    } else if (selector[i] === ',') {\n      parts.push(part);\n      part = '';\n    } else {\n      part += selector[i];\n    }\n  }\n  // catch any pieces after the last comma\n  if (part) {\n    parts.push(part);\n  }\n  return parts;\n}\n\nconst CSS_BUILD_ATTR = 'css-build';\n\n/**\n * Return the polymer-css-build \"build type\" applied to this element\n *\n * @param {!HTMLElement} element\n * @return {string} Can be \"\", \"shady\", or \"shadow\"\n */\nexport function getCssBuild(element) {\n  if (cssBuild !== undefined) {\n    return /** @type {string} */(cssBuild);\n  }\n  if (element.__cssBuild === undefined) {\n    // try attribute first, as it is the common case\n    const attrValue = element.getAttribute(CSS_BUILD_ATTR);\n    if (attrValue) {\n      element.__cssBuild = attrValue;\n    } else {\n      const buildComment = getBuildComment(element);\n      if (buildComment !== '') {\n        // remove build comment so it is not needlessly copied into every element instance\n        removeBuildComment(element);\n      }\n      element.__cssBuild = buildComment;\n    }\n  }\n  return element.__cssBuild || '';\n}\n\n/**\n * Check if the given element, either a <template> or <style>, has been processed\n * by polymer-css-build.\n *\n * If so, then we can make a number of optimizations:\n * - polymer-css-build will decompose mixins into individual CSS Custom Properties,\n * so the ApplyShim can be skipped entirely.\n * - Under native ShadowDOM, the style text can just be copied into each instance\n * without modification\n * - If the build is \"shady\" and ShadyDOM is in use, the styling does not need\n * scoping beyond the shimming of CSS Custom Properties\n *\n * @param {!HTMLElement} element\n * @return {boolean}\n */\nexport function elementHasBuiltCss(element) {\n  return getCssBuild(element) !== '';\n}\n\n/**\n * For templates made with tagged template literals, polymer-css-build will\n * insert a comment of the form `<!--css-build:shadow-->`\n *\n * @param {!HTMLElement} element\n * @return {string}\n */\nexport function getBuildComment(element) {\n  const buildComment = element.localName === 'template' ?\n      /** @type {!HTMLTemplateElement} */ (element).content.firstChild :\n      element.firstChild;\n  if (buildComment instanceof Comment) {\n    const commentParts = buildComment.textContent.trim().split(':');\n    if (commentParts[0] === CSS_BUILD_ATTR) {\n      return commentParts[1];\n    }\n  }\n  return '';\n}\n\n/**\n * Check if the css build status is optimal, and do no unneeded work.\n *\n * @param {string=} cssBuild CSS build status\n * @return {boolean} css build is optimal or not\n */\nexport function isOptimalCssBuild(cssBuild = '') {\n  // CSS custom property shim always requires work\n  if (cssBuild === '' || !nativeCssVariables) {\n    return false;\n  }\n  return nativeShadow ? cssBuild === 'shadow' : cssBuild === 'shady';\n}\n\n/**\n * @param {!HTMLElement} element\n */\nfunction removeBuildComment(element) {\n  const buildComment = element.localName === 'template' ?\n      /** @type {!HTMLTemplateElement} */ (element).content.firstChild :\n      element.firstChild;\n  buildComment.parentNode.removeChild(buildComment);\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\nimport * as StyleUtil from './style-util.js';\nimport {nativeShadow} from './style-settings.js';\n\n/* Transforms ShadowDOM styling into ShadyDOM styling\n\n* scoping:\n\n  * elements in scope get scoping selector class=\"x-foo-scope\"\n  * selectors re-written as follows:\n\n    div button -> div.x-foo-scope button.x-foo-scope\n\n* :host -> scopeName\n\n* :host(...) -> scopeName...\n\n* ::slotted(...) -> scopeName > ...\n\n* ...:dir(ltr|rtl) -> [dir=\"ltr|rtl\"] ..., ...[dir=\"ltr|rtl\"]\n\n* :host(:dir[rtl]) -> scopeName:dir(rtl) -> [dir=\"rtl\"] scopeName, scopeName[dir=\"rtl\"]\n\n*/\nconst SCOPE_NAME = 'style-scope';\n\nclass StyleTransformer {\n  /** @return {string} */\n  get SCOPE_NAME() {\n    return SCOPE_NAME;\n  }\n  /**\n   * Given a node and scope name, add a scoping class to each node\n   * in the tree. This facilitates transforming css into scoped rules.\n   * @param {!Node} node\n   * @param {string} scope\n   * @param {boolean=} shouldRemoveScope\n   * @deprecated\n   */\n  dom(node, scope, shouldRemoveScope) {\n    const fn = (node) => {\n      this.element(node, scope || '', shouldRemoveScope);\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * Given a node and scope name, add a scoping class to each node in the tree.\n   * @param {!Node} node\n   * @param {string} scope\n   */\n  domAddScope(node, scope) {\n    const fn = (node) => {\n      this.element(node, scope || '');\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * @param {!Node} startNode\n   * @param {function(!Node)} transformer\n   */\n  _transformDom(startNode, transformer) {\n    if (startNode.nodeType === Node.ELEMENT_NODE) {\n      transformer(startNode);\n    }\n    let c$;\n    if (startNode.localName === 'template') {\n      const template = /** @type {!HTMLTemplateElement} */ (startNode);\n      // In case the template is in svg context, fall back to the node\n      // since it won't be an HTMLTemplateElement with a .content property\n      c$ = (template.content || template._content || template).childNodes;\n    } else {\n      c$ = /** @type {!ParentNode} */ (startNode).children ||\n          startNode.childNodes;\n    }\n    if (c$) {\n      for (let i = 0; i < c$.length; i++) {\n        this._transformDom(c$[i], transformer);\n      }\n    }\n  }\n\n  /**\n   * @param {?} element\n   * @param {?} scope\n   * @param {?=} shouldRemoveScope\n   */\n  element(element, scope, shouldRemoveScope) {\n    // note: if using classes, we add both the general 'style-scope' class\n    // as well as the specific scope. This enables easy filtering of all\n    // `style-scope` elements\n    if (scope) {\n      // note: svg on IE does not have classList so fallback to class\n      if (element.classList) {\n        if (shouldRemoveScope) {\n          element.classList.remove(SCOPE_NAME);\n          element.classList.remove(scope);\n        } else {\n          element.classList.add(SCOPE_NAME);\n          element.classList.add(scope);\n        }\n      } else if (element.getAttribute) {\n        let c = element.getAttribute(CLASS);\n        if (shouldRemoveScope) {\n          if (c) {\n            let newValue = c.replace(SCOPE_NAME, '').replace(scope, '');\n            StyleUtil.setElementClassRaw(element, newValue);\n          }\n        } else {\n          let newValue = (c ? c + ' ' : '') + SCOPE_NAME + ' ' + scope;\n          StyleUtil.setElementClassRaw(element, newValue);\n        }\n      }\n    }\n  }\n\n  /**\n   * Given a node, replace the scoping class to each subnode in the tree.\n   * @param {!Node} node\n   * @param {string} oldScope\n   * @param {string} newScope\n   */\n  domReplaceScope(node, oldScope, newScope) {\n    const fn = (node) => {\n      this.element(node, oldScope, true);\n      this.element(node, newScope);\n    };\n    this._transformDom(node, fn);\n  }\n  /**\n   * Given a node, remove the scoping class to each subnode in the tree.\n   * @param {!Node} node\n   * @param {string} oldScope\n   */\n  domRemoveScope(node, oldScope) {\n    const fn = (node) => {\n      this.element(node, oldScope || '', true);\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * @param {?} element\n   * @param {?} styleRules\n   * @param {?=} callback\n   * @param {string=} cssBuild\n   * @param {string=} cssText\n   * @return {string}\n   */\n  elementStyles(element, styleRules, callback, cssBuild = '', cssText = '') {\n    // no need to shim selectors if settings.useNativeShadow, also\n    // a shady css build will already have transformed selectors\n    // NOTE: This method may be called as part of static or property shimming.\n    // When there is a targeted build it will not be called for static shimming,\n    // but when the property shim is used it is called and should opt out of\n    // static shimming work when a proper build exists.\n    if (cssText === '') {\n      if (nativeShadow || cssBuild === 'shady') {\n        cssText = StyleUtil.toCssText(styleRules, callback);\n      } else {\n        let {is, typeExtension} = StyleUtil.getIsExtends(element);\n        cssText = this.css(styleRules, is, typeExtension, callback) + '\\n\\n';\n      }\n    }\n    return cssText.trim();\n  }\n\n  // Given a string of cssText and a scoping string (scope), returns\n  // a string of scoped css where each selector is transformed to include\n  // a class created from the scope. ShadowDOM selectors are also transformed\n  // (e.g. :host) to use the scoping selector.\n  css(rules, scope, ext, callback) {\n    let hostScope = this._calcHostScope(scope, ext);\n    scope = this._calcElementScope(scope);\n    let self = this;\n    return StyleUtil.toCssText(rules, function(/** StyleNode */ rule) {\n      if (!/** @type {?} */ (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'] = /** @type {?} */ (rule).transformedSelector =\n        this._transformRuleCss(rule, transformer, scope, hostScope);\n  }\n\n  /**\n   * @param {StyleNode} rule\n   * @param {Function} transformer\n   * @param {string=} scope\n   * @param {string=} hostScope\n   */\n  _transformRuleCss(rule, transformer, scope, hostScope) {\n    let p$ = StyleUtil.splitSelectorList(rule['selector']);\n    // we want to skip transformation of rules that appear in keyframes,\n    // because they are keyframe selectors, not element selectors.\n    if (!StyleUtil.isKeyframesSelector(rule)) {\n      for (let i=0, l=p$.length, p; (i<l) && (p=p$[i]); i++) {\n        p$[i] = transformer.call(this, p, scope, hostScope);\n      }\n    }\n    return p$.filter((part) => Boolean(part)).join(COMPLEX_SELECTOR_SEP);\n  }\n\n  /**\n   * @param {string} selector\n   * @return {string}\n   */\n  _twiddleNthPlus(selector) {\n    return selector.replace(NTH, (m, type, inside) => {\n      if (inside.indexOf('+') > -1) {\n        inside = inside.replace(/\\+/g, '___');\n      } else if (inside.indexOf('___') > -1) {\n        inside = inside.replace(/___/g, '+');\n      }\n      return `:${type}(${inside})`;\n    });\n  }\n\n  /**\n   * Preserve `:matches()` selectors by replacing them with MATCHES_REPLACMENT\n   * and returning an array of `:matches()` selectors.\n   * Use `_replacesMatchesPseudo` to replace the `:matches()` parts\n   *\n   * @param {string} selector\n   * @return {{selector: string, matches: !Array<string>}}\n   */\n  _preserveMatchesPseudo(selector) {\n    /** @type {!Array<string>} */\n    const matches = [];\n    let match;\n    while ((match = selector.match(MATCHES))) {\n      const start = match.index;\n      const end = StyleUtil.findMatchingParen(selector, start);\n      if (end === -1) {\n        throw new Error(`${match.input} selector missing ')'`);\n      }\n      const part = selector.slice(start, end + 1);\n      selector = selector.replace(part, MATCHES_REPLACEMENT);\n      matches.push(part);\n    }\n    return {selector, matches};\n  }\n\n  /**\n   * Replace MATCHES_REPLACMENT character with the given set of `:matches()`\n   * selectors.\n   *\n   * @param {string} selector\n   * @param {!Array<string>} matches\n   * @return {string}\n   */\n  _replaceMatchesPseudo(selector, matches) {\n    const parts = selector.split(MATCHES_REPLACEMENT);\n    return matches.reduce((acc, cur, idx) => acc + cur + parts[idx + 1], parts[0]);\n  }\n\n/**\n * @param {string} selector\n * @param {string} scope\n * @param {string=} hostScope\n */\n  _transformComplexSelector(selector, scope, hostScope) {\n    let stop = false;\n    selector = selector.trim();\n    // Remove spaces inside of selectors like `:nth-of-type` because it confuses SIMPLE_SELECTOR_SEP\n    let isNth = NTH.test(selector);\n    if (isNth) {\n      selector = selector.replace(\n          NTH, (m, type, inner) => `:${type}(${inner.replace(/\\s/g, '')})`);\n      selector = this._twiddleNthPlus(selector);\n    }\n    // Preserve selectors like `:-webkit-any` so that SIMPLE_SELECTOR_SEP does\n    // not get confused by spaces inside the pseudo selector\n    const isMatches = MATCHES.test(selector);\n    /** @type {!Array<string>} */\n    let matches;\n    if (isMatches) {\n      ({selector, matches} = this._preserveMatchesPseudo(selector));\n    }\n    selector = selector.replace(SLOTTED_START, `${HOST} $1`);\n    selector = selector.replace(SIMPLE_SELECTOR_SEP, (m, c, s) => {\n      if (!stop) {\n        let info = this._transformCompoundSelector(s, c, scope, hostScope);\n        stop = stop || info.stop;\n        c = info.combinator;\n        s = info.value;\n      }\n      return c + s;\n    });\n    // replace `:matches()` selectors\n    if (isMatches) {\n      selector = this._replaceMatchesPseudo(selector, matches);\n    }\n    if (isNth) {\n      selector = this._twiddleNthPlus(selector);\n    }\n    selector = selector.replace(DIR_PAREN, (m, before, dir, after) =>\n      `[dir=\"${dir}\"] ${before}${after}, ${before}[dir=\"${dir}\"]${after}`);\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    return {value: selector, combinator, stop};\n  }\n\n  _transformSimpleSelector(selector, scope) {\n    const attributes = selector.split(/(\\[.+?\\])/);\n\n    const output = [];\n    for (let i = 0; i < attributes.length; i++) {\n      // Do not attempt to transform any attribute selector content\n      if ((i % 2) === 1) {\n        output.push(attributes[i]);\n      } else {\n        const part = attributes[i];\n\n        if (!(part === '' && i === attributes.length - 1)) {\n          let p$ = part.split(PSEUDO_PREFIX);\n          p$[0] += scope;\n          output.push(p$.join(PSEUDO_PREFIX));\n        }\n      }\n    }\n\n    return output.join('');\n  }\n\n  // :host(...) -> scopeName...\n  _transformHostSelector(selector, hostScope) {\n    let m = selector.match(HOST_PAREN);\n    let paren = m && m[2].trim() || '';\n    if (paren) {\n      if (!paren[0].match(SIMPLE_SELECTOR_PREFIX)) {\n        // paren starts with a type selector\n        let typeSelector = paren.split(SIMPLE_SELECTOR_PREFIX)[0];\n        // if the type selector is our hostScope then avoid pre-pending it\n        if (typeSelector === hostScope) {\n          return paren;\n        // otherwise, this selector should not match in this scope so\n        // output a bogus selector.\n        } else {\n          return SELECTOR_NO_MATCH;\n        }\n      } else {\n        // make sure to do a replace here to catch selectors like:\n        // `:host(.foo)::before`\n        return selector.replace(HOST_PAREN, function(m, host, paren) {\n          return hostScope + paren;\n        });\n      }\n    // if no paren, do a straight :host replacement.\n    // TODO(sorvell): this should not strictly be necessary but\n    // it's needed to maintain support for `:host[foo]` type selectors\n    // which have been improperly used under Shady DOM. This should be\n    // deprecated.\n    } else {\n      return selector.replace(HOST, hostScope);\n    }\n  }\n\n  /**\n   * @param {StyleNode} rule\n   */\n  documentRule(rule) {\n    // reset selector in case this is redone.\n    rule['selector'] = rule['parsedSelector'];\n    this.normalizeRootSelector(rule);\n    this._transformRule(rule, this._transformDocumentSelector);\n  }\n\n  /**\n   * @param {StyleNode} rule\n   */\n  normalizeRootSelector(rule) {\n    if (rule['selector'] === ROOT) {\n      rule['selector'] = 'html';\n    }\n  }\n\n/**\n * @param {string} selector\n */\n  _transformDocumentSelector(selector) {\n    if (selector.match(HOST)) {\n      // remove ':host' type selectors in document rules\n      return '';\n    } else if (selector.match(SLOTTED)) {\n      return this._transformComplexSelector(selector, SCOPE_DOC_SELECTOR);\n    } else {\n      return this._transformSimpleSelector(selector.trim(), SCOPE_DOC_SELECTOR);\n    }\n  }\n}\n\nconst NTH = /:(nth[-\\w]+)\\(([^)]+)\\)/;\nconst SCOPE_DOC_SELECTOR = `:not(.${SCOPE_NAME})`;\nconst COMPLEX_SELECTOR_SEP = ',';\nconst SIMPLE_SELECTOR_SEP = /(^|[\\s>+~]+)((?:\\[.+?\\]|[^\\s>+~=[])+)/g;\nconst SIMPLE_SELECTOR_PREFIX = /[[.:#*]/;\nconst HOST = ':host';\nconst ROOT = ':root';\nconst SLOTTED = '::slotted';\nconst SLOTTED_START = new RegExp(`^(${SLOTTED})`);\n// NOTE: this supports 1 nested () pair for things like\n// :host(:not([selected]), more general support requires\n// parsing which seems like overkill\nconst HOST_PAREN = /(:host)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))/;\n// similar to HOST_PAREN\nconst SLOTTED_PAREN = /(?:::slotted)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))/;\nconst DIR_PAREN = /(.*):dir\\((?:(ltr|rtl))\\)(.*)/;\nconst CSS_CLASS_PREFIX = '.';\nconst PSEUDO_PREFIX = ':';\nconst CLASS = 'class';\nconst SELECTOR_NO_MATCH = 'should_not_match';\nconst MATCHES = /:(?:matches|any|-(?:webkit|moz)-any)/;\nconst MATCHES_REPLACEMENT = '\\u{e000}';\n\nexport default new StyleTransformer();\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {parse, StyleNode} from './css-parse.js';\nimport {nativeShadow, nativeCssVariables, disableRuntime} from './style-settings.js';\nimport StyleTransformer from './style-transformer.js';\nimport * as StyleUtil from './style-util.js';\nimport StyleProperties from './style-properties.js';\nimport {ensureStylePlaceholder, getStylePlaceholder} from './style-placeholder.js';\nimport StyleInfo from './style-info.js';\nimport StyleCache from './style-cache.js';\nimport {flush as watcherFlush, getOwnerScope, getCurrentScope} from './document-watcher.js';\nimport templateMap from './template-map.js';\nimport * as ApplyShimUtils from './apply-shim-utils.js';\nimport {updateNativeProperties, detectMixin} from './common-utils.js';\nimport {CustomStyleInterfaceInterface, CustomStyleProvider} from './custom-style-interface.js'; // eslint-disable-line no-unused-vars\n\n/** @type {!Object<string, string>} */\nconst adoptedCssTextMap = {};\n\n/**\n * @const {StyleCache}\n */\nconst styleCache = new StyleCache();\n\nexport default class ScopingShim {\n  constructor() {\n    this._scopeCounter = {};\n    this._documentOwner = /** @type {!HTMLElement} */(document.documentElement);\n    let ast = new StyleNode();\n    ast['rules'] = [];\n    this._documentOwnerStyleInfo = StyleInfo.set(this._documentOwner, new StyleInfo(ast));\n    this._elementsHaveApplied = false;\n    /** @type {?Object} */\n    this._applyShim = null;\n    /** @type {?CustomStyleInterfaceInterface} */\n    this._customStyleInterface = null;\n  }\n  flush() {\n    watcherFlush();\n  }\n  _generateScopeSelector(name) {\n    let id = this._scopeCounter[name] = (this._scopeCounter[name] || 0) + 1;\n    return `${name}-${id}`;\n  }\n  getStyleAst(style) {\n    return StyleUtil.rulesForStyle(style);\n  }\n  styleAstToString(ast) {\n    return StyleUtil.toCssText(ast);\n  }\n  _gatherStyles(template) {\n    return StyleUtil.gatherStyleText(template.content);\n  }\n  /**\n   * Prepare the styling and template for the given element type\n   *\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} typeExtension\n   */\n  prepareTemplate(template, elementName, typeExtension) {\n    this.prepareTemplateDom(template, elementName);\n    this.prepareTemplateStyles(template, elementName, typeExtension);\n  }\n  /**\n   * Prepare styling for the given element type\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} typeExtension\n   */\n  prepareTemplateStyles(template, elementName, typeExtension) {\n    if (template._prepared || disableRuntime) {\n      return;\n    }\n    // style placeholders are only used when ShadyDOM is active\n    if (!nativeShadow) {\n      ensureStylePlaceholder(elementName);\n    }\n    template._prepared = true;\n    template.name = elementName;\n    template.extends = typeExtension;\n    templateMap[elementName] = template;\n    let cssBuild = StyleUtil.getCssBuild(template);\n    const optimalBuild = StyleUtil.isOptimalCssBuild(cssBuild);\n    let info = {\n      is: elementName,\n      extends: typeExtension,\n    };\n    let cssText = this._gatherStyles(template) + (adoptedCssTextMap[elementName] || '');\n    // check if the styling has mixin definitions or uses\n    this._ensure();\n    if (!optimalBuild) {\n      let hasMixins = !cssBuild && detectMixin(cssText);\n      let ast = parse(cssText);\n      // only run the applyshim transforms if there is a mixin involved\n      if (hasMixins && nativeCssVariables && this._applyShim) {\n        this._applyShim['transformRules'](ast, elementName);\n      }\n      template['_styleAst'] = ast;\n    }\n    let ownPropertyNames = [];\n    if (!nativeCssVariables) {\n      ownPropertyNames = StyleProperties.decorateStyles(template['_styleAst']);\n    }\n    if (!ownPropertyNames.length || nativeCssVariables) {\n      let root = nativeShadow ? template.content : null;\n      let placeholder = getStylePlaceholder(elementName);\n      let style = this._generateStaticStyle(info, template['_styleAst'], root, placeholder, cssBuild, optimalBuild ? cssText : '');\n      template._style = style;\n    }\n    template._ownPropertyNames = ownPropertyNames;\n  }\n\n  /**\n   * @param {!Array<string>} cssTextArray\n   * @param {string} elementName\n   */\n  prepareAdoptedCssText(cssTextArray, elementName) {\n    adoptedCssTextMap[elementName] = cssTextArray.join(' ');\n  }\n  /**\n   * Prepare template for the given element type\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   */\n  prepareTemplateDom(template, elementName) {\n    if (disableRuntime) {\n      return;\n    }\n    const cssBuild = StyleUtil.getCssBuild(template);\n    if (!nativeShadow && cssBuild !== 'shady' && !template._domPrepared) {\n      template._domPrepared = true;\n      StyleTransformer.domAddScope(template.content, elementName);\n    }\n  }\n  /**\n   * @param {!{is: string, extends: (string|undefined)}} info\n   * @param {!StyleNode} rules\n   * @param {DocumentFragment} shadowroot\n   * @param {Node} placeholder\n   * @param {string} cssBuild\n   * @param {string=} cssText\n   * @return {?HTMLStyleElement}\n   */\n  _generateStaticStyle(info, rules, shadowroot, placeholder, cssBuild, cssText) {\n    cssText = StyleTransformer.elementStyles(info, rules, null, cssBuild, cssText);\n    if (cssText.length) {\n      return StyleUtil.applyCss(cssText, info.is, shadowroot, placeholder);\n    }\n    return null;\n  }\n  _prepareHost(host) {\n    const {is, typeExtension} = StyleUtil.getIsExtends(host);\n    const placeholder = getStylePlaceholder(is);\n    const template = templateMap[is];\n    if (!template) {\n      return;\n    }\n    const ast = template['_styleAst'];\n    const ownStylePropertyNames = template._ownPropertyNames;\n    const cssBuild = StyleUtil.getCssBuild(template);\n    const styleInfo = new StyleInfo(\n      ast,\n      placeholder,\n      ownStylePropertyNames,\n      is,\n      typeExtension,\n      cssBuild\n    );\n    StyleInfo.set(host, styleInfo);\n    return styleInfo;\n  }\n  /**\n   * Returns a boolean that indicates if styles need to be reprocessed because\n   * the apply shim is now available.\n   * @return {boolean}\n   */\n  _ensureApplyShim() {\n    if (!this._applyShim && window.ShadyCSS && window.ShadyCSS.ApplyShim) {\n      this._applyShim = /** @type {!Object} */ (window.ShadyCSS.ApplyShim);\n      this._applyShim['invalidCallback'] = ApplyShimUtils.invalidate;\n      return true;\n    }\n    return false;\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  /**\n   * Returns a boolean that indicates if styles need to be reprocessed because\n   * the apply shim is now available.\n   * @return {boolean}\n   */\n  _ensure() {\n    const needsApplyShimUpdate = this._ensureApplyShim();\n    this._ensureCustomStyleInterface();\n    return needsApplyShimUpdate;\n  }\n  /**\n   * Flush and apply custom styles to document\n   */\n  flushCustomStyles() {\n    if (disableRuntime) {\n      return;\n    }\n    const needsApplyShimUpdate = 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 (!needsApplyShimUpdate && !this._customStyleInterface['enqueued']) {\n      return;\n    }\n    // bail if custom styles are built optimally\n    if (StyleUtil.isOptimalCssBuild(this._documentOwnerStyleInfo.cssBuild)) {\n      return;\n    }\n    if (!nativeCssVariables) {\n      this._reorderCustomStylesRules(customStyles);\n      this._updateProperties(this._documentOwner, this._documentOwnerStyleInfo);\n      this._applyCustomStyles(customStyles);\n      if (this._elementsHaveApplied) {\n        // if custom elements have upgraded and there are no native css variables, we must recalculate the whole tree\n        this.styleDocument();\n      }\n    } else if (!this._documentOwnerStyleInfo.cssBuild) {\n      this._revalidateCustomStyleApplyShim(customStyles);\n    }\n    this._customStyleInterface['enqueued'] = false;\n  }\n  /**\n   * Reorder of custom styles for Custom Property shim\n   * @param {!Array<!CustomStyleProvider>} customStyles\n   */\n  _reorderCustomStylesRules(customStyles) {\n    const styles = customStyles.map(c => this._customStyleInterface['getStyleForCustomStyle'](c)).filter(s => !!s);\n    // sort styles in document order\n    styles.sort((a, b) => {\n      // use `b.compare(a)` to be more straightforward\n      const position = b.compareDocumentPosition(a);\n      if (position & Node.DOCUMENT_POSITION_FOLLOWING) {\n        // A is after B, A should be higher sorted\n        return 1;\n      } else if (position & Node.DOCUMENT_POSITION_PRECEDING) {\n        // A is before B, A should be lower sorted\n        return -1;\n      } else {\n        return 0;\n      }\n    });\n    // sort ast ordering for document\n    this._documentOwnerStyleInfo.styleRules['rules'] = styles.map(s => StyleUtil.rulesForStyle(s));\n  }\n  /**\n   * Apply styles for the given element\n   *\n   * @param {!HTMLElement} host\n   * @param {Object=} overrideProps\n   */\n  styleElement(host, overrideProps) {\n    if (disableRuntime) {\n      if (overrideProps) {\n        if (!StyleInfo.get(host)) {\n          StyleInfo.set(host, new StyleInfo(null));\n        }\n        const styleInfo = /** @type {!StyleInfo} */(StyleInfo.get(host));\n        this._mixOverrideStyleProps(styleInfo, overrideProps);\n        this.styleElementNativeVariables(host, styleInfo);\n      }\n      return;\n    }\n    const styleInfo = StyleInfo.get(host) || this._prepareHost(host);\n    // if there is no style info at this point, bail\n    if (!styleInfo) {\n      return;\n    }\n    // Only trip the `elementsHaveApplied` flag if a node other that the root document has `applyStyle` called\n    if (!this._isRootOwner(host)) {\n      this._elementsHaveApplied = true;\n    }\n    if (overrideProps) {\n      this._mixOverrideStyleProps(styleInfo, overrideProps);\n    }\n    if (!nativeCssVariables) {\n      this.styleElementShimVariables(host, styleInfo);\n    } else {\n      this.styleElementNativeVariables(host, styleInfo);\n    }\n  }\n  /**\n   * @param {!StyleInfo} styleInfo\n   * @param {Object} overrideProps\n   */\n  _mixOverrideStyleProps(styleInfo, overrideProps) {\n    styleInfo.overrideStyleProperties =\n      styleInfo.overrideStyleProperties || {};\n    Object.assign(styleInfo.overrideStyleProperties, overrideProps);\n  }\n  /**\n   * @param {!HTMLElement} host\n   * @param {!StyleInfo} styleInfo\n   */\n  styleElementShimVariables(host, styleInfo) {\n    this.flush();\n    this._updateProperties(host, styleInfo);\n    if (styleInfo.ownStylePropertyNames && styleInfo.ownStylePropertyNames.length) {\n      this._applyStyleProperties(host, styleInfo);\n    }\n  }\n  /**\n   * @param {!HTMLElement} host\n   * @param {!StyleInfo} styleInfo\n   */\n  styleElementNativeVariables(host, styleInfo) {\n    const { is } = StyleUtil.getIsExtends(host);\n    if (styleInfo.overrideStyleProperties) {\n      updateNativeProperties(host, styleInfo.overrideStyleProperties);\n    }\n    const template = templateMap[is];\n    // bail early if there is no shadowroot for this element\n    if (!template && !this._isRootOwner(host)) {\n      return;\n    }\n    // bail early if the template was built with polymer-css-build\n    if (template && StyleUtil.elementHasBuiltCss(template)) {\n      return;\n    }\n    if (template && template._style && !ApplyShimUtils.templateIsValid(template)) {\n      // update template\n      if (!ApplyShimUtils.templateIsValidating(template)) {\n        this._ensure();\n        this._applyShim && this._applyShim['transformRules'](template['_styleAst'], is);\n        template._style.textContent = StyleTransformer.elementStyles(host, styleInfo.styleRules);\n        ApplyShimUtils.startValidatingTemplate(template);\n      }\n      // update instance if native shadowdom\n      if (nativeShadow) {\n        let root = host.shadowRoot;\n        if (root) {\n          let style = root.querySelector('style');\n          if (style) {\n            style.textContent = StyleTransformer.elementStyles(host, styleInfo.styleRules);\n          }\n        }\n      }\n      styleInfo.styleRules = template['_styleAst'];\n    }\n  }\n  _styleOwnerForNode(node) {\n    let root = StyleUtil.wrap(node).getRootNode();\n    let host = root.host;\n    if (host) {\n      if (StyleInfo.get(host) || this._prepareHost(host)) {\n        return host;\n      } else {\n        return this._styleOwnerForNode(host);\n      }\n    }\n    return this._documentOwner;\n  }\n  _isRootOwner(node) {\n    return (node === this._documentOwner);\n  }\n  _applyStyleProperties(host, styleInfo) {\n    let is = StyleUtil.getIsExtends(host).is;\n    let cacheEntry = styleCache.fetch(is, styleInfo.styleProperties, styleInfo.ownStylePropertyNames);\n    let cachedScopeSelector = cacheEntry && cacheEntry.scopeSelector;\n    let cachedStyle = cacheEntry ? cacheEntry.styleElement : null;\n    let oldScopeSelector = styleInfo.scopeSelector;\n    // only generate new scope if cached style is not found\n    styleInfo.scopeSelector = cachedScopeSelector || this._generateScopeSelector(is);\n    let style = StyleProperties.applyElementStyle(host, styleInfo.styleProperties, styleInfo.scopeSelector, cachedStyle);\n    if (!nativeShadow) {\n      StyleProperties.applyElementScopeSelector(host, styleInfo.scopeSelector, oldScopeSelector);\n    }\n    if (!cacheEntry) {\n      styleCache.store(is, styleInfo.styleProperties, style, styleInfo.scopeSelector);\n    }\n    return style;\n  }\n  _updateProperties(host, styleInfo) {\n    let owner = this._styleOwnerForNode(host);\n    let ownerStyleInfo = StyleInfo.get(owner);\n    let ownerProperties = ownerStyleInfo.styleProperties;\n    // style owner has not updated properties yet\n    // go up the chain and force property update,\n    // except if the owner is the document\n    if (owner !== this._documentOwner && !ownerProperties) {\n      this._updateProperties(owner, ownerStyleInfo);\n      ownerProperties = ownerStyleInfo.styleProperties;\n    }\n    let props = Object.create(ownerProperties || null);\n    let hostAndRootProps = StyleProperties.hostAndRootPropertiesForScope(host, styleInfo.styleRules, styleInfo.cssBuild);\n    let propertyData = StyleProperties.propertyDataFromStyles(ownerStyleInfo.styleRules, host);\n    let propertiesMatchingHost = propertyData.properties\n    Object.assign(\n      props,\n      hostAndRootProps.hostProps,\n      propertiesMatchingHost,\n      hostAndRootProps.rootProps\n    );\n    this._mixinOverrideStyles(props, styleInfo.overrideStyleProperties);\n    StyleProperties.reify(props);\n    styleInfo.styleProperties = props;\n  }\n  _mixinOverrideStyles(props, overrides) {\n    for (let p in overrides) {\n      let v = overrides[p];\n      // skip override props if they are not truthy or 0\n      // in order to fall back to inherited values\n      if (v || v === 0) {\n        props[p] = v;\n      }\n    }\n  }\n  /**\n   * Update styles of the whole document\n   *\n   * @param {Object=} properties\n   */\n  styleDocument(properties) {\n    this.styleSubtree(this._documentOwner, properties);\n  }\n  /**\n   * Update styles of a subtree\n   *\n   * @param {!HTMLElement} host\n   * @param {Object=} properties\n   */\n  styleSubtree(host, properties) {\n    const wrappedHost = StyleUtil.wrap(host);\n    const root = wrappedHost.shadowRoot;\n    const isRootOwner = this._isRootOwner(host);\n    if (root || isRootOwner) {\n      this.styleElement(host, properties);\n    }\n    const descendantRoot = isRootOwner ? wrappedHost : root;\n    if (descendantRoot) {\n      const descendantHosts = Array.from(descendantRoot.querySelectorAll('*'))\n          .filter(x => StyleUtil.wrap(x).shadowRoot);\n      for (let i = 0; i < descendantHosts.length; i++) {\n        this.styleSubtree(descendantHosts[i]);\n      }\n    }\n  }\n  /* Custom Style operations */\n  _revalidateCustomStyleApplyShim(customStyles) {\n    for (let i = 0; i < customStyles.length; i++) {\n      let c = customStyles[i];\n      let s = this._customStyleInterface['getStyleForCustomStyle'](c);\n      if (s) {\n        this._revalidateApplyShim(s);\n      }\n    }\n  }\n  _applyCustomStyles(customStyles) {\n    for (let i = 0; i < customStyles.length; i++) {\n      let c = customStyles[i];\n      let s = this._customStyleInterface['getStyleForCustomStyle'](c);\n      if (s) {\n        StyleProperties.applyCustomStyle(s, this._documentOwnerStyleInfo.styleProperties);\n      }\n    }\n  }\n  transformCustomStyleForDocument(style) {\n    const cssBuild = StyleUtil.getCssBuild(style);\n    if (cssBuild !== this._documentOwnerStyleInfo.cssBuild) {\n      this._documentOwnerStyleInfo.cssBuild = cssBuild;\n    }\n    if (StyleUtil.isOptimalCssBuild(cssBuild)) {\n      return;\n    }\n    let ast = StyleUtil.rulesForStyle(style);\n    StyleUtil.forEachRule(ast, (rule) => {\n      if (nativeShadow) {\n        StyleTransformer.normalizeRootSelector(rule);\n      } else {\n        StyleTransformer.documentRule(rule);\n      }\n      if (nativeCssVariables && cssBuild === '') {\n        this._ensure();\n        this._applyShim && this._applyShim['transformRule'](rule);\n      }\n    });\n    if (nativeCssVariables) {\n      style.textContent = StyleUtil.toCssText(ast);\n    } else {\n      this._documentOwnerStyleInfo.styleRules['rules'].push(ast);\n    }\n  }\n  _revalidateApplyShim(style) {\n    if (nativeCssVariables && this._applyShim) {\n      let ast = StyleUtil.rulesForStyle(style);\n      this._ensure();\n      this._applyShim['transformRules'](ast);\n      style.textContent = StyleUtil.toCssText(ast);\n    }\n  }\n  getComputedStyleValue(element, property) {\n    let value;\n    if (!nativeCssVariables) {\n      // element is either a style host, or an ancestor of a style host\n      let styleInfo = StyleInfo.get(element) || StyleInfo.get(this._styleOwnerForNode(element));\n      value = styleInfo.styleProperties[property];\n    }\n    // fall back to the property value from the computed styling\n    value = value || window.getComputedStyle(element).getPropertyValue(property);\n    // trim whitespace that can come after the `:` in css\n    // example: padding: 2px -> \" 2px\"\n    return value ? value.trim() : '';\n  }\n  // given an element and a classString, replaces\n  // the element's class with the provided classString and adds\n  // any necessary ShadyCSS static and property based scoping selectors\n  setElementClass(element, classString) {\n    let root = StyleUtil.wrap(element).getRootNode();\n    let classes;\n    if (classString) {\n      let definitelyString = typeof classString === 'string' ? classString : String(classString);\n      classes = definitelyString.split(/\\s/);\n    } else {\n      classes = [];\n    }\n    let scopeName = root.host && root.host.localName;\n    // If no scope, try to discover scope name from existing class.\n    // This can occur if, for example, a template stamped element that\n    // has been scoped is manipulated when not in a root.\n    if (!scopeName) {\n      var classAttr = element.getAttribute('class');\n      if (classAttr) {\n        let k$ = classAttr.split(/\\s/);\n        for (let i=0; i < k$.length; i++) {\n          if (k$[i] === StyleTransformer.SCOPE_NAME) {\n            scopeName = k$[i+1];\n            break;\n          }\n        }\n      }\n    }\n    if (scopeName) {\n      classes.push(StyleTransformer.SCOPE_NAME, scopeName);\n    }\n    if (!nativeCssVariables) {\n      let styleInfo = StyleInfo.get(element);\n      if (styleInfo && styleInfo.scopeSelector) {\n        classes.push(StyleProperties.XSCOPE_NAME, styleInfo.scopeSelector);\n      }\n    }\n    StyleUtil.setElementClassRaw(element, classes.join(' '));\n  }\n  _styleInfoForNode(node) {\n    return StyleInfo.get(node);\n  }\n  /**\n   * @param {!Element} node\n   * @param {string} scope\n   */\n  scopeNode(node, scope) {\n    StyleTransformer.element(node, scope);\n  }\n  /**\n   * @param {!Element} node\n   * @param {string} scope\n   */\n  unscopeNode(node, scope) {\n    StyleTransformer.element(node, scope, true);\n  }\n  /**\n   * @param {!Node} node\n   * @return {string}\n   */\n  scopeForNode(node) {\n    return getOwnerScope(node);\n  }\n  /**\n   * @param {!Element} node\n   * @return {string}\n   */\n  currentScopeForNode(node) {\n    return getCurrentScope(node);\n  }\n}\n\n/* exports */\n/* eslint-disable no-self-assign */\nScopingShim.prototype['flush'] = ScopingShim.prototype.flush;\nScopingShim.prototype['prepareTemplate'] = ScopingShim.prototype.prepareTemplate;\nScopingShim.prototype['styleElement'] = ScopingShim.prototype.styleElement;\nScopingShim.prototype['styleDocument'] = ScopingShim.prototype.styleDocument;\nScopingShim.prototype['styleSubtree'] = ScopingShim.prototype.styleSubtree;\nScopingShim.prototype['getComputedStyleValue'] = ScopingShim.prototype.getComputedStyleValue;\nScopingShim.prototype['setElementClass'] = ScopingShim.prototype.setElementClass;\nScopingShim.prototype['_styleInfoForNode'] = ScopingShim.prototype._styleInfoForNode;\nScopingShim.prototype['transformCustomStyleForDocument'] = ScopingShim.prototype.transformCustomStyleForDocument;\nScopingShim.prototype['getStyleAst'] = ScopingShim.prototype.getStyleAst;\nScopingShim.prototype['styleAstToString'] = ScopingShim.prototype.styleAstToString;\nScopingShim.prototype['flushCustomStyles'] = ScopingShim.prototype.flushCustomStyles;\nScopingShim.prototype['scopeNode'] = ScopingShim.prototype.scopeNode;\nScopingShim.prototype['unscopeNode'] = ScopingShim.prototype.unscopeNode;\nScopingShim.prototype['scopeForNode'] = ScopingShim.prototype.scopeForNode;\nScopingShim.prototype['currentScopeForNode'] = ScopingShim.prototype.currentScopeForNode;\nScopingShim.prototype['prepareAdoptedCssText'] = ScopingShim.prototype.prepareAdoptedCssText;\n/* eslint-enable no-self-assign */\nObject.defineProperties(ScopingShim.prototype, {\n  'nativeShadow': {\n    get() {\n      return nativeShadow;\n    }\n  },\n  'nativeCss': {\n    get() {\n      return nativeCssVariables;\n    }\n  }\n});\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {nativeShadow} from './style-settings.js';\nimport StyleTransformer from './style-transformer.js';\nimport {getIsExtends, elementHasBuiltCss, wrap} from './style-util.js';\n\nexport let flush = function() {};\n\n/**\n * @param {!Element} element\n * @return {string}\n */\nfunction getClasses(element) {\n  if (element.classList && element.classList.value) {\n    return element.classList.value;\n  } else {\n    // NOTE: className is patched to remove scoping classes in ShadyDOM\n    // use getAttribute('class') instead, which is unpatched\n    return element.getAttribute('class') || '';\n  }\n}\n\nconst scopeRegExp = new RegExp(`${StyleTransformer.SCOPE_NAME}\\\\s*([^\\\\s]*)`);\n\n/**\n * @param {!Element} element\n * @return {string}\n */\nexport function getCurrentScope(element) {\n  const match = getClasses(element).match(scopeRegExp);\n  if (match) {\n    return match[1];\n  } else {\n    return '';\n  }\n}\n\n/**\n * @param {!Node} node\n */\nexport function getOwnerScope(node) {\n  const ownerRoot = wrap(node).getRootNode();\n  if (ownerRoot === node || ownerRoot === node.ownerDocument) {\n    return '';\n  }\n  const host = /** @type {!ShadowRoot} */(ownerRoot).host;\n  if (!host) {\n    // this may actually be a document fragment\n    return '';\n  }\n  return getIsExtends(host).is;\n}\n\n/**\n * @param {!Element} element\n */\nexport function ensureCorrectScope(element) {\n  const currentScope = getCurrentScope(element);\n  const ownerRoot = wrap(element).getRootNode();\n  if (ownerRoot === element) {\n    return;\n  }\n  if (currentScope && ownerRoot === element.ownerDocument) {\n    // node was scoped, but now is in document\n    StyleTransformer.domRemoveScope(element, currentScope);\n  } else if (ownerRoot instanceof ShadowRoot) {\n    const ownerScope = getOwnerScope(element);\n    if (ownerScope !== currentScope) {\n      // node was scoped, but not by its current owner\n      StyleTransformer.domReplaceScope(element, currentScope, ownerScope);\n    }\n  }\n}\n\n/**\n * @param {!HTMLElement|!HTMLDocument} element\n */\nexport function ensureCorrectSubtreeScoping(element) {\n  // find unscoped subtree nodes\n  const unscopedNodes = window['ShadyDOM']['nativeMethods']['querySelectorAll'].call(\n    element, `:not(.${StyleTransformer.SCOPE_NAME})`);\n\n  for (let j = 0; j < unscopedNodes.length; j++) {\n    // it's possible, during large batch inserts, that nodes that aren't\n    // scoped within the current scope were added.\n    // To make sure that any unscoped nodes that were inserted in the current batch are correctly styled,\n    // query all unscoped nodes and force their style-scope to be applied.\n    // This could happen if a sub-element appended an unscoped node in its shadowroot and this function\n    // runs on a parent element of the host of that unscoped node:\n    // parent-element -> element -> unscoped node\n    // Here unscoped node should have the style-scope element, not parent-element.\n    const unscopedNode = unscopedNodes[j];\n    const scopeForPreviouslyUnscopedNode = getOwnerScope(unscopedNode);\n    if (scopeForPreviouslyUnscopedNode) {\n      StyleTransformer.element(unscopedNode, scopeForPreviouslyUnscopedNode);\n    }\n  }\n}\n\n/**\n * @param {HTMLElement} el\n * @return {boolean}\n */\nfunction isElementWithBuiltCss(el) {\n  if (el.localName === 'style' || el.localName === 'template') {\n    return elementHasBuiltCss(el);\n  }\n  return false;\n}\n\n/**\n * @param {Array<MutationRecord|null>|null} mxns\n */\nfunction handler(mxns) {\n  for (let x=0; x < mxns.length; x++) {\n    let mxn = mxns[x];\n    if (mxn.target === document.documentElement ||\n      mxn.target === document.head) {\n      continue;\n    }\n    for (let i=0; i < mxn.addedNodes.length; i++) {\n      let n = mxn.addedNodes[i];\n      if (n.nodeType !== Node.ELEMENT_NODE) {\n        continue;\n      }\n      n = /** @type {HTMLElement} */(n); // eslint-disable-line no-self-assign\n      let root = n.getRootNode();\n      let currentScope = getCurrentScope(n);\n      // node was scoped, but now is in document\n      // If this element has built css, we must not remove scoping as this node\n      // will be used as a template or style without re - applying scoping as an optimization\n      if (currentScope && root === n.ownerDocument && !isElementWithBuiltCss(n)) {\n        StyleTransformer.domRemoveScope(n, currentScope);\n      } else if (root instanceof ShadowRoot) {\n        const newScope = getOwnerScope(n);\n        // rescope current node and subtree if necessary\n        if (newScope !== currentScope) {\n          StyleTransformer.domReplaceScope(n, currentScope, newScope);\n        }\n        // make sure all the subtree elements are scoped correctly\n        ensureCorrectSubtreeScoping(n);\n      }\n    }\n  }\n}\n\n// if native Shadow DOM is being used, or ShadyDOM handles dynamic scoiping, do not activate the MutationObserver\nif (!nativeShadow && !(window['ShadyDOM'] && window['ShadyDOM']['handlesDynamicScoping'])) {\n  let observer = new MutationObserver(handler);\n  let start = (node) => {\n    observer.observe(node, {childList: true, subtree: true});\n  }\n  let nativeCustomElements = (window['customElements'] &&\n    !window['customElements']['polyfillWrapFlushCallback']);\n  // need to start immediately with native custom elements\n  // TODO(dfreedm): with polyfilled HTMLImports and native custom elements\n  // excessive mutations may be observed; this can be optimized via cooperation\n  // with the HTMLImports polyfill.\n  if (nativeCustomElements) {\n    start(document);\n  } else {\n    let delayedStart = () => {\n      start(document.body);\n    }\n    // use polyfill timing if it's available\n    if (window['HTMLImports']) {\n      window['HTMLImports']['whenReady'](delayedStart);\n    // otherwise push beyond native imports being ready\n    // which requires RAF + readystate interactive.\n    } else {\n      requestAnimationFrame(function() {\n        if (document.readyState === 'loading') {\n          let listener = function() {\n            delayedStart();\n            document.removeEventListener('readystatechange', listener);\n          }\n          document.addEventListener('readystatechange', listener);\n        } else {\n          delayedStart();\n        }\n      });\n    }\n  }\n\n  flush = function() {\n    handler(observer.takeRecords());\n  }\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {removeCustomPropAssignment, StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\nimport {nativeShadow} from './style-settings.js';\nimport StyleTransformer from './style-transformer.js';\nimport * as StyleUtil from './style-util.js';\nimport * as RX from './common-regex.js';\nimport StyleInfo from './style-info.js';\n\n// TODO: dedupe with shady\n/**\n * @param {string} selector\n * @return {boolean}\n * @this {Element}\n */\nconst matchesSelector = function(selector) {\n  const method = this.matches || this.matchesSelector ||\n    this.mozMatchesSelector || this.msMatchesSelector ||\n    this.oMatchesSelector || this.webkitMatchesSelector;\n  return method && method.call(this, selector);\n};\n\nconst rootSelector = /:host\\s*>\\s*/;\n\nfunction checkRoot(hostScope, selector) {\n  return Boolean(selector.match(rootSelector)) ||\n    (hostScope === 'html' && selector.indexOf('html') > -1);\n}\n\nconst IS_IE = navigator.userAgent.match('Trident');\n\nconst XSCOPE_NAME = 'x-scope';\n\nclass StyleProperties {\n  /** @return {string} */\n  get XSCOPE_NAME() {\n    return XSCOPE_NAME;\n  }\n/**\n * decorates styles with rule info and returns an array of used style property names\n *\n * @param {StyleNode} rules\n * @return {!Array<string>}\n */\n  decorateStyles(rules) {\n    let self = this, props = {}, keyframes = [], ruleIndex = 0;\n    StyleUtil.forEachRule(rules, function(rule) {\n      self.decorateRule(rule);\n      // mark in-order position of ast rule in styles block, used for cache key\n      rule.index = ruleIndex++;\n      self.collectPropertiesInCssText(rule.propertyInfo.cssText, props);\n    }, function onKeyframesRule(rule) {\n      keyframes.push(rule);\n    });\n    // Cache all found keyframes rules for later reference:\n    rules._keyframes = keyframes;\n    // return this list of property names *consumes* in these styles.\n    let names = [];\n    for (let i in props) {\n      names.push(i);\n    }\n    return names;\n  }\n\n  // decorate a single rule with property info\n  decorateRule(rule) {\n    if (rule.propertyInfo) {\n      return rule.propertyInfo;\n    }\n    let info = {}, properties = {};\n    let hasProperties = this.collectProperties(rule, properties);\n    if (hasProperties) {\n      info.properties = properties;\n      // TODO(sorvell): workaround parser seeing mixins as additional rules\n      rule['rules'] = null;\n    }\n    info.cssText = this.collectCssText(rule);\n    rule.propertyInfo = info;\n    return info;\n  }\n\n  // collects the custom properties from a rule's cssText\n  collectProperties(rule, properties) {\n    let info = rule.propertyInfo;\n    if (info) {\n      if (info.properties) {\n        Object.assign(properties, info.properties);\n        return true;\n      }\n    } else {\n      let m, rx = RX.VAR_ASSIGN;\n      let cssText = rule['parsedCssText'];\n      let value;\n      let any;\n      while ((m = rx.exec(cssText))) {\n        // note: group 2 is var, 3 is mixin\n        value = (m[2] || m[3]).trim();\n        // value of 'inherit' or 'unset' is equivalent to not setting the property here\n        if (value !== 'inherit' || value !== 'unset') {\n          properties[m[1].trim()] = value;\n        }\n        any = true;\n      }\n      return any;\n    }\n\n  }\n\n  // returns cssText of properties that consume variables/mixins\n  collectCssText(rule) {\n    return this.collectConsumingCssText(rule['parsedCssText']);\n  }\n\n  // NOTE: we support consumption inside mixin assignment\n  // but not production, so strip out {...}\n  collectConsumingCssText(cssText) {\n    return cssText.replace(RX.BRACKETED, '')\n      .replace(RX.VAR_ASSIGN, '');\n  }\n\n  collectPropertiesInCssText(cssText, props) {\n    let m;\n    while ((m = RX.VAR_CONSUMED.exec(cssText))) {\n      let name = m[1];\n      // This regex catches all variable names, and following non-whitespace char\n      // If next char is not ':', then variable is a consumer\n      if (m[2] !== ':') {\n        props[name] = true;\n      }\n    }\n  }\n\n  // turns custom properties into realized values.\n  reify(props) {\n    // big perf optimization here: reify only *own* properties\n    // since this object has __proto__ of the element's scope properties\n    let names = Object.getOwnPropertyNames(props);\n    for (let i=0, n; i < names.length; i++) {\n      n = names[i];\n      props[n] = this.valueForProperty(props[n], props);\n    }\n  }\n\n  // given a property value, returns the reified value\n  // a property value may be:\n  // (1) a literal value like: red or 5px;\n  // (2) a variable value like: var(--a), var(--a, red), or var(--a, --b) or\n  // var(--a, var(--b));\n  // (3) a literal mixin value like { properties }. Each of these properties\n  // can have values that are: (a) literal, (b) variables, (c) @apply mixins.\n  valueForProperty(property, props) {\n    // case (1) default\n    // case (3) defines a mixin and we have to reify the internals\n    if (property) {\n      if (property.indexOf(';') >=0) {\n        property = this.valueForProperties(property, props);\n      } else {\n        // case (2) variable\n        let self = this;\n        let fn = function(prefix, value, fallback, suffix) {\n          if (!value) {\n            return prefix + suffix;\n          }\n          let propertyValue = self.valueForProperty(props[value], props);\n          // if value is \"initial\", then the variable should be treated as unset\n          if (!propertyValue || propertyValue === 'initial') {\n            // fallback may be --a or var(--a) or literal\n            propertyValue = self.valueForProperty(props[fallback] || fallback, props) ||\n            fallback;\n          } else if (propertyValue === 'apply-shim-inherit') {\n            // CSS build will replace `inherit` with `apply-shim-inherit`\n            // for use with native css variables.\n            // Since we have full control, we can use `inherit` directly.\n            propertyValue = 'inherit';\n          }\n          return prefix + (propertyValue || '') + suffix;\n        };\n        property = StyleUtil.processVariableAndFallback(property, fn);\n      }\n    }\n    return property && property.trim() || '';\n  }\n\n  // note: we do not yet support mixin within mixin\n  valueForProperties(property, props) {\n    let parts = property.split(';');\n    for (let i=0, p, m; i<parts.length; i++) {\n      if ((p = parts[i])) {\n        RX.MIXIN_MATCH.lastIndex = 0;\n        m = RX.MIXIN_MATCH.exec(p);\n        if (m) {\n          p = this.valueForProperty(props[m[1]], props);\n        } else {\n          let colon = p.indexOf(':');\n          if (colon !== -1) {\n            let pp = p.substring(colon);\n            pp = pp.trim();\n            pp = this.valueForProperty(pp, props) || pp;\n            p = p.substring(0, colon) + pp;\n          }\n        }\n        parts[i] = (p && p.lastIndexOf(';') === p.length - 1) ?\n          // strip trailing ;\n          p.slice(0, -1) :\n          p || '';\n      }\n    }\n    return parts.join(';');\n  }\n\n  applyProperties(rule, props) {\n    let output = '';\n    // dynamically added sheets may not be decorated so ensure they are.\n    if (!rule.propertyInfo) {\n      this.decorateRule(rule);\n    }\n    if (rule.propertyInfo.cssText) {\n      output = this.valueForProperties(rule.propertyInfo.cssText, props);\n    }\n    rule['cssText'] = output;\n  }\n\n  // Apply keyframe transformations to the cssText of a given rule. The\n  // keyframeTransforms object is a map of keyframe names to transformer\n  // functions which take in cssText and spit out transformed cssText.\n  applyKeyframeTransforms(rule, keyframeTransforms) {\n    let input = rule['cssText'];\n    let output = rule['cssText'];\n    if (rule.hasAnimations == null) {\n      // Cache whether or not the rule has any animations to begin with:\n      rule.hasAnimations = RX.ANIMATION_MATCH.test(input);\n    }\n    // If there are no animations referenced, we can skip transforms:\n    if (rule.hasAnimations) {\n      let transform;\n      // If we haven't transformed this rule before, we iterate over all\n      // transforms:\n      if (rule.keyframeNamesToTransform == null) {\n        rule.keyframeNamesToTransform = [];\n        for (let keyframe in keyframeTransforms) {\n          transform = keyframeTransforms[keyframe];\n          output = transform(input);\n          // If the transform actually changed the CSS text, we cache the\n          // transform name for future use:\n          if (input !== output) {\n            input = output;\n            rule.keyframeNamesToTransform.push(keyframe);\n          }\n        }\n      } else {\n        // If we already have a list of keyframe names that apply to this\n        // rule, we apply only those keyframe name transforms:\n        for (let i = 0; i < rule.keyframeNamesToTransform.length; ++i) {\n          transform = keyframeTransforms[rule.keyframeNamesToTransform[i]];\n          input = transform(input);\n        }\n        output = input;\n      }\n    }\n    rule['cssText'] = output;\n  }\n\n  // Test if the rules in these styles matches the given `element` and if so,\n  // collect any custom properties into `props`.\n  /**\n   * @param {StyleNode} rules\n   * @param {Element} element\n   */\n  propertyDataFromStyles(rules, element) {\n    let props = {};\n    // generates a unique key for these matches\n    let o = [];\n    // note: active rules excludes non-matching @media rules\n    StyleUtil.forEachRule(rules, (rule) => {\n      // TODO(sorvell): we could trim the set of rules at declaration\n      // time to only include ones that have properties\n      if (!rule.propertyInfo) {\n        this.decorateRule(rule);\n      }\n      // match element against transformedSelector: selector may contain\n      // unwanted uniquification and parsedSelector does not directly match\n      // for :host selectors.\n      let selectorToMatch = rule.transformedSelector || rule['parsedSelector'];\n      if (element && rule.propertyInfo.properties && selectorToMatch) {\n        if (matchesSelector.call(element, selectorToMatch)) {\n          this.collectProperties(rule, props);\n          // produce numeric key for these matches for lookup\n          addToBitMask(rule.index, o);\n        }\n      }\n    }, null, true);\n    return {properties: props, key: o};\n  }\n\n  /**\n   * @param {Element} scope\n   * @param {StyleNode} rule\n   * @param {string} cssBuild\n   * @param {function(Object)} callback\n   */\n  whenHostOrRootRule(scope, rule, cssBuild, callback) {\n    if (!/** @type {?} */ (rule.propertyInfo)) {\n      this.decorateRule(rule);\n    }\n    if (!/** @type {?} */ (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 = checkRoot(hostScope, parsedSelector);\n    let isHost = parsedSelector.indexOf(':host') === 0 && !isRoot;\n    // build info is either in scope (when scope is an element) or in the style\n    // when scope is the default scope; note: this allows default scope to have\n    // mixed mode built and unbuilt styles.\n    if (cssBuild === 'shady') {\n      // :root -> x-foo > *.x-foo for elements and html for custom-style\n      isRoot = parsedSelector === (hostScope + ' > *.' + hostScope) || parsedSelector.indexOf('html') !== -1;\n      // :host -> x-foo for elements, but sub-rules have .x-foo in them\n      isHost = !isRoot && parsedSelector.indexOf(hostScope) === 0;\n    }\n    if (!isRoot && !isHost) {\n      return;\n    }\n    let selectorToMatch = hostScope;\n    if (isHost) {\n      // need to transform :host because `:host` does not work with `matches`\n      if (!/** @type {?} */ (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 =\n          /** @type {?} */ (rule.transformedSelector) || hostScope;\n    }\n    if (isRoot && hostScope === 'html') {\n      selectorToMatch = /** @type {?} */ (rule.transformedSelector) ||\n          /** @type {?} */ (rule.parsedSelector);\n    }\n    callback({\n      selector: selectorToMatch,\n      isHost: isHost,\n      isRoot: isRoot\n    });\n  }\n/**\n * @param {Element} scope\n * @param {StyleNode} rules\n * @param {string} cssBuild\n * @return {!Object}\n */\n  hostAndRootPropertiesForScope(scope, rules, cssBuild) {\n    let hostProps = {}, rootProps = {};\n    // note: active rules excludes non-matching @media rules\n    StyleUtil.forEachRule(rules, (rule) => {\n      // if scope is StyleDefaults, use _element for matchesSelector\n      this.whenHostOrRootRule(scope, rule, cssBuild, (info) => {\n        let element = scope._element || scope;\n        if (matchesSelector.call(element, info.selector)) {\n          if (info.isHost) {\n            this.collectProperties(rule, hostProps);\n          } else {\n            this.collectProperties(rule, rootProps);\n          }\n        }\n      });\n    }, null, true);\n    return {rootProps: rootProps, hostProps: hostProps};\n  }\n\n  /**\n   * @param {Element} element\n   * @param {Object} properties\n   * @param {string} scopeSelector\n   */\n  transformStyles(element, properties, scopeSelector) {\n    let self = this;\n    let {is, typeExtension} = StyleUtil.getIsExtends(element);\n    let hostSelector = StyleTransformer\n      ._calcHostScope(is, typeExtension);\n    let rxHostSelector = element.extends ?\n      '\\\\' + hostSelector.slice(0, -1) + '\\\\]' :\n      hostSelector;\n    let hostRx = new RegExp(RX.HOST_PREFIX + rxHostSelector +\n      RX.HOST_SUFFIX);\n    let {styleRules: rules, cssBuild} = StyleInfo.get(element);\n    let keyframeTransforms =\n      this._elementKeyframeTransforms(element, rules, scopeSelector);\n    return StyleTransformer.elementStyles(element, rules, function(rule) {\n      self.applyProperties(rule, properties);\n      if (!nativeShadow &&\n          !StyleUtil.isKeyframesSelector(rule) &&\n          rule['cssText']) {\n        // NOTE: keyframe transforms only scope munge animation names, so it\n        // is not necessary to apply them in ShadowDOM.\n        self.applyKeyframeTransforms(rule, keyframeTransforms);\n        self._scopeSelector(rule, hostRx, hostSelector, scopeSelector);\n      }\n    }, cssBuild);\n  }\n\n  /**\n   * @param {Element} element\n   * @param {StyleNode} rules\n   * @param {string} scopeSelector\n   * @return {!Object}\n   */\n  _elementKeyframeTransforms(element, rules, scopeSelector) {\n    let keyframesRules = rules._keyframes;\n    let keyframeTransforms = {};\n    if (!nativeShadow && keyframesRules) {\n      // For non-ShadowDOM, we transform all known keyframes rules in\n      // advance for the current scope. This allows us to catch keyframes\n      // rules that appear anywhere in the stylesheet:\n      for (let i = 0, keyframesRule = keyframesRules[i];\n           i < keyframesRules.length;\n           keyframesRule = keyframesRules[++i]) {\n        this._scopeKeyframes(keyframesRule, scopeSelector);\n        keyframeTransforms[keyframesRule['keyframesName']] =\n            this._keyframesRuleTransformer(keyframesRule);\n      }\n    }\n    return keyframeTransforms;\n  }\n\n  // Generate a factory for transforming a chunk of CSS text to handle a\n  // particular scoped keyframes rule.\n  /**\n   * @param {StyleNode} keyframesRule\n   * @return {function(string):string}\n   */\n  _keyframesRuleTransformer(keyframesRule) {\n    return function(cssText) {\n      return cssText.replace(\n          /** @type {?} */ (keyframesRule.keyframesNameRx),\n          /** @type {?} */ (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 =\n        /** @type {?} */ (rule.transformedSelector) || rule['selector'];\n    rule['selector'] =\n        /** @type {?} */ (rule.transformedSelector)\n            .replace(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 =\n        /** @type {?} */ (rule.transformedSelector) || rule['selector'];\n    let selector = rule.transformedSelector;\n    let scope = '.' + scopeId;\n    let parts = StyleUtil.splitSelectorList(selector);\n    for (let i=0, l=parts.length, p; (i<l) && (p=parts[i]); i++) {\n      parts[i] = p.match(hostRx) ?\n        p.replace(hostSelector, scope) :\n        scope + ' ' + p;\n    }\n    rule['selector'] = parts.join(',');\n  }\n\n  /**\n   * @param {Element} element\n   * @param {string} selector\n   * @param {string} old\n   */\n  applyElementScopeSelector(element, selector, old) {\n    let c = element.getAttribute('class') || '';\n    let v = c;\n    if (old) {\n      v = c.replace(\n        new RegExp('\\\\s*' + XSCOPE_NAME + '\\\\s*' + old + '\\\\s*', 'g'), ' ');\n    }\n    v += (v ? ' ' : '') + XSCOPE_NAME + ' ' + selector;\n    if (c !== v) {\n      StyleUtil.setElementClassRaw(element, v);\n    }\n  }\n\n  /**\n   * @param {HTMLElement} element\n   * @param {Object} properties\n   * @param {string} selector\n   * @param {HTMLStyleElement} style\n   * @return {HTMLStyleElement}\n   */\n  applyElementStyle(element, properties, selector, style) {\n    // calculate cssText to apply\n    let cssText = style ? style.textContent || '' :\n      this.transformStyles(element, properties, selector);\n    // if shady and we have a cached style that is not style, decrement\n    let styleInfo = StyleInfo.get(element);\n    let s = styleInfo.customStyle;\n    if (s && !nativeShadow && (s !== style)) {\n      s['_useCount']--;\n      if (s['_useCount'] <= 0 && s.parentNode) {\n        s.parentNode.removeChild(s);\n      }\n    }\n    // apply styling always under native or if we generated style\n    // or the cached style is not in document(!)\n    if (nativeShadow) {\n      // update existing style only under native\n      if (styleInfo.customStyle) {\n        styleInfo.customStyle.textContent = cssText;\n        style = styleInfo.customStyle;\n      // otherwise, if we have css to apply, do so\n      } else if (cssText) {\n        // apply css after the scope style of the element to help with\n        // style precedence rules.\n        style = StyleUtil.applyCss(cssText, selector, element.shadowRoot,\n          styleInfo.placeholder);\n      }\n    } else {\n      // shady and no cache hit\n      if (!style) {\n        // apply css after the scope style of the element to help with\n        // style precedence rules.\n        if (cssText) {\n          style = StyleUtil.applyCss(cssText, selector, null,\n            styleInfo.placeholder);\n        }\n      // shady and cache hit but not in document\n      } else if (!style.parentNode) {\n        if (IS_IE && cssText.indexOf('@media') > -1) {\n            // @media rules may be stale in IE 10 and 11\n            // refresh the text content of the style to revalidate them.\n          style.textContent = cssText;\n        }\n        StyleUtil.applyStyle(style, null, styleInfo.placeholder);\n      }\n    }\n    // ensure this style is our custom style and increment its use count.\n    if (style) {\n      style['_useCount'] = style['_useCount'] || 0;\n      // increment use count if we changed styles\n      if (styleInfo.customStyle != style) {\n        style['_useCount']++;\n      }\n      styleInfo.customStyle = style;\n    }\n    return style;\n  }\n\n  /**\n   * @param {Element} style\n   * @param {Object} properties\n   */\n  applyCustomStyle(style, properties) {\n    let rules = StyleUtil.rulesForStyle(/** @type {HTMLStyleElement} */(style));\n    let self = this;\n    style.textContent =\n        StyleUtil.toCssText(rules, function(/** StyleNode */ rule) {\n          let css = rule['cssText'] = rule['parsedCssText'];\n          if (/** @type {?} */ (rule.propertyInfo) &&\n              /** @type {?} */ (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","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\n\n/** @const {string} */\nconst infoKey = '__styleInfo';\n\nexport default class StyleInfo {\n  /**\n   * @param {Element} node\n   * @return {StyleInfo}\n   */\n  static get(node) {\n    if (node) {\n      return node[infoKey];\n    } else {\n      return null;\n    }\n  }\n  /**\n   * @param {!Element} node\n   * @param {StyleInfo} styleInfo\n   * @return {StyleInfo}\n   */\n  static set(node, styleInfo) {\n    node[infoKey] = styleInfo;\n    return styleInfo;\n  }\n  /**\n   * @param {StyleNode} ast\n   * @param {Node=} placeholder\n   * @param {Array<string>=} ownStylePropertyNames\n   * @param {string=} elementName\n   * @param {string=} typeExtension\n   * @param {string=} cssBuild\n   */\n  constructor(ast, placeholder, ownStylePropertyNames, elementName, typeExtension, cssBuild) {\n    /** @type {StyleNode} */\n    this.styleRules = ast || null;\n    /** @type {Node} */\n    this.placeholder = placeholder || null;\n    /** @type {!Array<string>} */\n    this.ownStylePropertyNames = ownStylePropertyNames || [];\n    /** @type {Object} */\n    this.overrideStyleProperties = null;\n    /** @type {string} */\n    this.elementName = elementName || '';\n    /** @type {string} */\n    this.cssBuild = cssBuild || '';\n    /** @type {string} */\n    this.typeExtension = typeExtension || '';\n    /** @type {Object<string, string>} */\n    this.styleProperties = null;\n    /** @type {?string} */\n    this.scopeSelector = null;\n    /** @type {HTMLStyleElement} */\n    this.customStyle = null;\n  }\n  _getStyleRules() {\n    return this.styleRules;\n  }\n}\n\n/* eslint-disable-next-line no-self-assign */\nStyleInfo.prototype['_getStyleRules'] = StyleInfo.prototype._getStyleRules;\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {applyStylePlaceHolder} from './style-util.js';\nimport {nativeShadow, disableRuntime} from './style-settings.js';\n\n/** @type {!Object<string, !Node>} */\nconst placeholderMap = {};\n\n/**\n * @param {string} elementName\n * @return {Node}\n */\nexport function getStylePlaceholder(elementName) {\n  return placeholderMap[elementName] || null;\n}\n\n/**\n * @param {string} elementName\n */\nexport function ensureStylePlaceholder(elementName) {\n  if (!placeholderMap[elementName]) {\n    placeholderMap[elementName] = applyStylePlaceHolder(elementName);\n  }\n}\n\n/**\n * @const {CustomElementRegistry}\n */\nconst ce = window['customElements'];\nif (ce && !nativeShadow && !disableRuntime) {\n  /**\n   * @const {function(this:CustomElementRegistry, string,function(new:HTMLElement),{extends: string}=)}\n   */\n  const origDefine = ce['define'];\n  /**\n   * @param {string} name\n   * @param {function(new:HTMLElement)} clazz\n   * @param {{extends: string}=} options\n   */\n  const wrappedDefine = (name, clazz, options) => {\n    ensureStylePlaceholder(name);\n    origDefine.call(/** @type {!CustomElementRegistry} */(ce), name, clazz, options);\n  };\n  ce['define'] = wrappedDefine;\n}","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n'use strict';\n\nexport default class StyleCache {\n  constructor(typeMax = 100) {\n    // map element name -> [{properties, styleElement, scopeSelector}]\n    this.cache = {};\n    /** @type {number} */\n    this.typeMax = typeMax;\n  }\n\n  _validate(cacheEntry, properties, ownPropertyNames) {\n    for (let idx = 0; idx < ownPropertyNames.length; idx++) {\n      let pn = ownPropertyNames[idx];\n      if (cacheEntry.properties[pn] !== properties[pn]) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  store(tagname, properties, styleElement, scopeSelector) {\n    let list = this.cache[tagname] || [];\n    list.push({properties, styleElement, scopeSelector});\n    if (list.length > this.typeMax) {\n      list.shift();\n    }\n    this.cache[tagname] = list;\n  }\n\n  fetch(tagname, properties, ownPropertyNames) {\n    let list = this.cache[tagname];\n    if (!list) {\n      return;\n    }\n    // reverse list for most-recent lookups\n    for (let idx = list.length - 1; idx >= 0; idx--) {\n      let entry = list[idx];\n      if (this._validate(entry, properties, ownPropertyNames)) {\n        return entry;\n      }\n    }\n  }\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\n/**\n * @const {!Object<string, !HTMLTemplateElement>}\n */\nconst templateMap = {};\nexport default templateMap;\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\nimport templateMap from './template-map.js';\nimport {StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\n\n/*\n * Utilities for handling invalidating apply-shim mixins for a given template.\n *\n * The invalidation strategy involves keeping track of the \"current\" version of a template's mixins, and updating that count when a mixin is invalidated.\n * The template\n */\n\n/** @const {string} */\nconst CURRENT_VERSION = '_applyShimCurrentVersion';\n\n/** @const {string} */\nconst NEXT_VERSION = '_applyShimNextVersion';\n\n/** @const {string} */\nconst VALIDATING_VERSION = '_applyShimValidatingVersion';\n\n/**\n * @const {Promise<void>}\n */\nconst promise = Promise.resolve();\n\n/**\n * @param {string} elementName\n */\nexport function invalidate(elementName){\n  let template = templateMap[elementName];\n  if (template) {\n    invalidateTemplate(template);\n  }\n}\n\n/**\n * This function can be called multiple times to mark a template invalid\n * and signal that the style inside must be regenerated.\n *\n * Use `startValidatingTemplate` to begin an asynchronous validation cycle.\n * During that cycle, call `templateIsValidating` to see if the template must\n * be revalidated\n * @param {HTMLTemplateElement} template\n */\nexport function invalidateTemplate(template) {\n  // default the current version to 0\n  template[CURRENT_VERSION] = template[CURRENT_VERSION] || 0;\n  // ensure the \"validating for\" flag exists\n  template[VALIDATING_VERSION] = template[VALIDATING_VERSION] || 0;\n  // increment the next version\n  template[NEXT_VERSION] = (template[NEXT_VERSION] || 0) + 1;\n}\n\n/**\n * @param {string} elementName\n * @return {boolean}\n */\nexport function isValid(elementName) {\n  let template = templateMap[elementName];\n  if (template) {\n    return templateIsValid(template);\n  }\n  return true;\n}\n\n/**\n * @param {HTMLTemplateElement} template\n * @return {boolean}\n */\nexport function templateIsValid(template) {\n  return template[CURRENT_VERSION] === template[NEXT_VERSION];\n}\n\n/**\n * @param {string} elementName\n * @return {boolean}\n */\nexport function isValidating(elementName) {\n  let template = templateMap[elementName];\n  if (template) {\n    return templateIsValidating(template);\n  }\n  return false;\n}\n\n/**\n * Returns true if the template is currently invalid and `startValidating` has been called since the last invalidation.\n * If false, the template must be validated.\n * @param {HTMLTemplateElement} template\n * @return {boolean}\n */\nexport function templateIsValidating(template) {\n  return !templateIsValid(template) && template[VALIDATING_VERSION] === template[NEXT_VERSION];\n}\n\n/**\n * the template is marked as `validating` for one microtask so that all instances\n * found in the tree crawl of `applyStyle` will update themselves,\n * but the template will only be updated once.\n * @param {string} elementName\n*/\nexport function startValidating(elementName) {\n  let template = templateMap[elementName];\n  startValidatingTemplate(template);\n}\n\n/**\n * Begin an asynchronous invalidation cycle.\n * This should be called after every validation of a template\n *\n * After one microtask, the template will be marked as valid until the next call to `invalidateTemplate`\n * @param {HTMLTemplateElement} template\n */\nexport function startValidatingTemplate(template) {\n  // remember that the current \"next version\" is the reason for this validation cycle\n  template[VALIDATING_VERSION] = template[NEXT_VERSION];\n  // however, there only needs to be one async task to clear the counters\n  if (!template._validating) {\n    template._validating = true;\n    promise.then(function() {\n      // sync the current version to let future invalidations cause a refresh cycle\n      template[CURRENT_VERSION] = template[NEXT_VERSION];\n      template._validating = false;\n    });\n  }\n}\n\n/**\n * @return {boolean}\n */\nexport function elementsAreInvalid() {\n  for (let elementName in templateMap) {\n    let template = templateMap[elementName];\n    if (!templateIsValid(template)) {\n      return true;\n    }\n  }\n  return false;\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport { MIXIN_MATCH, VAR_ASSIGN } from './common-regex.js';\n\n/**\n * @param {Element} element\n * @param {Object=} properties\n */\nexport function updateNativeProperties(element, properties) {\n  // remove previous properties\n  for (let p in properties) {\n    // NOTE: for bc with shim, don't apply null values.\n    if (p === null) {\n      element.style.removeProperty(p);\n    } else {\n      element.style.setProperty(p, properties[p]);\n    }\n  }\n}\n\n/**\n * @param {Element} element\n * @param {string} property\n * @return {string}\n */\nexport function getComputedStyleValue(element, property) {\n  /**\n   * @const {string}\n   */\n  const value = window.getComputedStyle(element).getPropertyValue(property);\n  if (!value) {\n    return '';\n  } else {\n    return value.trim();\n  }\n}\n\n/**\n * return true if `cssText` contains a mixin definition or consumption\n * @param {string} cssText\n * @return {boolean}\n */\nexport function detectMixin(cssText) {\n  const has = MIXIN_MATCH.test(cssText) || VAR_ASSIGN.test(cssText);\n  // reset state of the regexes\n  MIXIN_MATCH.lastIndex = 0;\n  VAR_ASSIGN.lastIndex = 0;\n  return has;\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport ScopingShim from '../src/scoping-shim.js';\nimport {nativeCssVariables, nativeShadow, cssBuild, disableRuntime} from '../src/style-settings.js';\n\n/** @const {ScopingShim} */\nconst scopingShim = new ScopingShim();\n\nlet ApplyShim, CustomStyleInterface;\n\nif (window['ShadyCSS']) {\n  ApplyShim = window['ShadyCSS']['ApplyShim'];\n  CustomStyleInterface = window['ShadyCSS']['CustomStyleInterface'];\n}\n\nwindow.ShadyCSS = {\n  ScopingShim: scopingShim,\n  /**\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} elementExtends\n   */\n  prepareTemplate(template, elementName, elementExtends) {\n    scopingShim.flushCustomStyles();\n    scopingShim.prepareTemplate(template, elementName, elementExtends)\n  },\n\n  /**\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   */\n  prepareTemplateDom(template, elementName) {\n    scopingShim.prepareTemplateDom(template, elementName);\n  },\n\n  /**\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} elementExtends\n   */\n  prepareTemplateStyles(template, elementName, elementExtends) {\n    scopingShim.flushCustomStyles();\n    scopingShim.prepareTemplateStyles(template, elementName, elementExtends)\n  },\n  /**\n   * @param {!HTMLElement} element\n   * @param {Object=} properties\n   */\n  styleSubtree(element, properties) {\n    scopingShim.flushCustomStyles();\n    scopingShim.styleSubtree(element, properties);\n  },\n\n  /**\n   * @param {!HTMLElement} element\n   */\n  styleElement(element) {\n    scopingShim.flushCustomStyles();\n    scopingShim.styleElement(element);\n  },\n\n  /**\n   * @param {Object=} properties\n   */\n  styleDocument(properties) {\n    scopingShim.flushCustomStyles();\n    scopingShim.styleDocument(properties);\n  },\n\n  flushCustomStyles() {\n    scopingShim.flushCustomStyles();\n  },\n\n  /**\n   * @param {Element} element\n   * @param {string} property\n   * @return {string}\n   */\n  getComputedStyleValue(element, property) {\n    return scopingShim.getComputedStyleValue(element, property);\n  },\n\n  nativeCss: nativeCssVariables,\n\n  nativeShadow: nativeShadow,\n\n  cssBuild: cssBuild,\n\n  disableRuntime: disableRuntime,\n};\n\nif (ApplyShim) {\n  window.ShadyCSS.ApplyShim = ApplyShim;\n}\n\nif (CustomStyleInterface) {\n  window.ShadyCSS.CustomStyleInterface = CustomStyleInterface;\n}"]}