{"version":3,"sources":[" [synthetic:util/global] ","entrypoints/webcomponents-hi-sd-ce-pf-index.js","bower_components/shadycss/src/scoping-shim.js","bower_components/shadycss/src/custom-style-interface.js","bower_components/shadycss/src/document-watcher.js","bower_components/shadycss/src/style-cache.js","bower_components/shadycss/src/style-properties.js","bower_components/shadycss/src/style-info.js","bower_components/shadycss/src/style-transformer.js","bower_components/shadycss/src/css-parse.js","bower_components/custom-elements/src/Patch/Element.js","bower_components/custom-elements/src/CustomElementState.js","bower_components/custom-elements/src/Patch/Interface/ChildNode.js","bower_components/custom-elements/src/Patch/Node.js","bower_components/custom-elements/src/Patch/Document.js","bower_components/custom-elements/src/Patch/Interface/ParentNode.js","bower_components/custom-elements/src/Patch/HTMLElement.js","bower_components/custom-elements/src/CustomElementRegistry.js","bower_components/custom-elements/src/Deferred.js","bower_components/custom-elements/src/DocumentConstructionObserver.js","bower_components/custom-elements/src/CustomElementInternals.js","bower_components/shadydom/src/attach-shadow.js","bower_components/shadydom/src/distributor.js","bower_components/shadydom/src/logical-tree.js","bower_components/shadydom/src/observe-changes.js","bower_components/shadydom/src/utils.js","bower_components/shadydom/src/flush.js","bower_components/shadydom/src/innerHTML.js","bower_components/shadydom/src/native-tree.js","bower_components/shadydom/src/patch-accessors.js","bower_components/shadydom/src/logical-mutation.js","bower_components/shadydom/src/patch-events.js","bower_components/shadydom/src/array-splice.js","bower_components/shadydom/src/patch-builtins.js","bower_components/custom-elements/src/Utilities.js","bower_components/shadycss/src/style-settings.js","bower_components/shadycss/src/style-util.js","bower_components/shadycss/src/apply-shim-utils.js","bower_components/shadycss/src/document-wait.js","bower_components/webcomponents-platform/webcomponents-platform.js","bower_components/template/template.js","bower_components/es6-promise/dist/es6-promise.auto.min.js","bower_components/html-imports/src/html-imports.js","src/pre-polyfill.js","bower_components/shadydom/src/native-methods.js","bower_components/shadydom/src/shadydom.js","bower_components/custom-elements/src/Patch/Native.js","bower_components/custom-elements/src/AlreadyConstructedMarker.js","bower_components/custom-elements/src/custom-elements.js","bower_components/shadycss/src/common-regex.js","bower_components/shadycss/src/style-placeholder.js","bower_components/shadycss/src/template-map.js","bower_components/shadycss/src/common-utils.js","bower_components/shadycss/entrypoints/scoping-shim.js","src/post-polyfill.js","src/unresolved.js"],"names":["$jscomp.global","constructor","ScopingShim","_scopeCounter","_documentOwner","document","documentElement","ast","StyleNode","_documentOwnerStyleInfo","StyleInfo","set","_elementsHaveApplied","_customStyleInterface","_applyShim","documentWait","_ensure","CustomStyleInterface$1","flush$1","StyleCache","typeMax","cache","StyleProperties","placeholder","ownStylePropertyNames","elementName","typeExtension","styleRules","overrideStyleProperties","customStyle","scopeSelector","styleProperties","StyleTransformer","PatchElement","internals","patch_innerHTML","destination","baseDescriptor","Object","defineProperty","enumerable","configurable","get","htmlString","removedElements","undefined","isConnected","isConnected$$1","walkDeepDescendantElements","element","push","call","i","length","custom","__CE_state","disconnectedCallback","ownerDocument","__CE_hasRegistry","patchAndUpgradeTree","patchTree","patch_insertAdjacentElement","baseMethod","setPropertyUnchecked","where","wasConnected","insertedElement","disconnectTree","connectTree","Element_attachShadow","Element","prototype","init","__CE_shadowRoot","shadowRoot","console","warn","Element_innerHTML","HTMLElement_innerHTML","HTMLElement","rawDiv","Document_createElement","addPatch","Node_cloneNode","innerHTML","assignedValue","content","localName","childNodes","Node_removeChild","Node_appendChild","name","newValue","Element_setAttribute","oldValue","Element_getAttribute","attributeChangedCallback","namespace","Element_setAttributeNS","Element_getAttributeNS","Element_removeAttribute","Element_removeAttributeNS","HTMLElement_insertAdjacentElement","Element_insertAdjacentElement","PatchParentNode","prepend","Element_prepend","append","Element_append","PatchChildNode","before","Element_before","after","Element_after","replaceWith","Element_replaceWith","remove","Element_remove","builtIn","connectedBefore","nodes","filter","node","Node","apply","PatchNode","patch_textContent","nodeType","TEXT_NODE","removedNodes","firstChild","childNodesLength","Array","refNode","DocumentFragment","insertedNodes","slice","nativeResult","Node_insertBefore","nodeWasConnected","deep","clone","nodeToInsert","nodeToRemove","Node_replaceChild","nodeToInsertWasConnected","thisIsConnected","Node_textContent","parts","textContent","join","createTextNode","PatchDocument","Document","definition","localNameToDefinition","result","patch","Document_importNode","NS_HTML","Document_createElementNS","Document_prepend","Document_append","PatchHTMLElement","window","constructorToDefinition","Error","constructionStack","setPrototypeOf","__CE_definition","lastIndex","AlreadyConstructedMarker$1","CustomElementRegistry","_elementDefinitionIsRunning","_internals","_whenDefinedDeferred","Map","_flushCallback","this._flushCallback","fn","_flushPending","_unflushedLocalNames","_documentConstructionObserver","DocumentConstructionObserver","Deferred","_resolve","_value","_promise","Promise","resolve","doc","_document","_observer","readyState","MutationObserver","_handleMutations","bind","observe","childList","subtree","CustomElementInternals","_localNameToDefinition","_constructorToDefinition","_patches","_hasPatches","ShadyRoot","token","host","ShadyRootConstructionToken","TypeError","createDocumentFragment","__proto__","_init","root","insertionPointTag","recordChildNodes","__shady","lastChild","patchInsideElementAccessors","c$","n","parentNode","nextSibling","previousSibling","patchOutsideElementAccessors","unobserveChildren","handle","observer","callbacks","delete","_callback","size","_node","observeChildren","callback","AsyncObserver","add","takeRecords","_scheduled","addedNodes","Set","isShadyRoot","obj","__localName","ownerShadyRootForNode","getRootNode","extend","target","source","n$","getOwnPropertyNames","pd","getOwnPropertyDescriptor","extendAll","sources","mixin","microtask","queue","twiddle","enqueue","scheduled","flush","flushList","didFlush","shift","filterMutations","mutations","targetRootNode","map","mutation","mutationInScope","from","create","value","m","escapeReplace","c","makeSet","arr","getInnerHTML","s","l","child","attr","ELEMENT_NODE","tagName","attrs","attributes","replace","escapeAttrRegExp","voidElements","data","plaintextParents","escapeDataRegExp","COMMENT_NODE","error","nodeWalker","currentNode","parentElement","elementWalker","firstElementChild","lastElementChild","previousElementSibling","nextElementSibling","children","nodeValue","textWalker","createTreeWalker","NodeFilter","SHOW_TEXT","nextNode","patchAccessorGroup","descriptors","force","p","objDesc","patchAccessors","proto","OutsideAccessors","InsideAccessors","ActiveElementAccessor","linkNode","container","ref_node","ps","ns","removeNode","logicalParent","distributed","ownerRoot","maybeDistributeParent","hostNeedsDist","ip$","_getInsertionPoints","insertionPoint","dc$","j","assignedNodes","flatten","parent","removeChild","addedInsertionPoint","_distributor","removedDistributed","_skipUpdateInsertionPoints","updateRootViaContentChange","_removeOwnerShadyRoot","_scheduleObserver","addedNode","removedNode","schedule","ownerShadyRoot","contains","_maybeAddInsertionPoint","added","DOCUMENT_FRAGMENT_NODE","querySelectorAll","np","na","_nodeNeedsDistribution","hasInsertionPoint","_changePending","update","distributeAttributeChange","query","matcher","halter","list","_queryElements","elements","renderRootNode","render","insertBefore$1","ipAdded","resetTo","fragContent","querySelector","wrappedContent","hasContent","needsDist","handled","_renderPending","isFinalDestination","insertBefore","appendChild","importNode$1","importNode","nc","pathComposer","startNode","composed","composedPath","current","startRoot","assignedSlot","retarget","path","refNodePath","ancestor","lastRoot","rootIdx","indexOf","mixinComposedFlag","Base","klazz","type","options","event","__composed","fireHandlers","phase","hs","__handlers","relatedTarget","__immediatePropagationStopped","retargetNonBubblingEvent","e","__propagationStopped","Event","AT_TARGET","lastFiredRoot","findListener","wrappers","capture","once","passive","savedType","savedListener","savedCapture","savedOnce","savedPassive","savedNode","addEventListener$1","fnOrObj","optionsOrCapture","__shadyTarget","__eventWrappers","wrapperFn","removeEventListener","patchEvent","lastCurrentTargetDesc","eventPhase","BUBBLING_PHASE","stopImmediatePropagation","CAPTURING_PHASE","bubbles","ret","handleEvent","nonBubblingEventsToRetarget","ael","Window","windowAddEventListener","addEventListener","removeEventListener$1","idx","splice","rel","windowRemoveEventListener","activateFocusEventOverrides","ev","__relatedTarget","settings","hasDescriptors","eventMixin","getPrototypeOf","hasOwnProperty","patchProto","__sourceProto","newSplice","index","addedCount","removed","calcSplices","currentEnd","old","oldEnd","prefixCount","suffixCount","minLength","Math","min","currentStart","oldStart","currentValue","previousValue","index1","index2","count","equals","rowCount","columnCount","distances","north","west","edits","northWest","EDIT_LEAVE","EDIT_UPDATE","EDIT_DELETE","EDIT_ADD","reverse","splices","oldIndex","getAssignedSlot","patchBuiltin","d","patchBuiltins","nativeHTMLElement","nodeMixin","windowMixin","Text","textMixin","fragmentMixin","elementMixin","documentMixin","HTMLSlotElement","slotMixin","htmlElementMixin","isValidCustomElementName","reserved","reservedTagList","has","validForm","test","nativeValue","__CE_isImportDocument","ShadowRoot","nextSiblingOrAncestorSibling","start","visitedImports","getAttribute","import","parse","text","RX","comments","port","parseCss","OPEN_BRACE","previous","CLOSE_BRACE","t","substring","trim","ss","_expandUnicodeEscapes","multipleSpaces","lastIndexOf","AT_START","MEDIA_START","match","keyframesRule","types","KEYFRAMES_RULE","split","pop","MEDIA_RULE","VAR_START","STYLE_RULE","MIXIN_RULE","r$","r","code","repeat","stringify","preserveProperties","cssText","rules","customProp","mixinProp","mixinApply","varApply","calcCssVariables","nativeCssVariables","navigator","userAgent","CSS","supports","toCssText","forEachRule","rulesForStyle","style","isKeyframesSelector","rule","styleRuleCallback","keyframesRuleCallback","onlyActiveRules","skipRules","matchMedia","MEDIA_MATCH","matches","applyCss","moniker","contextNode","createElement","setAttribute","applyStyle","head","lastHeadApplyNode","compareDocumentPosition","position","DOCUMENT_POSITION_PRECEDING","processVariableAndFallback","str","end","level","inner","prefix","suffix","comma","fallback","setElementClassRaw","nativeShadow","getIsExtends","is","extends","handler","mxns","x","mxn","currentScope","classes","classList","hasAttribute","StyleTransformer$1","SCOPE_NAME","dom","newScope","invalidate","template","templateMap","templateIsValid","startValidatingTemplate","_validating","promise","then","requestAnimationFrame","whenReady","readyPromise","resolveFn","workingDefaultPrevented","createEvent","initEvent","preventDefault","defaultPrevented","origPreventDefault","Event.prototype.preventDefault","cancelable","isIE","CustomEvent","window.CustomEvent","inType","params","initCustomEvent","detail","origEvent","window.Event","MouseEvent","origMouseEvent","window.MouseEvent","initMouseEvent","view","screenX","screenY","clientX","clientY","ctrlKey","altKey","shiftKey","metaKey","button","Array.from","object","assign","Object.assign","args","arguments","WebComponents","PolyfilledHTMLTemplateElement","needsTemplate","HTMLTemplateElement","Native_importNode","Document.prototype.importNode","f","Native_cloneNode","cloneNode","Native_createElement","needsCloning","t2","defineInnerHTML","o","outerHTML","contentDoc","body","bootstrap","implementation","createHTMLDocument","canDecorate","templateStyle","canProtoPatch","decorate","PolyfilledHTMLTemplateElement.decorate","template.cloneNode","_cloneNode","err","PolyfilledHTMLTemplateElement.bootstrap","templates","TEMPLATE_TAG","Document.prototype.createElement","el","PolyfilledHTMLTemplateElement._cloneNode","fixClonedDom","PolyfilledHTMLTemplateElement.prototype.cloneNode","PolyfilledHTMLTemplateElement.fixClonedDom","s$","t$","replaceChild","Node.prototype.cloneNode","window.HTMLTemplateElement.prototype.cloneNode","exports","module","define","amd","ES6Promise","J","$","G","I","a","tt","process","nextTick","H","V","characterData","u","MessageChannel","port1","onmessage","port2","postMessage","setTimeout","require","runOnLoop","runOnContext","et","k","_state","_result","E","h","g","_","it","y","S","b","rt","ot","w","A","_onerror","T","nt","_subscribers","M","st","C","ut","Y","_instanceConstructor","B","_input","_remaining","_enumerate","U","z","isArray","toString","R","Q","WebKitMutationObserver","Z","Uint8ClampedArray","importScripts","self","random","Y.prototype._enumerate","_eachEntry","Y.prototype._eachEntry","_settledAt","_willSettleAt","Y.prototype._settledAt","Y.prototype._willSettleAt","all","F","race","D","reject","K","_setScheduler","_setAsap","_asap","catch","polyfill","W","global","Function","cast","scope","newCustomEvent","importForElement","useNative","closest","importSelector","isImportLink","whenImportsReady","imports","rootImportSelector","pending","imp","whenElementLoaded","whenDocumentReady","stateChanged","src","onLoadingDone","Importer","documents","inflight","dynamicImportsMO","handleMutations","loadImports","currentScript","scripts","ABS_URL_TEST","CSS_URL_REGEXP","CSS_IMPORT_REGEXP","STYLESHEET_REGEXP","Path","fixUrls","base","href","replaceAttrUrl","replaceUrls","linkUrl","regexp","pre","url","post","urlPath","resolveUrl","__workingURL","URL","pathname","__tempDoc","__base","__anchor","Xhr","async","load","success","fail","pieces","resource","header","atob","decodeURIComponent","request","XMLHttpRequest","open","onload","request.onload","redirectedUrl","getResponseHeader","location","origin","protocol","response","responseText","status","send","links","loadImport","link","fireEventIfNeeded","makeDocument","processImportsIfLoadingDone","p1","p2","baseEl","removeAttribute","importDependenciesSelector","inlineScriptIndex","importDependencyAttr","encodeURIComponent","num","disconnect","scriptsOk","stylesOk","fireEvents","waitForStyles","runScripts","cloneScript","ll","pendingScriptsSelector","pendingStylesSelector","needsMove","disabledLinkSelector","newSibling","dispatchEvent","eventType","ii","elem","imps","native_baseURI","klass","ownerDoc","HTMLImports","script","flagMatcher","flags","search","forEach","option","forceShady","forceCE","hasNativeShadowDOM","attachShadow","desc","inUse","matchesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector","webkitMatchesSelector","cb","nativeMethods","freeze","SHOW_ALL","SHOW_ELEMENT","nativeTree","nativeInnerHTMLDesc","htmlContainer","inertDoc","nativeActiveElementDescriptor","className","childNodes$$1","item","childNodes$$1.item","childElementCount","tc","cn","children$$1","children$$1.item","ShadowRootAccessor","activeElement","active","isShadyRoot$$1","activeRoot","__outsideAccessors","__insideAccessors","scopingShim","alwaysComposed","isTrusted","__composedPath","currentTarget","__relatedTargetComposedPath","stopPropagation","PatchedEvent","PatchedCustomEvent","PatchedMouseEvent","NormalizedEvent","getInsertionPoints","isInsertionPoint","distribute","distributePool","collectPool","pool","dirtyRoots","p$","distributeInsertionPoint","prevAssignedNodes","clearAssignedSlots","needsSlotChange","anyDistributed","matchesInsertionPoint","_prevAssignedSlot","distributeNodeInto","setDistributedNodesOnInsertionPoint","_fireSlotChange","slot","savePrevious","slotName","distributedNodes","d$","ShadyRoot.prototype._init","Distributor","ShadyRoot.prototype.update","_getRenderRoot","ShadyRoot.prototype._getRenderRoot","renderRoot","_rendererForHost","ShadyRoot.prototype._rendererForHost","ShadyRoot.prototype.render","updateInsertionPoints","compose","ShadyRoot.prototype.distribute","ShadyRoot.prototype.updateInsertionPoints","i$","_insertionPoints","ShadyRoot.prototype.compose","_composeTree","ShadyRoot.prototype._composeTree","_updateChildNodes","_composeNode","ShadyRoot.prototype._composeNode","distributedNode","ShadyRoot.prototype.isFinalDestination","ShadyRoot.prototype._updateChildNodes","next","ShadyRoot.prototype.hasInsertionPoint","ShadyRoot.prototype._getInsertionPoints","ShadyRoot.prototype.addEventListener","ShadyRoot.prototype.removeEventListener","getElementById","ShadyRoot.prototype.getElementById","id","patchShadowRootAccessors","nativeParent","ownerDocumentElement","selector","defineProperties","nativeBlur","blur","shadowActive","ShadyDOM","setDefinition","listener","__CE_patched","connectedCallback","upgradeElement","gatherElements","__CE_documentLoadHandled","failed","observedAttributes","SyntaxError","adoptedCallback","getCallback","callbackValue","_flush","deferred","whenDefined","prior","polyfillWrapFlushCallback","outer","createElementNS","getAttributeNS","setAttributeNS","removeAttributeNS","AlreadyConstructedMarker","priorCustomElements","customElements","ShadyCSS","nativeCss","VAR_ASSIGN","MIXIN_MATCH","VAR_CONSUMED","ANIMATION_MATCH","BRACKETED","shouldRemoveScope","_transformDom","_content","CLASS","elementStyles","cssBuildType","css","ext","hostScope","_calcHostScope","_calcElementScope","isScoped","CSS_CLASS_PREFIX","_transformRule","_transformComplexSelector","transformer","transformedSelector","_transformRuleCss","COMPLEX_SELECTOR_SEP","stop","NTH","SLOTTED_START","HOST","SIMPLE_SELECTOR_SEP","info","_transformCompoundSelector","combinator","slottedIndex","SLOTTED","_transformHostSelector","_transformSimpleSelector","slotted","SLOTTED_PAREN","paren","DIR_PAREN","dir","PSEUDO_PREFIX","HOST_PAREN","SIMPLE_SELECTOR_PREFIX","typeSelector","SELECTOR_NO_MATCH","documentRule","normalizeRootSelector","_transformDocumentSelector","ROOT","SCOPE_DOC_SELECTOR","$jscomp.global.Object.defineProperties","RegExp","styleInfo","_getStyleRules","matchesSelector$1","IS_IE","decorateStyles","props","keyframes","ruleIndex","decorateRule","collectPropertiesInCssText","propertyInfo","onKeyframesRule","_keyframes","names","properties","collectProperties","hasProperties","collectCssText","exec","any","collectConsumingCssText","reify","valueForProperty","property","valueForProperties","propertyValue","colon","pp","applyProperties","output","applyKeyframeTransforms","keyframeTransforms","input","hasAnimations","keyframeNamesToTransform","keyframe","transform","propertyDataFromStyles","selectorToMatch","parseInt","key","whenHostOrRootRule","cssBuild","parsedSelector","isRoot","isHost","hostAndRootPropertiesForScope","hostProps","rootProps","_element","transformStyles","hostSelector","hostRx","HOST_PREFIX","rxHostSelector","HOST_SUFFIX","_elementKeyframeTransforms","_scopeSelector","keyframesRules","_scopeKeyframes","_keyframesRuleTransformer","keyframesNameRx","transformedKeyframesName","scopeId","applyElementScopeSelector","v","applyElementStyle","applyCustomStyle","XSCOPE_NAME","StyleProperties$1","placeholderMap","ce","origDefine","wrappedDefine","clazz","placeHolder","createComment","_validate","cacheEntry","ownPropertyNames","pn","store","tagname","styleElement","fetch","entry","delayedStart","transformFn","validateFn","enqueueDocumentValidation","addCustomStyle","getStyleForCustomStyle","processStyles","cs","appliedStyle","styleToTransform","needsEnqueue","styleCache","_generateScopeSelector","getStyleAst","styleAstToString","_gatherStyles","styles","_getCssBuild","prepareTemplate","_prepared","__cssBuild","_cssBuild","_generateStaticStyle","_style","_ownPropertyNames","shadowroot","_prepareHost","_ensureApplyShim","ApplyShim","_ensureCustomStyleInterface","CustomStyleInterface","transformCustomStyleForDocument","flushCustomStyles","customStyles","_revalidateCustomStyleApplyShim","_updateProperties","_applyCustomStyles","styleDocument","overrideProps","_isRootOwner","removeProperty","setProperty","_applyStyleProperties","_styleOwnerForNode","cachedStyle","oldScopeSelector","owner","ownerStyleInfo","hostAndRootProps","propertiesMatchingHost","propertyData","_mixinOverrideStyles","overrides","styleSubtree","shadowChildren","_revalidateApplyShim","getComputedStyleValue","getComputedStyle","getPropertyValue","setElementClass","classString","scopeName","classAttr","k$","_styleInfoForNode","scopingShim$1","elementExtends","flushCallback","runAndClearCallback","origWhenReady","ready"],"mappings":"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","file":"webcomponents-lite.js","sourcesContent":[null,"/**\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\n/*\n * Polyfills loaded: HTML Imports, Custom Elements, Shady DOM/Shady CSS, platform polyfills, template\n * Used in: IE 11\n */\n\nimport '../bower_components/webcomponents-platform/webcomponents-platform.js'\nimport '../bower_components/template/template.js'\nimport '../bower_components/es6-promise/dist/es6-promise.auto.min.js'\nimport '../bower_components/html-imports/src/html-imports.js'\nimport '../src/pre-polyfill.js'\nimport '../bower_components/shadydom/src/shadydom.js'\nimport '../bower_components/custom-elements/src/custom-elements.js'\nimport '../bower_components/shadycss/entrypoints/scoping-shim.js'\nimport '../src/post-polyfill.js'\nimport '../src/unresolved.js'\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {parse, StyleNode} from './css-parse.js'\nimport {nativeShadow, nativeCssVariables} from './style-settings.js'\nimport StyleTransformer from './style-transformer.js'\nimport * as StyleUtil from './style-util.js'\nimport StyleProperties from './style-properties.js'\nimport placeholderMap from './style-placeholder.js'\nimport StyleInfo from './style-info.js'\nimport StyleCache from './style-cache.js'\nimport {flush as watcherFlush} from './document-watcher.js'\nimport templateMap from './template-map.js'\nimport * as ApplyShimUtils from './apply-shim-utils.js'\nimport documentWait from './document-wait.js'\nimport {updateNativeProperties, detectMixin} from './common-utils.js'\nimport {CustomStyleInterfaceInterface} from './custom-style-interface.js' //eslint-disable-line no-unused-vars\n\n/**\n * @const {StyleCache}\n */\nconst styleCache = new StyleCache();\n\nexport default class ScopingShim {\n  constructor() {\n    this._scopeCounter = {};\n    this._documentOwner = document.documentElement;\n    let ast = new StyleNode();\n    ast['rules'] = [];\n    this._documentOwnerStyleInfo = StyleInfo.set(this._documentOwner, new StyleInfo(ast));\n    this._elementsHaveApplied = false;\n    this._applyShim = null;\n    /** @type {?CustomStyleInterfaceInterface} */\n    this._customStyleInterface = null;\n    documentWait(() => {\n      this._ensure();\n    });\n  }\n  flush() {\n    watcherFlush();\n  }\n  _generateScopeSelector(name) {\n    let id = this._scopeCounter[name] = (this._scopeCounter[name] || 0) + 1;\n    return `${name}-${id}`;\n  }\n  getStyleAst(style) {\n    return StyleUtil.rulesForStyle(style);\n  }\n  styleAstToString(ast) {\n    return StyleUtil.toCssText(ast);\n  }\n  _gatherStyles(template) {\n    let styles = template.content.querySelectorAll('style');\n    let cssText = [];\n    for (let i = 0; i < styles.length; i++) {\n      let s = styles[i];\n      cssText.push(s.textContent);\n      s.parentNode.removeChild(s);\n    }\n    return cssText.join('').trim();\n  }\n  _getCssBuild(template) {\n    let style = template.content.querySelector('style');\n    if (!style) {\n      return '';\n    }\n    return style.getAttribute('css-build') || '';\n  }\n  /**\n   * Prepare the styling and template for the given element type\n   *\n   * @param {HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} typeExtension\n   */\n  prepareTemplate(template, elementName, typeExtension) {\n    if (template._prepared) {\n      return;\n    }\n    template._prepared = true;\n    template.name = elementName;\n    template.extends = typeExtension;\n    templateMap[elementName] = template;\n    let cssBuild = this._getCssBuild(template);\n    let cssText = this._gatherStyles(template);\n    let info = {\n      is: elementName,\n      extends: typeExtension,\n      __cssBuild: cssBuild,\n    };\n    if (!nativeShadow) {\n      StyleTransformer.dom(template.content, elementName);\n    }\n    // check if the styling has mixin definitions or uses\n    this._ensure();\n    let hasMixins = detectMixin(cssText)\n    let ast = parse(cssText);\n    // only run the applyshim transforms if there is a mixin involved\n    if (hasMixins && nativeCssVariables && this._applyShim) {\n      this._applyShim['transformRules'](ast, elementName);\n    }\n    template['_styleAst'] = ast;\n    template._cssBuild = cssBuild;\n\n    let ownPropertyNames = [];\n    if (!nativeCssVariables) {\n      ownPropertyNames = StyleProperties.decorateStyles(template['_styleAst'], info);\n    }\n    if (!ownPropertyNames.length || nativeCssVariables) {\n      let root = nativeShadow ? template.content : null;\n      let placeholder = placeholderMap[elementName];\n      let style = this._generateStaticStyle(info, template['_styleAst'], root, placeholder);\n      template._style = style;\n    }\n    template._ownPropertyNames = ownPropertyNames;\n  }\n  _generateStaticStyle(info, rules, shadowroot, placeholder) {\n    let cssText = StyleTransformer.elementStyles(info, rules);\n    if (cssText.length) {\n      return StyleUtil.applyCss(cssText, info.is, shadowroot, placeholder);\n    }\n  }\n  _prepareHost(host) {\n    let {is, typeExtension} = StyleUtil.getIsExtends(host);\n    let placeholder = placeholderMap[is];\n    let template = templateMap[is];\n    let ast;\n    let ownStylePropertyNames;\n    let cssBuild;\n    if (template) {\n      ast = template['_styleAst'];\n      ownStylePropertyNames = template._ownPropertyNames;\n      cssBuild = template._cssBuild;\n    }\n    return StyleInfo.set(host,\n      new StyleInfo(\n        ast,\n        placeholder,\n        ownStylePropertyNames,\n        is,\n        typeExtension,\n        cssBuild\n      )\n    );\n  }\n  _ensureApplyShim() {\n    if (this._applyShim) {\n      return;\n    } else if (window.ShadyCSS && window.ShadyCSS.ApplyShim) {\n      this._applyShim = window.ShadyCSS.ApplyShim;\n      this._applyShim['invalidCallback'] = ApplyShimUtils.invalidate;\n    }\n  }\n  _ensureCustomStyleInterface() {\n    if (this._customStyleInterface) {\n      return;\n    } else if (window.ShadyCSS && window.ShadyCSS.CustomStyleInterface) {\n      this._customStyleInterface = /** @type {!CustomStyleInterfaceInterface} */(window.ShadyCSS.CustomStyleInterface);\n      /** @type {function(!HTMLStyleElement)} */\n      this._customStyleInterface['transformCallback'] = (style) => {this.transformCustomStyleForDocument(style)};\n      this._customStyleInterface['validateCallback'] = () => {\n        requestAnimationFrame(() => {\n          if (this._customStyleInterface['enqueued'] || this._elementsHaveApplied) {\n            this.flushCustomStyles();\n          }\n        })\n      };\n    }\n  }\n  _ensure() {\n    this._ensureApplyShim();\n    this._ensureCustomStyleInterface();\n  }\n  /**\n   * Flush and apply custom styles to document\n   */\n  flushCustomStyles() {\n    this._ensure();\n    if (!this._customStyleInterface) {\n      return;\n    }\n    let customStyles = this._customStyleInterface['processStyles']();\n    // early return if custom-styles don't need validation\n    if (!this._customStyleInterface['enqueued']) {\n      return;\n    }\n    if (!nativeCssVariables) {\n      this._updateProperties(this._documentOwner, this._documentOwnerStyleInfo);\n      this._applyCustomStyles(customStyles);\n    } else {\n      this._revalidateCustomStyleApplyShim(customStyles);\n    }\n    this._customStyleInterface['enqueued'] = false;\n    // if custom elements have upgraded and there are no native css variables, we must recalculate the whole tree\n    if (this._elementsHaveApplied && !nativeCssVariables) {\n      this.styleDocument();\n    }\n  }\n  /**\n   * Apply styles for the given element\n   *\n   * @param {!HTMLElement} host\n   * @param {Object=} overrideProps\n   */\n  styleElement(host, overrideProps) {\n    let {is} = StyleUtil.getIsExtends(host);\n    let styleInfo = StyleInfo.get(host);\n    if (!styleInfo) {\n      styleInfo = this._prepareHost(host);\n    }\n    // Only trip the `elementsHaveApplied` flag if a node other that the root document has `applyStyle` called\n    if (!this._isRootOwner(host)) {\n      this._elementsHaveApplied = true;\n    }\n    if (overrideProps) {\n      styleInfo.overrideStyleProperties =\n        styleInfo.overrideStyleProperties || {};\n      Object.assign(styleInfo.overrideStyleProperties, overrideProps);\n    }\n    if (!nativeCssVariables) {\n     this._updateProperties(host, styleInfo);\n      if (styleInfo.ownStylePropertyNames && styleInfo.ownStylePropertyNames.length) {\n        this._applyStyleProperties(host, styleInfo);\n      }\n    } else {\n      if (styleInfo.overrideStyleProperties) {\n        updateNativeProperties(host, styleInfo.overrideStyleProperties);\n      }\n      let template = templateMap[is];\n      // bail early if there is no shadowroot for this element\n      if (!template && !this._isRootOwner(host)) {\n        return;\n      }\n      if (template && template._style && !ApplyShimUtils.templateIsValid(template)) {\n        // update template\n        if (!ApplyShimUtils.templateIsValidating(template)) {\n          this._ensure();\n          this._applyShim && this._applyShim['transformRules'](template['_styleAst'], is);\n          template._style.textContent = StyleTransformer.elementStyles(host, styleInfo.styleRules);\n          ApplyShimUtils.startValidatingTemplate(template);\n        }\n        // update instance if native shadowdom\n        if (nativeShadow) {\n          let root = host.shadowRoot;\n          if (root) {\n            let style = root.querySelector('style');\n            style.textContent = StyleTransformer.elementStyles(host, styleInfo.styleRules);\n          }\n        }\n        styleInfo.styleRules = template['_styleAst'];\n      }\n    }\n  }\n  _styleOwnerForNode(node) {\n    let root = node.getRootNode();\n    let host = root.host;\n    if (host) {\n      if (StyleInfo.get(host)) {\n        return host;\n      } else {\n        return this._styleOwnerForNode(host);\n      }\n    }\n    return this._documentOwner;\n  }\n  _isRootOwner(node) {\n    return (node === this._documentOwner);\n  }\n  _applyStyleProperties(host, styleInfo) {\n    let is = StyleUtil.getIsExtends(host).is;\n    let cacheEntry = styleCache.fetch(is, styleInfo.styleProperties, styleInfo.ownStylePropertyNames);\n    let cachedScopeSelector = cacheEntry && cacheEntry.scopeSelector;\n    let cachedStyle = cacheEntry ? cacheEntry.styleElement : null;\n    let oldScopeSelector = styleInfo.scopeSelector;\n    // only generate new scope if cached style is not found\n    styleInfo.scopeSelector = cachedScopeSelector || this._generateScopeSelector(is);\n    let style = StyleProperties.applyElementStyle(host, styleInfo.styleProperties, styleInfo.scopeSelector, cachedStyle);\n    if (!nativeShadow) {\n      StyleProperties.applyElementScopeSelector(host, styleInfo.scopeSelector, oldScopeSelector);\n    }\n    if (!cacheEntry) {\n      styleCache.store(is, styleInfo.styleProperties, style, styleInfo.scopeSelector);\n    }\n    return style;\n  }\n  _updateProperties(host, styleInfo) {\n    let owner = this._styleOwnerForNode(host);\n    let ownerStyleInfo = StyleInfo.get(owner);\n    let ownerProperties = ownerStyleInfo.styleProperties;\n    let props = Object.create(ownerProperties || null);\n    let hostAndRootProps = StyleProperties.hostAndRootPropertiesForScope(host, styleInfo.styleRules);\n    let propertyData = StyleProperties.propertyDataFromStyles(ownerStyleInfo.styleRules, host);\n    let propertiesMatchingHost = propertyData.properties\n    Object.assign(\n      props,\n      hostAndRootProps.hostProps,\n      propertiesMatchingHost,\n      hostAndRootProps.rootProps\n    );\n    this._mixinOverrideStyles(props, styleInfo.overrideStyleProperties);\n    StyleProperties.reify(props);\n    styleInfo.styleProperties = props;\n  }\n  _mixinOverrideStyles(props, overrides) {\n    for (let p in overrides) {\n      let v = overrides[p];\n      // skip override props if they are not truthy or 0\n      // in order to fall back to inherited values\n      if (v || v === 0) {\n        props[p] = v;\n      }\n    }\n  }\n  /**\n   * Update styles of the whole document\n   *\n   * @param {Object=} properties\n   */\n  styleDocument(properties) {\n    this.styleSubtree(this._documentOwner, properties);\n  }\n  /**\n   * Update styles of a subtree\n   *\n   * @param {!HTMLElement} host\n   * @param {Object=} properties\n   */\n  styleSubtree(host, properties) {\n    let root = host.shadowRoot;\n    if (root || this._isRootOwner(host)) {\n      this.styleElement(host, properties);\n    }\n    // process the shadowdom children of `host`\n    let shadowChildren = root && (root.children || root.childNodes);\n    if (shadowChildren) {\n      for (let i = 0; i < shadowChildren.length; i++) {\n        let c = /** @type {!HTMLElement} */(shadowChildren[i]);\n        this.styleSubtree(c);\n      }\n    } else {\n      // process the lightdom children of `host`\n      let children = host.children || host.childNodes;\n      if (children) {\n        for (let i = 0; i < children.length; i++) {\n          let c = /** @type {!HTMLElement} */(children[i]);\n          this.styleSubtree(c);\n        }\n      }\n    }\n  }\n  /* Custom Style operations */\n  _revalidateCustomStyleApplyShim(customStyles) {\n    for (let i = 0; i < customStyles.length; i++) {\n      let c = customStyles[i];\n      let s = this._customStyleInterface['getStyleForCustomStyle'](c);\n      if (s) {\n        this._revalidateApplyShim(s);\n      }\n    }\n  }\n  _applyCustomStyles(customStyles) {\n    for (let i = 0; i < customStyles.length; i++) {\n      let c = customStyles[i];\n      let s = this._customStyleInterface['getStyleForCustomStyle'](c);\n      if (s) {\n        StyleProperties.applyCustomStyle(s, this._documentOwnerStyleInfo.styleProperties);\n      }\n    }\n  }\n  transformCustomStyleForDocument(style) {\n    let ast = StyleUtil.rulesForStyle(style);\n    StyleUtil.forEachRule(ast, (rule) => {\n      if (nativeShadow) {\n        StyleTransformer.normalizeRootSelector(rule);\n      } else {\n        StyleTransformer.documentRule(rule);\n      }\n      if (nativeCssVariables) {\n        this._ensure();\n        this._applyShim && this._applyShim['transformRule'](rule);\n      }\n    });\n    if (nativeCssVariables) {\n      style.textContent = StyleUtil.toCssText(ast);\n    } else {\n      this._documentOwnerStyleInfo.styleRules.rules.push(ast);\n    }\n  }\n  _revalidateApplyShim(style) {\n    if (nativeCssVariables && this._applyShim) {\n      let ast = StyleUtil.rulesForStyle(style);\n      this._ensure();\n      this._applyShim['transformRules'](ast);\n      style.textContent = StyleUtil.toCssText(ast);\n    }\n  }\n  getComputedStyleValue(element, property) {\n    let value;\n    if (!nativeCssVariables) {\n      // element is either a style host, or an ancestor of a style host\n      let styleInfo = StyleInfo.get(element) || StyleInfo.get(this._styleOwnerForNode(element));\n      value = styleInfo.styleProperties[property];\n    }\n    // fall back to the property value from the computed styling\n    value = value || window.getComputedStyle(element).getPropertyValue(property);\n    // trim whitespace that can come after the `:` in css\n    // example: padding: 2px -> \" 2px\"\n    return value ? value.trim() : '';\n  }\n  // given an element and a classString, replaces\n  // the element's class with the provided classString and adds\n  // any necessary ShadyCSS static and property based scoping selectors\n  setElementClass(element, classString) {\n    let root = element.getRootNode();\n    let classes = classString ? classString.split(/\\s/) : [];\n    let scopeName = root.host && root.host.localName;\n    // If no scope, try to discover scope name from existing class.\n    // This can occur if, for example, a template stamped element that\n    // has been scoped is manipulated when not in a root.\n    if (!scopeName) {\n      var classAttr = element.getAttribute('class');\n      if (classAttr) {\n        let k$ = classAttr.split(/\\s/);\n        for (let i=0; i < k$.length; i++) {\n          if (k$[i] === StyleTransformer.SCOPE_NAME) {\n            scopeName = k$[i+1];\n            break;\n          }\n        }\n      }\n    }\n    if (scopeName) {\n      classes.push(StyleTransformer.SCOPE_NAME, scopeName);\n    }\n    if (!nativeCssVariables) {\n      let styleInfo = StyleInfo.get(element);\n      if (styleInfo && styleInfo.scopeSelector) {\n        classes.push(StyleProperties.XSCOPE_NAME, styleInfo.scopeSelector);\n      }\n    }\n    StyleUtil.setElementClassRaw(element, classes.join(' '));\n  }\n  _styleInfoForNode(node) {\n    return StyleInfo.get(node);\n  }\n}\n\n/* exports */\nScopingShim.prototype['flush'] = ScopingShim.prototype.flush;\nScopingShim.prototype['prepareTemplate'] = ScopingShim.prototype.prepareTemplate;\nScopingShim.prototype['styleElement'] = ScopingShim.prototype.styleElement;\nScopingShim.prototype['styleDocument'] = ScopingShim.prototype.styleDocument;\nScopingShim.prototype['styleSubtree'] = ScopingShim.prototype.styleSubtree;\nScopingShim.prototype['getComputedStyleValue'] = ScopingShim.prototype.getComputedStyleValue;\nScopingShim.prototype['setElementClass'] = ScopingShim.prototype.setElementClass;\nScopingShim.prototype['_styleInfoForNode'] = ScopingShim.prototype._styleInfoForNode;\nScopingShim.prototype['transformCustomStyleForDocument'] = ScopingShim.prototype.transformCustomStyleForDocument;\nScopingShim.prototype['getStyleAst'] = ScopingShim.prototype.getStyleAst;\nScopingShim.prototype['styleAstToString'] = ScopingShim.prototype.styleAstToString;\nScopingShim.prototype['flushCustomStyles'] = ScopingShim.prototype.flushCustomStyles;\nObject.defineProperties(ScopingShim.prototype, {\n  'nativeShadow': {\n    get() {\n      return nativeShadow;\n    }\n  },\n  'nativeCss': {\n    get() {\n      return nativeCssVariables;\n    }\n  }\n});","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport documentWait from './document-wait.js'\n\n/**\n * @typedef {HTMLStyleElement | {getStyle: function():HTMLStyleElement}}\n */\nexport let CustomStyleProvider;\n\nconst SEEN_MARKER = '__seenByShadyCSS';\nconst CACHED_STYLE = '__shadyCSSCachedStyle';\n\n/** @type {?function(!HTMLStyleElement)} */\nlet transformFn = null;\n\n/** @type {?function()} */\nlet validateFn = null;\n\n/**\nThis interface is provided to add document-level <style> elements to ShadyCSS for processing.\nThese styles must be processed by ShadyCSS to simulate ShadowRoot upper-bound encapsulation from outside styles\nIn addition, these styles may also need to be processed for @apply rules and CSS Custom Properties\n\nTo add document-level styles to ShadyCSS, one can call `ShadyCSS.addDocumentStyle(styleElement)` or `ShadyCSS.addDocumentStyle({getStyle: () => styleElement})`\n\nIn addition, if the process used to discover document-level styles can be synchronously flushed, one should set `ShadyCSS.documentStyleFlush`.\nThis function will be called when calculating styles.\n\nAn example usage of the document-level styling api can be found in `examples/document-style-lib.js`\n\n@unrestricted\n*/\nexport default class CustomStyleInterface {\n  constructor() {\n    /** @type {!Array<!CustomStyleProvider>} */\n    this['customStyles'] = [];\n    this['enqueued'] = false;\n  }\n  /**\n   * Queue a validation for new custom styles to batch style recalculations\n   */\n  enqueueDocumentValidation() {\n    if (this['enqueued'] || !validateFn) {\n      return;\n    }\n    this['enqueued'] = true;\n    documentWait(validateFn);\n  }\n  /**\n   * @param {!HTMLStyleElement} style\n   */\n  addCustomStyle(style) {\n    if (!style[SEEN_MARKER]) {\n      style[SEEN_MARKER] = true;\n      this['customStyles'].push(style);\n      this.enqueueDocumentValidation();\n    }\n  }\n  /**\n   * @param {!CustomStyleProvider} customStyle\n   * @return {HTMLStyleElement}\n   */\n  getStyleForCustomStyle(customStyle) {\n    if (customStyle[CACHED_STYLE]) {\n      return customStyle[CACHED_STYLE];\n    }\n    let style;\n    if (customStyle['getStyle']) {\n      style = customStyle['getStyle']();\n    } else {\n      style = customStyle;\n    }\n    return style;\n  }\n  /**\n   * @return {!Array<!CustomStyleProvider>}\n   */\n  processStyles() {\n    let cs = this['customStyles'];\n    for (let i = 0; i < cs.length; i++) {\n      let customStyle = cs[i];\n      if (customStyle[CACHED_STYLE]) {\n        continue;\n      }\n      let style = this.getStyleForCustomStyle(customStyle);\n      if (style) {\n        // HTMLImports polyfill may have cloned the style into the main document,\n        // which is referenced with __appliedElement.\n        // Also, we must copy over the attributes.\n        let appliedStyle = /** @type {HTMLStyleElement} */(style['__appliedElement']);\n        if (appliedStyle) {\n          for (let i = 0; i < style.attributes.length; i++) {\n            let attr = style.attributes[i];\n            appliedStyle.setAttribute(attr.name, attr.value);\n          }\n        }\n        let styleToTransform = appliedStyle || style;\n        if (transformFn) {\n          transformFn(styleToTransform);\n        }\n        customStyle[CACHED_STYLE] = styleToTransform;\n      }\n    }\n    return cs;\n  }\n}\n\nCustomStyleInterface.prototype['addCustomStyle'] = CustomStyleInterface.prototype.addCustomStyle;\nCustomStyleInterface.prototype['getStyleForCustomStyle'] = CustomStyleInterface.prototype.getStyleForCustomStyle;\nCustomStyleInterface.prototype['processStyles'] = CustomStyleInterface.prototype.processStyles;\n\nObject.defineProperties(CustomStyleInterface.prototype, {\n  'transformCallback': {\n    /** @return {?function(!HTMLStyleElement)} */\n    get() {\n      return transformFn;\n    },\n    /** @param {?function(!HTMLStyleElement)} fn */\n    set(fn) {\n      transformFn = fn;\n    }\n  },\n  'validateCallback': {\n    /** @return {?function()} */\n    get() {\n      return validateFn;\n    },\n    /**\n     * @param {?function()} fn\n     * @this {CustomStyleInterface}\n     */\n    set(fn) {\n      let needsEnqueue = false;\n      if (!validateFn) {\n        needsEnqueue = true;\n      }\n      validateFn = fn;\n      if (needsEnqueue) {\n        this.enqueueDocumentValidation();\n      }\n    },\n  }\n})\n\n/** @typedef {{\n * customStyles: !Array<!CustomStyleProvider>,\n * addCustomStyle: function(!CustomStyleProvider),\n * getStyleForCustomStyle: function(!CustomStyleProvider): HTMLStyleElement,\n * findStyles: function(),\n * transformCallback: ?function(!HTMLStyleElement),\n * validateCallback: ?function()\n * }}\n */\nexport let CustomStyleInterfaceInterface;","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {nativeShadow} from './style-settings.js'\nimport StyleTransformer from './style-transformer.js'\nimport {getIsExtends} from './style-util.js'\n\nexport let flush = function() {};\n\n/**\n * @param {HTMLElement} element\n * @return {!Array<string>}\n */\nfunction getClasses(element) {\n  let classes = [];\n  if (element.classList) {\n    classes = Array.from(element.classList);\n  } else if (element instanceof window['SVGElement'] && element.hasAttribute('class')) {\n    classes = element.getAttribute('class').split(/\\s+/);\n  }\n  return classes;\n}\n\n/**\n * @param {HTMLElement} element\n * @return {string}\n */\nfunction getCurrentScope(element) {\n  let classes = getClasses(element);\n  let idx = classes.indexOf(StyleTransformer.SCOPE_NAME);\n  if (idx > -1) {\n    return classes[idx + 1];\n  }\n  return '';\n}\n\n/**\n * @param {Array<MutationRecord|null>|null} mxns\n */\nfunction handler(mxns) {\n  for (let x=0; x < mxns.length; x++) {\n    let mxn = mxns[x];\n    if (mxn.target === document.documentElement ||\n      mxn.target === document.head) {\n      continue;\n    }\n    for (let i=0; i < mxn.addedNodes.length; i++) {\n      let n = mxn.addedNodes[i];\n      if (n.nodeType !== Node.ELEMENT_NODE) {\n        continue;\n      }\n      n = /** @type {HTMLElement} */(n); // eslint-disable-line no-self-assign\n      let root = n.getRootNode();\n      let currentScope = getCurrentScope(n);\n      // node was scoped, but now is in document\n      if (currentScope && root === n.ownerDocument) {\n        StyleTransformer.dom(n, currentScope, true);\n      } else if (root.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n        let newScope;\n        let host = /** @type {ShadowRoot} */(root).host;\n        // element may no longer be in a shadowroot\n        if (!host) {\n          continue;\n        }\n        newScope = getIsExtends(host).is;\n        if (currentScope === newScope) {\n          continue;\n        }\n        if (currentScope) {\n          StyleTransformer.dom(n, currentScope, true);\n        }\n        StyleTransformer.dom(n, newScope);\n      }\n    }\n  }\n}\n\nif (!nativeShadow) {\n  let observer = new MutationObserver(handler);\n  let start = (node) => {\n    observer.observe(node, {childList: true, subtree: true});\n  }\n  let nativeCustomElements = (window['customElements'] &&\n    !window['customElements']['polyfillWrapFlushCallback']);\n  // need to start immediately with native custom elements\n  // TODO(dfreedm): with polyfilled HTMLImports and native custom elements\n  // excessive mutations may be observed; this can be optimized via cooperation\n  // with the HTMLImports polyfill.\n  if (nativeCustomElements) {\n    start(document);\n  } else {\n    let delayedStart = () => {\n      start(document.body);\n    }\n    // use polyfill timing if it's available\n    if (window['HTMLImports']) {\n      window['HTMLImports']['whenReady'](delayedStart);\n    // otherwise push beyond native imports being ready\n    // which requires RAF + readystate interactive.\n    } else {\n      requestAnimationFrame(function() {\n        if (document.readyState === 'loading') {\n          let listener = function() {\n            delayedStart();\n            document.removeEventListener('readystatechange', listener);\n          }\n          document.addEventListener('readystatechange', listener);\n        } else {\n          delayedStart();\n        }\n      });\n    }\n  }\n\n  flush = function() {\n    handler(observer.takeRecords());\n  }\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n'use strict';\n\nexport default class StyleCache {\n  constructor(typeMax = 100) {\n    // map element name -> [{properties, styleElement, scopeSelector}]\n    this.cache = {};\n    this.typeMax = typeMax;\n  }\n\n  _validate(cacheEntry, properties, ownPropertyNames) {\n    for (let idx = 0; idx < ownPropertyNames.length; idx++) {\n      let pn = ownPropertyNames[idx];\n      if (cacheEntry.properties[pn] !== properties[pn]) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  store(tagname, properties, styleElement, scopeSelector) {\n    let list = this.cache[tagname] || [];\n    list.push({properties, styleElement, scopeSelector});\n    if (list.length > this.typeMax) {\n      list.shift();\n    }\n    this.cache[tagname] = list;\n  }\n\n  fetch(tagname, properties, ownPropertyNames) {\n    let list = this.cache[tagname];\n    if (!list) {\n      return;\n    }\n    // reverse list for most-recent lookups\n    for (let idx = list.length - 1; idx >= 0; idx--) {\n      let entry = list[idx];\n      if (this._validate(entry, properties, ownPropertyNames)) {\n        return entry;\n      }\n    }\n  }\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {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 * @const {function(string):boolean}\n */\nconst matchesSelector = ((p) => p.matches || p.matchesSelector ||\n  p.mozMatchesSelector || p.msMatchesSelector ||\np.oMatchesSelector || p.webkitMatchesSelector)(window.Element.prototype);\n\nconst IS_IE = navigator.userAgent.match('Trident');\n\nconst XSCOPE_NAME = 'x-scope';\n\nclass StyleProperties {\n  get XSCOPE_NAME() {\n    return XSCOPE_NAME;\n  }\n/**\n * decorates styles with rule info and returns an array of used style property names\n *\n * @param {StyleNode} rules\n * @return {Array<string>}\n */\n  decorateStyles(rules) {\n    let self = this, props = {}, keyframes = [], ruleIndex = 0;\n    StyleUtil.forEachRule(rules, function(rule) {\n      self.decorateRule(rule);\n      // mark in-order position of ast rule in styles block, used for cache key\n      rule.index = ruleIndex++;\n      self.collectPropertiesInCssText(rule.propertyInfo.cssText, props);\n    }, function onKeyframesRule(rule) {\n      keyframes.push(rule);\n    });\n    // Cache all found keyframes rules for later reference:\n    rules._keyframes = keyframes;\n    // return this list of property names *consumes* in these styles.\n    let names = [];\n    for (let i in props) {\n      names.push(i);\n    }\n    return names;\n  }\n\n  // decorate a single rule with property info\n  decorateRule(rule) {\n    if (rule.propertyInfo) {\n      return rule.propertyInfo;\n    }\n    let info = {}, properties = {};\n    let hasProperties = this.collectProperties(rule, properties);\n    if (hasProperties) {\n      info.properties = properties;\n      // TODO(sorvell): workaround parser seeing mixins as additional rules\n      rule['rules'] = null;\n    }\n    info.cssText = this.collectCssText(rule);\n    rule.propertyInfo = info;\n    return info;\n  }\n\n  // collects the custom properties from a rule's cssText\n  collectProperties(rule, properties) {\n    let info = rule.propertyInfo;\n    if (info) {\n      if (info.properties) {\n        Object.assign(properties, info.properties);\n        return true;\n      }\n    } else {\n      let m, rx = RX.VAR_ASSIGN;\n      let cssText = rule['parsedCssText'];\n      let value;\n      let any;\n      while ((m = rx.exec(cssText))) {\n        // note: group 2 is var, 3 is mixin\n        value = (m[2] || m[3]).trim();\n        // value of 'inherit' or 'unset' is equivalent to not setting the property here\n        if (value !== 'inherit' || value !== 'unset') {\n          properties[m[1].trim()] = value;\n        }\n        any = true;\n      }\n      return any;\n    }\n\n  }\n\n  // returns cssText of properties that consume variables/mixins\n  collectCssText(rule) {\n    return this.collectConsumingCssText(rule['parsedCssText']);\n  }\n\n  // NOTE: we support consumption inside mixin assignment\n  // but not production, so strip out {...}\n  collectConsumingCssText(cssText) {\n    return cssText.replace(RX.BRACKETED, '')\n      .replace(RX.VAR_ASSIGN, '');\n  }\n\n  collectPropertiesInCssText(cssText, props) {\n    let m;\n    while ((m = RX.VAR_CONSUMED.exec(cssText))) {\n      let name = m[1];\n      // This regex catches all variable names, and following non-whitespace char\n      // If next char is not ':', then variable is a consumer\n      if (m[2] !== ':') {\n        props[name] = true;\n      }\n    }\n  }\n\n  // turns custom properties into realized values.\n  reify(props) {\n    // big perf optimization here: reify only *own* properties\n    // since this object has __proto__ of the element's scope properties\n    let names = Object.getOwnPropertyNames(props);\n    for (let i=0, n; i < names.length; i++) {\n      n = names[i];\n      props[n] = this.valueForProperty(props[n], props);\n    }\n  }\n\n  // given a property value, returns the reified value\n  // a property value may be:\n  // (1) a literal value like: red or 5px;\n  // (2) a variable value like: var(--a), var(--a, red), or var(--a, --b) or\n  // var(--a, var(--b));\n  // (3) a literal mixin value like { properties }. Each of these properties\n  // can have values that are: (a) literal, (b) variables, (c) @apply mixins.\n  valueForProperty(property, props) {\n    // case (1) default\n    // case (3) defines a mixin and we have to reify the internals\n    if (property) {\n      if (property.indexOf(';') >=0) {\n        property = this.valueForProperties(property, props);\n      } else {\n        // case (2) variable\n        let self = this;\n        let fn = function(prefix, value, fallback, suffix) {\n          if (!value) {\n            return prefix + suffix;\n          }\n          let propertyValue = self.valueForProperty(props[value], props);\n          // if value is \"initial\", then the variable should be treated as unset\n          if (!propertyValue || propertyValue === 'initial') {\n            // fallback may be --a or var(--a) or literal\n            propertyValue = self.valueForProperty(props[fallback] || fallback, props) ||\n            fallback;\n          } else if (propertyValue === 'apply-shim-inherit') {\n            // CSS build will replace `inherit` with `apply-shim-inherit`\n            // for use with native css variables.\n            // Since we have full control, we can use `inherit` directly.\n            propertyValue = 'inherit';\n          }\n          return prefix + (propertyValue || '') + suffix;\n        };\n        property = StyleUtil.processVariableAndFallback(property, fn);\n      }\n    }\n    return property && property.trim() || '';\n  }\n\n  // note: we do not yet support mixin within mixin\n  valueForProperties(property, props) {\n    let parts = property.split(';');\n    for (let i=0, p, m; i<parts.length; i++) {\n      if ((p = parts[i])) {\n        RX.MIXIN_MATCH.lastIndex = 0;\n        m = RX.MIXIN_MATCH.exec(p);\n        if (m) {\n          p = this.valueForProperty(props[m[1]], props);\n        } else {\n          let colon = p.indexOf(':');\n          if (colon !== -1) {\n            let pp = p.substring(colon);\n            pp = pp.trim();\n            pp = this.valueForProperty(pp, props) || pp;\n            p = p.substring(0, colon) + pp;\n          }\n        }\n        parts[i] = (p && p.lastIndexOf(';') === p.length - 1) ?\n          // strip trailing ;\n          p.slice(0, -1) :\n          p || '';\n      }\n    }\n    return parts.join(';');\n  }\n\n  applyProperties(rule, props) {\n    let output = '';\n    // dynamically added sheets may not be decorated so ensure they are.\n    if (!rule.propertyInfo) {\n      this.decorateRule(rule);\n    }\n    if (rule.propertyInfo.cssText) {\n      output = this.valueForProperties(rule.propertyInfo.cssText, props);\n    }\n    rule['cssText'] = output;\n  }\n\n  // Apply keyframe transformations to the cssText of a given rule. The\n  // keyframeTransforms object is a map of keyframe names to transformer\n  // functions which take in cssText and spit out transformed cssText.\n  applyKeyframeTransforms(rule, keyframeTransforms) {\n    let input = rule['cssText'];\n    let output = rule['cssText'];\n    if (rule.hasAnimations == null) {\n      // Cache whether or not the rule has any animations to begin with:\n      rule.hasAnimations = RX.ANIMATION_MATCH.test(input);\n    }\n    // If there are no animations referenced, we can skip transforms:\n    if (rule.hasAnimations) {\n      let transform;\n      // If we haven't transformed this rule before, we iterate over all\n      // transforms:\n      if (rule.keyframeNamesToTransform == null) {\n        rule.keyframeNamesToTransform = [];\n        for (let keyframe in keyframeTransforms) {\n          transform = keyframeTransforms[keyframe];\n          output = transform(input);\n          // If the transform actually changed the CSS text, we cache the\n          // transform name for future use:\n          if (input !== output) {\n            input = output;\n            rule.keyframeNamesToTransform.push(keyframe);\n          }\n        }\n      } else {\n        // If we already have a list of keyframe names that apply to this\n        // rule, we apply only those keyframe name transforms:\n        for (let i = 0; i < rule.keyframeNamesToTransform.length; ++i) {\n          transform = keyframeTransforms[rule.keyframeNamesToTransform[i]];\n          input = transform(input);\n        }\n        output = input;\n      }\n    }\n    rule['cssText'] = output;\n  }\n\n  // Test if the rules in these styles matches the given `element` and if so,\n  // collect any custom properties into `props`.\n  /**\n   * @param {StyleNode} rules\n   * @param {Element} element\n   */\n  propertyDataFromStyles(rules, element) {\n    let props = {}, self = this;\n    // generates a unique key for these matches\n    let o = [];\n    // note: active rules excludes non-matching @media rules\n    StyleUtil.forEachRule(rules, function(rule) {\n      // TODO(sorvell): we could trim the set of rules at declaration\n      // time to only include ones that have properties\n      if (!rule.propertyInfo) {\n        self.decorateRule(rule);\n      }\n      // match element against transformedSelector: selector may contain\n      // unwanted uniquification and parsedSelector does not directly match\n      // for :host selectors.\n      let selectorToMatch = rule.transformedSelector || rule['parsedSelector'];\n      if (element && rule.propertyInfo.properties && selectorToMatch) {\n        if (matchesSelector.call(element, selectorToMatch)) {\n          self.collectProperties(rule, props);\n          // produce numeric key for these matches for lookup\n          addToBitMask(rule.index, o);\n        }\n      }\n    }, null, true);\n    return {properties: props, key: o};\n  }\n\n  /**\n   * @param {Element} scope\n   * @param {StyleNode} rule\n   * @param {string|undefined} cssBuild\n   * @param {function(Object)} callback\n   */\n  whenHostOrRootRule(scope, rule, cssBuild, callback) {\n    if (!rule.propertyInfo) {\n      this.decorateRule(rule);\n    }\n    if (!rule.propertyInfo.properties) {\n      return;\n    }\n    let {is, typeExtension} = StyleUtil.getIsExtends(scope);\n    let hostScope = is ?\n      StyleTransformer._calcHostScope(is, typeExtension) :\n      'html';\n    let parsedSelector = rule['parsedSelector'];\n    let isRoot = (parsedSelector === ':host > *' || parsedSelector === 'html');\n    let isHost = parsedSelector.indexOf(':host') === 0 && !isRoot;\n    // build info is either in scope (when scope is an element) or in the style\n    // when scope is the default scope; note: this allows default scope to have\n    // mixed mode built and unbuilt styles.\n    if (cssBuild === 'shady') {\n      // :root -> x-foo > *.x-foo for elements and html for custom-style\n      isRoot = parsedSelector === (hostScope + ' > *.' + hostScope) || parsedSelector.indexOf('html') !== -1;\n      // :host -> x-foo for elements, but sub-rules have .x-foo in them\n      isHost = !isRoot && parsedSelector.indexOf(hostScope) === 0;\n    }\n    if (cssBuild === 'shadow') {\n      isRoot = parsedSelector === ':host > *' || parsedSelector === 'html';\n      isHost = isHost && !isRoot;\n    }\n    if (!isRoot && !isHost) {\n      return;\n    }\n    let selectorToMatch = hostScope;\n    if (isHost) {\n      // need to transform :host under ShadowDOM because `:host` does not work with `matches`\n      if (nativeShadow && !rule.transformedSelector) {\n        // transform :host into a matchable selector\n        rule.transformedSelector =\n        StyleTransformer._transformRuleCss(\n          rule,\n          StyleTransformer._transformComplexSelector,\n          StyleTransformer._calcElementScope(is),\n          hostScope\n        );\n      }\n      selectorToMatch = rule.transformedSelector || hostScope;\n    }\n    callback({\n      selector: selectorToMatch,\n      isHost: isHost,\n      isRoot: isRoot\n    });\n  }\n/**\n * @param {Element} scope\n * @param {StyleNode} rules\n * @return {Object}\n */\n  hostAndRootPropertiesForScope(scope, rules) {\n    let hostProps = {}, rootProps = {}, self = this;\n    // note: active rules excludes non-matching @media rules\n    let cssBuild = rules && rules['__cssBuild'];\n    StyleUtil.forEachRule(rules, function(rule) {\n      // if scope is StyleDefaults, use _element for matchesSelector\n      self.whenHostOrRootRule(scope, rule, cssBuild, function(info) {\n        let element = scope._element || scope;\n        if (matchesSelector.call(element, info.selector)) {\n          if (info.isHost) {\n            self.collectProperties(rule, hostProps);\n          } else {\n            self.collectProperties(rule, rootProps);\n          }\n        }\n      });\n    }, null, true);\n    return {rootProps: rootProps, hostProps: hostProps};\n  }\n\n  /**\n   * @param {Element} element\n   * @param {Object} properties\n   * @param {string} scopeSelector\n   */\n  transformStyles(element, properties, scopeSelector) {\n    let self = this;\n    let {is, typeExtension} = StyleUtil.getIsExtends(element);\n    let hostSelector = StyleTransformer\n      ._calcHostScope(is, typeExtension);\n    let rxHostSelector = element.extends ?\n      '\\\\' + hostSelector.slice(0, -1) + '\\\\]' :\n      hostSelector;\n    let hostRx = new RegExp(RX.HOST_PREFIX + rxHostSelector +\n      RX.HOST_SUFFIX);\n    let rules = StyleInfo.get(element).styleRules;\n    let keyframeTransforms =\n      this._elementKeyframeTransforms(element, rules, scopeSelector);\n    return StyleTransformer.elementStyles(element, rules, function(rule) {\n      self.applyProperties(rule, properties);\n      if (!nativeShadow &&\n          !StyleUtil.isKeyframesSelector(rule) &&\n          rule['cssText']) {\n        // NOTE: keyframe transforms only scope munge animation names, so it\n        // is not necessary to apply them in ShadowDOM.\n        self.applyKeyframeTransforms(rule, keyframeTransforms);\n        self._scopeSelector(rule, hostRx, hostSelector, scopeSelector);\n      }\n    });\n  }\n\n  /**\n   * @param {Element} element\n   * @param {StyleNode} rules\n   * @param {string} scopeSelector\n   * @return {Object}\n   */\n  _elementKeyframeTransforms(element, rules, scopeSelector) {\n    let keyframesRules = rules._keyframes;\n    let keyframeTransforms = {};\n    if (!nativeShadow && keyframesRules) {\n      // For non-ShadowDOM, we transform all known keyframes rules in\n      // advance for the current scope. This allows us to catch keyframes\n      // rules that appear anywhere in the stylesheet:\n      for (let i = 0, keyframesRule = keyframesRules[i];\n           i < keyframesRules.length;\n           keyframesRule = keyframesRules[++i]) {\n        this._scopeKeyframes(keyframesRule, scopeSelector);\n        keyframeTransforms[keyframesRule['keyframesName']] =\n            this._keyframesRuleTransformer(keyframesRule);\n      }\n    }\n    return keyframeTransforms;\n  }\n\n  // Generate a factory for transforming a chunk of CSS text to handle a\n  // particular scoped keyframes rule.\n  /**\n   * @param {StyleNode} keyframesRule\n   * @return {function(string):string}\n   */\n  _keyframesRuleTransformer(keyframesRule) {\n    return function(cssText) {\n      return cssText.replace(\n          keyframesRule.keyframesNameRx,\n          keyframesRule.transformedKeyframesName);\n    };\n  }\n\n/**\n * Transforms `@keyframes` names to be unique for the current host.\n * Example: @keyframes foo-anim -> @keyframes foo-anim-x-foo-0\n *\n * @param {StyleNode} rule\n * @param {string} scopeId\n */\n  _scopeKeyframes(rule, scopeId) {\n    rule.keyframesNameRx = new RegExp(rule['keyframesName'], 'g');\n    rule.transformedKeyframesName = rule['keyframesName'] + '-' + scopeId;\n    rule.transformedSelector = rule.transformedSelector || rule['selector'];\n    rule['selector'] = rule.transformedSelector.replace(\n        rule['keyframesName'], rule.transformedKeyframesName);\n  }\n\n  // Strategy: x scope shim a selector e.g. to scope `.x-foo-42` (via classes):\n  // non-host selector: .a.x-foo -> .x-foo-42 .a.x-foo\n  // host selector: x-foo.wide -> .x-foo-42.wide\n  // note: we use only the scope class (.x-foo-42) and not the hostSelector\n  // (x-foo) to scope :host rules; this helps make property host rules\n  // have low specificity. They are overrideable by class selectors but,\n  // unfortunately, not by type selectors (e.g. overriding via\n  // `.special` is ok, but not by `x-foo`).\n  /**\n   * @param {StyleNode} rule\n   * @param {RegExp} hostRx\n   * @param {string} hostSelector\n   * @param {string} scopeId\n   */\n  _scopeSelector(rule, hostRx, hostSelector, scopeId) {\n    rule.transformedSelector = rule.transformedSelector || rule['selector'];\n    let selector = rule.transformedSelector;\n    let scope = '.' + scopeId;\n    let parts = selector.split(',');\n    for (let i=0, l=parts.length, p; (i<l) && (p=parts[i]); i++) {\n      parts[i] = p.match(hostRx) ?\n        p.replace(hostSelector, scope) :\n        scope + ' ' + p;\n    }\n    rule['selector'] = parts.join(',');\n  }\n\n  /**\n   * @param {Element} element\n   * @param {string} selector\n   * @param {string} old\n   */\n  applyElementScopeSelector(element, selector, old) {\n    let c = element.getAttribute('class') || '';\n    let v = c;\n    if (old) {\n      v = c.replace(\n        new RegExp('\\\\s*' + XSCOPE_NAME + '\\\\s*' + old + '\\\\s*', 'g'), ' ');\n    }\n    v += (v ? ' ' : '') + XSCOPE_NAME + ' ' + selector;\n    if (c !== v) {\n      StyleUtil.setElementClassRaw(element, v);\n    }\n  }\n\n  /**\n   * @param {HTMLElement} element\n   * @param {Object} properties\n   * @param {string} selector\n   * @param {HTMLStyleElement} style\n   * @return {HTMLStyleElement}\n   */\n  applyElementStyle(element, properties, selector, style) {\n    // calculate cssText to apply\n    let cssText = style ? style.textContent || '' :\n      this.transformStyles(element, properties, selector);\n    // if shady and we have a cached style that is not style, decrement\n    let styleInfo = StyleInfo.get(element);\n    let s = styleInfo.customStyle;\n    if (s && !nativeShadow && (s !== style)) {\n      s['_useCount']--;\n      if (s['_useCount'] <= 0 && s.parentNode) {\n        s.parentNode.removeChild(s);\n      }\n    }\n    // apply styling always under native or if we generated style\n    // or the cached style is not in document(!)\n    if (nativeShadow) {\n      // update existing style only under native\n      if (styleInfo.customStyle) {\n        styleInfo.customStyle.textContent = cssText;\n        style = styleInfo.customStyle;\n      // otherwise, if we have css to apply, do so\n      } else if (cssText) {\n        // apply css after the scope style of the element to help with\n        // style precedence rules.\n        style = StyleUtil.applyCss(cssText, selector, element.shadowRoot,\n          styleInfo.placeholder);\n      }\n    } else {\n      // shady and no cache hit\n      if (!style) {\n        // apply css after the scope style of the element to help with\n        // style precedence rules.\n        if (cssText) {\n          style = StyleUtil.applyCss(cssText, selector, null,\n            styleInfo.placeholder);\n        }\n      // shady and cache hit but not in document\n      } else if (!style.parentNode) {\n        if (IS_IE && cssText.indexOf('@media') > -1) {\n            // @media rules may be stale in IE 10 and 11\n            // refresh the text content of the style to revalidate them.\n          style.textContent = cssText;\n        }\n        StyleUtil.applyStyle(style, null, styleInfo.placeholder);\n      }\n    }\n    // ensure this style is our custom style and increment its use count.\n    if (style) {\n      style['_useCount'] = style['_useCount'] || 0;\n      // increment use count if we changed styles\n      if (styleInfo.customStyle != style) {\n        style['_useCount']++;\n      }\n      styleInfo.customStyle = style;\n    }\n    return style;\n  }\n\n  /**\n   * @param {Element} style\n   * @param {Object} properties\n   */\n  applyCustomStyle(style, properties) {\n    let rules = StyleUtil.rulesForStyle(/** @type {HTMLStyleElement} */(style));\n    let self = this;\n    style.textContent = StyleUtil.toCssText(rules, function(/** StyleNode */rule) {\n      let css = rule['cssText'] = rule['parsedCssText'];\n      if (rule.propertyInfo && rule.propertyInfo.cssText) {\n        // remove property assignments\n        // so next function isn't confused\n        // NOTE: we have 3 categories of css:\n        // (1) normal properties,\n        // (2) custom property assignments (--foo: red;),\n        // (3) custom property usage: border: var(--foo); @apply(--foo);\n        // In elements, 1 and 3 are separated for efficiency; here they\n        // are not and this makes this case unique.\n        css = removeCustomPropAssignment(/** @type {string} */(css));\n        // replace with reified properties, scenario is same as mixin\n        rule['cssText'] = self.valueForProperties(css, properties);\n      }\n    });\n  }\n}\n\n/**\n * @param {number} n\n * @param {Array<number>} bits\n */\nfunction addToBitMask(n, bits) {\n  let o = parseInt(n / 32, 10);\n  let v = 1 << (n % 32);\n  bits[o] = (bits[o] || 0) | v;\n}\n\nexport default new StyleProperties();","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {StyleNode} from './css-parse.js' // eslint-disable-line no-unused-vars\n\n/** @const {string} */\nconst infoKey = '__styleInfo';\n\nexport default class StyleInfo {\n  /**\n   * @param {Element} node\n   * @return {StyleInfo}\n   */\n  static get(node) {\n    if (node) {\n      return node[infoKey];\n    } else {\n      return null;\n    }\n  }\n  /**\n   * @param {!Element} node\n   * @param {StyleInfo} styleInfo\n   * @return {StyleInfo}\n   */\n  static set(node, styleInfo) {\n    node[infoKey] = styleInfo;\n    return styleInfo;\n  }\n  /**\n   * @param {StyleNode} ast\n   * @param {Node=} placeholder\n   * @param {Array<string>=} ownStylePropertyNames\n   * @param {string=} elementName\n   * @param {string=} typeExtension\n   * @param {string=} cssBuild\n   */\n  constructor(ast, placeholder, ownStylePropertyNames, elementName, typeExtension, cssBuild) {\n    /** @type {StyleNode} */\n    this.styleRules = ast || null;\n    /** @type {Node} */\n    this.placeholder = placeholder || null;\n    /** @type {!Array<string>} */\n    this.ownStylePropertyNames = ownStylePropertyNames || [];\n    /** @type {Array<Object>} */\n    this.overrideStyleProperties = null;\n    /** @type {string} */\n    this.elementName = elementName || '';\n    /** @type {string} */\n    this.cssBuild = cssBuild || '';\n    /** @type {string} */\n    this.typeExtension = typeExtension || '';\n    /** @type {Object<string, string>} */\n    this.styleProperties = null;\n    /** @type {?string} */\n    this.scopeSelector = null;\n    /** @type {HTMLStyleElement} */\n    this.customStyle = null;\n  }\n  _getStyleRules() {\n    return this.styleRules;\n  }\n}\n\nStyleInfo.prototype['_getStyleRules'] = StyleInfo.prototype._getStyleRules;","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {StyleNode} from './css-parse.js' // eslint-disable-line no-unused-vars\nimport * as StyleUtil from './style-util.js'\nimport {nativeShadow} from './style-settings.js'\n\n/* Transforms ShadowDOM styling into ShadyDOM styling\n\n* scoping:\n\n  * elements in scope get scoping selector class=\"x-foo-scope\"\n  * selectors re-written as follows:\n\n    div button -> div.x-foo-scope button.x-foo-scope\n\n* :host -> scopeName\n\n* :host(...) -> scopeName...\n\n* ::slotted(...) -> scopeName > ...\n\n* ...:dir(ltr|rtl) -> [dir=\"ltr|rtl\"] ..., ...[dir=\"ltr|rtl\"]\n\n* :host(:dir[rtl]) -> scopeName:dir(rtl) -> [dir=\"rtl\"] scopeName, scopeName[dir=\"rtl\"]\n\n*/\nconst SCOPE_NAME = 'style-scope';\n\nclass StyleTransformer {\n  get SCOPE_NAME() {\n    return SCOPE_NAME;\n  }\n  // Given a node and scope name, add a scoping class to each node\n  // in the tree. This facilitates transforming css into scoped rules.\n  dom(node, scope, shouldRemoveScope) {\n    // one time optimization to skip scoping...\n    if (node['__styleScoped']) {\n      node['__styleScoped'] = null;\n    } else {\n      this._transformDom(node, scope || '', shouldRemoveScope);\n    }\n  }\n\n  _transformDom(node, selector, shouldRemoveScope) {\n    if (node.nodeType === Node.ELEMENT_NODE) {\n      this.element(node, selector, shouldRemoveScope);\n    }\n    let c$ = (node.localName === 'template') ?\n      (node.content || node._content).childNodes :\n      node.children || node.childNodes;\n    if (c$) {\n      for (let i=0; i<c$.length; i++) {\n        this._transformDom(c$[i], selector, shouldRemoveScope);\n      }\n    }\n  }\n\n  element(element, scope, shouldRemoveScope) {\n    // note: if using classes, we add both the general 'style-scope' class\n    // as well as the specific scope. This enables easy filtering of all\n    // `style-scope` elements\n    if (scope) {\n      // note: svg on IE does not have classList so fallback to class\n      if (element.classList) {\n        if (shouldRemoveScope) {\n          element.classList.remove(SCOPE_NAME);\n          element.classList.remove(scope);\n        } else {\n          element.classList.add(SCOPE_NAME);\n          element.classList.add(scope);\n        }\n      } else if (element.getAttribute) {\n        let c = element.getAttribute(CLASS);\n        if (shouldRemoveScope) {\n          if (c) {\n            let newValue = c.replace(SCOPE_NAME, '').replace(scope, '');\n            StyleUtil.setElementClassRaw(element, newValue);\n          }\n        } else {\n          let newValue = (c ? c + ' ' : '') + SCOPE_NAME + ' ' + scope;\n          StyleUtil.setElementClassRaw(element, newValue);\n        }\n      }\n    }\n  }\n\n  elementStyles(element, styleRules, callback) {\n    let cssBuildType = element['__cssBuild'];\n    // no need to shim selectors if settings.useNativeShadow, also\n    // a shady css build will already have transformed selectors\n    // NOTE: This method may be called as part of static or property shimming.\n    // When there is a targeted build it will not be called for static shimming,\n    // but when the property shim is used it is called and should opt out of\n    // static shimming work when a proper build exists.\n    let cssText = '';\n    if (nativeShadow || cssBuildType === 'shady') {\n      cssText = StyleUtil.toCssText(styleRules, callback);\n    } else {\n      let {is, typeExtension} = StyleUtil.getIsExtends(element);\n      cssText = this.css(styleRules, is, typeExtension, callback) + '\\n\\n';\n    }\n    return cssText.trim();\n  }\n\n  // Given a string of cssText and a scoping string (scope), returns\n  // a string of scoped css where each selector is transformed to include\n  // a class created from the scope. ShadowDOM selectors are also transformed\n  // (e.g. :host) to use the scoping selector.\n  css(rules, scope, ext, callback) {\n    let hostScope = this._calcHostScope(scope, ext);\n    scope = this._calcElementScope(scope);\n    let self = this;\n    return StyleUtil.toCssText(rules, function(/** StyleNode */rule) {\n      if (!rule.isScoped) {\n        self.rule(rule, scope, hostScope);\n        rule.isScoped = true;\n      }\n      if (callback) {\n        callback(rule, scope, hostScope);\n      }\n    });\n  }\n\n  _calcElementScope(scope) {\n    if (scope) {\n      return CSS_CLASS_PREFIX + scope;\n    } else {\n      return '';\n    }\n  }\n\n  _calcHostScope(scope, ext) {\n    return ext ? `[is=${scope}]` : scope;\n  }\n\n  rule(rule, scope, hostScope) {\n    this._transformRule(rule, this._transformComplexSelector,\n      scope, hostScope);\n  }\n\n  /**\n   * transforms a css rule to a scoped rule.\n   *\n   * @param {StyleNode} rule\n   * @param {Function} transformer\n   * @param {string=} scope\n   * @param {string=} hostScope\n   */\n  _transformRule(rule, transformer, scope, hostScope) {\n    // NOTE: save transformedSelector for subsequent matching of elements\n    // against selectors (e.g. when calculating style properties)\n    rule['selector'] = rule.transformedSelector =\n      this._transformRuleCss(rule, transformer, scope, hostScope);\n  }\n\n  /**\n   * @param {StyleNode} rule\n   * @param {Function} transformer\n   * @param {string=} scope\n   * @param {string=} hostScope\n   */\n  _transformRuleCss(rule, transformer, scope, hostScope) {\n    let p$ = rule['selector'].split(COMPLEX_SELECTOR_SEP);\n    // we want to skip transformation of rules that appear in keyframes,\n    // because they are keyframe selectors, not element selectors.\n    if (!StyleUtil.isKeyframesSelector(rule)) {\n      for (let i=0, l=p$.length, p; (i<l) && (p=p$[i]); i++) {\n        p$[i] = transformer.call(this, p, scope, hostScope);\n      }\n    }\n    return p$.join(COMPLEX_SELECTOR_SEP);\n  }\n\n/**\n * @param {string} selector\n * @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    selector = selector.replace(NTH, (m, type, inner) => `:${type}(${inner.replace(/\\s/g, '')})`);\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    return selector;\n  }\n\n  _transformCompoundSelector(selector, combinator, scope, hostScope) {\n    // replace :host with host scoping class\n    let slottedIndex = selector.indexOf(SLOTTED);\n    if (selector.indexOf(HOST) >= 0) {\n      selector = this._transformHostSelector(selector, hostScope);\n    // replace other selectors with scoping class\n    } else if (slottedIndex !== 0) {\n      selector = scope ? this._transformSimpleSelector(selector, scope) :\n        selector;\n    }\n    // mark ::slotted() scope jump to replace with descendant selector + arg\n    // also ignore left-side combinator\n    let slotted = false;\n    if (slottedIndex >= 0) {\n      combinator = '';\n      slotted = true;\n    }\n    // process scope jumping selectors up to the scope jump and then stop\n    let stop;\n    if (slotted) {\n      stop = true;\n      if (slotted) {\n        // .zonk ::slotted(.foo) -> .zonk.scope > .foo\n        selector = selector.replace(SLOTTED_PAREN, (m, paren) => ` > ${paren}`);\n      }\n    }\n    selector = selector.replace(DIR_PAREN, (m, before, dir) =>\n      `[dir=\"${dir}\"] ${before}, ${before}[dir=\"${dir}\"]`);\n    return {value: selector, combinator, stop};\n  }\n\n  _transformSimpleSelector(selector, scope) {\n    let p$ = selector.split(PSEUDO_PREFIX);\n    p$[0] += scope;\n    return p$.join(PSEUDO_PREFIX);\n  }\n\n  // :host(...) -> scopeName...\n  _transformHostSelector(selector, hostScope) {\n    let m = selector.match(HOST_PAREN);\n    let paren = m && m[2].trim() || '';\n    if (paren) {\n      if (!paren[0].match(SIMPLE_SELECTOR_PREFIX)) {\n        // paren starts with a type selector\n        let typeSelector = paren.split(SIMPLE_SELECTOR_PREFIX)[0];\n        // if the type selector is our hostScope then avoid pre-pending it\n        if (typeSelector === hostScope) {\n          return paren;\n        // otherwise, this selector should not match in this scope so\n        // output a bogus selector.\n        } else {\n          return SELECTOR_NO_MATCH;\n        }\n      } else {\n        // make sure to do a replace here to catch selectors like:\n        // `:host(.foo)::before`\n        return selector.replace(HOST_PAREN, function(m, host, paren) {\n          return hostScope + paren;\n        });\n      }\n    // if no paren, do a straight :host replacement.\n    // TODO(sorvell): this should not strictly be necessary but\n    // it's needed to maintain support for `:host[foo]` type selectors\n    // which have been improperly used under Shady DOM. This should be\n    // deprecated.\n    } else {\n      return selector.replace(HOST, hostScope);\n    }\n  }\n\n  /**\n   * @param {StyleNode} rule\n   */\n  documentRule(rule) {\n    // reset selector in case this is redone.\n    rule['selector'] = rule['parsedSelector'];\n    this.normalizeRootSelector(rule);\n    this._transformRule(rule, this._transformDocumentSelector);\n  }\n\n  /**\n   * @param {StyleNode} rule\n   */\n  normalizeRootSelector(rule) {\n    if (rule['selector'] === ROOT) {\n      rule['selector'] = 'html';\n    }\n  }\n\n/**\n * @param {string} selector\n */\n  _transformDocumentSelector(selector) {\n    return selector.match(SLOTTED) ?\n      this._transformComplexSelector(selector, SCOPE_DOC_SELECTOR) :\n      this._transformSimpleSelector(selector.trim(), SCOPE_DOC_SELECTOR);\n  }\n}\n\nlet NTH = /:(nth[-\\w]+)\\(([^)]+)\\)/;\nlet SCOPE_DOC_SELECTOR = `:not(.${SCOPE_NAME})`;\nlet COMPLEX_SELECTOR_SEP = ',';\nlet SIMPLE_SELECTOR_SEP = /(^|[\\s>+~]+)((?:\\[.+?\\]|[^\\s>+~=\\[])+)/g;\nlet SIMPLE_SELECTOR_PREFIX = /[[.:#*]/;\nlet HOST = ':host';\nlet ROOT = ':root';\nlet SLOTTED = '::slotted';\nlet SLOTTED_START = new RegExp(`^(${SLOTTED})`);\n// NOTE: this supports 1 nested () pair for things like\n// :host(:not([selected]), more general support requires\n// parsing which seems like overkill\nlet HOST_PAREN = /(:host)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))/;\n// similar to HOST_PAREN\nlet SLOTTED_PAREN = /(?:::slotted)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))/;\nlet DIR_PAREN = /(.*):dir\\((?:(ltr|rtl))\\)/;\nlet CSS_CLASS_PREFIX = '.';\nlet PSEUDO_PREFIX = ':';\nlet CLASS = 'class';\nlet SELECTOR_NO_MATCH = 'should_not_match';\n\nexport default new StyleTransformer()","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n/*\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","import Native from './Native.js';\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport CEState from '../CustomElementState.js';\nimport * as Utilities from '../Utilities.js';\n\nimport PatchParentNode from './Interface/ParentNode.js';\nimport PatchChildNode from './Interface/ChildNode.js';\n\n/**\n * @param {!CustomElementInternals} internals\n */\nexport default function(internals) {\n  if (Native.Element_attachShadow) {\n    Utilities.setPropertyUnchecked(Element.prototype, 'attachShadow',\n      /**\n       * @this {Element}\n       * @param {!{mode: string}} init\n       * @return {ShadowRoot}\n       */\n      function(init) {\n        const shadowRoot = Native.Element_attachShadow.call(this, init);\n        this.__CE_shadowRoot = shadowRoot;\n        return shadowRoot;\n      });\n  } else {\n    console.warn('Custom Elements: `Element#attachShadow` was not patched.');\n  }\n\n\n  function patch_innerHTML(destination, baseDescriptor) {\n    Object.defineProperty(destination, 'innerHTML', {\n      enumerable: baseDescriptor.enumerable,\n      configurable: true,\n      get: baseDescriptor.get,\n      set: /** @this {Element} */ function(htmlString) {\n        const isConnected = Utilities.isConnected(this);\n\n        // NOTE: In IE11, when using the native `innerHTML` setter, all nodes\n        // that were previously descendants of the context element have all of\n        // their children removed as part of the set - the entire subtree is\n        // 'disassembled'. This work around walks the subtree *before* using the\n        // native setter.\n        /** @type {!Array<!Element>|undefined} */\n        let removedElements = undefined;\n        if (isConnected) {\n          removedElements = [];\n          Utilities.walkDeepDescendantElements(this, element => {\n            if (element !== this) {\n              removedElements.push(element);\n            }\n          });\n        }\n\n        baseDescriptor.set.call(this, htmlString);\n\n        if (removedElements) {\n          for (let i = 0; i < removedElements.length; i++) {\n            const element = removedElements[i];\n            if (element.__CE_state === CEState.custom) {\n              internals.disconnectedCallback(element);\n            }\n          }\n        }\n\n        // Only create custom elements if this element's owner document is\n        // associated with the registry.\n        if (!this.ownerDocument.__CE_hasRegistry) {\n          internals.patchTree(this);\n        } else {\n          internals.patchAndUpgradeTree(this);\n        }\n        return htmlString;\n      },\n    });\n  }\n\n  if (Native.Element_innerHTML && Native.Element_innerHTML.get) {\n    patch_innerHTML(Element.prototype, Native.Element_innerHTML);\n  } else if (Native.HTMLElement_innerHTML && Native.HTMLElement_innerHTML.get) {\n    patch_innerHTML(HTMLElement.prototype, Native.HTMLElement_innerHTML);\n  } else {\n\n    /** @type {HTMLDivElement} */\n    const rawDiv = Native.Document_createElement.call(document, 'div');\n\n    internals.addPatch(function(element) {\n      patch_innerHTML(element, {\n        enumerable: true,\n        configurable: true,\n        // Implements getting `innerHTML` by performing an unpatched `cloneNode`\n        // of the element and returning the resulting element's `innerHTML`.\n        // TODO: Is this too expensive?\n        get: /** @this {Element} */ function() {\n          return Native.Node_cloneNode.call(this, true).innerHTML;\n        },\n        // Implements setting `innerHTML` by creating an unpatched element,\n        // setting `innerHTML` of that element and replacing the target\n        // element's children with those of the unpatched element.\n        set: /** @this {Element} */ function(assignedValue) {\n          // NOTE: re-route to `content` for `template` elements.\n          // We need to do this because `template.appendChild` does not\n          // route into `template.content`.\n          /** @type {!Node} */\n          const content = this.localName === 'template' ? (/** @type {!HTMLTemplateElement} */ (this)).content : this;\n          rawDiv.innerHTML = assignedValue;\n\n          while (content.childNodes.length > 0) {\n            Native.Node_removeChild.call(content, content.childNodes[0]);\n          }\n          while (rawDiv.childNodes.length > 0) {\n            Native.Node_appendChild.call(content, rawDiv.childNodes[0]);\n          }\n        },\n      });\n    });\n  }\n\n\n  Utilities.setPropertyUnchecked(Element.prototype, 'setAttribute',\n    /**\n     * @this {Element}\n     * @param {string} name\n     * @param {string} newValue\n     */\n    function(name, newValue) {\n      // Fast path for non-custom elements.\n      if (this.__CE_state !== CEState.custom) {\n        return Native.Element_setAttribute.call(this, name, newValue);\n      }\n\n      const oldValue = Native.Element_getAttribute.call(this, name);\n      Native.Element_setAttribute.call(this, name, newValue);\n      newValue = Native.Element_getAttribute.call(this, name);\n      internals.attributeChangedCallback(this, name, oldValue, newValue, null);\n    });\n\n  Utilities.setPropertyUnchecked(Element.prototype, 'setAttributeNS',\n    /**\n     * @this {Element}\n     * @param {?string} namespace\n     * @param {string} name\n     * @param {string} newValue\n     */\n    function(namespace, name, newValue) {\n      // Fast path for non-custom elements.\n      if (this.__CE_state !== CEState.custom) {\n        return Native.Element_setAttributeNS.call(this, namespace, name, newValue);\n      }\n\n      const oldValue = Native.Element_getAttributeNS.call(this, namespace, name);\n      Native.Element_setAttributeNS.call(this, namespace, name, newValue);\n      newValue = Native.Element_getAttributeNS.call(this, namespace, name);\n      internals.attributeChangedCallback(this, name, oldValue, newValue, namespace);\n    });\n\n  Utilities.setPropertyUnchecked(Element.prototype, 'removeAttribute',\n    /**\n     * @this {Element}\n     * @param {string} name\n     */\n    function(name) {\n      // Fast path for non-custom elements.\n      if (this.__CE_state !== CEState.custom) {\n        return Native.Element_removeAttribute.call(this, name);\n      }\n\n      const oldValue = Native.Element_getAttribute.call(this, name);\n      Native.Element_removeAttribute.call(this, name);\n      if (oldValue !== null) {\n        internals.attributeChangedCallback(this, name, oldValue, null, null);\n      }\n    });\n\n  Utilities.setPropertyUnchecked(Element.prototype, 'removeAttributeNS',\n    /**\n     * @this {Element}\n     * @param {?string} namespace\n     * @param {string} name\n     */\n    function(namespace, name) {\n      // Fast path for non-custom elements.\n      if (this.__CE_state !== CEState.custom) {\n        return Native.Element_removeAttributeNS.call(this, namespace, name);\n      }\n\n      const oldValue = Native.Element_getAttributeNS.call(this, namespace, name);\n      Native.Element_removeAttributeNS.call(this, namespace, name);\n      // In older browsers, `Element#getAttributeNS` may return the empty string\n      // instead of null if the attribute does not exist. For details, see;\n      // https://developer.mozilla.org/en-US/docs/Web/API/Element/getAttributeNS#Notes\n      const newValue = Native.Element_getAttributeNS.call(this, namespace, name);\n      if (oldValue !== newValue) {\n        internals.attributeChangedCallback(this, name, oldValue, newValue, namespace);\n      }\n    });\n\n\n  function patch_insertAdjacentElement(destination, baseMethod) {\n    Utilities.setPropertyUnchecked(destination, 'insertAdjacentElement',\n      /**\n       * @this {Element}\n       * @param {string} where\n       * @param {!Element} element\n       * @return {?Element}\n       */\n      function(where, element) {\n        const wasConnected = Utilities.isConnected(element);\n        const insertedElement = /** @type {!Element} */\n          (baseMethod.call(this, where, element));\n\n        if (wasConnected) {\n          internals.disconnectTree(element);\n        }\n\n        if (Utilities.isConnected(insertedElement)) {\n          internals.connectTree(element);\n        }\n        return insertedElement;\n      });\n  }\n\n  if (Native.HTMLElement_insertAdjacentElement) {\n    patch_insertAdjacentElement(HTMLElement.prototype, Native.HTMLElement_insertAdjacentElement);\n  } else if (Native.Element_insertAdjacentElement) {\n    patch_insertAdjacentElement(Element.prototype, Native.Element_insertAdjacentElement);\n  } else {\n    console.warn('Custom Elements: `Element#insertAdjacentElement` was not patched.');\n  }\n\n\n  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 * @enum {number}\n */\nconst CustomElementState = {\n  custom: 1,\n  failed: 2,\n};\n\nexport default CustomElementState;\n","import CustomElementInternals from '../../CustomElementInternals.js';\nimport * as Utilities from '../../Utilities.js';\n\n/**\n * @typedef {{\n *   before: !function(...(!Node|string)),\n *   after: !function(...(!Node|string)),\n *   replaceWith: !function(...(!Node|string)),\n *   remove: !function(),\n * }}\n */\nlet ChildNodeNativeMethods;\n\n/**\n * @param {!CustomElementInternals} internals\n * @param {!Object} destination\n * @param {!ChildNodeNativeMethods} builtIn\n */\nexport default function(internals, destination, builtIn) {\n  /**\n   * @param {...(!Node|string)} nodes\n   */\n  destination['before'] = function(...nodes) {\n    // TODO: Fix this for when one of `nodes` is a DocumentFragment!\n    const connectedBefore = /** @type {!Array<!Node>} */ (nodes.filter(node => {\n      // DocumentFragments are not connected and will not be added to the list.\n      return node instanceof Node && Utilities.isConnected(node);\n    }));\n\n    builtIn.before.apply(this, nodes);\n\n    for (let i = 0; i < connectedBefore.length; i++) {\n      internals.disconnectTree(connectedBefore[i]);\n    }\n\n    if (Utilities.isConnected(this)) {\n      for (let i = 0; i < nodes.length; i++) {\n        const node = nodes[i];\n        if (node instanceof Element) {\n          internals.connectTree(node);\n        }\n      }\n    }\n  };\n\n  /**\n   * @param {...(!Node|string)} nodes\n   */\n  destination['after'] = function(...nodes) {\n    // TODO: Fix this for when one of `nodes` is a DocumentFragment!\n    const connectedBefore = /** @type {!Array<!Node>} */ (nodes.filter(node => {\n      // DocumentFragments are not connected and will not be added to the list.\n      return node instanceof Node && Utilities.isConnected(node);\n    }));\n\n    builtIn.after.apply(this, nodes);\n\n    for (let i = 0; i < connectedBefore.length; i++) {\n      internals.disconnectTree(connectedBefore[i]);\n    }\n\n    if (Utilities.isConnected(this)) {\n      for (let i = 0; i < nodes.length; i++) {\n        const node = nodes[i];\n        if (node instanceof Element) {\n          internals.connectTree(node);\n        }\n      }\n    }\n  };\n\n  /**\n   * @param {...(!Node|string)} nodes\n   */\n  destination['replaceWith'] = function(...nodes) {\n    // TODO: Fix this for when one of `nodes` is a DocumentFragment!\n    const connectedBefore = /** @type {!Array<!Node>} */ (nodes.filter(node => {\n      // DocumentFragments are not connected and will not be added to the list.\n      return node instanceof Node && Utilities.isConnected(node);\n    }));\n\n    const wasConnected = Utilities.isConnected(this);\n\n    builtIn.replaceWith.apply(this, nodes);\n\n    for (let i = 0; i < connectedBefore.length; i++) {\n      internals.disconnectTree(connectedBefore[i]);\n    }\n\n    if (wasConnected) {\n      internals.disconnectTree(this);\n      for (let i = 0; i < nodes.length; i++) {\n        const node = nodes[i];\n        if (node instanceof Element) {\n          internals.connectTree(node);\n        }\n      }\n    }\n  };\n\n  destination['remove'] = function() {\n    const wasConnected = Utilities.isConnected(this);\n\n    builtIn.remove.call(this);\n\n    if (wasConnected) {\n      internals.disconnectTree(this);\n    }\n  };\n};\n","import Native from './Native.js';\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport * as Utilities from '../Utilities.js';\n\n/**\n * @param {!CustomElementInternals} internals\n */\nexport default function(internals) {\n  // `Node#nodeValue` is implemented on `Attr`.\n  // `Node#textContent` is implemented on `Attr`, `Element`.\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'insertBefore',\n    /**\n     * @this {Node}\n     * @param {!Node} node\n     * @param {?Node} refNode\n     * @return {!Node}\n     */\n    function(node, refNode) {\n      if (node instanceof DocumentFragment) {\n        const insertedNodes = Array.prototype.slice.apply(node.childNodes);\n        const nativeResult = Native.Node_insertBefore.call(this, node, refNode);\n\n        // DocumentFragments can't be connected, so `disconnectTree` will never\n        // need to be called on a DocumentFragment's children after inserting it.\n\n        if (Utilities.isConnected(this)) {\n          for (let i = 0; i < insertedNodes.length; i++) {\n            internals.connectTree(insertedNodes[i]);\n          }\n        }\n\n        return nativeResult;\n      }\n\n      const nodeWasConnected = Utilities.isConnected(node);\n      const nativeResult = Native.Node_insertBefore.call(this, node, refNode);\n\n      if (nodeWasConnected) {\n        internals.disconnectTree(node);\n      }\n\n      if (Utilities.isConnected(this)) {\n        internals.connectTree(node);\n      }\n\n      return nativeResult;\n    });\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'appendChild',\n    /**\n     * @this {Node}\n     * @param {!Node} node\n     * @return {!Node}\n     */\n    function(node) {\n      if (node instanceof DocumentFragment) {\n        const insertedNodes = Array.prototype.slice.apply(node.childNodes);\n        const nativeResult = Native.Node_appendChild.call(this, node);\n\n        // DocumentFragments can't be connected, so `disconnectTree` will never\n        // need to be called on a DocumentFragment's children after inserting it.\n\n        if (Utilities.isConnected(this)) {\n          for (let i = 0; i < insertedNodes.length; i++) {\n            internals.connectTree(insertedNodes[i]);\n          }\n        }\n\n        return nativeResult;\n      }\n\n      const nodeWasConnected = Utilities.isConnected(node);\n      const nativeResult = Native.Node_appendChild.call(this, node);\n\n      if (nodeWasConnected) {\n        internals.disconnectTree(node);\n      }\n\n      if (Utilities.isConnected(this)) {\n        internals.connectTree(node);\n      }\n\n      return nativeResult;\n    });\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'cloneNode',\n    /**\n     * @this {Node}\n     * @param {boolean=} deep\n     * @return {!Node}\n     */\n    function(deep) {\n      const clone = Native.Node_cloneNode.call(this, deep);\n      // Only create custom elements if this element's owner document is\n      // associated with the registry.\n      if (!this.ownerDocument.__CE_hasRegistry) {\n        internals.patchTree(clone);\n      } else {\n        internals.patchAndUpgradeTree(clone);\n      }\n      return clone;\n    });\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'removeChild',\n    /**\n     * @this {Node}\n     * @param {!Node} node\n     * @return {!Node}\n     */\n    function(node) {\n      const nodeWasConnected = Utilities.isConnected(node);\n      const nativeResult = Native.Node_removeChild.call(this, node);\n\n      if (nodeWasConnected) {\n        internals.disconnectTree(node);\n      }\n\n      return nativeResult;\n    });\n\n  Utilities.setPropertyUnchecked(Node.prototype, 'replaceChild',\n    /**\n     * @this {Node}\n     * @param {!Node} nodeToInsert\n     * @param {!Node} nodeToRemove\n     * @return {!Node}\n     */\n    function(nodeToInsert, nodeToRemove) {\n      if (nodeToInsert instanceof DocumentFragment) {\n        const insertedNodes = Array.prototype.slice.apply(nodeToInsert.childNodes);\n        const nativeResult = Native.Node_replaceChild.call(this, nodeToInsert, nodeToRemove);\n\n        // DocumentFragments can't be connected, so `disconnectTree` will never\n        // need to be called on a DocumentFragment's children after inserting it.\n\n        if (Utilities.isConnected(this)) {\n          internals.disconnectTree(nodeToRemove);\n          for (let i = 0; i < insertedNodes.length; i++) {\n            internals.connectTree(insertedNodes[i]);\n          }\n        }\n\n        return nativeResult;\n      }\n\n      const nodeToInsertWasConnected = Utilities.isConnected(nodeToInsert);\n      const nativeResult = Native.Node_replaceChild.call(this, nodeToInsert, nodeToRemove);\n      const thisIsConnected = Utilities.isConnected(this);\n\n      if (thisIsConnected) {\n        internals.disconnectTree(nodeToRemove);\n      }\n\n      if (nodeToInsertWasConnected) {\n        internals.disconnectTree(nodeToInsert);\n      }\n\n      if (thisIsConnected) {\n        internals.connectTree(nodeToInsert);\n      }\n\n      return nativeResult;\n    });\n\n\n  function patch_textContent(destination, baseDescriptor) {\n    Object.defineProperty(destination, 'textContent', {\n      enumerable: baseDescriptor.enumerable,\n      configurable: true,\n      get: baseDescriptor.get,\n      set: /** @this {Node} */ function(assignedValue) {\n        // If this is a text node then there are no nodes to disconnect.\n        if (this.nodeType === Node.TEXT_NODE) {\n          baseDescriptor.set.call(this, assignedValue);\n          return;\n        }\n\n        let removedNodes = undefined;\n        // Checking for `firstChild` is faster than reading `childNodes.length`\n        // to compare with 0.\n        if (this.firstChild) {\n          // Using `childNodes` is faster than `children`, even though we only\n          // care about elements.\n          const childNodes = this.childNodes;\n          const childNodesLength = childNodes.length;\n          if (childNodesLength > 0 && Utilities.isConnected(this)) {\n            // Copying an array by iterating is faster than using slice.\n            removedNodes = new Array(childNodesLength);\n            for (let i = 0; i < childNodesLength; i++) {\n              removedNodes[i] = childNodes[i];\n            }\n          }\n        }\n\n        baseDescriptor.set.call(this, assignedValue);\n\n        if (removedNodes) {\n          for (let i = 0; i < removedNodes.length; i++) {\n            internals.disconnectTree(removedNodes[i]);\n          }\n        }\n      },\n    });\n  }\n\n  if (Native.Node_textContent && Native.Node_textContent.get) {\n    patch_textContent(Node.prototype, Native.Node_textContent);\n  } else {\n    internals.addPatch(function(element) {\n      patch_textContent(element, {\n        enumerable: true,\n        configurable: true,\n        // NOTE: This implementation of the `textContent` getter assumes that\n        // text nodes' `textContent` getter will not be patched.\n        get: /** @this {Node} */ function() {\n          /** @type {!Array<string>} */\n          const parts = [];\n\n          for (let i = 0; i < this.childNodes.length; i++) {\n            parts.push(this.childNodes[i].textContent);\n          }\n\n          return parts.join('');\n        },\n        set: /** @this {Node} */ function(assignedValue) {\n          while (this.firstChild) {\n            Native.Node_removeChild.call(this, this.firstChild);\n          }\n          Native.Node_appendChild.call(this, document.createTextNode(assignedValue));\n        },\n      });\n    });\n  }\n};\n","import Native from './Native.js';\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport * as Utilities from '../Utilities.js';\n\nimport PatchParentNode from './Interface/ParentNode.js';\n\n/**\n * @param {!CustomElementInternals} internals\n */\nexport default function(internals) {\n  Utilities.setPropertyUnchecked(Document.prototype, 'createElement',\n    /**\n     * @this {Document}\n     * @param {string} localName\n     * @return {!Element}\n     */\n    function(localName) {\n      // Only create custom elements if this document is associated with the registry.\n      if (this.__CE_hasRegistry) {\n        const definition = internals.localNameToDefinition(localName);\n        if (definition) {\n          return new (definition.constructor)();\n        }\n      }\n\n      const result = /** @type {!Element} */\n        (Native.Document_createElement.call(this, localName));\n      internals.patch(result);\n      return result;\n    });\n\n  Utilities.setPropertyUnchecked(Document.prototype, 'importNode',\n    /**\n     * @this {Document}\n     * @param {!Node} node\n     * @param {boolean=} deep\n     * @return {!Node}\n     */\n    function(node, deep) {\n      const clone = Native.Document_importNode.call(this, node, deep);\n      // Only create custom elements if this document is associated with the registry.\n      if (!this.__CE_hasRegistry) {\n        internals.patchTree(clone);\n      } else {\n        internals.patchAndUpgradeTree(clone);\n      }\n      return clone;\n    });\n\n  const NS_HTML = \"http://www.w3.org/1999/xhtml\";\n\n  Utilities.setPropertyUnchecked(Document.prototype, 'createElementNS',\n    /**\n     * @this {Document}\n     * @param {?string} namespace\n     * @param {string} localName\n     * @return {!Element}\n     */\n    function(namespace, localName) {\n      // Only create custom elements if this document is associated with the registry.\n      if (this.__CE_hasRegistry && (namespace === null || namespace === NS_HTML)) {\n        const definition = internals.localNameToDefinition(localName);\n        if (definition) {\n          return new (definition.constructor)();\n        }\n      }\n\n      const result = /** @type {!Element} */\n        (Native.Document_createElementNS.call(this, namespace, localName));\n      internals.patch(result);\n      return result;\n    });\n\n  PatchParentNode(internals, Document.prototype, {\n    prepend: Native.Document_prepend,\n    append: Native.Document_append,\n  });\n};\n","import CustomElementInternals from '../../CustomElementInternals.js';\nimport * as Utilities from '../../Utilities.js';\n\n/**\n * @typedef {{\n *   prepend: !function(...(!Node|string)),\n  *  append: !function(...(!Node|string)),\n * }}\n */\nlet ParentNodeNativeMethods;\n\n/**\n * @param {!CustomElementInternals} internals\n * @param {!Object} destination\n * @param {!ParentNodeNativeMethods} builtIn\n */\nexport default function(internals, destination, builtIn) {\n  /**\n   * @param {...(!Node|string)} nodes\n   */\n  destination['prepend'] = function(...nodes) {\n    // TODO: Fix this for when one of `nodes` is a DocumentFragment!\n    const connectedBefore = /** @type {!Array<!Node>} */ (nodes.filter(node => {\n      // DocumentFragments are not connected and will not be added to the list.\n      return node instanceof Node && Utilities.isConnected(node);\n    }));\n\n    builtIn.prepend.apply(this, nodes);\n\n    for (let i = 0; i < connectedBefore.length; i++) {\n      internals.disconnectTree(connectedBefore[i]);\n    }\n\n    if (Utilities.isConnected(this)) {\n      for (let i = 0; i < nodes.length; i++) {\n        const node = nodes[i];\n        if (node instanceof Element) {\n          internals.connectTree(node);\n        }\n      }\n    }\n  };\n\n  /**\n   * @param {...(!Node|string)} nodes\n   */\n  destination['append'] = function(...nodes) {\n    // TODO: Fix this for when one of `nodes` is a DocumentFragment!\n    const connectedBefore = /** @type {!Array<!Node>} */ (nodes.filter(node => {\n      // DocumentFragments are not connected and will not be added to the list.\n      return node instanceof Node && Utilities.isConnected(node);\n    }));\n\n    builtIn.append.apply(this, nodes);\n\n    for (let i = 0; i < connectedBefore.length; i++) {\n      internals.disconnectTree(connectedBefore[i]);\n    }\n\n    if (Utilities.isConnected(this)) {\n      for (let i = 0; i < nodes.length; i++) {\n        const node = nodes[i];\n        if (node instanceof Element) {\n          internals.connectTree(node);\n        }\n      }\n    }\n  };\n};\n","import Native from './Native.js';\nimport CustomElementInternals from '../CustomElementInternals.js';\nimport CEState from '../CustomElementState.js';\nimport AlreadyConstructedMarker from '../AlreadyConstructedMarker.js';\n\n/**\n * @param {!CustomElementInternals} internals\n */\nexport default function(internals) {\n  window['HTMLElement'] = (function() {\n    /**\n     * @type {function(new: HTMLElement): !HTMLElement}\n     */\n    function HTMLElement() {\n      // This should really be `new.target` but `new.target` can't be emulated\n      // in ES5. Assuming the user keeps the default value of the constructor's\n      // prototype's `constructor` property, this is equivalent.\n      /** @type {!Function} */\n      const constructor = this.constructor;\n\n      const definition = internals.constructorToDefinition(constructor);\n      if (!definition) {\n        throw new Error('The custom element being constructed was not registered with `customElements`.');\n      }\n\n      const constructionStack = definition.constructionStack;\n\n      if (constructionStack.length === 0) {\n        const element = Native.Document_createElement.call(document, definition.localName);\n        Object.setPrototypeOf(element, constructor.prototype);\n        element.__CE_state = CEState.custom;\n        element.__CE_definition = definition;\n        internals.patch(element);\n        return element;\n      }\n\n      const lastIndex = constructionStack.length - 1;\n      const element = constructionStack[lastIndex];\n      if (element === AlreadyConstructedMarker) {\n        throw new Error('The HTMLElement constructor was either called reentrantly for this constructor or called multiple times.');\n      }\n      constructionStack[lastIndex] = AlreadyConstructedMarker;\n\n      Object.setPrototypeOf(element, constructor.prototype);\n      internals.patch(/** @type {!HTMLElement} */ (element));\n\n      return element;\n    }\n\n    HTMLElement.prototype = Native.HTMLElement.prototype;\n\n    return HTMLElement;\n  })();\n};\n","import CustomElementInternals from './CustomElementInternals.js';\nimport DocumentConstructionObserver from './DocumentConstructionObserver.js';\nimport Deferred from './Deferred.js';\nimport * as Utilities from './Utilities.js';\n\n/**\n * @unrestricted\n */\nexport default class CustomElementRegistry {\n\n  /**\n   * @param {!CustomElementInternals} internals\n   */\n  constructor(internals) {\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this._elementDefinitionIsRunning = false;\n\n    /**\n     * @private\n     * @type {!CustomElementInternals}\n     */\n    this._internals = internals;\n\n    /**\n     * @private\n     * @type {!Map<string, !Deferred<undefined>>}\n     */\n    this._whenDefinedDeferred = new Map();\n\n    /**\n     * The default flush callback triggers the document walk synchronously.\n     * @private\n     * @type {!Function}\n     */\n    this._flushCallback = fn => fn();\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this._flushPending = false;\n\n    /**\n     * @private\n     * @type {!Array<string>}\n     */\n    this._unflushedLocalNames = [];\n\n    /**\n     * @private\n     * @type {!DocumentConstructionObserver}\n     */\n    this._documentConstructionObserver = new DocumentConstructionObserver(internals, document);\n  }\n\n  /**\n   * @param {string} localName\n   * @param {!Function} constructor\n   */\n  define(localName, constructor) {\n    if (!(constructor instanceof Function)) {\n      throw new TypeError('Custom element constructors must be functions.');\n    }\n\n    if (!Utilities.isValidCustomElementName(localName)) {\n      throw new SyntaxError(`The element name '${localName}' is not valid.`);\n    }\n\n    if (this._internals.localNameToDefinition(localName)) {\n      throw new Error(`A custom element with name '${localName}' has already been defined.`);\n    }\n\n    if (this._elementDefinitionIsRunning) {\n      throw new Error('A custom element is already being defined.');\n    }\n    this._elementDefinitionIsRunning = true;\n\n    let connectedCallback;\n    let disconnectedCallback;\n    let adoptedCallback;\n    let attributeChangedCallback;\n    let observedAttributes;\n    try {\n      /** @type {!Object} */\n      const prototype = constructor.prototype;\n      if (!(prototype instanceof Object)) {\n        throw new TypeError('The custom element constructor\\'s prototype is not an object.');\n      }\n\n      function getCallback(name) {\n        const callbackValue = prototype[name];\n        if (callbackValue !== undefined && !(callbackValue instanceof Function)) {\n          throw new Error(`The '${name}' callback must be a function.`);\n        }\n        return callbackValue;\n      }\n\n      connectedCallback = getCallback('connectedCallback');\n      disconnectedCallback = getCallback('disconnectedCallback');\n      adoptedCallback = getCallback('adoptedCallback');\n      attributeChangedCallback = getCallback('attributeChangedCallback');\n      observedAttributes = constructor['observedAttributes'] || [];\n    } catch (e) {\n      return;\n    } finally {\n      this._elementDefinitionIsRunning = false;\n    }\n\n    const definition = {\n      localName,\n      constructor,\n      connectedCallback,\n      disconnectedCallback,\n      adoptedCallback,\n      attributeChangedCallback,\n      observedAttributes,\n      constructionStack: [],\n    };\n\n    this._internals.setDefinition(localName, definition);\n\n    this._unflushedLocalNames.push(localName);\n\n    // If we've already called the flush callback and it hasn't called back yet,\n    // don't call it again.\n    if (!this._flushPending) {\n      this._flushPending = true;\n      this._flushCallback(() => this._flush());\n    }\n  }\n\n  _flush() {\n    // If no new definitions were defined, don't attempt to flush. This could\n    // happen if a flush callback keeps the function it is given and calls it\n    // multiple times.\n    if (this._flushPending === false) return;\n\n    this._flushPending = false;\n    this._internals.patchAndUpgradeTree(document);\n\n    while (this._unflushedLocalNames.length > 0) {\n      const localName = this._unflushedLocalNames.shift();\n      const deferred = this._whenDefinedDeferred.get(localName);\n      if (deferred) {\n        deferred.resolve(undefined);\n      }\n    }\n  }\n\n  /**\n   * @param {string} localName\n   * @return {Function|undefined}\n   */\n  get(localName) {\n    const definition = this._internals.localNameToDefinition(localName);\n    if (definition) {\n      return definition.constructor;\n    }\n\n    return undefined;\n  }\n\n  /**\n   * @param {string} localName\n   * @return {!Promise<undefined>}\n   */\n  whenDefined(localName) {\n    if (!Utilities.isValidCustomElementName(localName)) {\n      return Promise.reject(new SyntaxError(`'${localName}' is not a valid custom element name.`));\n    }\n\n    const prior = this._whenDefinedDeferred.get(localName);\n    if (prior) {\n      return prior.toPromise();\n    }\n\n    const deferred = new Deferred();\n    this._whenDefinedDeferred.set(localName, deferred);\n\n    const definition = this._internals.localNameToDefinition(localName);\n    // Resolve immediately only if the given local name has a definition *and*\n    // the full document walk to upgrade elements with that local name has\n    // already happened.\n    if (definition && this._unflushedLocalNames.indexOf(localName) === -1) {\n      deferred.resolve(undefined);\n    }\n\n    return deferred.toPromise();\n  }\n\n  polyfillWrapFlushCallback(outer) {\n    this._documentConstructionObserver.disconnect();\n    const inner = this._flushCallback;\n    this._flushCallback = flush => outer(() => inner(flush));\n  }\n}\n\n// Closure compiler exports.\nwindow['CustomElementRegistry'] = CustomElementRegistry;\nCustomElementRegistry.prototype['define'] = CustomElementRegistry.prototype.define;\nCustomElementRegistry.prototype['get'] = CustomElementRegistry.prototype.get;\nCustomElementRegistry.prototype['whenDefined'] = CustomElementRegistry.prototype.whenDefined;\nCustomElementRegistry.prototype['polyfillWrapFlushCallback'] = CustomElementRegistry.prototype.polyfillWrapFlushCallback;\n","/**\n * @template T\n */\nexport default class Deferred {\n  constructor() {\n    /**\n     * @private\n     * @type {T|undefined}\n     */\n    this._value = undefined;\n\n    /**\n     * @private\n     * @type {Function|undefined}\n     */\n    this._resolve = undefined;\n\n    /**\n     * @private\n     * @type {!Promise<T>}\n     */\n    this._promise = new Promise(resolve => {\n      this._resolve = resolve;\n\n      if (this._value) {\n        resolve(this._value);\n      }\n    });\n  }\n\n  /**\n   * @param {T} value\n   */\n  resolve(value) {\n    if (this._value) {\n      throw new Error('Already resolved.');\n    }\n\n    this._value = value;\n\n    if (this._resolve) {\n      this._resolve(value);\n    }\n  }\n\n  /**\n   * @return {!Promise<T>}\n   */\n  toPromise() {\n    return this._promise;\n  }\n}\n","import CustomElementInternals from './CustomElementInternals.js';\n\nexport default class DocumentConstructionObserver {\n  constructor(internals, doc) {\n    /**\n     * @type {!CustomElementInternals}\n     */\n    this._internals = internals;\n\n    /**\n     * @type {!Document}\n     */\n    this._document = doc;\n\n    /**\n     * @type {MutationObserver|undefined}\n     */\n    this._observer = undefined;\n\n\n    // Simulate tree construction for all currently accessible nodes in the\n    // document.\n    this._internals.patchAndUpgradeTree(this._document);\n\n    if (this._document.readyState === 'loading') {\n      this._observer = new MutationObserver(this._handleMutations.bind(this));\n\n      // Nodes created by the parser are given to the observer *before* the next\n      // task runs. Inline scripts are run in a new task. This means that the\n      // observer will be able to handle the newly parsed nodes before the inline\n      // script is run.\n      this._observer.observe(this._document, {\n        childList: true,\n        subtree: true,\n      });\n    }\n  }\n\n  disconnect() {\n    if (this._observer) {\n      this._observer.disconnect();\n    }\n  }\n\n  /**\n   * @param {!Array<!MutationRecord>} mutations\n   */\n  _handleMutations(mutations) {\n    // Once the document's `readyState` is 'interactive' or 'complete', all new\n    // nodes created within that document will be the result of script and\n    // should be handled by patching.\n    const readyState = this._document.readyState;\n    if (readyState === 'interactive' || readyState === 'complete') {\n      this.disconnect();\n    }\n\n    for (let i = 0; i < mutations.length; i++) {\n      const addedNodes = mutations[i].addedNodes;\n      for (let j = 0; j < addedNodes.length; j++) {\n        const node = addedNodes[j];\n        this._internals.patchAndUpgradeTree(node);\n      }\n    }\n  }\n}\n","import * as Utilities from './Utilities.js';\nimport CEState from './CustomElementState.js';\n\nexport default class CustomElementInternals {\n  constructor() {\n    /** @type {!Map<string, !CustomElementDefinition>} */\n    this._localNameToDefinition = new Map();\n\n    /** @type {!Map<!Function, !CustomElementDefinition>} */\n    this._constructorToDefinition = new Map();\n\n    /** @type {!Array<!function(!Node)>} */\n    this._patches = [];\n\n    /** @type {boolean} */\n    this._hasPatches = false;\n  }\n\n  /**\n   * @param {string} localName\n   * @param {!CustomElementDefinition} definition\n   */\n  setDefinition(localName, definition) {\n    this._localNameToDefinition.set(localName, definition);\n    this._constructorToDefinition.set(definition.constructor, definition);\n  }\n\n  /**\n   * @param {string} localName\n   * @return {!CustomElementDefinition|undefined}\n   */\n  localNameToDefinition(localName) {\n    return this._localNameToDefinition.get(localName);\n  }\n\n  /**\n   * @param {!Function} constructor\n   * @return {!CustomElementDefinition|undefined}\n   */\n  constructorToDefinition(constructor) {\n    return this._constructorToDefinition.get(constructor);\n  }\n\n  /**\n   * @param {!function(!Node)} listener\n   */\n  addPatch(listener) {\n    this._hasPatches = true;\n    this._patches.push(listener);\n  }\n\n  /**\n   * @param {!Node} node\n   */\n  patchTree(node) {\n    if (!this._hasPatches) return;\n\n    Utilities.walkDeepDescendantElements(node, element => this.patch(element));\n  }\n\n  /**\n   * @param {!Node} node\n   */\n  patch(node) {\n    if (!this._hasPatches) return;\n\n    if (node.__CE_patched) return;\n    node.__CE_patched = true;\n\n    for (let i = 0; i < this._patches.length; i++) {\n      this._patches[i](node);\n    }\n  }\n\n  /**\n   * @param {!Node} root\n   */\n  connectTree(root) {\n    const elements = [];\n\n    Utilities.walkDeepDescendantElements(root, element => elements.push(element));\n\n    for (let i = 0; i < elements.length; i++) {\n      const element = elements[i];\n      if (element.__CE_state === CEState.custom) {\n        this.connectedCallback(element);\n      } else {\n        this.upgradeElement(element);\n      }\n    }\n  }\n\n  /**\n   * @param {!Node} root\n   */\n  disconnectTree(root) {\n    const elements = [];\n\n    Utilities.walkDeepDescendantElements(root, element => elements.push(element));\n\n    for (let i = 0; i < elements.length; i++) {\n      const element = elements[i];\n      if (element.__CE_state === CEState.custom) {\n        this.disconnectedCallback(element);\n      }\n    }\n  }\n\n  /**\n   * Upgrades all uncustomized custom elements at and below a root node for\n   * which there is a definition. When custom element reaction callbacks are\n   * assumed to be called synchronously (which, by the current DOM / HTML spec\n   * definitions, they are *not*), callbacks for both elements customized\n   * synchronously by the parser and elements being upgraded occur in the same\n   * relative order.\n   *\n   * NOTE: This function, when used to simulate the construction of a tree that\n   * is already created but not customized (i.e. by the parser), does *not*\n   * prevent the element from reading the 'final' (true) state of the tree. For\n   * example, the element, during truly synchronous parsing / construction would\n   * see that it contains no children as they have not yet been inserted.\n   * However, this function does not modify the tree, the element will\n   * (incorrectly) have children. Additionally, self-modification restrictions\n   * for custom element constructors imposed by the DOM spec are *not* enforced.\n   *\n   *\n   * The following nested list shows the steps extending down from the HTML\n   * spec's parsing section that cause elements to be synchronously created and\n   * upgraded:\n   *\n   * The \"in body\" insertion mode:\n   * https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody\n   * - Switch on token:\n   *   .. other cases ..\n   *   -> Any other start tag\n   *      - [Insert an HTML element](below) for the token.\n   *\n   * Insert an HTML element:\n   * https://html.spec.whatwg.org/multipage/syntax.html#insert-an-html-element\n   * - Insert a foreign element for the token in the HTML namespace:\n   *   https://html.spec.whatwg.org/multipage/syntax.html#insert-a-foreign-element\n   *   - Create an element for a token:\n   *     https://html.spec.whatwg.org/multipage/syntax.html#create-an-element-for-the-token\n   *     - Will execute script flag is true?\n   *       - (Element queue pushed to the custom element reactions stack.)\n   *     - Create an element:\n   *       https://dom.spec.whatwg.org/#concept-create-element\n   *       - Sync CE flag is true?\n   *         - Constructor called.\n   *         - Self-modification restrictions enforced.\n   *       - Sync CE flag is false?\n   *         - (Upgrade reaction enqueued.)\n   *     - Attributes appended to element.\n   *       (`attributeChangedCallback` reactions enqueued.)\n   *     - Will execute script flag is true?\n   *       - (Element queue popped from the custom element reactions stack.\n   *         Reactions in the popped stack are invoked.)\n   *   - (Element queue pushed to the custom element reactions stack.)\n   *   - Insert the element:\n   *     https://dom.spec.whatwg.org/#concept-node-insert\n   *     - Shadow-including descendants are connected. During parsing\n   *       construction, there are no shadow-*excluding* descendants.\n   *       However, the constructor may have validly attached a shadow\n   *       tree to itself and added descendants to that shadow tree.\n   *       (`connectedCallback` reactions enqueued.)\n   *   - (Element queue popped from the custom element reactions stack.\n   *     Reactions in the popped stack are invoked.)\n   *\n   * @param {!Node} root\n   * @param {!Set<Node>=} visitedImports\n   */\n  patchAndUpgradeTree(root, visitedImports = new Set()) {\n    const elements = [];\n\n    const gatherElements = element => {\n      if (element.localName === 'link' && element.getAttribute('rel') === 'import') {\n        // The HTML Imports polyfill sets a descendant element of the link to\n        // the `import` property, specifically this is *not* a Document.\n        const importNode = /** @type {?Node} */ (element.import);\n\n        if (importNode instanceof Node && importNode.readyState === 'complete') {\n          importNode.__CE_isImportDocument = true;\n\n          // Connected links are associated with the registry.\n          importNode.__CE_hasRegistry = true;\n        } else {\n          // If this link's import root is not available, its contents can't be\n          // walked. Wait for 'load' and walk it when it's ready.\n          element.addEventListener('load', () => {\n            const importNode = /** @type {!Node} */ (element.import);\n\n            if (importNode.__CE_documentLoadHandled) return;\n            importNode.__CE_documentLoadHandled = true;\n\n            importNode.__CE_isImportDocument = true;\n\n            // Connected links are associated with the registry.\n            importNode.__CE_hasRegistry = true;\n\n            // Clone the `visitedImports` set that was populated sync during\n            // the `patchAndUpgradeTree` call that caused this 'load' handler to\n            // be added. Then, remove *this* link's import node so that we can\n            // walk that import again, even if it was partially walked later\n            // during the same `patchAndUpgradeTree` call.\n            const clonedVisitedImports = new Set(visitedImports);\n            visitedImports.delete(importNode);\n\n            this.patchAndUpgradeTree(importNode, visitedImports);\n          });\n        }\n      } else {\n        elements.push(element);\n      }\n    };\n\n    // `walkDeepDescendantElements` populates (and internally checks against)\n    // `visitedImports` when traversing a loaded import.\n    Utilities.walkDeepDescendantElements(root, gatherElements, visitedImports);\n\n    if (this._hasPatches) {\n      for (let i = 0; i < elements.length; i++) {\n        this.patch(elements[i]);\n      }\n    }\n\n    for (let i = 0; i < elements.length; i++) {\n      this.upgradeElement(elements[i]);\n    }\n  }\n\n  /**\n   * @param {!Element} element\n   */\n  upgradeElement(element) {\n    const currentState = element.__CE_state;\n    if (currentState !== undefined) return;\n\n    const definition = this.localNameToDefinition(element.localName);\n    if (!definition) return;\n\n    definition.constructionStack.push(element);\n\n    const constructor = definition.constructor;\n    try {\n      try {\n        let result = new (constructor)();\n        if (result !== element) {\n          throw new Error('The custom element constructor did not produce the element being upgraded.');\n        }\n      } finally {\n        definition.constructionStack.pop();\n      }\n    } catch (e) {\n      element.__CE_state = CEState.failed;\n      throw e;\n    }\n\n    element.__CE_state = CEState.custom;\n    element.__CE_definition = definition;\n\n    if (definition.attributeChangedCallback) {\n      const observedAttributes = definition.observedAttributes;\n      for (let i = 0; i < observedAttributes.length; i++) {\n        const name = observedAttributes[i];\n        const value = element.getAttribute(name);\n        if (value !== null) {\n          this.attributeChangedCallback(element, name, null, value, null);\n        }\n      }\n    }\n\n    if (Utilities.isConnected(element)) {\n      this.connectedCallback(element);\n    }\n  }\n\n  /**\n   * @param {!Element} element\n   */\n  connectedCallback(element) {\n    const definition = element.__CE_definition;\n    if (definition.connectedCallback) {\n      definition.connectedCallback.call(element);\n    }\n  }\n\n  /**\n   * @param {!Element} element\n   */\n  disconnectedCallback(element) {\n    const definition = element.__CE_definition;\n    if (definition.disconnectedCallback) {\n      definition.disconnectedCallback.call(element);\n    }\n  }\n\n  /**\n   * @param {!Element} element\n   * @param {string} name\n   * @param {?string} oldValue\n   * @param {?string} newValue\n   * @param {?string} namespace\n   */\n  attributeChangedCallback(element, name, oldValue, newValue, namespace) {\n    const definition = element.__CE_definition;\n    if (\n      definition.attributeChangedCallback &&\n      definition.observedAttributes.indexOf(name) > -1\n    ) {\n      definition.attributeChangedCallback.call(element, name, oldValue, newValue, namespace);\n    }\n  }\n}\n","/**\n@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'use strict';\n\nimport {calculateSplices} from './array-splice'\nimport * as utils from './utils'\nimport {enqueue} from './flush'\nimport {recordChildNodes} from './logical-tree'\nimport {removeChild, insertBefore} from './native-methods'\nimport {parentNode, childNodes} from './native-tree'\nimport {patchShadowRootAccessors} from './patch-accessors'\nimport Distributor from './distributor'\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\n/**\n * @constructor\n * @extends {ShadowRoot}\n */\nexport let ShadyRoot = function(token, host) {\n  if (token !== ShadyRootConstructionToken) {\n    throw new TypeError('Illegal constructor');\n  }\n  // NOTE: this strange construction is necessary because\n  // DocumentFragment cannot be subclassed on older browsers.\n  let shadowRoot = document.createDocumentFragment();\n  shadowRoot.__proto__ = ShadyRoot.prototype;\n  /** @type {ShadyRoot} */ (shadowRoot)._init(host);\n  return shadowRoot;\n};\n\nShadyRoot.prototype = Object.create(DocumentFragment.prototype);\n\nShadyRoot.prototype._init = function(host) {\n  // NOTE: set a fake local name so this element can be\n  // distinguished from a DocumentFragment when patching.\n  // FF doesn't allow this to be `localName`\n  this.__localName = 'ShadyRoot';\n  // logical dom setup\n  recordChildNodes(host);\n  recordChildNodes(this);\n  // root <=> host\n  host.shadowRoot = this;\n  this.host = host;\n  // state flags\n  this._renderPending = false;\n  this._hasRendered = false;\n  this._changePending = false;\n  this._distributor = new Distributor(this);\n  this.update();\n}\n\n\n// async render\nShadyRoot.prototype.update = function() {\n  if (!this._renderPending) {\n    this._renderPending = true;\n    enqueue(() => this.render());\n  }\n}\n\n// returns the oldest renderPending ancestor root.\nShadyRoot.prototype._getRenderRoot = function() {\n  let renderRoot = this;\n  let root = this;\n  while (root) {\n    if (root._renderPending) {\n      renderRoot = root;\n    }\n    root = root._rendererForHost();\n  }\n  return renderRoot;\n}\n\n// Returns the shadyRoot `this.host` if `this.host`\n// has children that require distribution.\nShadyRoot.prototype._rendererForHost = function() {\n  let root = this.host.getRootNode();\n  if (utils.isShadyRoot(root)) {\n    let c$ = this.host.childNodes;\n    for (let i=0, c; i < c$.length; i++) {\n      c = c$[i];\n      if (this._distributor.isInsertionPoint(c)) {\n        return root;\n      }\n    }\n  }\n}\n\nShadyRoot.prototype.render = function() {\n  if (this._renderPending) {\n    this._getRenderRoot()['_render']();\n  }\n}\n\n// NOTE: avoid renaming to ease testability.\nShadyRoot.prototype['_render'] = function() {\n  this._renderPending = false;\n  this._changePending = false;\n  if (!this._skipUpdateInsertionPoints) {\n    this.updateInsertionPoints();\n  } else if (!this._hasRendered) {\n    this.__insertionPoints = [];\n  }\n  this._skipUpdateInsertionPoints = false;\n  // TODO(sorvell): can add a first render optimization here\n  // to use if there are no insertion points\n  // 1. clear host node of composed children\n  // 2. appendChild the shadowRoot itself or (more robust) its logical children\n  // NOTE: this didn't seem worth it in perf testing\n  // but not ready to delete this info.\n  // logical\n  this.distribute();\n  // physical\n  this.compose();\n  this._hasRendered = true;\n}\n\nShadyRoot.prototype.forceRender = function() {\n  this._renderPending = true;\n  this.render();\n}\n\nShadyRoot.prototype.distribute = function() {\n  let dirtyRoots = this._distributor.distribute();\n  for (let i=0; i<dirtyRoots.length; i++) {\n    dirtyRoots[i]['_render']();\n  }\n}\n\nShadyRoot.prototype.updateInsertionPoints = function() {\n  let i$ = this._insertionPoints;\n  // if any insertion points have been removed, clear their distribution info\n  if (i$) {\n    for (let i=0, c; i < i$.length; i++) {\n      c = i$[i];\n      if (c.getRootNode() !== this) {\n        this._distributor.clearAssignedSlots(c);\n      }\n    }\n  }\n  i$ = this._insertionPoints = this._distributor.getInsertionPoints();\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  for (let i=0, c; i < i$.length; i++) {\n    c = i$[i];\n    c.__shady = c.__shady || {};\n    recordChildNodes(c);\n    recordChildNodes(c.parentNode);\n  }\n}\n\nShadyRoot.prototype.compose = function() {\n  // compose self\n  // note: it's important to mark this clean before distribution\n  // so that attachment that provokes additional distribution (e.g.\n  // adding something to your parentNode) works\n  this._composeTree();\n  // TODO(sorvell): See fast paths here in Polymer v1\n  // (these seem unnecessary)\n}\n\n// Reify dom such that it is at its correct rendering position\n// based on logical distribution.\nShadyRoot.prototype._composeTree = function() {\n  this._updateChildNodes(this.host, this._composeNode(this.host));\n  let p$ = this._getInsertionPoints();\n  for (let i=0, l=p$.length, p, parent; (i<l) && (p=p$[i]); i++) {\n    parent = p.parentNode;\n    if ((parent !== this.host) && (parent !== this)) {\n      this._updateChildNodes(parent, this._composeNode(parent));\n    }\n  }\n}\n\n// Returns the list of nodes which should be rendered inside `node`.\nShadyRoot.prototype._composeNode = function(node) {\n  let children = [];\n  let c$ = ((node.__shady && node.__shady.root) || node).childNodes;\n  for (let i = 0; i < c$.length; i++) {\n    let child = c$[i];\n    if (this._distributor.isInsertionPoint(child)) {\n      let distributedNodes = child.__shady.distributedNodes ||\n        (child.__shady.distributedNodes = []);\n      for (let j = 0; j < distributedNodes.length; j++) {\n        let distributedNode = distributedNodes[j];\n        if (this.isFinalDestination(child, distributedNode)) {\n          children.push(distributedNode);\n        }\n      }\n    } else {\n      children.push(child);\n    }\n  }\n  return children;\n}\n\nShadyRoot.prototype.isFinalDestination = function(insertionPoint, node) {\n  return this._distributor.isFinalDestination(\n    insertionPoint, node);\n}\n\n// Ensures that the rendered node list inside `container` is `children`.\nShadyRoot.prototype._updateChildNodes = function(container, children) {\n  let composed = childNodes(container);\n  let splices = calculateSplices(children, composed);\n  // process removals\n  for (let i=0, d=0, s; (i<splices.length) && (s=splices[i]); i++) {\n    for (let j=0, n; (j < s.removed.length) && (n=s.removed[j]); j++) {\n      // check if the node is still where we expect it is before trying\n      // to remove it; this can happen if we move a node and\n      // then schedule its previous host for distribution resulting in\n      // the node being removed here.\n      if (parentNode(n) === container) {\n        removeChild.call(container, n);\n      }\n      composed.splice(s.index + d, 1);\n    }\n    d -= s.addedCount;\n  }\n  // process adds\n  for (let i=0, s, next; (i<splices.length) && (s=splices[i]); i++) { //eslint-disable-line no-redeclare\n    next = composed[s.index];\n    for (let j=s.index, n; j < s.index + s.addedCount; j++) {\n      n = children[j];\n      insertBefore.call(container, n, next);\n      // TODO(sorvell): is this splice strictly needed?\n      composed.splice(j, 0, n);\n    }\n  }\n}\n\nShadyRoot.prototype.getInsertionPointTag = function() {\n  return this._distributor.insertionPointTag;\n}\n\nShadyRoot.prototype.hasInsertionPoint = function() {\n  return Boolean(this._insertionPoints && this._insertionPoints.length);\n}\n\nShadyRoot.prototype._getInsertionPoints = function() {\n  if (!this._insertionPoints) {\n    this.updateInsertionPoints();\n  }\n  return this._insertionPoints;\n}\n\nShadyRoot.prototype.addEventListener = function(type, fn, optionsOrCapture) {\n  if (typeof optionsOrCapture !== 'object') {\n    optionsOrCapture = {\n      capture: Boolean(optionsOrCapture)\n    }\n  }\n  optionsOrCapture.__shadyTarget = this;\n  this.host.addEventListener(type, fn, optionsOrCapture);\n}\n\nShadyRoot.prototype.removeEventListener = function(type, fn, optionsOrCapture) {\n  if (typeof optionsOrCapture !== 'object') {\n    optionsOrCapture = {\n      capture: Boolean(optionsOrCapture)\n    }\n  }\n  optionsOrCapture.__shadyTarget = this;\n  this.host.removeEventListener(type, fn, optionsOrCapture);\n}\n\nShadyRoot.prototype.getElementById = function(id) {\n  return this.querySelector(`#${id}`);\n}\n\n/**\n  Implements a pared down version of ShadowDOM's scoping, which is easy to\n  polyfill across browsers.\n*/\nexport function attachShadow(host, options) {\n  if (!host) {\n    throw 'Must provide a host.';\n  }\n  if (!options) {\n    throw 'Not enough arguments.'\n  }\n  return new ShadyRoot(ShadyRootConstructionToken, host);\n}\n\npatchShadowRootAccessors(ShadyRoot.prototype);\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'use strict';\n\nimport {removeChild, dispatchEvent} from './native-methods'\nimport {parentNode} from './native-tree'\n\n// NOTE: normalize event contruction where necessary (IE11)\nlet NormalizedEvent = typeof Event === 'function' ? Event :\n  function(inType, params) {\n    params = params || {};\n    var e = document.createEvent('Event');\n    e.initEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable));\n    return e;\n  };\n\nexport default class {\n\n  constructor(root) {\n    this.root = root;\n    this.insertionPointTag = 'slot';\n  }\n\n  getInsertionPoints() {\n    return this.root.querySelectorAll(this.insertionPointTag);\n  }\n\n  isInsertionPoint(node) {\n    return node.localName && node.localName == this.insertionPointTag;\n  }\n\n  distribute() {\n    if (this.root.hasInsertionPoint()) {\n      return this.distributePool(this.root, this.collectPool());\n    }\n    return [];\n  }\n\n  // Gather the pool of nodes that should be distributed. We will combine\n  // these with the \"content root\" to arrive at the composed tree.\n  collectPool() {\n    let host = this.root.host;\n    let pool=[], i=0;\n    for (let n=host.firstChild; n; n=n.nextSibling) {\n      pool[i++] = n;\n    }\n    return pool;\n  }\n\n  // perform \"logical\" distribution; note, no actual dom is moved here,\n  // instead elements are distributed into storage\n  // array where applicable.\n  distributePool(node, pool) {\n    let dirtyRoots = [];\n    let p$ = this.root._getInsertionPoints();\n    for (let i=0, l=p$.length, p; (i<l) && (p=p$[i]); i++) {\n      this.distributeInsertionPoint(p, pool);\n      // provoke redistribution on insertion point parents\n      // must do this on all candidate hosts since distribution in this\n      // scope invalidates their distribution.\n      // only get logical parent.\n      let parent = p.parentNode;\n      let root = parent && parent.__shady && parent.__shady.root\n      if (root && root.hasInsertionPoint()) {\n        dirtyRoots.push(root);\n      }\n    }\n    for (let i=0; i < pool.length; i++) {\n      let p = pool[i];\n      if (p) {\n        p.__shady = p.__shady || {};\n        p.__shady.assignedSlot = undefined;\n        // remove undistributed elements from physical dom.\n        let parent = parentNode(p);\n        if (parent) {\n          removeChild.call(parent, p);\n        }\n      }\n    }\n    return dirtyRoots;\n  }\n\n  distributeInsertionPoint(insertionPoint, pool) {\n    let prevAssignedNodes = insertionPoint.__shady.assignedNodes;\n    if (prevAssignedNodes) {\n      this.clearAssignedSlots(insertionPoint, true);\n    }\n    insertionPoint.__shady.assignedNodes = [];\n    let needsSlotChange = false;\n    // distribute nodes from the pool that this selector matches\n    let anyDistributed = false;\n    for (let i=0, l=pool.length, node; i < l; i++) {\n      node=pool[i];\n      // skip nodes that were already used\n      if (!node) {\n        continue;\n      }\n      // distribute this node if it matches\n      if (this.matchesInsertionPoint(node, insertionPoint)) {\n        if (node.__shady._prevAssignedSlot != insertionPoint) {\n          needsSlotChange = true;\n        }\n        this.distributeNodeInto(node, insertionPoint)\n        // remove this node from the pool\n        pool[i] = undefined;\n        // since at least one node matched, we won't need fallback content\n        anyDistributed = true;\n      }\n    }\n    // Fallback content if nothing was distributed here\n    if (!anyDistributed) {\n      let children = insertionPoint.childNodes;\n      for (let j = 0, node; j < children.length; j++) {\n        node = children[j];\n        if (node.__shady._prevAssignedSlot != insertionPoint) {\n          needsSlotChange = true;\n        }\n        this.distributeNodeInto(node, insertionPoint);\n      }\n    }\n    // we're already dirty if a node was newly added to the slot\n    // and we're also dirty if the assigned count decreased.\n    if (prevAssignedNodes) {\n      // TODO(sorvell): the tracking of previously assigned slots\n      // could instead by done with a Set and then we could\n      // avoid needing to iterate here to clear the info.\n      for (let i=0; i < prevAssignedNodes.length; i++) {\n        prevAssignedNodes[i].__shady._prevAssignedSlot = null;\n      }\n      if (insertionPoint.__shady.assignedNodes.length < prevAssignedNodes.length) {\n        needsSlotChange = true;\n      }\n    }\n    this.setDistributedNodesOnInsertionPoint(insertionPoint);\n    if (needsSlotChange) {\n      this._fireSlotChange(insertionPoint);\n    }\n  }\n\n  clearAssignedSlots(slot, savePrevious) {\n    let n$ = slot.__shady.assignedNodes;\n    if (n$) {\n      for (let i=0; i < n$.length; i++) {\n        let n = n$[i];\n        if (savePrevious) {\n          n.__shady._prevAssignedSlot = n.__shady.assignedSlot;\n        }\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.__shady.assignedSlot === slot) {\n          n.__shady.assignedSlot = null;\n        }\n      }\n    }\n  }\n\n  matchesInsertionPoint(node, insertionPoint) {\n    let slotName = insertionPoint.getAttribute('name');\n    slotName = slotName ? slotName.trim() : '';\n    let slot = node.getAttribute && node.getAttribute('slot');\n    slot = slot ? slot.trim() : '';\n    return (slot == slotName);\n  }\n\n  distributeNodeInto(child, insertionPoint) {\n    insertionPoint.__shady.assignedNodes.push(child);\n    child.__shady.assignedSlot = insertionPoint;\n  }\n\n  setDistributedNodesOnInsertionPoint(insertionPoint) {\n    let n$ = insertionPoint.__shady.assignedNodes;\n    insertionPoint.__shady.distributedNodes = [];\n    for (let i=0, n; (i<n$.length) && (n=n$[i]) ; i++) {\n      if (this.isInsertionPoint(n)) {\n        let d$ = n.__shady.distributedNodes;\n        if (d$) {\n          for (let j=0; j < d$.length; j++) {\n            insertionPoint.__shady.distributedNodes.push(d$[j]);\n          }\n        }\n      } else {\n        insertionPoint.__shady.distributedNodes.push(n$[i]);\n      }\n    }\n  }\n\n  _fireSlotChange(insertionPoint) {\n    // NOTE: cannot bubble correctly here so not setting bubbles: true\n    // Safari tech preview does not bubble but chrome does\n    // Spec says it bubbles (https://dom.spec.whatwg.org/#mutation-observers)\n    dispatchEvent.call(insertionPoint, new NormalizedEvent('slotchange'));\n    if (insertionPoint.__shady.assignedSlot) {\n      this._fireSlotChange(insertionPoint.__shady.assignedSlot);\n    }\n  }\n\n  isFinalDestination(insertionPoint) {\n    return !(insertionPoint.__shady.assignedSlot);\n  }\n\n}","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {patchInsideElementAccessors, patchOutsideElementAccessors} from './patch-accessors'\nimport {firstChild, lastChild, childNodes} from './native-tree'\n\nexport function recordInsertBefore(node, container, ref_node) {\n  patchInsideElementAccessors(container);\n  container.__shady = container.__shady || {};\n  if (container.__shady.firstChild !== undefined) {\n    container.__shady.childNodes = null;\n  }\n  // handle document fragments\n  if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n    let c$ = node.childNodes;\n    for (let i=0; i < c$.length; i++) {\n      linkNode(c$[i], container, ref_node);\n    }\n    // cleanup logical dom in doc fragment.\n    node.__shady = node.__shady || {};\n    let resetTo = (node.__shady.firstChild !== undefined) ? null : undefined;\n    node.__shady.firstChild = node.__shady.lastChild = resetTo;\n    node.__shady.childNodes = resetTo;\n  } else {\n    linkNode(node, container, ref_node);\n  }\n}\n\nfunction linkNode(node, container, ref_node) {\n  patchOutsideElementAccessors(node);\n  ref_node = ref_node || null;\n  node.__shady = node.__shady || {};\n  container.__shady = container.__shady || {};\n  if (ref_node) {\n    ref_node.__shady = ref_node.__shady || {};\n  }\n  // update ref_node.previousSibling <-> node\n  node.__shady.previousSibling = ref_node ? ref_node.__shady.previousSibling :\n    container.lastChild;\n  let ps = node.__shady.previousSibling;\n  if (ps && ps.__shady) {\n    ps.__shady.nextSibling = node;\n  }\n  // update node <-> ref_node\n  let ns = node.__shady.nextSibling = ref_node;\n  if (ns && ns.__shady) {\n    ns.__shady.previousSibling = node;\n  }\n  // update node <-> container\n  node.__shady.parentNode = container;\n  if (ref_node) {\n    if (ref_node === container.__shady.firstChild) {\n      container.__shady.firstChild = node;\n    }\n  } else {\n    container.__shady.lastChild = node;\n    if (!container.__shady.firstChild) {\n      container.__shady.firstChild = node;\n    }\n  }\n  // remove caching of childNodes\n  container.__shady.childNodes = null;\n}\n\nexport function recordRemoveChild(node, container) {\n  node.__shady = node.__shady || {};\n  container.__shady = container.__shady || {};\n  if (node === container.__shady.firstChild) {\n    container.__shady.firstChild = node.__shady.nextSibling;\n  }\n  if (node === container.__shady.lastChild) {\n    container.__shady.lastChild = node.__shady.previousSibling;\n  }\n  let p = node.__shady.previousSibling;\n  let n = node.__shady.nextSibling;\n  if (p) {\n    p.__shady = p.__shady || {};\n    p.__shady.nextSibling = n;\n  }\n  if (n) {\n    n.__shady = n.__shady || {};\n    n.__shady.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  node.__shady.parentNode = node.__shady.previousSibling =\n    node.__shady.nextSibling = undefined;\n  if (container.__shady.childNodes !== undefined) {\n    // remove caching of childNodes\n    container.__shady.childNodes = null;\n  }\n}\n\nexport let recordChildNodes = function(node) {\n  if (!node.__shady || node.__shady.firstChild === undefined) {\n    node.__shady = node.__shady || {};\n    node.__shady.firstChild = firstChild(node);\n    node.__shady.lastChild = lastChild(node);\n    patchInsideElementAccessors(node);\n    let c$ = node.__shady.childNodes = childNodes(node);\n    for (let i=0, n; (i<c$.length) && (n=c$[i]); i++) {\n      n.__shady = n.__shady || {};\n      n.__shady.parentNode = node;\n      n.__shady.nextSibling = c$[i+1] || null;\n      n.__shady.previousSibling = c$[i-1] || null;\n      patchOutsideElementAccessors(n);\n    }\n  }\n}","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport * as utils from './utils'\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  node.__shady = node.__shady || {};\n  if (!node.__shady.observer) {\n    node.__shady.observer = new AsyncObserver();\n  }\n  node.__shady.observer.callbacks.add(callback);\n  let observer = node.__shady.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      handle._node.__shady.observer = null;\n    }\n  }\n}\n\nexport function filterMutations(mutations, target) {\n  /** @const {Node} */\n  const targetRootNode = target.getRootNode();\n  return mutations.map(function(mutation) {\n    /** @const {boolean} */\n    const mutationInScope = (targetRootNode === mutation.target.getRootNode());\n    if (mutationInScope && mutation.addedNodes) {\n      let nodes = Array.from(mutation.addedNodes).filter(function(n) {\n        return (targetRootNode === n.getRootNode());\n      });\n      if (nodes.length) {\n        mutation = Object.create(mutation);\n        Object.defineProperty(mutation, 'addedNodes', {\n          value: nodes,\n          configurable: true\n        });\n        return mutation;\n      }\n    } else if (mutationInScope) {\n      return mutation;\n    }\n  }).filter(function(m) { return m});\n}","/**\n@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'use strict';\n\nexport let settings = window['ShadyDOM'] || {};\n\nsettings.hasNativeShadowDOM = Boolean(Element.prototype.attachShadow && Node.prototype.getRootNode);\n\nlet desc = Object.getOwnPropertyDescriptor(Node.prototype, 'firstChild');\n\nsettings.hasDescriptors = Boolean(desc && desc.configurable && desc.get);\nsettings.inUse = settings['force'] || !settings.hasNativeShadowDOM;\n\nexport function isShadyRoot(obj) {\n  return Boolean(obj.__localName === 'ShadyRoot');\n}\n\nexport function ownerShadyRootForNode(node) {\n  let root = node.getRootNode();\n  if (isShadyRoot(root)) {\n    return root;\n  }\n}\n\nlet p = Element.prototype;\nlet matches = p.matches || p.matchesSelector ||\n  p.mozMatchesSelector || p.msMatchesSelector ||\n  p.oMatchesSelector || p.webkitMatchesSelector;\n\nexport function matchesSelector(element, selector) {\n  return matches.call(element, selector);\n}\n\nfunction copyOwnProperty(name, source, target) {\n  let pd = Object.getOwnPropertyDescriptor(source, name);\n  if (pd) {\n    Object.defineProperty(target, name, pd);\n  }\n}\n\nexport function extend(target, source) {\n  if (target && source) {\n    let n$ = Object.getOwnPropertyNames(source);\n    for (let i=0, n; (i<n$.length) && (n=n$[i]); i++) {\n      copyOwnProperty(n, source, target);\n    }\n  }\n  return target || source;\n}\n\nexport function extendAll(target, ...sources) {\n  for (let i=0; i < sources.length; i++) {\n    extend(target, sources[i]);\n  }\n  return target;\n}\n\nexport function mixin(target, source) {\n  for (var i in source) {\n    target[i] = source[i];\n  }\n  return target;\n}\n\nexport function patchPrototype(obj, mixin) {\n  let proto = Object.getPrototypeOf(obj);\n  if (!proto.hasOwnProperty('__patchProto')) {\n    let patchProto = Object.create(proto);\n    patchProto.__sourceProto = proto;\n    extend(patchProto, mixin);\n    proto['__patchProto'] = patchProto;\n  }\n  // old browsers don't have setPrototypeOf\n  obj.__proto__ = proto['__patchProto'];\n}\n\n\nlet twiddle = document.createTextNode('');\nlet content = 0;\nlet queue = [];\nnew MutationObserver(() => {\n  while (queue.length) {\n    // catch errors in user code...\n    try {\n      queue.shift()();\n    } catch(e) {\n      // enqueue another record and throw\n      twiddle.textContent = content++;\n      throw(e);\n    }\n  }\n}).observe(twiddle, {characterData: true});\n\n// use MutationObserver to get microtask async timing.\nexport function microtask(callback) {\n  queue.push(callback);\n  twiddle.textContent = content++;\n}","/**\n@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'use strict';\n\nimport * as utils from './utils'\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@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'use strict';\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@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'use strict';\n\nimport {getInnerHTML} from './innerHTML'\n\nlet nodeWalker = document.createTreeWalker(document, NodeFilter.SHOW_ALL,\n  null, false);\n\nlet elementWalker = document.createTreeWalker(document, NodeFilter.SHOW_ELEMENT,\n  null, false);\n\nexport function parentNode(node) {\n  nodeWalker.currentNode = node;\n  return nodeWalker.parentNode();\n}\n\nexport function firstChild(node) {\n  nodeWalker.currentNode = node;\n  return nodeWalker.firstChild();\n}\n\nexport function lastChild(node) {\n  nodeWalker.currentNode = node;\n  return nodeWalker.lastChild();\n}\n\nexport function previousSibling(node) {\n  nodeWalker.currentNode = node;\n  return nodeWalker.previousSibling();\n}\n\nexport function nextSibling(node) {\n  nodeWalker.currentNode = node;\n  return nodeWalker.nextSibling();\n}\n\nexport function childNodes(node) {\n  let nodes = [];\n  nodeWalker.currentNode = node;\n  let n = nodeWalker.firstChild();\n  while (n) {\n    nodes.push(n);\n    n = nodeWalker.nextSibling();\n  }\n  return nodes;\n}\n\nexport function parentElement(node) {\n  elementWalker.currentNode = node;\n  return elementWalker.parentNode();\n}\n\nexport function firstElementChild(node) {\n  elementWalker.currentNode = node;\n  return elementWalker.firstChild();\n}\n\nexport function lastElementChild(node) {\n  elementWalker.currentNode = node;\n  return elementWalker.lastChild();\n}\n\nexport function previousElementSibling(node) {\n  elementWalker.currentNode = node;\n  return elementWalker.previousSibling();\n}\n\nexport function nextElementSibling(node) {\n  elementWalker.currentNode = node;\n  return elementWalker.nextSibling();\n}\n\nexport function children(node) {\n  let nodes = [];\n  elementWalker.currentNode = node;\n  let n = elementWalker.firstChild();\n  while (n) {\n    nodes.push(n);\n    n = elementWalker.nextSibling();\n  }\n  return nodes;\n}\n\nexport function innerHTML(node) {\n  return getInnerHTML(node, (n) => childNodes(n));\n}\n\nexport function textContent(node) {\n  if (node.nodeType !== Node.ELEMENT_NODE) {\n    return node.nodeValue;\n  }\n  let textWalker = document.createTreeWalker(node, NodeFilter.SHOW_TEXT,\n    null, false);\n  let content = '', n;\n  while ( (n = textWalker.nextNode()) ) {\n    // TODO(sorvell): can't use textContent since we patch it on Node.prototype!\n    // However, should probably patch it only on element.\n    content += n.nodeValue;\n  }\n  return content;\n}","/**\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'use strict';\n\nimport * as utils from './utils'\nimport {getInnerHTML} from './innerHTML'\nimport * as nativeTree from './native-tree'\n\nfunction clearNode(node) {\n  while (node.firstChild) {\n    node.removeChild(node.firstChild);\n  }\n}\n\nconst nativeInnerHTMLDesc = /** @type {ObjectPropertyDescriptor} */(\n  Object.getOwnPropertyDescriptor(Element.prototype, 'innerHTML') ||\n  Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'innerHTML'));\n\nconst inertDoc = document.implementation.createHTMLDocument('inert');\nconst htmlContainer = inertDoc.createElement('div');\n\nconst nativeActiveElementDescriptor =\n  /** @type {ObjectPropertyDescriptor} */(\n    Object.getOwnPropertyDescriptor(Document.prototype, 'activeElement')\n  );\nfunction getDocumentActiveElement() {\n  if (nativeActiveElementDescriptor && nativeActiveElementDescriptor.get) {\n    return nativeActiveElementDescriptor.get.call(document);\n  } else if (!utils.settings.hasDescriptors) {\n    return document.activeElement;\n  }\n}\n\nfunction activeElementForNode(node) {\n  let active = getDocumentActiveElement();\n  // In IE11, activeElement might be an empty object if the document is\n  // contained in an iframe.\n  // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/10998788/\n  if (!active || !active.nodeType) {\n    return null;\n  }\n  let isShadyRoot = !!(utils.isShadyRoot(node));\n  if (node !== document) {\n    // If this node isn't a document or shady root, then it doesn't have\n    // an active element.\n    if (!isShadyRoot) {\n      return null;\n    }\n    // If this shady root's host is the active element or the active\n    // element is not a descendant of the host (in the composed tree),\n    // then it doesn't have an active element.\n    if (node.host === active ||\n        !node.host.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 = utils.ownerShadyRootForNode(active);\n  while (activeRoot && activeRoot !== node) {\n    active = activeRoot.host;\n    activeRoot = utils.ownerShadyRootForNode(active);\n  }\n  if (node === document) {\n    // This node is the document, so activeRoot should be null.\n    return activeRoot ? null : active;\n  } else {\n    // This node is a non-document shady root, and it should be\n    // activeRoot.\n    return activeRoot === node ? active : null;\n  }\n}\n\nlet OutsideAccessors = {\n\n  parentElement: {\n    /** @this {Node} */\n    get() {\n      let l = this.__shady && this.__shady.parentNode;\n      if (l && l.nodeType !== Node.ELEMENT_NODE) {\n        l = null;\n      }\n      return l !== undefined ? l : nativeTree.parentElement(this);\n    },\n    configurable: true\n  },\n\n  parentNode: {\n    /** @this {Node} */\n    get() {\n      let l = this.__shady && this.__shady.parentNode;\n      return l !== undefined ? l : nativeTree.parentNode(this);\n    },\n    configurable: true\n  },\n\n  nextSibling: {\n    /** @this {Node} */\n    get() {\n      let l = this.__shady && this.__shady.nextSibling;\n      return l !== undefined ? l : nativeTree.nextSibling(this);\n    },\n    configurable: true\n  },\n\n  previousSibling: {\n    /** @this {Node} */\n    get() {\n      let l = this.__shady && this.__shady.previousSibling;\n      return l !== undefined ? l : nativeTree.previousSibling(this);\n    },\n    configurable: true\n  },\n\n  className: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      return this.getAttribute('class') || '';\n    },\n    /**\n     * @this {HTMLElement}\n     */\n    set(value) {\n      this.setAttribute('class', value);\n    },\n    configurable: true\n  },\n\n  // fragment, element, document\n  nextElementSibling: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      if (this.__shady && this.__shady.nextSibling !== undefined) {\n        let n = this.nextSibling;\n        while (n && n.nodeType !== Node.ELEMENT_NODE) {\n          n = n.nextSibling;\n        }\n        return n;\n      } else {\n        return nativeTree.nextElementSibling(this);\n      }\n    },\n    configurable: true\n  },\n\n  previousElementSibling: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      if (this.__shady && this.__shady.previousSibling !== undefined) {\n        let n = this.previousSibling;\n        while (n && n.nodeType !== Node.ELEMENT_NODE) {\n          n = n.previousSibling;\n        }\n        return n;\n      } else {\n        return nativeTree.previousElementSibling(this);\n      }\n    },\n    configurable: true\n  }\n\n};\n\nlet InsideAccessors = {\n\n  childNodes: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      let childNodes;\n      if (this.__shady && this.__shady.firstChild !== undefined) {\n        if (!this.__shady.childNodes) {\n          this.__shady.childNodes = [];\n          for (let n=this.firstChild; n; n=n.nextSibling) {\n            this.__shady.childNodes.push(n);\n          }\n        }\n        childNodes = this.__shady.childNodes;\n      } else {\n        childNodes = nativeTree.childNodes(this);\n      }\n      childNodes.item = function(index) {\n        return childNodes[index];\n      }\n      return childNodes;\n    },\n    configurable: true\n  },\n\n  childElementCount: {\n    /** @this {HTMLElement} */\n    get() {\n      return this.children.length;\n    },\n    configurable: true\n  },\n\n  firstChild: {\n    /** @this {HTMLElement} */\n    get() {\n      let l = this.__shady && this.__shady.firstChild;\n      return l !== undefined ? l : nativeTree.firstChild(this);\n    },\n    configurable: true\n  },\n\n  lastChild: {\n  /** @this {HTMLElement} */\n    get() {\n      let l = this.__shady && this.__shady.lastChild;\n      return l !== undefined ? l : nativeTree.lastChild(this);\n    },\n    configurable: true\n  },\n\n  textContent: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      if (this.__shady && this.__shady.firstChild !== undefined) {\n        let tc = [];\n        for (let i = 0, cn = this.childNodes, c; (c = cn[i]); i++) {\n          if (c.nodeType !== Node.COMMENT_NODE) {\n            tc.push(c.textContent);\n          }\n        }\n        return tc.join('');\n      } else {\n        return nativeTree.textContent(this);\n      }\n    },\n    /**\n     * @this {HTMLElement}\n     */\n    set(text) {\n      if (this.nodeType !== Node.ELEMENT_NODE) {\n        // TODO(sorvell): can't do this if patch nodeValue.\n        this.nodeValue = text;\n      } else {\n        clearNode(this);\n        this.appendChild(document.createTextNode(text));\n      }\n    },\n    configurable: true\n  },\n\n  // fragment, element, document\n  firstElementChild: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      if (this.__shady && this.__shady.firstChild !== undefined) {\n        let n = this.firstChild;\n        while (n && n.nodeType !== Node.ELEMENT_NODE) {\n          n = n.nextSibling;\n        }\n        return n;\n      } else {\n        return nativeTree.firstElementChild(this);\n      }\n    },\n    configurable: true\n  },\n\n  lastElementChild: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      if (this.__shady && this.__shady.lastChild !== undefined) {\n        let n = this.lastChild;\n        while (n && n.nodeType !== Node.ELEMENT_NODE) {\n          n = n.previousSibling;\n        }\n        return n;\n      } else {\n        return nativeTree.lastElementChild(this);\n      }\n    },\n    configurable: true\n  },\n\n  children: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      let children;\n      if (this.__shady && this.__shady.firstChild !== undefined) {\n        children = Array.prototype.filter.call(this.childNodes, function(n) {\n          return (n.nodeType === Node.ELEMENT_NODE);\n        });\n      } else {\n        children = nativeTree.children(this);\n      }\n      children.item = function(index) {\n        return children[index];\n      }\n      return children;\n    },\n    configurable: true\n  },\n\n  // element (HTMLElement on IE11)\n  innerHTML: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      let content = this.localName === 'template' ?\n        /** @type {HTMLTemplateElement} */(this).content : this;\n      if (this.__shady && this.__shady.firstChild !== undefined) {\n        return getInnerHTML(content);\n      } else {\n        return nativeTree.innerHTML(content);\n      }\n    },\n    /**\n     * @this {HTMLElement}\n     */\n    set(text) {\n      let content = this.localName === 'template' ?\n        /** @type {HTMLTemplateElement} */(this).content : this;\n      clearNode(content);\n      if (nativeInnerHTMLDesc && nativeInnerHTMLDesc.set) {\n        nativeInnerHTMLDesc.set.call(htmlContainer, text);\n      } else {\n        htmlContainer.innerHTML = text;\n      }\n      while (htmlContainer.firstChild) {\n        content.appendChild(htmlContainer.firstChild);\n      }\n    },\n    configurable: true\n  }\n\n};\n\n// Note: Can be patched on element prototype on all browsers.\n// Must be patched on instance on browsers that support native Shadow DOM\n// but do not have builtin accessors (old Chrome).\nexport let ShadowRootAccessor = {\n\n  shadowRoot: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      return this.__shady && this.__shady.root || null;\n    },\n    /**\n     * @this {HTMLElement}\n     */\n    set(value) {\n      this.__shady = this.__shady || {};\n      this.__shady.root = value;\n    },\n    configurable: true\n  }\n};\n\n// Note: Can be patched on document prototype on browsers with builtin accessors.\n// Must be patched separately on simulated ShadowRoot.\n// Must be patched as `_activeElement` on browsers without builtin accessors.\nexport let ActiveElementAccessor = {\n\n  activeElement: {\n    /**\n     * @this {HTMLElement}\n     */\n    get() {\n      return activeElementForNode(this);\n    },\n    /**\n     * @this {HTMLElement}\n     */\n    set() {},\n    configurable: true\n  }\n\n};\n\n// patch a group of descriptors on an object only if it exists or if the `force`\n// argument is true.\n/**\n * @param {!Object} obj\n * @param {!Object} descriptors\n * @param {boolean=} force\n */\nfunction patchAccessorGroup(obj, descriptors, force) {\n  for (let p in descriptors) {\n    let objDesc = Object.getOwnPropertyDescriptor(obj, p);\n    if ((objDesc && objDesc.configurable) ||\n      (!objDesc && force)) {\n      Object.defineProperty(obj, p, descriptors[p]);\n    } else if (force) {\n      console.warn('Could not define', p, 'on', obj);\n    }\n  }\n}\n\n// patch dom accessors on proto where they exist\nexport function patchAccessors(proto) {\n  patchAccessorGroup(proto, OutsideAccessors);\n  patchAccessorGroup(proto, InsideAccessors);\n  patchAccessorGroup(proto, ActiveElementAccessor);\n}\n\n// ensure element descriptors (IE/Edge don't have em)\nexport function patchShadowRootAccessors(proto) {\n  patchAccessorGroup(proto, InsideAccessors, true);\n  patchAccessorGroup(proto, ActiveElementAccessor, true);\n}\n\n// ensure an element has patched \"outside\" accessors; no-op when not needed\nexport let patchOutsideElementAccessors = utils.settings.hasDescriptors ?\n  function() {} : function(element) {\n    if (!(element.__shady && element.__shady.__outsideAccessors)) {\n      element.__shady = element.__shady || {};\n      element.__shady.__outsideAccessors = true;\n      patchAccessorGroup(element, OutsideAccessors, true);\n    }\n  }\n\n// ensure an element has patched \"inside\" accessors; no-op when not needed\nexport let patchInsideElementAccessors = utils.settings.hasDescriptors ?\n  function() {} : function(element) {\n    if (!(element.__shady && element.__shady.__insideAccessors)) {\n      element.__shady = element.__shady || {};\n      element.__shady.__insideAccessors = true;\n      patchAccessorGroup(element, InsideAccessors, true);\n      patchAccessorGroup(element, ShadowRootAccessor, true);\n    }\n  }\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport * as utils from './utils'\nimport * as logicalTree from './logical-tree'\nimport * as nativeMethods from './native-methods'\nimport {parentNode} from './native-tree'\n\n/**\n * Try to add node. Record logical info, track insertion points, perform\n * distribution iff needed. Return true if the add is handled.\n * @param {Node} container\n * @param {Node} node\n * @param {Node} ref_node\n * @return {boolean}\n */\nfunction addNode(container, node, ref_node) {\n  let ownerRoot = utils.ownerShadyRootForNode(container);\n  let ipAdded;\n  if (ownerRoot) {\n    // optimization: special insertion point tracking\n    // TODO(sorvell): verify that the renderPending check here should not be needed.\n    if (node['__noInsertionPoint'] && !ownerRoot._changePending) {\n      ownerRoot._skipUpdateInsertionPoints = true;\n    }\n    // note: we always need to see if an insertion point is added\n    // since this saves logical tree info; however, invalidation state\n    // needs\n    ipAdded = _maybeAddInsertionPoint(node, container, ownerRoot);\n    // invalidate insertion points IFF not already invalid!\n    if (ipAdded) {\n      ownerRoot._skipUpdateInsertionPoints = false;\n    }\n  }\n  if (container.__shady && container.__shady.firstChild !== undefined) {\n    logicalTree.recordInsertBefore(node, container, ref_node);\n  }\n  // if not distributing and not adding to host, do a fast path addition\n  // TODO(sorvell): revisit flow since `ipAdded` needed here if\n  // node is a fragment that has a patched QSA.\n  let handled = _maybeDistribute(node, container, ownerRoot, ipAdded) ||\n    container.__shady.root ||\n    // TODO(sorvell): we *should* consider the add \"handled\"\n    // if the container or ownerRoot is `_renderPending`.\n    // However, this will regress performance right now and is blocked on a\n    // fix for https://github.com/webcomponents/shadydom/issues/95\n    // handled if ref_node parent is a root that is rendering.\n    (ref_node && utils.isShadyRoot(ref_node.parentNode) &&\n      ref_node.parentNode._renderPending);\n  return handled;\n}\n\n\n/**\n * Try to remove node: update logical info and perform distribution iff\n * needed. Return true if the removal has been handled.\n * note that it's possible for both the node's host and its parent\n * to require distribution... both cases are handled here.\n * @param {Node} node\n * @return {boolean}\n */\nfunction removeNode(node) {\n  // important that we want to do this only if the node has a logical parent\n  let logicalParent = node.__shady && node.__shady.parentNode;\n  let distributed;\n  let ownerRoot = utils.ownerShadyRootForNode(node);\n  if (logicalParent || ownerRoot) {\n    // distribute node's parent iff needed\n    distributed = maybeDistributeParent(node);\n    if (logicalParent) {\n      logicalTree.recordRemoveChild(node, logicalParent);\n    }\n    // remove node from root and distribute it iff needed\n    let removedDistributed = ownerRoot &&\n      _removeDistributedChildren(ownerRoot, node);\n    let addedInsertionPoint = (logicalParent && ownerRoot &&\n      logicalParent.localName === ownerRoot.getInsertionPointTag());\n    if (removedDistributed || addedInsertionPoint) {\n      ownerRoot._skipUpdateInsertionPoints = false;\n      updateRootViaContentChange(ownerRoot);\n    }\n  }\n  _removeOwnerShadyRoot(node);\n  return distributed;\n}\n\n/**\n * @param {Node} node\n * @param {Node=} addedNode\n * @param {Node=} removedNode\n */\nfunction _scheduleObserver(node, addedNode, removedNode) {\n  let observer = node.__shady && node.__shady.observer;\n  if (observer) {\n    if (addedNode) {\n      observer.addedNodes.push(addedNode);\n    }\n    if (removedNode) {\n      observer.removedNodes.push(removedNode);\n    }\n    observer.schedule();\n  }\n}\n\nfunction removeNodeFromParent(node, logicalParent) {\n  if (logicalParent) {\n    _scheduleObserver(logicalParent, null, node);\n    return removeNode(node);\n  } else {\n    // composed but not logical parent\n    if (node.parentNode) {\n      nativeMethods.removeChild.call(node.parentNode, node);\n    }\n    _removeOwnerShadyRoot(node);\n  }\n}\n\nfunction _hasCachedOwnerRoot(node) {\n  return Boolean(node.__shady && node.__shady.ownerShadyRoot !== undefined);\n}\n\n/**\n * @param {Node} node\n * @param {Object=} options\n */\nexport function getRootNode(node, options) { // eslint-disable-line no-unused-vars\n  if (!node || !node.nodeType) {\n    return;\n  }\n  node.__shady = node.__shady || {};\n  let root = node.__shady.ownerShadyRoot;\n  if (root === undefined) {\n    if (utils.isShadyRoot(node)) {\n      root = node;\n    } else {\n      let parent = node.parentNode;\n      root = parent ? getRootNode(parent) : node;\n    }\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.contains(node)) {\n      node.__shady.ownerShadyRoot = root;\n    }\n  }\n  return root;\n}\n\nfunction _maybeDistribute(node, container, ownerRoot, ipAdded) {\n  // TODO(sorvell): technically we should check non-fragment nodes for\n  // <content> children but since this case is assumed to be exceedingly\n  // rare, we avoid the cost and will address with some specific api\n  // when the need arises.  For now, the user must call\n  // distributeContent(true), which updates insertion points manually\n  // and forces distribution.\n  let insertionPointTag = ownerRoot && ownerRoot.getInsertionPointTag() || '';\n  let fragContent = (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) &&\n    !node['__noInsertionPoint'] &&\n    insertionPointTag && node.querySelector(insertionPointTag);\n  let wrappedContent = fragContent &&\n    (fragContent.parentNode.nodeType !==\n    Node.DOCUMENT_FRAGMENT_NODE);\n  let hasContent = fragContent || (node.localName === insertionPointTag);\n  // There are 3 possible cases where a distribution may need to occur:\n  // 1. <content> being inserted (the host of the shady root where\n  //    content is inserted needs distribution)\n  // 2. children being inserted into parent with a shady root (parent\n  //    needs distribution)\n  // 3. container is an insertionPoint\n  if (hasContent || (container.localName === insertionPointTag) || ipAdded) {\n    if (ownerRoot) {\n      // note, insertion point list update is handled after node\n      // mutations are complete\n      updateRootViaContentChange(ownerRoot);\n    }\n  }\n  let needsDist = _nodeNeedsDistribution(container);\n  if (needsDist) {\n    let root = container.__shady && container.__shady.root;\n    updateRootViaContentChange(root);\n  }\n  // Return true when distribution will fully handle the composition\n  // Note that if a content was being inserted that was wrapped by a node,\n  // and the parent does not need distribution, return false to allow\n  // the nodes to be added directly, after which children may be\n  // distributed and composed into the wrapping node(s)\n  return needsDist || (hasContent && !wrappedContent);\n}\n\n/* note: parent argument is required since node may have an out\nof date parent at this point; returns true if a <content> is being added */\nfunction _maybeAddInsertionPoint(node, parent, root) {\n  let added;\n  let insertionPointTag = root.getInsertionPointTag();\n  if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE &&\n    !node['__noInsertionPoint']) {\n    let c$ = node.querySelectorAll(insertionPointTag);\n    for (let i=0, n, np, na; (i<c$.length) && (n=c$[i]); i++) {\n      np = n.parentNode;\n      // don't allow node's parent to be fragment itself\n      if (np === node) {\n        np = parent;\n      }\n      na = _maybeAddInsertionPoint(n, np, root);\n      added = added || na;\n    }\n  } else if (node.localName === insertionPointTag) {\n    logicalTree.recordChildNodes(parent);\n    logicalTree.recordChildNodes(node);\n    added = true;\n  }\n  return added;\n}\n\nfunction _nodeNeedsDistribution(node) {\n  let root = node && node.__shady && node.__shady.root;\n  return root && root.hasInsertionPoint();\n}\n\nfunction _removeDistributedChildren(root, container) {\n  let hostNeedsDist;\n  let ip$ = root._getInsertionPoints();\n  for (let i=0; i<ip$.length; i++) {\n    let insertionPoint = ip$[i];\n    if (_contains(container, insertionPoint)) {\n      let dc$ = insertionPoint.assignedNodes({flatten: true});\n      for (let j=0; j<dc$.length; j++) {\n        hostNeedsDist = true;\n        let node = dc$[j];\n        let parent = parentNode(node);\n        if (parent) {\n          nativeMethods.removeChild.call(parent, node);\n        }\n      }\n    }\n  }\n  return hostNeedsDist;\n}\n\nfunction _contains(container, node) {\n  while (node) {\n    if (node == container) {\n      return true;\n    }\n    node = node.parentNode;\n  }\n}\n\nfunction _removeOwnerShadyRoot(node) {\n  // optimization: only reset the tree if node is actually in a root\n  if (_hasCachedOwnerRoot(node)) {\n    let c$ = node.childNodes;\n    for (let i=0, l=c$.length, n; (i<l) && (n=c$[i]); i++) {\n      _removeOwnerShadyRoot(n);\n    }\n  }\n  node.__shady = node.__shady || {};\n  node.__shady.ownerShadyRoot = undefined;\n}\n\n// TODO(sorvell): This will fail if distribution that affects this\n// question is pending; this is expected to be exceedingly rare, but if\n// the issue comes up, we can force a flush in this case.\nfunction firstComposedNode(insertionPoint) {\n  let n$ = insertionPoint.assignedNodes({flatten: true});\n  let root = getRootNode(insertionPoint);\n  for (let i=0, l=n$.length, n; (i<l) && (n=n$[i]); i++) {\n    // means that we're composed to this spot.\n    if (root.isFinalDestination(insertionPoint, n)) {\n      return n;\n    }\n  }\n}\n\nfunction maybeDistributeParent(node) {\n  let parent = node.parentNode;\n  if (_nodeNeedsDistribution(parent)) {\n    updateRootViaContentChange(parent.__shady.root);\n    return true;\n  }\n}\n\nfunction updateRootViaContentChange(root) {\n  // mark root as mutation based on a mutation\n  root._changePending = true;\n  root.update();\n}\n\nfunction distributeAttributeChange(node, name) {\n  if (name === 'slot') {\n    maybeDistributeParent(node);\n  } else if (node.localName === 'slot' && name === 'name') {\n    let root = utils.ownerShadyRootForNode(node);\n    if (root) {\n      root.update();\n    }\n  }\n}\n\n// NOTE: `query` is used primarily for ShadyDOM's querySelector impl,\n// but it's also generally useful to recurse through the element tree\n// and is used by Polymer's styling system.\n/**\n * @param {Node} node\n * @param {Function} matcher\n * @param {Function=} halter\n */\nexport function query(node, matcher, halter) {\n  let list = [];\n  _queryElements(node.childNodes, matcher,\n    halter, list);\n  return list;\n}\n\nfunction _queryElements(elements, matcher, halter, list) {\n  for (let i=0, l=elements.length, c; (i<l) && (c=elements[i]); i++) {\n    if (c.nodeType === Node.ELEMENT_NODE &&\n        _queryElement(c, matcher, halter, list)) {\n      return true;\n    }\n  }\n}\n\nfunction _queryElement(node, matcher, halter, list) {\n  let result = matcher(node);\n  if (result) {\n    list.push(node);\n  }\n  if (halter && halter(result)) {\n    return result;\n  }\n  _queryElements(node.childNodes, matcher,\n    halter, list);\n}\n\nexport function renderRootNode(element) {\n  var root = element.getRootNode();\n  if (utils.isShadyRoot(root)) {\n    root.render();\n  }\n}\n\nlet scopingShim = null;\n\nexport function setAttribute(node, attr, value) {\n  if (!scopingShim) {\n    scopingShim = window['ShadyCSS'] && window['ShadyCSS']['ScopingShim'];\n  }\n  if (scopingShim && attr === 'class') {\n    scopingShim['setElementClass'](node, value);\n  } else {\n    nativeMethods.setAttribute.call(node, attr, value);\n    distributeAttributeChange(node, attr);\n  }\n}\n\nexport function removeAttribute(node, attr) {\n  nativeMethods.removeAttribute.call(node, attr);\n  distributeAttributeChange(node, attr);\n}\n\n// cases in which we may not be able to just do standard native call\n// 1. container has a shadyRoot (needsDistribution IFF the shadyRoot\n// has an insertion point)\n// 2. container is a shadyRoot (don't distribute, instead set\n// container to container.host.\n// 3. node is <content> (host of container needs distribution)\n/**\n * @param {Node} parent\n * @param {Node} node\n * @param {Node=} ref_node\n */\nexport function insertBefore(parent, node, ref_node) {\n  if (ref_node) {\n    let p = ref_node.__shady && ref_node.__shady.parentNode;\n    if ((p !== undefined && p !== parent) ||\n      (p === undefined && parentNode(ref_node) !== parent)) {\n      throw Error(`Failed to execute 'insertBefore' on 'Node': The node ` +\n       `before which the new node is to be inserted is not a child of this node.`);\n    }\n  }\n  if (ref_node === node) {\n    return node;\n  }\n  // remove node from its current position iff it's in a tree.\n  if (node.nodeType !== Node.DOCUMENT_FRAGMENT_NODE) {\n    let parent = node.__shady && node.__shady.parentNode;\n    removeNodeFromParent(node, parent);\n  }\n  if (!addNode(parent, node, ref_node)) {\n    if (ref_node) {\n      // if ref_node is an insertion point replace with first distributed node\n      let root = utils.ownerShadyRootForNode(ref_node);\n      if (root) {\n        ref_node = ref_node.localName === root.getInsertionPointTag() ?\n          firstComposedNode(/** @type {!HTMLSlotElement} */(ref_node)) : ref_node;\n      }\n    }\n    // if adding to a shadyRoot, add to host instead\n    let container = utils.isShadyRoot(parent) ? /** @type {ShadowRoot} */(parent).host : parent;\n    if (ref_node) {\n      nativeMethods.insertBefore.call(container, node, ref_node);\n    } else {\n      nativeMethods.appendChild.call(container, node);\n    }\n  }\n  _scheduleObserver(parent, node);\n  return node;\n}\n\n/**\n  Removes the given `node` from the element's `lightChildren`.\n  This method also performs dom composition.\n*/\nexport function removeChild(parent, node) {\n  if (node.parentNode !== parent) {\n    throw Error('The node to be removed is not a child of this node: ' +\n      node);\n  }\n  if (!removeNode(node)) {\n    // if removing from a shadyRoot, remove form host instead\n    let container = utils.isShadyRoot(parent) ?\n      parent.host :\n      parent;\n    // not guaranteed to physically be in container; e.g.\n    // undistributed nodes.\n    let nativeParent = parentNode(node);\n    if (container === nativeParent) {\n      nativeMethods.removeChild.call(container, node);\n    }\n  }\n  _scheduleObserver(parent, null, node);\n  return node;\n}\n\nexport function cloneNode(node, deep) {\n  if (node.localName == 'template') {\n    return nativeMethods.cloneNode.call(node, deep);\n  } else {\n    let n = nativeMethods.cloneNode.call(node, false);\n    if (deep) {\n      let c$ = node.childNodes;\n      for (let i=0, nc; i < c$.length; i++) {\n        nc = c$[i].cloneNode(true);\n        n.appendChild(nc);\n      }\n    }\n    return n;\n  }\n}\n\n// note: Though not technically correct, we fast path `importNode`\n// when called on a node not owned by the main document.\n// This allows, for example, elements that cannot\n// contain custom elements and are therefore not likely to contain shadowRoots\n// to cloned natively. This is a fairly significant performance win.\nexport function importNode(node, deep) {\n  if (node.ownerDocument !== document) {\n    return nativeMethods.importNode.call(document, node, deep);\n  }\n  let n = nativeMethods.importNode.call(document, node, false);\n  if (deep) {\n    let c$ = node.childNodes;\n    for (let i=0, nc; i < c$.length; i++) {\n      nc = importNode(c$[i], true);\n      n.appendChild(nc);\n    }\n  }\n  return n;\n}\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'use strict';\n\nimport * as utils from './utils'\nimport * as nativeMethods from './native-methods'\n\n// https://github.com/w3c/webcomponents/issues/513#issuecomment-224183937\nlet alwaysComposed = {\n  'blur': true,\n  'focus': true,\n  'focusin': true,\n  'focusout': true,\n  'click': true,\n  'dblclick': true,\n  'mousedown': true,\n  'mouseenter': true,\n  'mouseleave': true,\n  'mousemove': true,\n  'mouseout': true,\n  'mouseover': true,\n  'mouseup': true,\n  'wheel': true,\n  'beforeinput': true,\n  'input': true,\n  'keydown': true,\n  'keyup': true,\n  'compositionstart': true,\n  'compositionupdate': true,\n  'compositionend': true,\n  'touchstart': true,\n  'touchend': true,\n  'touchmove': true,\n  'touchcancel': true,\n  'pointerover': true,\n  'pointerenter': true,\n  'pointerdown': true,\n  'pointermove': true,\n  'pointerup': true,\n  'pointercancel': true,\n  'pointerout': true,\n  'pointerleave': true,\n  'gotpointercapture': true,\n  'lostpointercapture': true,\n  'dragstart': true,\n  'drag': true,\n  'dragenter': true,\n  'dragleave': true,\n  'dragover': true,\n  'drop': true,\n  'dragend': true,\n  'DOMActivate': true,\n  'DOMFocusIn': true,\n  'DOMFocusOut': true,\n  'keypress': true\n};\n\nfunction pathComposer(startNode, composed) {\n  let composedPath = [];\n  let current = startNode;\n  let startRoot = startNode === window ? window : startNode.getRootNode();\n  while (current) {\n    composedPath.push(current);\n    if (current.assignedSlot) {\n      current = current.assignedSlot;\n    } else if (current.nodeType === Node.DOCUMENT_FRAGMENT_NODE && current.host && (composed || current !== startRoot)) {\n      current = current.host;\n    } else {\n      current = current.parentNode;\n    }\n  }\n  // event composedPath includes window when startNode's ownerRoot is document\n  if (composedPath[composedPath.length - 1] === document) {\n    composedPath.push(window);\n  }\n  return composedPath;\n}\n\nfunction retarget(refNode, path) {\n  if (!utils.isShadyRoot) {\n    return refNode;\n  }\n  // If ANCESTOR's root is not a shadow root or ANCESTOR's root is BASE's\n  // shadow-including inclusive ancestor, return ANCESTOR.\n  let refNodePath = pathComposer(refNode, true);\n  let p$ = path;\n  for (let i=0, ancestor, lastRoot, root, rootIdx; i < p$.length; i++) {\n    ancestor = p$[i];\n    root = ancestor === window ? window : ancestor.getRootNode();\n    if (root !== lastRoot) {\n      rootIdx = refNodePath.indexOf(root);\n      lastRoot = root;\n    }\n    if (!utils.isShadyRoot(root) || rootIdx > -1) {\n      return ancestor;\n    }\n  }\n}\n\nlet eventMixin = {\n\n  /**\n   * @this {Event}\n   */\n  get composed() {\n    // isTrusted may not exist in this browser, so just check if isTrusted is explicitly false\n    if (this.isTrusted !== false && this.__composed === undefined) {\n      this.__composed = alwaysComposed[this.type];\n    }\n    return this.__composed || false;\n  },\n\n  /**\n   * @this {Event}\n   */\n  composedPath() {\n    if (!this.__composedPath) {\n      this.__composedPath = pathComposer(this['__target'], this.composed);\n    }\n    return this.__composedPath;\n  },\n\n  /**\n   * @this {Event}\n   */\n  get target() {\n    return retarget(this.currentTarget, this.composedPath());\n  },\n\n  // http://w3c.github.io/webcomponents/spec/shadow/#event-relatedtarget-retargeting\n  /**\n   * @this {Event}\n   */\n  get relatedTarget() {\n    if (!this.__relatedTarget) {\n      return null;\n    }\n    if (!this.__relatedTargetComposedPath) {\n      this.__relatedTargetComposedPath = pathComposer(this.__relatedTarget, true);\n    }\n    // find the deepest node in relatedTarget composed path that is in the same root with the currentTarget\n    return retarget(this.currentTarget, this.__relatedTargetComposedPath);\n  },\n  /**\n   * @this {Event}\n   */\n  stopPropagation() {\n    Event.prototype.stopPropagation.call(this);\n    this.__propagationStopped = true;\n  },\n  /**\n   * @this {Event}\n   */\n  stopImmediatePropagation() {\n    Event.prototype.stopImmediatePropagation.call(this);\n    this.__immediatePropagationStopped = true;\n    this.__propagationStopped = true;\n  }\n\n};\n\nfunction mixinComposedFlag(Base) {\n  // NOTE: avoiding use of `class` here so that transpiled output does not\n  // try to do `Base.call` with a dom construtor.\n  let klazz = function(type, options) {\n    let event = new Base(type, options);\n    event.__composed = options && Boolean(options['composed']);\n    return event;\n  }\n  // put constructor properties on subclass\n  utils.mixin(klazz, Base);\n  klazz.prototype = Base.prototype;\n  return klazz;\n}\n\nlet nonBubblingEventsToRetarget = {\n  'focus': true,\n  'blur': true\n};\n\n\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 (event.target === event.relatedTarget) {\n        return;\n      }\n      fn.call(node, event);\n      if (event.__immediatePropagationStopped) {\n        return;\n      }\n    }\n  }\n}\n\nfunction retargetNonBubblingEvent(e) {\n  let path = e.composedPath();\n  let node;\n  // override `currentTarget` to let patched `target` calculate correctly\n  Object.defineProperty(e, 'currentTarget', {\n    get: function() {\n      return node;\n    },\n    configurable: true\n  });\n  for (let i = path.length - 1; i >= 0; i--) {\n    node = path[i];\n    // capture phase fires all capture handlers\n    fireHandlers(e, node, 'capture');\n    if (e.__propagationStopped) {\n      return;\n    }\n  }\n\n  // set the event phase to `AT_TARGET` as in spec\n  Object.defineProperty(e, 'eventPhase', {get() { return Event.AT_TARGET }});\n\n  // the event only needs to be fired when owner roots change when iterating the event path\n  // keep track of the last seen owner root\n  let lastFiredRoot;\n  for (let i = 0; i < path.length; i++) {\n    node = path[i];\n    if (i === 0 || (node.shadowRoot && node.shadowRoot === lastFiredRoot)) {\n      fireHandlers(e, node, 'bubble');\n      // don't bother with window, it doesn't have `getRootNode` and will be last in the path anyway\n      if (node !== window) {\n        lastFiredRoot = node.getRootNode();\n      }\n      if (e.__propagationStopped) {\n        return;\n      }\n    }\n  }\n}\n\nfunction listenerSettingsEqual(savedListener, node, type, capture, once, passive) {\n  let {\n    node: savedNode,\n    type: savedType,\n    capture: savedCapture,\n    once: savedOnce,\n    passive: savedPassive\n  } = savedListener;\n  return node === savedNode &&\n    type === savedType &&\n    capture === savedCapture &&\n    once === savedOnce &&\n    passive === savedPassive;\n}\n\nexport function findListener(wrappers, node, type, capture, once, passive) {\n  for (let i = 0; i < wrappers.length; i++) {\n    if (listenerSettingsEqual(wrappers[i], node, type, capture, once, passive)) {\n      return i;\n    }\n  }\n  return -1;\n}\n\n/**\n * Firefox can throw on accessing __eventWrappers inside of `removeEventListener` during a selenium run\n * Try/Catch accessing __eventWrappers to work around\n * https://bugzilla.mozilla.org/show_bug.cgi?id=1353074\n */\nfunction getEventWrappers(eventLike) {\n  let wrappers = null;\n  try {\n    wrappers = eventLike.__eventWrappers;\n  } catch (e) {} // eslint-disable-line no-empty\n  return wrappers;\n}\n\n/**\n * @this {Event}\n */\nexport function addEventListener(type, fnOrObj, optionsOrCapture) {\n  if (!fnOrObj) {\n    return;\n  }\n\n  // The callback `fn` might be used for multiple nodes/events. Since we generate\n  // a wrapper function, we need to keep track of it when we remove the listener.\n  // It's more efficient to store the node/type/options information as Array in\n  // `fn` itself rather than the node (we assume that the same callback is used\n  // for few nodes at most, whereas a node will likely have many event listeners).\n  // NOTE(valdrin) invoking external functions is costly, inline has better perf.\n  let capture, once, passive;\n  if (typeof optionsOrCapture === 'object') {\n    capture = Boolean(optionsOrCapture.capture);\n    once = Boolean(optionsOrCapture.once);\n    passive = Boolean(optionsOrCapture.passive);\n  } else {\n    capture = Boolean(optionsOrCapture);\n    once = false;\n    passive = false;\n  }\n  // hack to let ShadyRoots have event listeners\n  // event listener will be on host, but `currentTarget`\n  // will be set to shadyroot for event listener\n  let target = (optionsOrCapture && optionsOrCapture.__shadyTarget) || this;\n\n  let wrappers = fnOrObj.__eventWrappers;\n  if (wrappers) {\n    // Stop if the wrapper function has already been created.\n    if (findListener(wrappers, target, type, capture, once, passive) > -1) {\n      return;\n    }\n  } else {\n    fnOrObj.__eventWrappers = [];\n  }\n\n  /**\n   * @this {HTMLElement}\n   */\n  const wrapperFn = function(e) {\n    // Support `once` option.\n    if (once) {\n      this.removeEventListener(type, fnOrObj, optionsOrCapture);\n    }\n    if (!e['__target']) {\n      patchEvent(e);\n    }\n    let lastCurrentTargetDesc;\n    if (target !== this) {\n      // replace `currentTarget` to make `target` and `relatedTarget` correct for inside the shadowroot\n      lastCurrentTargetDesc = Object.getOwnPropertyDescriptor(e, 'currentTarget');\n      Object.defineProperty(e, 'currentTarget', {get() { return target }, configurable: true});\n    }\n    // There are two critera that should stop events from firing on this node\n    // 1. the event is not composed and the current node is not in the same root as the target\n    // 2. when bubbling, if after retargeting, relatedTarget and target point to the same node\n    if (e.composed || e.composedPath().indexOf(target) > -1) {\n      if (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) {\n        return;\n      }\n      let ret = (typeof fnOrObj === 'object' && fnOrObj.handleEvent) ?\n        fnOrObj.handleEvent(e) :\n        fnOrObj.call(target, e);\n      if (target !== this) {\n        // replace the \"correct\" `currentTarget`\n        if (lastCurrentTargetDesc) {\n          Object.defineProperty(e, 'currentTarget', lastCurrentTargetDesc);\n          lastCurrentTargetDesc = null;\n        } else {\n          delete e['currentTarget'];\n        }\n      }\n      return ret;\n    }\n  };\n  // Store the wrapper information.\n  fnOrObj.__eventWrappers.push({\n    node: this,\n    type: type,\n    capture: capture,\n    once: once,\n    passive: passive,\n    wrapperFn: wrapperFn\n  });\n\n  if (nonBubblingEventsToRetarget[type]) {\n    this.__handlers = this.__handlers || {};\n    this.__handlers[type] = this.__handlers[type] ||\n      {'capture': [], 'bubble': []};\n    this.__handlers[type][capture ? 'capture' : 'bubble'].push(wrapperFn);\n  } else {\n    let ael = this instanceof Window ? nativeMethods.windowAddEventListener :\n      nativeMethods.addEventListener;\n    ael.call(this, type, wrapperFn, optionsOrCapture);\n  }\n}\n\n/**\n * @this {Event}\n */\nexport function removeEventListener(type, fnOrObj, optionsOrCapture) {\n  if (!fnOrObj) {\n    return;\n  }\n\n  // NOTE(valdrin) invoking external functions is costly, inline has better perf.\n  let capture, once, passive;\n  if (typeof optionsOrCapture === 'object') {\n    capture = Boolean(optionsOrCapture.capture);\n    once = Boolean(optionsOrCapture.once);\n    passive = Boolean(optionsOrCapture.passive);\n  } else {\n    capture = Boolean(optionsOrCapture);\n    once = false;\n    passive = false;\n  }\n  let target = (optionsOrCapture && optionsOrCapture.__shadyTarget) || this;\n  // Search the wrapped function.\n  let wrapperFn = undefined;\n  let wrappers = getEventWrappers(fnOrObj);\n  if (wrappers) {\n    let idx = findListener(wrappers, target, type, capture, once, passive);\n    if (idx > -1) {\n      wrapperFn = wrappers.splice(idx, 1)[0].wrapperFn;\n      // Cleanup.\n      if (!wrappers.length) {\n        fnOrObj.__eventWrappers = undefined;\n      }\n    }\n  }\n  let rel = this instanceof Window ? nativeMethods.windowRemoveEventListener :\n    nativeMethods.removeEventListener;\n  rel.call(this, type, wrapperFn || fnOrObj, optionsOrCapture);\n  if (wrapperFn && nonBubblingEventsToRetarget[type] &&\n      this.__handlers && this.__handlers[type]) {\n    const arr = this.__handlers[type][capture ? 'capture' : 'bubble'];\n    const idx = arr.indexOf(wrapperFn);\n    if (idx > -1) {\n      arr.splice(idx, 1);\n    }\n  }\n}\n\nfunction activateFocusEventOverrides() {\n  for (let ev in nonBubblingEventsToRetarget) {\n    window.addEventListener(ev, function(e) {\n      if (!e['__target']) {\n        patchEvent(e);\n        retargetNonBubblingEvent(e);\n      }\n    }, true);\n  }\n}\n\nfunction patchEvent(event) {\n  event['__target'] = event.target;\n  event.__relatedTarget = event.relatedTarget;\n  // patch event prototype if we can\n  if (utils.settings.hasDescriptors) {\n    utils.patchPrototype(event, eventMixin);\n  // and fallback to patching instance\n  } else {\n    utils.extend(event, eventMixin);\n  }\n}\n\nlet PatchedEvent = mixinComposedFlag(window.Event);\nlet PatchedCustomEvent = mixinComposedFlag(window.CustomEvent);\nlet PatchedMouseEvent = mixinComposedFlag(window.MouseEvent);\n\nexport function patchEvents() {\n  window.Event = PatchedEvent;\n  window.CustomEvent = PatchedCustomEvent;\n  window.MouseEvent = PatchedMouseEvent;\n  activateFocusEventOverrides();\n}\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nfunction newSplice(index, removed, addedCount) {\n  return {\n    index: index,\n    removed: removed,\n    addedCount: addedCount\n  };\n}\n\nconst EDIT_LEAVE = 0;\nconst EDIT_UPDATE = 1;\nconst EDIT_ADD = 2;\nconst EDIT_DELETE = 3;\n\n// Note: This function is *based* on the computation of the Levenshtein\n// \"edit\" distance. The one change is that \"updates\" are treated as two\n// edits - not one. With Array splices, an update is really a delete\n// followed by an add. By retaining this, we optimize for \"keeping\" the\n// maximum array items in the original array. For example:\n//\n//   'xxxx123' -> '123yyyy'\n//\n// With 1-edit updates, the shortest path would be just to update all seven\n// characters. With 2-edit updates, we delete 4, leave 3, and add 4. This\n// leaves the substring '123' intact.\nfunction calcEditDistances(current, currentStart, currentEnd,\n                            old, oldStart, oldEnd) {\n  // \"Deletion\" columns\n  let rowCount = oldEnd - oldStart + 1;\n  let columnCount = currentEnd - currentStart + 1;\n  let distances = new Array(rowCount);\n\n  // \"Addition\" rows. Initialize null column.\n  for (let i = 0; i < rowCount; i++) {\n    distances[i] = new Array(columnCount);\n    distances[i][0] = i;\n  }\n\n  // Initialize null row\n  for (let j = 0; j < columnCount; j++)\n    distances[0][j] = j;\n\n  for (let i = 1; i < rowCount; i++) {\n    for (let j = 1; j < columnCount; j++) {\n      if (equals(current[currentStart + j - 1], old[oldStart + i - 1]))\n        distances[i][j] = distances[i - 1][j - 1];\n      else {\n        let north = distances[i - 1][j] + 1;\n        let west = distances[i][j - 1] + 1;\n        distances[i][j] = north < west ? north : west;\n      }\n    }\n  }\n\n  return distances;\n}\n\n// This starts at the final weight, and walks \"backward\" by finding\n// the minimum previous weight recursively until the origin of the weight\n// matrix.\nfunction spliceOperationsFromEditDistances(distances) {\n  let i = distances.length - 1;\n  let j = distances[0].length - 1;\n  let current = distances[i][j];\n  let edits = [];\n  while (i > 0 || j > 0) {\n    if (i == 0) {\n      edits.push(EDIT_ADD);\n      j--;\n      continue;\n    }\n    if (j == 0) {\n      edits.push(EDIT_DELETE);\n      i--;\n      continue;\n    }\n    let northWest = distances[i - 1][j - 1];\n    let west = distances[i - 1][j];\n    let north = distances[i][j - 1];\n\n    let min;\n    if (west < north)\n      min = west < northWest ? west : northWest;\n    else\n      min = north < northWest ? north : northWest;\n\n    if (min == northWest) {\n      if (northWest == current) {\n        edits.push(EDIT_LEAVE);\n      } else {\n        edits.push(EDIT_UPDATE);\n        current = northWest;\n      }\n      i--;\n      j--;\n    } else if (min == west) {\n      edits.push(EDIT_DELETE);\n      i--;\n      current = west;\n    } else {\n      edits.push(EDIT_ADD);\n      j--;\n      current = north;\n    }\n  }\n\n  edits.reverse();\n  return edits;\n}\n\n/**\n * Splice Projection functions:\n *\n * A splice map is a representation of how a previous array of items\n * was transformed into a new array of items. Conceptually it is a list of\n * tuples of\n *\n *   <index, removed, addedCount>\n *\n * which are kept in ascending index order of. The tuple represents that at\n * the |index|, |removed| sequence of items were removed, and counting forward\n * from |index|, |addedCount| items were added.\n */\n\n/**\n * Lacking individual splice mutation information, the minimal set of\n * splices can be synthesized given the previous state and final state of an\n * array. The basic approach is to calculate the edit distance matrix and\n * choose the shortest path through it.\n *\n * Complexity: O(l * p)\n *   l: The length of the current array\n *   p: The length of the old array\n */\nfunction calcSplices(current, currentStart, currentEnd,\n                      old, oldStart, oldEnd) {\n  let prefixCount = 0;\n  let suffixCount = 0;\n  let splice;\n\n  let minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart);\n  if (currentStart == 0 && oldStart == 0)\n    prefixCount = sharedPrefix(current, old, minLength);\n\n  if (currentEnd == current.length && oldEnd == old.length)\n    suffixCount = sharedSuffix(current, old, minLength - prefixCount);\n\n  currentStart += prefixCount;\n  oldStart += prefixCount;\n  currentEnd -= suffixCount;\n  oldEnd -= suffixCount;\n\n  if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0)\n    return [];\n\n  if (currentStart == currentEnd) {\n    splice = newSplice(currentStart, [], 0);\n    while (oldStart < oldEnd)\n      splice.removed.push(old[oldStart++]);\n\n    return [ splice ];\n  } else if (oldStart == oldEnd)\n    return [ newSplice(currentStart, [], currentEnd - currentStart) ];\n\n  let ops = spliceOperationsFromEditDistances(\n      calcEditDistances(current, currentStart, currentEnd,\n                             old, oldStart, oldEnd));\n\n  splice = undefined;\n  let splices = [];\n  let index = currentStart;\n  let oldIndex = oldStart;\n  for (let i = 0; i < ops.length; i++) {\n    switch(ops[i]) {\n      case EDIT_LEAVE:\n        if (splice) {\n          splices.push(splice);\n          splice = undefined;\n        }\n\n        index++;\n        oldIndex++;\n        break;\n      case EDIT_UPDATE:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.addedCount++;\n        index++;\n\n        splice.removed.push(old[oldIndex]);\n        oldIndex++;\n        break;\n      case EDIT_ADD:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.addedCount++;\n        index++;\n        break;\n      case EDIT_DELETE:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.removed.push(old[oldIndex]);\n        oldIndex++;\n        break;\n    }\n  }\n\n  if (splice) {\n    splices.push(splice);\n  }\n  return splices;\n}\n\nfunction sharedPrefix(current, old, searchLength) {\n  for (let i = 0; i < searchLength; i++)\n    if (!equals(current[i], old[i]))\n      return i;\n  return searchLength;\n}\n\nfunction sharedSuffix(current, old, searchLength) {\n  let index1 = current.length;\n  let index2 = old.length;\n  let count = 0;\n  while (count < searchLength && equals(current[--index1], old[--index2]))\n    count++;\n\n  return count;\n}\n\nfunction equals(currentValue, previousValue) {\n  return currentValue === previousValue;\n}\n\nexport function calculateSplices(current, previous) {\n  return calcSplices(current, 0, current.length, previous, 0,\n                          previous.length);\n}\n\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport * as utils from './utils'\nimport {flush} from './flush'\nimport {dispatchEvent} from './native-methods'\nimport * as mutation from './logical-mutation'\nimport {ActiveElementAccessor, ShadowRootAccessor, patchAccessors} from './patch-accessors'\nimport {addEventListener, removeEventListener} from './patch-events'\nimport {attachShadow, ShadyRoot} from './attach-shadow'\n\nfunction getAssignedSlot(node) {\n  mutation.renderRootNode(node);\n  return node.__shady && node.__shady.assignedSlot || null;\n}\n\nlet windowMixin = {\n\n  // NOTE: ensure these methods are bound to `window` so that `this` is correct\n  // when called directly from global context without a receiver; e.g.\n  // `addEventListener(...)`.\n  addEventListener: addEventListener.bind(window),\n\n  removeEventListener: removeEventListener.bind(window)\n\n};\n\nlet nodeMixin = {\n\n  addEventListener: addEventListener,\n\n  removeEventListener: removeEventListener,\n\n  appendChild(node) {\n    return mutation.insertBefore(this, node);\n  },\n\n  insertBefore(node, ref_node) {\n    return mutation.insertBefore(this, node, ref_node);\n  },\n\n  removeChild(node) {\n    return mutation.removeChild(this, node);\n  },\n\n  /**\n   * @this {Node}\n   */\n  replaceChild(node, ref_node) {\n    this.insertBefore(node, ref_node);\n    this.removeChild(ref_node);\n    return node;\n  },\n\n  /**\n   * @this {Node}\n   */\n  cloneNode(deep) {\n    return mutation.cloneNode(this, deep);\n  },\n\n  /**\n   * @this {Node}\n   */\n  getRootNode(options) {\n    return mutation.getRootNode(this, options);\n  },\n\n  /**\n   * @this {Node}\n   */\n  get isConnected() {\n    // Fast path for distributed nodes.\n    const ownerDocument = this.ownerDocument;\n    if (ownerDocument && ownerDocument.contains && ownerDocument.contains(this)) return true;\n    const ownerDocumentElement = ownerDocument.documentElement;\n    if (ownerDocumentElement && ownerDocumentElement.contains && ownerDocumentElement.contains(this)) return true;\n\n    let node = this;\n    while (node && !(node instanceof Document)) {\n      node = node.parentNode || (node instanceof ShadyRoot ? /** @type {ShadowRoot} */(node).host : undefined);\n    }\n    return !!(node && node instanceof Document);\n  },\n\n  /**\n   * @this {Node}\n   */\n  dispatchEvent(event) {\n    flush();\n    return dispatchEvent.call(this, event);\n  }\n\n};\n\n// NOTE: For some reason `Text` redefines `assignedSlot`\nlet textMixin = {\n  /**\n   * @this {Text}\n   */\n  get assignedSlot() {\n    return getAssignedSlot(this);\n  }\n};\n\nlet fragmentMixin = {\n\n  // TODO(sorvell): consider doing native QSA and filtering results.\n  /**\n   * @this {DocumentFragment}\n   */\n  querySelector(selector) {\n    // match selector and halt on first result.\n    let result = mutation.query(this, function(n) {\n      return utils.matchesSelector(n, selector);\n    }, function(n) {\n      return Boolean(n);\n    })[0];\n    return result || null;\n  },\n\n  /**\n   * @this {DocumentFragment}\n   */\n  querySelectorAll(selector) {\n    return mutation.query(this, function(n) {\n      return utils.matchesSelector(n, selector);\n    });\n  }\n\n};\n\nlet slotMixin = {\n\n  /**\n   * @this {HTMLSlotElement}\n   */\n  assignedNodes(options) {\n    if (this.localName === 'slot') {\n      mutation.renderRootNode(this);\n      return this.__shady ?\n        ((options && options.flatten ? this.__shady.distributedNodes :\n        this.__shady.assignedNodes) || []) :\n        [];\n    }\n  }\n\n};\n\nlet elementMixin = utils.extendAll({\n\n  /**\n   * @this {HTMLElement}\n   */\n  setAttribute(name, value) {\n    mutation.setAttribute(this, name, value);\n  },\n\n  /**\n   * @this {HTMLElement}\n   */\n  removeAttribute(name) {\n    mutation.removeAttribute(this, name);\n  },\n\n  /**\n   * @this {HTMLElement}\n   */\n  attachShadow(options) {\n    return attachShadow(this, options);\n  },\n\n  /**\n   * @this {HTMLElement}\n   */\n  get slot() {\n    return this.getAttribute('slot');\n  },\n\n  /**\n   * @this {HTMLElement}\n   */\n  set slot(value) {\n    this.setAttribute('slot', value);\n  },\n\n  /**\n   * @this {HTMLElement}\n   */\n  get assignedSlot() {\n    return getAssignedSlot(this);\n  }\n\n}, fragmentMixin, slotMixin);\n\nObject.defineProperties(elementMixin, ShadowRootAccessor);\n\nlet documentMixin = utils.extendAll({\n  /**\n   * @this {Document}\n   */\n  importNode(node, deep) {\n    return mutation.importNode(node, deep);\n  },\n\n  /**\n   * @this {Document}\n   */\n  getElementById(id) {\n    return this.querySelector(`#${id}`);\n  }\n\n}, fragmentMixin);\n\nObject.defineProperties(documentMixin, {\n  '_activeElement': ActiveElementAccessor.activeElement\n});\n\nlet nativeBlur = HTMLElement.prototype.blur;\n\nlet htmlElementMixin = utils.extendAll({\n  /**\n   * @this {HTMLElement}\n   */\n  blur() {\n    let root = this.shadowRoot;\n    let shadowActive = root && root.activeElement;\n    if (shadowActive) {\n      shadowActive.blur();\n    } else {\n      nativeBlur.call(this);\n    }\n  }\n})\n\nfunction patchBuiltin(proto, obj) {\n  let n$ = Object.getOwnPropertyNames(obj);\n  for (let i=0; i < n$.length; i++) {\n    let n = n$[i];\n    let d = Object.getOwnPropertyDescriptor(obj, n);\n    // NOTE: we prefer writing directly here because some browsers\n    // have descriptors that are writable but not configurable (e.g.\n    // `appendChild` on older browsers)\n    if (d.value) {\n      proto[n] = d.value;\n    } else {\n      Object.defineProperty(proto, n, d);\n    }\n  }\n}\n\n\n// Apply patches to builtins (e.g. Element.prototype). Some of these patches\n// can be done unconditionally (mostly methods like\n// `Element.prototype.appendChild`) and some can only be done when the browser\n// has proper descriptors on the builtin prototype\n// (e.g. `Element.prototype.firstChild`)`. When descriptors are not available,\n// elements are individually patched when needed (see e.g.\n// `patchInside/OutsideElementAccessors` in `patch-accessors.js`).\nexport function patchBuiltins() {\n  let nativeHTMLElement =\n    (window['customElements'] && window['customElements']['nativeHTMLElement']) ||\n    HTMLElement;\n  // These patches can always be done, for all supported browsers.\n  patchBuiltin(window.Node.prototype, nodeMixin);\n  patchBuiltin(window.Window.prototype, windowMixin);\n  patchBuiltin(window.Text.prototype, textMixin);\n  patchBuiltin(window.DocumentFragment.prototype, fragmentMixin);\n  patchBuiltin(window.Element.prototype, elementMixin);\n  patchBuiltin(window.Document.prototype, documentMixin);\n  if (window.HTMLSlotElement) {\n    patchBuiltin(window.HTMLSlotElement.prototype, slotMixin);\n  }\n  patchBuiltin(nativeHTMLElement.prototype, htmlElementMixin);\n  // These patches can *only* be done\n  // on browsers that have proper property descriptors on builtin prototypes.\n  // This includes: IE11, Edge, Chrome >= 4?; Safari >= 10, Firefox\n  // On older browsers (Chrome <= 4?, Safari 9), a per element patching\n  // strategy is used for patching accessors.\n  if (utils.settings.hasDescriptors) {\n    patchAccessors(window.Node.prototype);\n    patchAccessors(window.Text.prototype);\n    patchAccessors(window.DocumentFragment.prototype);\n    patchAccessors(window.Element.prototype);\n    patchAccessors(nativeHTMLElement.prototype);\n    patchAccessors(window.Document.prototype);\n    if (window.HTMLSlotElement) {\n      patchAccessors(window.HTMLSlotElement.prototype);\n    }\n  }\n}\n","const reservedTagList = new Set([\n  'annotation-xml',\n  'color-profile',\n  'font-face',\n  'font-face-src',\n  'font-face-uri',\n  'font-face-format',\n  'font-face-name',\n  'missing-glyph',\n]);\n\n/**\n * @param {string} localName\n * @returns {boolean}\n */\nexport function isValidCustomElementName(localName) {\n  const reserved = reservedTagList.has(localName);\n  const validForm = /^[a-z][.0-9_a-z]*-[\\-.0-9_a-z]*$/.test(localName);\n  return !reserved && validForm;\n}\n\n/**\n * @private\n * @param {!Node} node\n * @return {boolean}\n */\nexport function isConnected(node) {\n  // Use `Node#isConnected`, if defined.\n  const nativeValue = node.isConnected;\n  if (nativeValue !== undefined) {\n    return nativeValue;\n  }\n\n  /** @type {?Node|undefined} */\n  let current = node;\n  while (current && !(current.__CE_isImportDocument || current instanceof Document)) {\n    current = current.parentNode || (window.ShadowRoot && current instanceof ShadowRoot ? current.host : undefined);\n  }\n  return !!(current && (current.__CE_isImportDocument || current instanceof Document));\n}\n\n/**\n * @param {!Node} root\n * @param {!Node} start\n * @return {?Node}\n */\nfunction nextSiblingOrAncestorSibling(root, start) {\n  let node = start;\n  while (node && node !== root && !node.nextSibling) {\n    node = node.parentNode;\n  }\n  return (!node || node === root) ? null : node.nextSibling;\n}\n\n/**\n * @param {!Node} root\n * @param {!Node} start\n * @return {?Node}\n */\nfunction nextNode(root, start) {\n  return start.firstChild ? start.firstChild : nextSiblingOrAncestorSibling(root, start);\n}\n\n/**\n * @param {!Node} root\n * @param {!function(!Element)} callback\n * @param {!Set<Node>=} visitedImports\n */\nexport function walkDeepDescendantElements(root, callback, visitedImports = new Set()) {\n  let node = root;\n  while (node) {\n    if (node.nodeType === Node.ELEMENT_NODE) {\n      const element = /** @type {!Element} */(node);\n\n      callback(element);\n\n      const localName = element.localName;\n      if (localName === 'link' && element.getAttribute('rel') === 'import') {\n        // If this import (polyfilled or not) has it's root node available,\n        // walk it.\n        const importNode = /** @type {!Node} */ (element.import);\n        if (importNode instanceof Node && !visitedImports.has(importNode)) {\n          // Prevent multiple walks of the same import root.\n          visitedImports.add(importNode);\n\n          for (let child = importNode.firstChild; child; child = child.nextSibling) {\n            walkDeepDescendantElements(child, callback, visitedImports);\n          }\n        }\n\n        // Ignore descendants of import links to prevent attempting to walk the\n        // elements created by the HTML Imports polyfill that we just walked\n        // above.\n        node = nextSiblingOrAncestorSibling(root, element);\n        continue;\n      } else if (localName === 'template') {\n        // Ignore descendants of templates. There shouldn't be any descendants\n        // because they will be moved into `.content` during construction in\n        // browsers that support template but, in case they exist and are still\n        // waiting to be moved by a polyfill, they will be ignored.\n        node = nextSiblingOrAncestorSibling(root, element);\n        continue;\n      }\n\n      // Walk shadow roots.\n      const shadowRoot = element.__CE_shadowRoot;\n      if (shadowRoot) {\n        for (let child = shadowRoot.firstChild; child; child = child.nextSibling) {\n          walkDeepDescendantElements(child, callback, visitedImports);\n        }\n      }\n    }\n\n    node = nextNode(root, node);\n  }\n}\n\n/**\n * Used to suppress Closure's \"Modifying the prototype is only allowed if the\n * constructor is in the same scope\" warning without using\n * `@suppress {newCheckTypes, duplicate}` because `newCheckTypes` is too broad.\n *\n * @param {!Object} destination\n * @param {string} name\n * @param {*} value\n */\nexport function setPropertyUnchecked(destination, name, value) {\n  destination[name] = value;\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nexport let nativeShadow = !(window['ShadyDOM'] && window['ShadyDOM']['inUse']);\nexport let nativeCssVariables;\n\n/**\n * @param {(ShadyCSSOptions | ShadyCSSInterface)=} settings\n */\nfunction calcCssVariables(settings) {\n  if (settings && settings['shimcssproperties']) {\n    nativeCssVariables = false;\n  } else {\n    // chrome 49 has semi-working css vars, check if box-shadow works\n    // safari 9.1 has a recalc bug: https://bugs.webkit.org/show_bug.cgi?id=155782\n    nativeCssVariables = Boolean(!navigator.userAgent.match('AppleWebKit/601') &&\n      window.CSS && CSS.supports && CSS.supports('box-shadow', '0 0 0 var(--foo)'));\n  }\n}\n\nif (window.ShadyCSS && window.ShadyCSS.nativeCss !== undefined) {\n  nativeCssVariables = window.ShadyCSS.nativeCss;\n} else if (window.ShadyCSS) {\n  calcCssVariables(window.ShadyCSS);\n  // reset window variable to let ShadyCSS API take its place\n  window.ShadyCSS = undefined;\n} else {\n  calcCssVariables(window['WebComponents'] && window['WebComponents']['flags']);\n}","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {nativeShadow, nativeCssVariables} from './style-settings.js'\nimport {parse, stringify, types, StyleNode} from './css-parse.js' // eslint-disable-line no-unused-vars\nimport {MEDIA_MATCH} from './common-regex.js';\n\n/**\n * @param {string|StyleNode} rules\n * @param {function(StyleNode)=} callback\n * @return {string}\n */\nexport function toCssText (rules, callback) {\n  if (!rules) {\n    return '';\n  }\n  if (typeof rules === 'string') {\n    rules = parse(rules);\n  }\n  if (callback) {\n    forEachRule(rules, callback);\n  }\n  return stringify(rules, nativeCssVariables);\n}\n\n/**\n * @param {HTMLStyleElement} style\n * @return {StyleNode}\n */\nexport function rulesForStyle(style) {\n  if (!style['__cssRules'] && style.textContent) {\n    style['__cssRules'] = parse(style.textContent);\n  }\n  return style['__cssRules'] || null;\n}\n\n// Tests if a rule is a keyframes selector, which looks almost exactly\n// like a normal selector but is not (it has nothing to do with scoping\n// for example).\n/**\n * @param {StyleNode} rule\n * @return {boolean}\n */\nexport function isKeyframesSelector(rule) {\n  return Boolean(rule['parent']) &&\n  rule['parent']['type'] === types.KEYFRAMES_RULE;\n}\n\n/**\n * @param {StyleNode} node\n * @param {Function=} styleRuleCallback\n * @param {Function=} keyframesRuleCallback\n * @param {boolean=} onlyActiveRules\n */\nexport function forEachRule(node, styleRuleCallback, keyframesRuleCallback, onlyActiveRules) {\n  if (!node) {\n    return;\n  }\n  let skipRules = false;\n  let type = node['type'];\n  if (onlyActiveRules) {\n    if (type === types.MEDIA_RULE) {\n      let matchMedia = node['selector'].match(MEDIA_MATCH);\n      if (matchMedia) {\n        // if rule is a non matching @media rule, skip subrules\n        if (!window.matchMedia(matchMedia[1]).matches) {\n          skipRules = true;\n        }\n      }\n    }\n  }\n  if (type === types.STYLE_RULE) {\n    styleRuleCallback(node);\n  } else if (keyframesRuleCallback &&\n    type === types.KEYFRAMES_RULE) {\n    keyframesRuleCallback(node);\n  } else if (type === types.MIXIN_RULE) {\n    skipRules = true;\n  }\n  let r$ = node['rules'];\n  if (r$ && !skipRules) {\n    for (let i=0, l=r$.length, r; (i<l) && (r=r$[i]); i++) {\n      forEachRule(r, styleRuleCallback, keyframesRuleCallback, onlyActiveRules);\n    }\n  }\n}\n\n// add a string of cssText to the document.\n/**\n * @param {string} cssText\n * @param {string} moniker\n * @param {Node} target\n * @param {Node} contextNode\n * @return {HTMLStyleElement}\n */\nexport function applyCss(cssText, moniker, target, contextNode) {\n  let style = createScopeStyle(cssText, moniker);\n  applyStyle(style, target, contextNode);\n  return style;\n}\n\n/**\n * @param {string} cssText\n * @param {string} moniker\n * @return {HTMLStyleElement}\n */\nexport function createScopeStyle(cssText, moniker) {\n  let style = /** @type {HTMLStyleElement} */(document.createElement('style'));\n  if (moniker) {\n    style.setAttribute('scope', moniker);\n  }\n  style.textContent = cssText;\n  return style;\n}\n\n/**\n * Track the position of the last added style for placing placeholders\n * @type {Node}\n */\nlet lastHeadApplyNode = null;\n\n// insert a comment node as a styling position placeholder.\n/**\n * @param {string} moniker\n * @return {!Comment}\n */\nexport function applyStylePlaceHolder(moniker) {\n  let placeHolder = document.createComment(' Shady DOM styles for ' +\n    moniker + ' ');\n  let after = lastHeadApplyNode ?\n    lastHeadApplyNode['nextSibling'] : null;\n  let scope = document.head;\n  scope.insertBefore(placeHolder, after || scope.firstChild);\n  lastHeadApplyNode = placeHolder;\n  return placeHolder;\n}\n\n/**\n * @param {HTMLStyleElement} style\n * @param {?Node} target\n * @param {?Node} contextNode\n */\nexport function applyStyle(style, target, contextNode) {\n  target = target || document.head;\n  let after = (contextNode && contextNode.nextSibling) ||\n    target.firstChild;\n  target.insertBefore(style, after);\n  if (!lastHeadApplyNode) {\n    lastHeadApplyNode = style;\n  } else {\n    // only update lastHeadApplyNode if the new style is inserted after the old lastHeadApplyNode\n    let position = style.compareDocumentPosition(lastHeadApplyNode);\n    if (position === Node.DOCUMENT_POSITION_PRECEDING) {\n      lastHeadApplyNode = style;\n    }\n  }\n}\n\n/**\n * @param {string} buildType\n * @return {boolean}\n */\nexport function isTargetedBuild(buildType) {\n  return nativeShadow ? buildType === 'shadow' : buildType === 'shady';\n}\n\n/**\n * @param {Element} element\n * @return {?string}\n */\nexport function getCssBuildType(element) {\n  return element.getAttribute('css-build');\n}\n\n/**\n * Walk from text[start] matching parens and\n * returns position of the outer end paren\n * @param {string} text\n * @param {number} start\n * @return {number}\n */\nfunction findMatchingParen(text, start) {\n  let level = 0;\n  for (let i=start, l=text.length; i < l; i++) {\n    if (text[i] === '(') {\n      level++;\n    } else if (text[i] === ')') {\n      if (--level === 0) {\n        return i;\n      }\n    }\n  }\n  return -1;\n}\n\n/**\n * @param {string} str\n * @param {function(string, string, string, string)} callback\n */\nexport function processVariableAndFallback(str, callback) {\n  // find 'var('\n  let start = str.indexOf('var(');\n  if (start === -1) {\n    // no var?, everything is prefix\n    return callback(str, '', '', '');\n  }\n  //${prefix}var(${inner})${suffix}\n  let end = findMatchingParen(str, start + 3);\n  let inner = str.substring(start + 4, end);\n  let prefix = str.substring(0, start);\n  // suffix may have other variables\n  let suffix = processVariableAndFallback(str.substring(end + 1), callback);\n  let comma = inner.indexOf(',');\n  // value and fallback args should be trimmed to match in property lookup\n  if (comma === -1) {\n    // variable, no fallback\n    return callback(prefix, inner.trim(), '', suffix);\n  }\n  // var(${value},${fallback})\n  let value = inner.substring(0, comma).trim();\n  let fallback = inner.substring(comma + 1).trim();\n  return callback(prefix, value, fallback, suffix);\n}\n\n/**\n * @param {Element} element\n * @param {string} value\n */\nexport function setElementClassRaw(element, value) {\n  // use native setAttribute provided by ShadyDOM when setAttribute is patched\n  if (nativeShadow) {\n    element.setAttribute('class', value);\n  } else {\n    window['ShadyDOM']['nativeMethods']['setAttribute'].call(element, 'class', value);\n  }\n}\n\n/**\n * @param {Element | {is: string, extends: string}} element\n * @return {{is: string, typeExtension: string}}\n */\nexport function getIsExtends(element) {\n  let localName = element['localName'];\n  let is = '', typeExtension = '';\n  /*\n  NOTE: technically, this can be wrong for certain svg elements\n  with `-` in the name like `<font-face>`\n  */\n  if (localName) {\n    if (localName.indexOf('-') > -1) {\n      is = localName;\n    } else {\n      typeExtension = localName;\n      is = (element.getAttribute && element.getAttribute('is')) || '';\n    }\n  } else {\n    is = /** @type {?} */(element).is;\n    typeExtension = /** @type {?} */(element).extends;\n  }\n  return {is, typeExtension};\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\nimport templateMap from './template-map.js'\nimport {StyleNode} from './css-parse.js' // eslint-disable-line no-unused-vars\n\n/*\n * Utilities for handling invalidating apply-shim mixins for a given template.\n *\n * The invalidation strategy involves keeping track of the \"current\" version of a template's mixins, and updating that count when a mixin is invalidated.\n * The template\n */\n\n/** @const {string} */\nconst CURRENT_VERSION = '_applyShimCurrentVersion';\n\n/** @const {string} */\nconst NEXT_VERSION = '_applyShimNextVersion';\n\n/** @const {string} */\nconst VALIDATING_VERSION = '_applyShimValidatingVersion';\n\n/**\n * @const {Promise<void>}\n */\nconst promise = Promise.resolve();\n\n/**\n * @param {string} elementName\n */\nexport function invalidate(elementName){\n  let template = templateMap[elementName];\n  if (template) {\n    invalidateTemplate(template);\n  }\n}\n\n/**\n * This function can be called multiple times to mark a template invalid\n * and signal that the style inside must be regenerated.\n *\n * Use `startValidatingTemplate` to begin an asynchronous validation cycle.\n * During that cycle, call `templateIsValidating` to see if the template must\n * be revalidated\n * @param {HTMLTemplateElement} template\n */\nexport function invalidateTemplate(template) {\n  // default the current version to 0\n  template[CURRENT_VERSION] = template[CURRENT_VERSION] || 0;\n  // ensure the \"validating for\" flag exists\n  template[VALIDATING_VERSION] = template[VALIDATING_VERSION] || 0;\n  // increment the next version\n  template[NEXT_VERSION] = (template[NEXT_VERSION] || 0) + 1;\n}\n\n/**\n * @param {string} elementName\n * @return {boolean}\n */\nexport function isValid(elementName) {\n  let template = templateMap[elementName];\n  if (template) {\n    return templateIsValid(template);\n  }\n  return true;\n}\n\n/**\n * @param {HTMLTemplateElement} template\n * @return {boolean}\n */\nexport function templateIsValid(template) {\n  return template[CURRENT_VERSION] === template[NEXT_VERSION];\n}\n\n/**\n * @param {string} elementName\n * @return {boolean}\n */\nexport function isValidating(elementName) {\n  let template = templateMap[elementName];\n  if (template) {\n    return templateIsValidating(template);\n  }\n  return false;\n}\n\n/**\n * Returns true if the template is currently invalid and `startValidating` has been called since the last invalidation.\n * If false, the template must be validated.\n * @param {HTMLTemplateElement} template\n * @return {boolean}\n */\nexport function templateIsValidating(template) {\n  return !templateIsValid(template) && template[VALIDATING_VERSION] === template[NEXT_VERSION];\n}\n\n/**\n * the template is marked as `validating` for one microtask so that all instances\n * found in the tree crawl of `applyStyle` will update themselves,\n * but the template will only be updated once.\n * @param {string} elementName\n*/\nexport function startValidating(elementName) {\n  let template = templateMap[elementName];\n  startValidatingTemplate(template);\n}\n\n/**\n * Begin an asynchronous invalidation cycle.\n * This should be called after every validation of a template\n *\n * After one microtask, the template will be marked as valid until the next call to `invalidateTemplate`\n * @param {HTMLTemplateElement} template\n */\nexport function startValidatingTemplate(template) {\n  // remember that the current \"next version\" is the reason for this validation cycle\n  template[VALIDATING_VERSION] = template[NEXT_VERSION];\n  // however, there only needs to be one async task to clear the counters\n  if (!template._validating) {\n    template._validating = true;\n    promise.then(function() {\n      // sync the current version to let future invalidations cause a refresh cycle\n      template[CURRENT_VERSION] = template[NEXT_VERSION];\n      template._validating = false;\n    });\n  }\n}\n\n/**\n * @return {boolean}\n */\nexport function elementsAreInvalid() {\n  for (let elementName in templateMap) {\n    let template = templateMap[elementName];\n    if (!templateIsValid(template)) {\n      return true;\n    }\n  }\n  return false;\n}","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\n/** @type {Promise<void>} */\nlet readyPromise = null;\n\n/** @type {?function(?function())} */\nlet whenReady = window['HTMLImports'] && window['HTMLImports']['whenReady'] || null;\n\n/** @type {function()} */\nlet resolveFn;\n\n/**\n * @param {?function()} callback\n */\nexport default function documentWait(callback) {\n  requestAnimationFrame(function() {\n    if (whenReady) {\n      whenReady(callback)\n    } else {\n      if (!readyPromise) {\n        readyPromise = new Promise((resolve) => {resolveFn = resolve});\n        if (document.readyState === 'complete') {\n          resolveFn();\n        } else {\n          document.addEventListener('readystatechange', () => {\n            if (document.readyState === 'complete') {\n              resolveFn();\n            }\n          });\n        }\n      }\n      readyPromise.then(function(){ callback && callback(); });\n    }\n  });\n}\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function(scope) {\n\n  'use strict';\n\n  // defaultPrevented is broken in IE.\n  // https://connect.microsoft.com/IE/feedback/details/790389/event-defaultprevented-returns-false-after-preventdefault-was-called\n  var workingDefaultPrevented = (function() {\n    var e = document.createEvent('Event');\n    e.initEvent('foo', true, true);\n    e.preventDefault();\n    return e.defaultPrevented;\n  })();\n\n  if (!workingDefaultPrevented) {\n    var origPreventDefault = Event.prototype.preventDefault;\n    Event.prototype.preventDefault = function() {\n      if (!this.cancelable) {\n        return;\n      }\n\n      origPreventDefault.call(this);\n\n      Object.defineProperty(this, 'defaultPrevented', {\n        get: function() {\n          return true;\n        },\n        configurable: true\n      });\n    };\n  }\n\n  var isIE = /Trident/.test(navigator.userAgent);\n\n  // CustomEvent constructor shim\n  if (!window.CustomEvent || isIE && (typeof window.CustomEvent !== 'function')) {\n    window.CustomEvent = function(inType, params) {\n      params = params || {};\n      var e = document.createEvent('CustomEvent');\n      e.initCustomEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable), params.detail);\n      return e;\n    };\n    window.CustomEvent.prototype = window.Event.prototype;\n  }\n\n  // Event constructor shim\n  if (!window.Event || isIE && (typeof window.Event !== 'function')) {\n    var origEvent = window.Event;\n    window.Event = function(inType, params) {\n      params = params || {};\n      var e = document.createEvent('Event');\n      e.initEvent(inType, Boolean(params.bubbles), Boolean(params.cancelable));\n      return e;\n    };\n    if (origEvent) {\n      for (var i in origEvent) {\n        window.Event[i] = origEvent[i];\n      }\n    }\n    window.Event.prototype = origEvent.prototype;\n  }\n\n  if (!window.MouseEvent || isIE && (typeof window.MouseEvent !== 'function')) {\n    var origMouseEvent = window.MouseEvent;\n    window.MouseEvent = function(inType, params) {\n      params = params || {};\n      var e = document.createEvent('MouseEvent');\n      e.initMouseEvent(inType,\n        Boolean(params.bubbles), Boolean(params.cancelable),\n        params.view || window, params.detail,\n        params.screenX, params.screenY, params.clientX, params.clientY,\n        params.ctrlKey, params.altKey, params.shiftKey, params.metaKey,\n        params.button, params.relatedTarget);\n      return e;\n    };\n    if (origMouseEvent) {\n      for (var i in origMouseEvent) {\n        window.MouseEvent[i] = origMouseEvent[i];\n      }\n    }\n    window.MouseEvent.prototype = origMouseEvent.prototype;\n  }\n\n  // ES6 stuff\n  if (!Array.from) {\n    Array.from = function (object) {\n      return [].slice.call(object);\n    };\n  }\n\n  if (!Object.assign) {\n    var assign = function(target, source) {\n      var n$ = Object.getOwnPropertyNames(source);\n      for (var i=0, p; i < n$.length; i++) {\n        p = n$[i];\n        target[p] = source[p];\n      }\n    }\n\n    Object.assign = function(target, sources) {\n      var args = [].slice.call(arguments, 1);\n      for (var i=0, s; i < args.length; i++) {\n        s = args[i];\n        if (s) {\n          assign(target, s);\n        }\n      }\n      return target;\n    }\n  }\n\n})(window.WebComponents);\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n// minimal template polyfill\n(function() {\n\n  var needsTemplate = (typeof HTMLTemplateElement === 'undefined');\n\n  // NOTE: Patch document.importNode to work around IE11 bug that\n  // casues children of a document fragment imported while\n  // there is a mutation observer to not have a parentNode (!?!)\n  // It's important that this is the first patch to `importNode` so that\n  // dom produced for later patches is correct.\n  if (/Trident/.test(navigator.userAgent)) {\n    (function() {\n      var Native_importNode = Document.prototype.importNode;\n      Document.prototype.importNode = function() {\n        var n = Native_importNode.apply(this, arguments);\n        // Copy all children to a new document fragment since\n        // this one may be broken\n        if (n.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n          var f = this.createDocumentFragment();\n          f.appendChild(n);\n          return f;\n        } else {\n          return n;\n        }\n      };\n    })();\n  }\n\n  // NOTE: we rely on this cloneNode not causing element upgrade.\n  // This means this polyfill must load before the CE polyfill and\n  // this would need to be re-worked if a browser supports native CE\n  // but not <template>.\n  var Native_cloneNode = Node.prototype.cloneNode;\n  var Native_createElement = Document.prototype.createElement;\n  var Native_importNode = Document.prototype.importNode;\n\n  // returns true if nested templates cannot be cloned (they cannot be on\n  // some impl's like Safari 8 and Edge)\n  // OR if cloning a document fragment does not result in a document fragment\n  var needsCloning = (function() {\n    if (!needsTemplate) {\n      var t = document.createElement('template');\n      var t2 = document.createElement('template');\n      t2.content.appendChild(document.createElement('div'));\n      t.content.appendChild(t2);\n      var clone = t.cloneNode(true);\n      return (clone.content.childNodes.length === 0 || clone.content.firstChild.content.childNodes.length === 0\n        || !(document.createDocumentFragment().cloneNode() instanceof DocumentFragment));\n    }\n  })();\n\n  var TEMPLATE_TAG = 'template';\n  var PolyfilledHTMLTemplateElement = function() {};\n\n  if (needsTemplate) {\n\n    var contentDoc = document.implementation.createHTMLDocument('template');\n    var canDecorate = true;\n\n    var templateStyle = document.createElement('style');\n    templateStyle.textContent = TEMPLATE_TAG + '{display:none;}';\n\n    var head = document.head;\n    head.insertBefore(templateStyle, head.firstElementChild);\n\n    /**\n      Provides a minimal shim for the <template> element.\n    */\n    PolyfilledHTMLTemplateElement.prototype = Object.create(HTMLElement.prototype);\n\n\n    // if elements do not have `innerHTML` on instances, then\n    // templates can be patched by swizzling their prototypes.\n    var canProtoPatch =\n      !(document.createElement('div').hasOwnProperty('innerHTML'));\n\n    /**\n      The `decorate` method moves element children to the template's `content`.\n      NOTE: there is no support for dynamically adding elements to templates.\n    */\n    PolyfilledHTMLTemplateElement.decorate = function(template) {\n      // if the template is decorated, return fast\n      if (template.content) {\n        return;\n      }\n      template.content = contentDoc.createDocumentFragment();\n      var child;\n      while (child = template.firstChild) {\n        template.content.appendChild(child);\n      }\n      // NOTE: prefer prototype patching for performance and\n      // because on some browsers (IE11), re-defining `innerHTML`\n      // can result in intermittent errors.\n      if (canProtoPatch) {\n        template.__proto__ = PolyfilledHTMLTemplateElement.prototype;\n      } else {\n        template.cloneNode = function(deep) {\n          return PolyfilledHTMLTemplateElement._cloneNode(this, deep);\n        };\n        // add innerHTML to template, if possible\n        // Note: this throws on Safari 7\n        if (canDecorate) {\n          try {\n            defineInnerHTML(template);\n          } catch (err) {\n            canDecorate = false;\n          }\n        }\n      }\n      // bootstrap recursively\n      PolyfilledHTMLTemplateElement.bootstrap(template.content);\n    };\n\n    function defineInnerHTML(obj) {\n      Object.defineProperty(obj, 'innerHTML', {\n        get: function() {\n          var o = '';\n          for (var e = this.content.firstChild; e; e = e.nextSibling) {\n            o += e.outerHTML || escapeData(e.data);\n          }\n          return o;\n        },\n        set: function(text) {\n          contentDoc.body.innerHTML = text;\n          PolyfilledHTMLTemplateElement.bootstrap(contentDoc);\n          while (this.content.firstChild) {\n            this.content.removeChild(this.content.firstChild);\n          }\n          while (contentDoc.body.firstChild) {\n            this.content.appendChild(contentDoc.body.firstChild);\n          }\n        },\n        configurable: true\n      });\n    }\n\n    defineInnerHTML(PolyfilledHTMLTemplateElement.prototype);\n\n    /**\n      The `bootstrap` method is called automatically and \"fixes\" all\n      <template> elements in the document referenced by the `doc` argument.\n    */\n    PolyfilledHTMLTemplateElement.bootstrap = function(doc) {\n      var templates = doc.querySelectorAll(TEMPLATE_TAG);\n      for (var i=0, l=templates.length, t; (i<l) && (t=templates[i]); i++) {\n        PolyfilledHTMLTemplateElement.decorate(t);\n      }\n    };\n\n    // auto-bootstrapping for main document\n    document.addEventListener('DOMContentLoaded', function() {\n      PolyfilledHTMLTemplateElement.bootstrap(document);\n    });\n\n    // Patch document.createElement to ensure newly created templates have content\n    Document.prototype.createElement = function() {\n      'use strict';\n      var el = Native_createElement.apply(this, arguments);\n      if (el.localName === 'template') {\n        PolyfilledHTMLTemplateElement.decorate(el);\n      }\n      return el;\n    };\n\n    var escapeDataRegExp = /[&\\u00A0<>]/g;\n\n    function escapeReplace(c) {\n      switch (c) {\n        case '&':\n          return '&amp;';\n        case '<':\n          return '&lt;';\n        case '>':\n          return '&gt;';\n        case '\\u00A0':\n          return '&nbsp;';\n      }\n    }\n\n    function escapeData(s) {\n      return s.replace(escapeDataRegExp, escapeReplace);\n    }\n  }\n\n  // make cloning/importing work!\n  if (needsTemplate || needsCloning) {\n\n    PolyfilledHTMLTemplateElement._cloneNode = function(template, deep) {\n      var clone = Native_cloneNode.call(template, false);\n      // NOTE: decorate doesn't auto-fix children because they are already\n      // decorated so they need special clone fixup.\n      if (this.decorate) {\n        this.decorate(clone);\n      }\n      if (deep) {\n        // NOTE: use native clone node to make sure CE's wrapped\n        // cloneNode does not cause elements to upgrade.\n        clone.content.appendChild(\n            Native_cloneNode.call(template.content, true));\n        // now ensure nested templates are cloned correctly.\n        this.fixClonedDom(clone.content, template.content);\n      }\n      return clone;\n    };\n\n    PolyfilledHTMLTemplateElement.prototype.cloneNode = function(deep) {\n      return PolyfilledHTMLTemplateElement._cloneNode(this, deep);\n    }\n\n    // Given a source and cloned subtree, find <template>'s in the cloned\n    // subtree and replace them with cloned <template>'s from source.\n    // We must do this because only the source templates have proper .content.\n    PolyfilledHTMLTemplateElement.fixClonedDom = function(clone, source) {\n      // do nothing if cloned node is not an element\n      if (!source.querySelectorAll) return;\n      // these two lists should be coincident\n      var s$ = source.querySelectorAll(TEMPLATE_TAG);\n      var t$ = clone.querySelectorAll(TEMPLATE_TAG);\n      for (var i=0, l=t$.length, t, s; i<l; i++) {\n        s = s$[i];\n        t = t$[i];\n        if (this.decorate) {\n          this.decorate(s);\n        }\n        t.parentNode.replaceChild(s.cloneNode(true), t);\n      }\n    };\n\n    // override all cloning to fix the cloned subtree to contain properly\n    // cloned templates.\n    Node.prototype.cloneNode = function(deep) {\n      var dom;\n      // workaround for Edge bug cloning documentFragments\n      // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/8619646/\n      if (this instanceof DocumentFragment) {\n        if (!deep) {\n          return this.ownerDocument.createDocumentFragment();\n        } else {\n          dom = this.ownerDocument.importNode(this, true);\n        }\n      } else {\n        dom = Native_cloneNode.call(this, deep);\n      }\n      // template.content is cloned iff `deep`.\n      if (deep) {\n        PolyfilledHTMLTemplateElement.fixClonedDom(dom, this);\n      }\n      return dom;\n    };\n\n    // NOTE: we are cloning instead of importing <template>'s.\n    // However, the ownerDocument of the cloned template will be correct!\n    // This is because the native import node creates the right document owned\n    // subtree and `fixClonedDom` inserts cloned templates into this subtree,\n    // thus updating the owner doc.\n    Document.prototype.importNode = function(element, deep) {\n      if (element.localName === TEMPLATE_TAG) {\n        return PolyfilledHTMLTemplateElement._cloneNode(element, deep);\n      } else {\n        var dom = Native_importNode.call(this, element, deep);\n        if (deep) {\n          PolyfilledHTMLTemplateElement.fixClonedDom(dom, element);\n        }\n        return dom;\n      }\n    };\n\n    if (needsCloning) {\n      window.HTMLTemplateElement.prototype.cloneNode = function(deep) {\n        return PolyfilledHTMLTemplateElement._cloneNode(this, deep);\n      };\n    }\n  }\n\n  if (needsTemplate) {\n    window.HTMLTemplateElement = PolyfilledHTMLTemplateElement;\n  }\n\n})();\n","!function(t,e){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=e():\"function\"==typeof define&&define.amd?define(e):t.ES6Promise=e()}(this,function(){\"use strict\";function t(t){return\"function\"==typeof t||\"object\"==typeof t&&null!==t}function e(t){return\"function\"==typeof t}function n(t){I=t}function r(t){J=t}function o(){return function(){return process.nextTick(a)}}function i(){return\"undefined\"!=typeof H?function(){H(a)}:c()}function s(){var t=0,e=new V(a),n=document.createTextNode(\"\");return e.observe(n,{characterData:!0}),function(){n.data=t=++t%2}}function u(){var t=new MessageChannel;return t.port1.onmessage=a,function(){return t.port2.postMessage(0)}}function c(){var t=setTimeout;return function(){return t(a,1)}}function a(){for(var t=0;t<G;t+=2){var e=$[t],n=$[t+1];e(n),$[t]=void 0,$[t+1]=void 0}G=0}function f(){try{var t=require,e=t(\"vertx\");return H=e.runOnLoop||e.runOnContext,i()}catch(n){return c()}}function l(t,e){var n=arguments,r=this,o=new this.constructor(p);void 0===o[et]&&k(o);var i=r._state;return i?!function(){var t=n[i-1];J(function(){return x(i,o,t,r._result)})}():E(r,o,t,e),o}function h(t){var e=this;if(t&&\"object\"==typeof t&&t.constructor===e)return t;var n=new e(p);return g(n,t),n}function p(){}function v(){return new TypeError(\"You cannot resolve a promise with itself\")}function d(){return new TypeError(\"A promises callback cannot return that same promise.\")}function _(t){try{return t.then}catch(e){return it.error=e,it}}function y(t,e,n,r){try{t.call(e,n,r)}catch(o){return o}}function m(t,e,n){J(function(t){var r=!1,o=y(n,e,function(n){r||(r=!0,e!==n?g(t,n):S(t,n))},function(e){r||(r=!0,j(t,e))},\"Settle: \"+(t._label||\" unknown promise\"));!r&&o&&(r=!0,j(t,o))},t)}function b(t,e){e._state===rt?S(t,e._result):e._state===ot?j(t,e._result):E(e,void 0,function(e){return g(t,e)},function(e){return j(t,e)})}function w(t,n,r){n.constructor===t.constructor&&r===l&&n.constructor.resolve===h?b(t,n):r===it?(j(t,it.error),it.error=null):void 0===r?S(t,n):e(r)?m(t,n,r):S(t,n)}function g(e,n){e===n?j(e,v()):t(n)?w(e,n,_(n)):S(e,n)}function A(t){t._onerror&&t._onerror(t._result),T(t)}function S(t,e){t._state===nt&&(t._result=e,t._state=rt,0!==t._subscribers.length&&J(T,t))}function j(t,e){t._state===nt&&(t._state=ot,t._result=e,J(A,t))}function E(t,e,n,r){var o=t._subscribers,i=o.length;t._onerror=null,o[i]=e,o[i+rt]=n,o[i+ot]=r,0===i&&t._state&&J(T,t)}function T(t){var e=t._subscribers,n=t._state;if(0!==e.length){for(var r=void 0,o=void 0,i=t._result,s=0;s<e.length;s+=3)r=e[s],o=e[s+n],r?x(n,r,o,i):o(i);t._subscribers.length=0}}function M(){this.error=null}function P(t,e){try{return t(e)}catch(n){return st.error=n,st}}function x(t,n,r,o){var i=e(r),s=void 0,u=void 0,c=void 0,a=void 0;if(i){if(s=P(r,o),s===st?(a=!0,u=s.error,s.error=null):c=!0,n===s)return void j(n,d())}else s=o,c=!0;n._state!==nt||(i&&c?g(n,s):a?j(n,u):t===rt?S(n,s):t===ot&&j(n,s))}function C(t,e){try{e(function(e){g(t,e)},function(e){j(t,e)})}catch(n){j(t,n)}}function O(){return ut++}function k(t){t[et]=ut++,t._state=void 0,t._result=void 0,t._subscribers=[]}function Y(t,e){this._instanceConstructor=t,this.promise=new t(p),this.promise[et]||k(this.promise),B(e)?(this._input=e,this.length=e.length,this._remaining=e.length,this._result=new Array(this.length),0===this.length?S(this.promise,this._result):(this.length=this.length||0,this._enumerate(),0===this._remaining&&S(this.promise,this._result))):j(this.promise,q())}function q(){return new Error(\"Array Methods must be provided an Array\")}function F(t){return new Y(this,t).promise}function D(t){var e=this;return new e(B(t)?function(n,r){for(var o=t.length,i=0;i<o;i++)e.resolve(t[i]).then(n,r)}:function(t,e){return e(new TypeError(\"You must pass an array to race.\"))})}function K(t){var e=this,n=new e(p);return j(n,t),n}function L(){throw new TypeError(\"You must pass a resolver function as the first argument to the promise constructor\")}function N(){throw new TypeError(\"Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.\")}function U(t){this[et]=O(),this._result=this._state=void 0,this._subscribers=[],p!==t&&(\"function\"!=typeof t&&L(),this instanceof U?C(this,t):N())}function W(){var t=void 0;if(\"undefined\"!=typeof global)t=global;else if(\"undefined\"!=typeof self)t=self;else try{t=Function(\"return this\")()}catch(e){throw new Error(\"polyfill failed because global object is unavailable in this environment\")}var n=t.Promise;if(n){var r=null;try{r=Object.prototype.toString.call(n.resolve())}catch(e){}if(\"[object Promise]\"===r&&!n.cast)return}t.Promise=U}var z=void 0;z=Array.isArray?Array.isArray:function(t){return\"[object Array]\"===Object.prototype.toString.call(t)};var B=z,G=0,H=void 0,I=void 0,J=function(t,e){$[G]=t,$[G+1]=e,G+=2,2===G&&(I?I(a):tt())},Q=\"undefined\"!=typeof window?window:void 0,R=Q||{},V=R.MutationObserver||R.WebKitMutationObserver,X=\"undefined\"==typeof self&&\"undefined\"!=typeof process&&\"[object process]\"==={}.toString.call(process),Z=\"undefined\"!=typeof Uint8ClampedArray&&\"undefined\"!=typeof importScripts&&\"undefined\"!=typeof MessageChannel,$=new Array(1e3),tt=void 0;tt=X?o():V?s():Z?u():void 0===Q&&\"function\"==typeof require?f():c();var et=Math.random().toString(36).substring(16),nt=void 0,rt=1,ot=2,it=new M,st=new M,ut=0;return Y.prototype._enumerate=function(){for(var t=this.length,e=this._input,n=0;this._state===nt&&n<t;n++)this._eachEntry(e[n],n)},Y.prototype._eachEntry=function(t,e){var n=this._instanceConstructor,r=n.resolve;if(r===h){var o=_(t);if(o===l&&t._state!==nt)this._settledAt(t._state,e,t._result);else if(\"function\"!=typeof o)this._remaining--,this._result[e]=t;else if(n===U){var i=new n(p);w(i,t,o),this._willSettleAt(i,e)}else this._willSettleAt(new n(function(e){return e(t)}),e)}else this._willSettleAt(r(t),e)},Y.prototype._settledAt=function(t,e,n){var r=this.promise;r._state===nt&&(this._remaining--,t===ot?j(r,n):this._result[e]=n),0===this._remaining&&S(r,this._result)},Y.prototype._willSettleAt=function(t,e){var n=this;E(t,void 0,function(t){return n._settledAt(rt,e,t)},function(t){return n._settledAt(ot,e,t)})},U.all=F,U.race=D,U.resolve=h,U.reject=K,U._setScheduler=n,U._setAsap=r,U._asap=J,U.prototype={constructor:U,then:l,\"catch\":function(t){return this.then(null,t)}},U.polyfill=W,U.Promise=U,U.polyfill(),U});","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n(scope => {\n\n  /********************* base setup *********************/\n  const useNative = Boolean('import' in document.createElement('link'));\n\n  // Polyfill `currentScript` for browsers without it.\n  let currentScript = null;\n  if ('currentScript' in document === false) {\n    Object.defineProperty(document, 'currentScript', {\n      get() {\n        return currentScript ||\n          // NOTE: only works when called in synchronously executing code.\n          // readyState should check if `loading` but IE10 is\n          // interactive when scripts run so we cheat. This is not needed by\n          // html-imports polyfill but helps generally polyfill `currentScript`.\n          (document.readyState !== 'complete' ?\n            document.scripts[document.scripts.length - 1] : null);\n      },\n      configurable: true\n    });\n  }\n\n  /********************* path fixup *********************/\n  const ABS_URL_TEST = /(^\\/)|(^#)|(^[\\w-\\d]*:)/;\n  const CSS_URL_REGEXP = /(url\\()([^)]*)(\\))/g;\n  const CSS_IMPORT_REGEXP = /(@import[\\s]+(?!url\\())([^;]*)(;)/g;\n  const STYLESHEET_REGEXP = /(<link[^>]*)(rel=['|\"]?stylesheet['|\"]?[^>]*>)/g;\n\n  // path fixup: style elements in imports must be made relative to the main\n  // document. We fixup url's in url() and @import.\n  const Path = {\n\n    fixUrls(element, base) {\n      if (element.href) {\n        element.setAttribute('href',\n          Path.replaceAttrUrl(element.getAttribute('href'), base));\n      }\n      if (element.src) {\n        element.setAttribute('src',\n          Path.replaceAttrUrl(element.getAttribute('src'), base));\n      }\n      if (element.localName === 'style') {\n        const r = Path.replaceUrls(element.textContent, base, CSS_URL_REGEXP);\n        element.textContent = Path.replaceUrls(r, base, CSS_IMPORT_REGEXP);\n      }\n    },\n\n    replaceUrls(text, linkUrl, regexp) {\n      return text.replace(regexp, (m, pre, url, post) => {\n        let urlPath = url.replace(/[\"']/g, '');\n        if (linkUrl) {\n          urlPath = Path.resolveUrl(urlPath, linkUrl);\n        }\n        return pre + '\\'' + urlPath + '\\'' + post;\n      });\n    },\n\n    replaceAttrUrl(text, linkUrl) {\n      if (text && ABS_URL_TEST.test(text)) {\n        return text;\n      } else {\n        return Path.resolveUrl(text, linkUrl);\n      }\n    },\n\n    resolveUrl(url, base) {\n      // Lazy feature detection.\n      if (Path.__workingURL === undefined) {\n        Path.__workingURL = false;\n        try {\n          const u = new URL('b', 'http://a');\n          u.pathname = 'c%20d';\n          Path.__workingURL = (u.href === 'http://a/c%20d');\n        } catch (e) {}\n      }\n\n      if (Path.__workingURL) {\n        return (new URL(url, base)).href;\n      }\n\n      // Fallback to creating an anchor into a disconnected document.\n      let doc = Path.__tempDoc;\n      if (!doc) {\n        doc = document.implementation.createHTMLDocument('temp');\n        Path.__tempDoc = doc;\n        doc.__base = doc.createElement('base');\n        doc.head.appendChild(doc.__base);\n        doc.__anchor = doc.createElement('a');\n      }\n      doc.__base.href = base;\n      doc.__anchor.href = url;\n      return doc.__anchor.href || url;\n    }\n  };\n\n  /********************* Xhr processor *********************/\n  const Xhr = {\n\n    async: true,\n\n    /**\n     * @param {!string} url\n     * @param {!function(!string, string=)} success\n     * @param {!function(!string)} fail\n     */\n    load(url, success, fail) {\n      if (!url) {\n        fail('error: href must be specified');\n      } else if (url.match(/^data:/)) {\n        // Handle Data URI Scheme\n        const pieces = url.split(',');\n        const header = pieces[0];\n        let resource = pieces[1];\n        if (header.indexOf(';base64') > -1) {\n          resource = atob(resource);\n        } else {\n          resource = decodeURIComponent(resource);\n        }\n        success(resource);\n      } else {\n        const request = new XMLHttpRequest();\n        request.open('GET', url, Xhr.async);\n        request.onload = () => {\n          // Servers redirecting an import can add a Location header to help us\n          // polyfill correctly. Handle relative and full paths.\n          let redirectedUrl = request.getResponseHeader('Location');\n          if (redirectedUrl && redirectedUrl.indexOf('/') === 0) {\n            // In IE location.origin might not work\n            // https://connect.microsoft.com/IE/feedback/details/1763802/location-origin-is-undefined-in-ie-11-on-windows-10-but-works-on-windows-7\n            const origin = (location.origin || location.protocol + '//' + location.host);\n            redirectedUrl = origin + redirectedUrl;\n          }\n          const resource = /** @type {string} */ (request.response || request.responseText);\n          if (request.status === 304 || request.status === 0 ||\n            request.status >= 200 && request.status < 300) {\n            success(resource, redirectedUrl);\n          } else {\n            fail(resource);\n          }\n        };\n        request.send();\n      }\n    }\n  };\n\n  /********************* importer *********************/\n\n  const isIE = /Trident/.test(navigator.userAgent) ||\n    /Edge\\/\\d./i.test(navigator.userAgent);\n\n  const importSelector = 'link[rel=import]';\n\n  // Used to disable loading of resources.\n  const importDisableType = 'import-disable';\n\n  const disabledLinkSelector = `link[rel=stylesheet][href][type=${importDisableType}]`;\n\n  const importDependenciesSelector = `${importSelector}, ${disabledLinkSelector},\n    style:not([type]), link[rel=stylesheet][href]:not([type]),\n    script:not([type]), script[type=\"application/javascript\"],\n    script[type=\"text/javascript\"]`;\n\n  const importDependencyAttr = 'import-dependency';\n\n  const rootImportSelector = `${importSelector}:not(${importDependencyAttr})`;\n\n  const pendingScriptsSelector = `script[${importDependencyAttr}]`;\n\n  const pendingStylesSelector = `style[${importDependencyAttr}],\n    link[rel=stylesheet][${importDependencyAttr}]`;\n\n  /**\n   * Importer will:\n   * - load any linked import documents (with deduping)\n   * - whenever an import is loaded, prompt the parser to try to parse\n   * - observe imported documents for new elements (these are handled via the\n   *   dynamic importer)\n   */\n  class Importer {\n    constructor() {\n      this.documents = {};\n      // Used to keep track of pending loads, so that flattening and firing of\n      // events can be done when all resources are ready.\n      this.inflight = 0;\n      this.dynamicImportsMO = new MutationObserver(m => this.handleMutations(m));\n      // Observe changes on <head>.\n      this.dynamicImportsMO.observe(document.head, {\n        childList: true,\n        subtree: true\n      });\n      // 1. Load imports contents\n      // 2. Assign them to first import links on the document\n      // 3. Wait for import styles & scripts to be done loading/running\n      // 4. Fire load/error events\n      this.loadImports(document);\n    }\n\n    /**\n     * @param {!(HTMLDocument|DocumentFragment|Element)} doc\n     */\n    loadImports(doc) {\n      const links = /** @type {!NodeList<!HTMLLinkElement>} */\n        (doc.querySelectorAll(importSelector));\n      for (let i = 0, l = links.length; i < l; i++) {\n        this.loadImport(links[i]);\n      }\n    }\n\n    /**\n     * @param {!HTMLLinkElement} link\n     */\n    loadImport(link) {\n      const url = link.href;\n      // This resource is already being handled by another import.\n      if (this.documents[url] !== undefined) {\n        // If import is already loaded, we can safely associate it to the link\n        // and fire the load/error event.\n        const imp = this.documents[url];\n        if (imp && imp['__loaded']) {\n          link.import = imp;\n          this.fireEventIfNeeded(link);\n        }\n        return;\n      }\n      this.inflight++;\n      // Mark it as pending to notify others this url is being loaded.\n      this.documents[url] = 'pending';\n      Xhr.load(url, (resource, redirectedUrl) => {\n        const doc = this.makeDocument(resource, redirectedUrl || url);\n        this.documents[url] = doc;\n        this.inflight--;\n        // Load subtree.\n        this.loadImports(doc);\n        this.processImportsIfLoadingDone();\n      }, () => {\n        // If load fails, handle error.\n        this.documents[url] = null;\n        this.inflight--;\n        this.processImportsIfLoadingDone();\n      });\n    }\n\n    /**\n     * Creates a new document containing resource and normalizes urls accordingly.\n     * @param {string=} resource\n     * @param {string=} url\n     * @return {!DocumentFragment}\n     */\n    makeDocument(resource, url) {\n      if (!resource) {\n        return document.createDocumentFragment();\n      }\n\n      if (isIE) {\n        // <link rel=stylesheet> should be appended to <head>. Not doing so\n        // in IE/Edge breaks the cascading order. We disable the loading by\n        // setting the type before setting innerHTML to avoid loading\n        // resources twice.\n        resource = resource.replace(STYLESHEET_REGEXP, (match, p1, p2) => {\n          if (match.indexOf('type=') === -1) {\n            return `${p1} type=${importDisableType} ${p2}`;\n          }\n          return match;\n        });\n      }\n\n      let content;\n      const template = /** @type {!HTMLTemplateElement} */\n        (document.createElement('template'));\n      template.innerHTML = resource;\n      if (template.content) {\n        // This creates issues in Safari10 when used with shadydom (see #12).\n        content = template.content;\n      } else {\n        // <template> not supported, create fragment and move content into it.\n        content = document.createDocumentFragment();\n        while (template.firstChild) {\n          content.appendChild(template.firstChild);\n        }\n      }\n\n      // Support <base> in imported docs. Resolve url and remove its href.\n      const baseEl = content.querySelector('base');\n      if (baseEl) {\n        url = Path.replaceAttrUrl(baseEl.getAttribute('href'), url);\n        baseEl.removeAttribute('href');\n      }\n\n      const n$ = /** @type {!NodeList<!(HTMLLinkElement|HTMLScriptElement|HTMLStyleElement)>} */\n        (content.querySelectorAll(importDependenciesSelector));\n      // For source map hints.\n      let inlineScriptIndex = 0;\n      for (let i = 0, l = n$.length, n; i < l && (n = n$[i]); i++) {\n        // Listen for load/error events, then fix urls.\n        whenElementLoaded(n);\n        Path.fixUrls(n, url);\n        // Mark for easier selectors.\n        n.setAttribute(importDependencyAttr, '');\n        // Generate source map hints for inline scripts.\n        if (n.localName === 'script' && !n.src && n.textContent) {\n          const num = inlineScriptIndex ? `-${inlineScriptIndex}` : '';\n          const content = n.textContent + `\\n//# sourceURL=${url}${num}.js\\n`;\n          // We use the src attribute so it triggers load/error events, and it's\n          // easier to capture errors (e.g. parsing) like this.\n          n.setAttribute('src', 'data:text/javascript;charset=utf-8,' + encodeURIComponent(content));\n          n.textContent = '';\n          inlineScriptIndex++;\n        }\n      }\n      return content;\n    }\n\n    /**\n     * Waits for loaded imports to finish loading scripts and styles, then fires\n     * the load/error events.\n     */\n    processImportsIfLoadingDone() {\n      // Wait until all resources are ready, then load import resources.\n      if (this.inflight) return;\n\n      // Stop observing, flatten & load resource, then restart observing <head>.\n      this.dynamicImportsMO.disconnect();\n      this.flatten(document);\n      // We wait for styles to load, and at the same time we execute the scripts,\n      // then fire the load/error events for imports to have faster whenReady\n      // callback execution.\n      // NOTE: This is different for native behavior where scripts would be\n      // executed after the styles before them are loaded.\n      // To achieve that, we could select pending styles and scripts in the\n      // document and execute them sequentially in their dom order.\n      let scriptsOk = false,\n        stylesOk = false;\n      const onLoadingDone = () => {\n        if (stylesOk && scriptsOk) {\n          // Catch any imports that might have been added while we\n          // weren't looking, wait for them as well.\n          this.loadImports(document);\n          if (this.inflight) return;\n\n          // Restart observing.\n          this.dynamicImportsMO.observe(document.head, {\n            childList: true,\n            subtree: true\n          });\n          this.fireEvents();\n        }\n      }\n      this.waitForStyles(() => {\n        stylesOk = true;\n        onLoadingDone();\n      });\n      this.runScripts(() => {\n        scriptsOk = true;\n        onLoadingDone();\n      });\n    }\n\n    /**\n     * @param {!HTMLDocument} doc\n     */\n    flatten(doc) {\n      const n$ = /** @type {!NodeList<!HTMLLinkElement>} */\n        (doc.querySelectorAll(importSelector));\n      for (let i = 0, l = n$.length, n; i < l && (n = n$[i]); i++) {\n        const imp = this.documents[n.href];\n        n.import = /** @type {!Document} */ (imp);\n        if (imp && imp.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n          // We set the .import to be the link itself, and update its readyState.\n          // Other links with the same href will point to this link.\n          this.documents[n.href] = n;\n          n.readyState = 'loading';\n          // Suppress Closure warning about incompatible subtype assignment.\n          ( /** @type {!HTMLElement} */ (n).import = n);\n          this.flatten(imp);\n          n.appendChild(imp);\n        }\n      }\n    }\n\n    /**\n     * Replaces all the imported scripts with a clone in order to execute them.\n     * Updates the `currentScript`.\n     * @param {!function()} callback\n     */\n    runScripts(callback) {\n      const s$ = document.querySelectorAll(pendingScriptsSelector);\n      const l = s$.length;\n      const cloneScript = i => {\n        if (i < l) {\n          // The pending scripts have been generated through innerHTML and\n          // browsers won't execute them for security reasons. We cannot use\n          // s.cloneNode(true) either, the only way to run the script is manually\n          // creating a new element and copying its attributes.\n          const s = s$[i];\n          const clone = /** @type {!HTMLScriptElement} */\n            (document.createElement('script'));\n          // Remove import-dependency attribute to avoid double cloning.\n          s.removeAttribute(importDependencyAttr);\n          for (let j = 0, ll = s.attributes.length; j < ll; j++) {\n            clone.setAttribute(s.attributes[j].name, s.attributes[j].value);\n          }\n          // Update currentScript and replace original with clone script.\n          currentScript = clone;\n          s.parentNode.replaceChild(clone, s);\n          whenElementLoaded(clone, () => {\n            currentScript = null;\n            cloneScript(i + 1);\n          });\n        } else {\n          callback();\n        }\n      };\n      cloneScript(0);\n    }\n\n    /**\n     * Waits for all the imported stylesheets/styles to be loaded.\n     * @param {!function()} callback\n     */\n    waitForStyles(callback) {\n      const s$ = /** @type {!NodeList<!(HTMLLinkElement|HTMLStyleElement)>} */\n        (document.querySelectorAll(pendingStylesSelector));\n      let pending = s$.length;\n      if (!pending) {\n        callback();\n        return;\n      }\n      // <link rel=stylesheet> should be appended to <head>. Not doing so\n      // in IE/Edge breaks the cascading order\n      // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/10472273/\n      // If there is one <link rel=stylesheet> imported, we must move all imported\n      // links and styles to <head>.\n      const needsMove = isIE && !!document.querySelector(disabledLinkSelector);\n      for (let i = 0, l = s$.length, s; i < l && (s = s$[i]); i++) {\n        // Listen for load/error events, remove selector once is done loading.\n        whenElementLoaded(s, () => {\n          s.removeAttribute(importDependencyAttr);\n          if (--pending === 0) {\n            callback();\n          }\n        });\n        // Check if was already moved to head, to handle the case where the element\n        // has already been moved but it is still loading.\n        if (needsMove && s.parentNode !== document.head) {\n          // Replace the element we're about to move with a placeholder.\n          const placeholder = document.createElement(s.localName);\n          // Add reference of the moved element.\n          placeholder['__appliedElement'] = s;\n          // Disable this from appearing in document.styleSheets.\n          placeholder.setAttribute('type', 'import-placeholder');\n          // Append placeholder next to the sibling, and move original to <head>.\n          s.parentNode.insertBefore(placeholder, s.nextSibling);\n          let newSibling = importForElement(s);\n          while (newSibling && importForElement(newSibling)) {\n            newSibling = importForElement(newSibling);\n          }\n          if (newSibling.parentNode !== document.head) {\n            newSibling = null;\n          }\n          document.head.insertBefore(s, newSibling);\n          // Enable the loading of <link rel=stylesheet>.\n          s.removeAttribute('type');\n        }\n      }\n    }\n\n    /**\n     * Fires load/error events for imports in the right order .\n     */\n    fireEvents() {\n      const n$ = /** @type {!NodeList<!HTMLLinkElement>} */\n        (document.querySelectorAll(importSelector));\n      // Inverse order to have events firing bottom-up.\n      for (let i = n$.length - 1, n; i >= 0 && (n = n$[i]); i--) {\n        this.fireEventIfNeeded(n);\n      }\n    }\n\n    /**\n     * Fires load/error event for the import if this wasn't done already.\n     * @param {!HTMLLinkElement} link\n     */\n    fireEventIfNeeded(link) {\n      // Don't fire twice same event.\n      if (!link['__loaded']) {\n        link['__loaded'] = true;\n        // Update link's import readyState.\n        link.import && (link.import.readyState = 'complete');\n        const eventType = link.import ? 'load' : 'error';\n        link.dispatchEvent(newCustomEvent(eventType, {\n          bubbles: false,\n          cancelable: false,\n          detail: undefined\n        }));\n      }\n    }\n\n    /**\n     * @param {Array<MutationRecord>} mutations\n     */\n    handleMutations(mutations) {\n      for (let i = 0; i < mutations.length; i++) {\n        const m = mutations[i];\n        if (!m.addedNodes) {\n          continue;\n        }\n        for (let ii = 0; ii < m.addedNodes.length; ii++) {\n          const elem = m.addedNodes[ii];\n          if (!elem || elem.nodeType !== Node.ELEMENT_NODE) {\n            continue;\n          }\n          // NOTE: added scripts are not updating currentScript in IE.\n          if (isImportLink(elem)) {\n            this.loadImport( /** @type {!HTMLLinkElement} */ (elem));\n          } else {\n            this.loadImports( /** @type {!Element} */ (elem));\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * @param {!Node} node\n   * @return {boolean}\n   */\n  const isImportLink = node => {\n    return node.nodeType === Node.ELEMENT_NODE && node.localName === 'link' &&\n      ( /** @type {!HTMLLinkElement} */ (node).rel === 'import');\n  };\n\n  /**\n   * Waits for an element to finish loading. If already done loading, it will\n   * mark the element accordingly.\n   * @param {!(HTMLLinkElement|HTMLScriptElement|HTMLStyleElement)} element\n   * @param {function()=} callback\n   */\n  const whenElementLoaded = (element, callback) => {\n    if (element['__loaded']) {\n      callback && callback();\n    } else if (element.localName === 'script' && !element.src) {\n      // Inline scripts don't trigger load/error events, consider them already loaded.\n      element['__loaded'] = true;\n      callback && callback();\n    } else {\n      const onLoadingDone = event => {\n        element.removeEventListener(event.type, onLoadingDone);\n        element['__loaded'] = true;\n        callback && callback();\n      };\n      element.addEventListener('load', onLoadingDone);\n      // NOTE: We listen only for load events in IE/Edge, because in IE/Edge\n      // <style> with @import will fire error events for each failing @import,\n      // and finally will trigger the load event when all @import are\n      // finished (even if all fail).\n      if (!isIE || element.localName !== 'style') {\n        element.addEventListener('error', onLoadingDone);\n      }\n    }\n  }\n\n  /**\n   * Calls the callback when all imports in the document at call time\n   * (or at least document ready) have loaded. Callback is called synchronously\n   * if imports are already done loading.\n   * @param {function()=} callback\n   */\n  const whenReady = callback => {\n    // 1. ensure the document is in a ready state (has dom), then\n    // 2. watch for loading of imports and call callback when done\n    whenDocumentReady(() => whenImportsReady(() => callback && callback()));\n  }\n\n  /**\n   * Invokes the callback when document is in ready state. Callback is called\n   *  synchronously if document is already done loading.\n   * @param {!function()} callback\n   */\n  const whenDocumentReady = callback => {\n    const stateChanged = () => {\n      // NOTE: Firefox can hit readystate interactive without document.body existing.\n      // This is anti-spec, but we handle it here anyways by waiting for next change.\n      if (document.readyState !== 'loading' && !!document.body) {\n        document.removeEventListener('readystatechange', stateChanged);\n        callback();\n      }\n    }\n    document.addEventListener('readystatechange', stateChanged);\n    stateChanged();\n  }\n\n  /**\n   * Invokes the callback after all imports are loaded. Callback is called\n   * synchronously if imports are already done loading.\n   * @param {!function()} callback\n   */\n  const whenImportsReady = callback => {\n    let imports = /** @type {!NodeList<!HTMLLinkElement>} */\n      (document.querySelectorAll(rootImportSelector));\n    let pending = imports.length;\n    if (!pending) {\n      callback();\n      return;\n    }\n    for (let i = 0, l = imports.length, imp; i < l && (imp = imports[i]); i++) {\n      whenElementLoaded(imp, () => {\n        if (--pending === 0) {\n          callback();\n        }\n      });\n    }\n  }\n\n  /**\n   * Returns the import document containing the element.\n   * @param {!Node} element\n   * @return {HTMLLinkElement|Document|undefined}\n   */\n  const importForElement = element => {\n    if (useNative) {\n      // Return only if not in the main doc!\n      return element.ownerDocument !== document ? element.ownerDocument : null;\n    }\n    let doc = element['__importDoc'];\n    if (!doc && element.parentNode) {\n      doc = /** @type {!Element} */ (element.parentNode);\n      if (typeof doc.closest === 'function') {\n        // Element.closest returns the element itself if it matches the selector,\n        // so we search the closest import starting from the parent.\n        doc = doc.closest(importSelector);\n      } else {\n        // Walk up the parent tree until we find an import.\n        while (!isImportLink(doc) && (doc = doc.parentNode)) {}\n      }\n      element['__importDoc'] = doc;\n    }\n    return doc;\n  }\n\n  const newCustomEvent = (type, params) => {\n    if (typeof window.CustomEvent === 'function') {\n      return new CustomEvent(type, params);\n    }\n    const event = /** @type {!CustomEvent} */ (document.createEvent('CustomEvent'));\n    event.initCustomEvent(type, Boolean(params.bubbles), Boolean(params.cancelable), params.detail);\n    return event;\n  };\n\n  if (useNative) {\n    // Check for imports that might already be done loading by the time this\n    // script is actually executed. Native imports are blocking, so the ones\n    // available in the document by this time should already have failed\n    // or have .import defined.\n    const imps = /** @type {!NodeList<!HTMLLinkElement>} */\n      (document.querySelectorAll(importSelector));\n    for (let i = 0, l = imps.length, imp; i < l && (imp = imps[i]); i++) {\n      if (!imp.import || imp.import.readyState !== 'loading') {\n        imp['__loaded'] = true;\n      }\n    }\n    // Listen for load/error events to capture dynamically added scripts.\n    /**\n     * @type {!function(!Event)}\n     */\n    const onLoadingDone = event => {\n      const elem = /** @type {!Element} */ (event.target);\n      if (isImportLink(elem)) {\n        elem['__loaded'] = true;\n      }\n    };\n    document.addEventListener('load', onLoadingDone, true /* useCapture */ );\n    document.addEventListener('error', onLoadingDone, true /* useCapture */ );\n  } else {\n    // Override baseURI so that imported elements' baseURI can be used seemlessly\n    // on native or polyfilled html-imports.\n    // NOTE: a <link rel=import> will have `link.baseURI === link.href`, as the link\n    // itself is used as the `import` document.\n    /** @type {Object|undefined} */\n    const native_baseURI = Object.getOwnPropertyDescriptor(Node.prototype, 'baseURI');\n    // NOTE: if not configurable (e.g. safari9), set it on the Element prototype. \n    const klass = !native_baseURI || native_baseURI.configurable ? Node : Element;\n    Object.defineProperty(klass.prototype, 'baseURI', {\n      get() {\n        const ownerDoc = /** @type {HTMLLinkElement} */ (isImportLink(this) ? this : importForElement(this));\n        if (ownerDoc) return ownerDoc.href;\n        // Use native baseURI if possible.\n        if (native_baseURI && native_baseURI.get) return native_baseURI.get.call(this);\n        // Polyfill it if not available.\n        const base = /** @type {HTMLBaseElement} */ (document.querySelector('base'));\n        return (base || window.location).href;\n      },\n      configurable: true,\n      enumerable: true\n    });\n\n    whenDocumentReady(() => new Importer());\n  }\n\n  /**\n    Add support for the `HTMLImportsLoaded` event and the `HTMLImports.whenReady`\n    method. This api is necessary because unlike the native implementation,\n    script elements do not force imports to resolve. Instead, users should wrap\n    code in either an `HTMLImportsLoaded` handler or after load time in an\n    `HTMLImports.whenReady(callback)` call.\n\n    NOTE: This module also supports these apis under the native implementation.\n    Therefore, if this file is loaded, the same code can be used under both\n    the polyfill and native implementation.\n   */\n  whenReady(() => document.dispatchEvent(newCustomEvent('HTMLImportsLoaded', {\n    cancelable: true,\n    bubbles: true,\n    detail: undefined\n  })));\n\n  // exports\n  scope.useNative = useNative;\n  scope.whenReady = whenReady;\n  scope.importForElement = importForElement;\n\n})(window.HTMLImports = (window.HTMLImports || {}));","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function() {\n\n  'use strict';\n\n  // Establish scope.\n  window['WebComponents'] = window['WebComponents'] || {'flags':{}};\n\n  // loading script\n  var file = 'webcomponents-lite.js';\n  var script = document.querySelector('script[src*=\"' + file + '\"]');\n  var flagMatcher = /wc-(.+)/;\n\n  // Flags. Convert url arguments to flags\n  var flags = {};\n  if (!flags['noOpts']) {\n    // from url\n    location.search.slice(1).split('&').forEach(function(option) {\n      var parts = option.split('=');\n      var match;\n      if (parts[0] && (match = parts[0].match(flagMatcher))) {\n        flags[match[1]] = parts[1] || true;\n      }\n    });\n    // from script\n    if (script) {\n      for (var i=0, a; (a=script.attributes[i]); i++) {\n        if (a.name !== 'src') {\n          flags[a.name] = a.value || true;\n        }\n      }\n    }\n    // log flags\n    if (flags['log'] && flags['log']['split']) {\n      var parts = flags['log'].split(',');\n      flags['log'] = {};\n      parts.forEach(function(f) {\n        flags['log'][f] = true;\n      });\n    } else {\n      flags['log'] = {};\n    }\n  }\n\n  // exports\n  window['WebComponents']['flags'] = flags;\n  var forceShady = flags['shadydom'];\n  if (forceShady) {\n    window['ShadyDOM'] = window['ShadyDOM'] || {};\n    window['ShadyDOM']['force'] = forceShady;\n  }\n\n  var forceCE = flags['register'] || flags['ce'];\n  if (forceCE && window['customElements']) {\n    window['customElements']['forcePolyfill'] = forceCE;\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\n'use strict';\n\nexport let appendChild = Element.prototype.appendChild;\nexport let insertBefore = Element.prototype.insertBefore;\nexport let removeChild = Element.prototype.removeChild;\nexport let setAttribute = Element.prototype.setAttribute;\nexport let removeAttribute = Element.prototype.removeAttribute;\nexport let cloneNode = Element.prototype.cloneNode;\nexport let importNode = Document.prototype.importNode;\nexport let addEventListener = Element.prototype.addEventListener;\nexport let removeEventListener = Element.prototype.removeEventListener;\nexport let windowAddEventListener = Window.prototype.addEventListener;\nexport let windowRemoveEventListener = Window.prototype.removeEventListener;\nexport let dispatchEvent = Element.prototype.dispatchEvent;","/**\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\n'use strict';\nimport * as utils from './utils'\nimport {flush, enqueue} from './flush'\nimport {observeChildren, unobserveChildren, filterMutations} from './observe-changes'\nimport * as nativeMethods from './native-methods'\nimport * as nativeTree from './native-tree'\nimport {patchBuiltins} from './patch-builtins'\nimport {patchEvents} from './patch-events'\nimport {ShadyRoot} from './attach-shadow'\n\nif (utils.settings.inUse) {\n  let ShadyDOM = {\n    // TODO(sorvell): remove when Polymer does not depend on this.\n    'inUse': utils.settings.inUse,\n    // TODO(sorvell): remove when Polymer does not depend on this\n    'patch': (node) => node,\n    'isShadyRoot': utils.isShadyRoot,\n    'enqueue': enqueue,\n    'flush': flush,\n    'settings': utils.settings,\n    'filterMutations': filterMutations,\n    'observeChildren': observeChildren,\n    'unobserveChildren': unobserveChildren,\n    'nativeMethods': nativeMethods,\n    'nativeTree': nativeTree\n  };\n\n  window['ShadyDOM'] = ShadyDOM;\n\n  // Apply patches to events...\n  patchEvents();\n  // Apply patches to builtins (e.g. Element.prototype) where applicable.\n  patchBuiltins();\n\n  window.ShadowRoot = ShadyRoot;\n}","export default {\n  Document_createElement: window.Document.prototype.createElement,\n  Document_createElementNS: window.Document.prototype.createElementNS,\n  Document_importNode: window.Document.prototype.importNode,\n  Document_prepend: window.Document.prototype['prepend'],\n  Document_append: window.Document.prototype['append'],\n  Node_cloneNode: window.Node.prototype.cloneNode,\n  Node_appendChild: window.Node.prototype.appendChild,\n  Node_insertBefore: window.Node.prototype.insertBefore,\n  Node_removeChild: window.Node.prototype.removeChild,\n  Node_replaceChild: window.Node.prototype.replaceChild,\n  Node_textContent: Object.getOwnPropertyDescriptor(window.Node.prototype, 'textContent'),\n  Element_attachShadow: window.Element.prototype['attachShadow'],\n  Element_innerHTML: Object.getOwnPropertyDescriptor(window.Element.prototype, 'innerHTML'),\n  Element_getAttribute: window.Element.prototype.getAttribute,\n  Element_setAttribute: window.Element.prototype.setAttribute,\n  Element_removeAttribute: window.Element.prototype.removeAttribute,\n  Element_getAttributeNS: window.Element.prototype.getAttributeNS,\n  Element_setAttributeNS: window.Element.prototype.setAttributeNS,\n  Element_removeAttributeNS: window.Element.prototype.removeAttributeNS,\n  Element_insertAdjacentElement: window.Element.prototype['insertAdjacentElement'],\n  Element_prepend: window.Element.prototype['prepend'],\n  Element_append: window.Element.prototype['append'],\n  Element_before: window.Element.prototype['before'],\n  Element_after: window.Element.prototype['after'],\n  Element_replaceWith: window.Element.prototype['replaceWith'],\n  Element_remove: window.Element.prototype['remove'],\n  HTMLElement: window.HTMLElement,\n  HTMLElement_innerHTML: Object.getOwnPropertyDescriptor(window.HTMLElement.prototype, 'innerHTML'),\n  HTMLElement_insertAdjacentElement: window.HTMLElement.prototype['insertAdjacentElement'],\n};\n","/**\n * This class exists only to work around Closure's lack of a way to describe\n * singletons. It represents the 'already constructed marker' used in custom\n * element construction stacks.\n *\n * https://html.spec.whatwg.org/#concept-already-constructed-marker\n */\nclass AlreadyConstructedMarker {}\n\nexport default new AlreadyConstructedMarker();\n","/**\n * @license\n * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\nimport CustomElementInternals from './CustomElementInternals.js';\nimport CustomElementRegistry from './CustomElementRegistry.js';\n\nimport PatchHTMLElement from './Patch/HTMLElement.js';\nimport PatchDocument from './Patch/Document.js';\nimport PatchNode from './Patch/Node.js';\nimport PatchElement from './Patch/Element.js';\n\nconst priorCustomElements = window['customElements'];\n\nif (!priorCustomElements ||\n     priorCustomElements['forcePolyfill'] ||\n     (typeof priorCustomElements['define'] != 'function') ||\n     (typeof priorCustomElements['get'] != 'function')) {\n  /** @type {!CustomElementInternals} */\n  const internals = new CustomElementInternals();\n\n  PatchHTMLElement(internals);\n  PatchDocument(internals);\n  PatchNode(internals);\n  PatchElement(internals);\n\n  // The main document is always associated with the registry.\n  document.__CE_hasRegistry = true;\n\n  /** @type {!CustomElementRegistry} */\n  const customElements = new CustomElementRegistry(internals);\n\n  Object.defineProperty(window, 'customElements', {\n    configurable: true,\n    enumerable: true,\n    value: customElements,\n  });\n}\n","/**\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[^(]*(\\([^)]*\\))/;\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\nimport {applyStylePlaceHolder} from './style-util.js'\nimport {nativeShadow} from './style-settings.js'\n\n/** @type {Object<string, !Node>} */\nlet placeholderMap = {};\n\n/**\n * @const {CustomElementRegistry}\n */\nconst ce = window['customElements'];\nif (ce && !nativeShadow) {\n  /**\n   * @const {function(this:CustomElementRegistry, string,function(new:HTMLElement),{extends: string}=)}\n   */\n  const origDefine = ce['define'];\n  /**\n   * @param {string} name\n   * @param {function(new:HTMLElement)} clazz\n   * @param {{extends: string}=} options\n   * @return {function(new:HTMLElement)}\n   */\n  const wrappedDefine = (name, clazz, options) => {\n    placeholderMap[name] = applyStylePlaceHolder(name);\n    return origDefine.call(/** @type {!CustomElementRegistry} */(ce), name, clazz, options);\n  }\n  ce['define'] = wrappedDefine;\n}\n\nexport default placeholderMap;\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\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';\n\nimport { MIXIN_MATCH, VAR_ASSIGN } from './common-regex'\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@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport ScopingShim from '../src/scoping-shim.js'\nimport {nativeCssVariables, nativeShadow} from '../src/style-settings.js'\n\n/** @const {ScopingShim} */\nconst scopingShim = new ScopingShim();\n\nlet ApplyShim, CustomStyleInterface;\n\nif (window['ShadyCSS']) {\n  ApplyShim = window['ShadyCSS']['ApplyShim'];\n  CustomStyleInterface = window['ShadyCSS']['CustomStyleInterface'];\n}\n\nwindow.ShadyCSS = {\n  ScopingShim: scopingShim,\n  /**\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} elementExtends\n   */\n  prepareTemplate(template, elementName, elementExtends) {\n    scopingShim.flushCustomStyles();\n    scopingShim.prepareTemplate(template, elementName, elementExtends)\n  },\n\n  /**\n   * @param {!HTMLElement} element\n   * @param {Object=} properties\n   */\n  styleSubtree(element, properties) {\n    scopingShim.flushCustomStyles();\n    scopingShim.styleSubtree(element, properties);\n  },\n\n  /**\n   * @param {!HTMLElement} element\n   */\n  styleElement(element) {\n    scopingShim.flushCustomStyles();\n    scopingShim.styleElement(element);\n  },\n\n  /**\n   * @param {Object=} properties\n   */\n  styleDocument(properties) {\n    scopingShim.flushCustomStyles();\n    scopingShim.styleDocument(properties);\n  },\n\n  /**\n   * @param {Element} element\n   * @param {string} property\n   * @return {string}\n   */\n  getComputedStyleValue(element, property) {\n    return scopingShim.getComputedStyleValue(element, property);\n  },\n\n  nativeCss: nativeCssVariables,\n\n  nativeShadow: nativeShadow\n};\n\nif (ApplyShim) {\n  window.ShadyCSS.ApplyShim = ApplyShim;\n}\n\nif (CustomStyleInterface) {\n  window.ShadyCSS.CustomStyleInterface = CustomStyleInterface;\n}","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function() {\n\n  'use strict';\n\n  var customElements = window['customElements'];\n  var HTMLImports = window['HTMLImports'];\n  // global for (1) existence means `WebComponentsReady` will file,\n  // (2) WebComponents.ready == true means event has fired.\n  window.WebComponents = window.WebComponents || {};\n\n  if (customElements && customElements['polyfillWrapFlushCallback']) {\n    // Here we ensure that the public `HTMLImports.whenReady`\n    // always comes *after* custom elements have upgraded.\n    var flushCallback;\n    var runAndClearCallback = function runAndClearCallback() {\n      if (flushCallback) {\n        var cb = flushCallback;\n        flushCallback = null;\n        cb();\n        return true;\n      }\n    }\n    var origWhenReady = HTMLImports['whenReady'];\n    customElements['polyfillWrapFlushCallback'](function(cb) {\n      flushCallback = cb;\n      origWhenReady(runAndClearCallback);\n    });\n\n    HTMLImports['whenReady'] = function(cb) {\n      origWhenReady(function() {\n        // custom element code may add dynamic imports\n        // to match processing of native custom elements before\n        // domContentLoaded, we wait for these imports to resolve first.\n        if (runAndClearCallback()) {\n          HTMLImports['whenReady'](cb);\n        } else {\n          cb();\n        }\n      });\n    }\n\n  }\n\n  HTMLImports['whenReady'](function() {\n    requestAnimationFrame(function() {\n      window.WebComponents.ready = true;\n      document.dispatchEvent(new CustomEvent('WebComponentsReady', {bubbles: true}));\n    });\n  });\n\n})();","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n\n(function() {\n  'use strict';\n  // It's desireable to provide a default stylesheet\n  // that's convenient for styling unresolved elements, but\n  // it's cumbersome to have to include this manually in every page.\n  // It would make sense to put inside some HTMLImport but\n  // the HTMLImports polyfill does not allow loading of stylesheets\n  // that block rendering. Therefore this injection is tolerated here.\n  //\n  // NOTE: position: relative fixes IE's failure to inherit opacity\n  // when a child is not statically positioned.\n  var style = document.createElement('style');\n  style.textContent = ''\n      + 'body {'\n      + 'transition: opacity ease-in 0.2s;'\n      + ' } \\n'\n      + 'body[unresolved] {'\n      + 'opacity: 0; display: block; overflow: hidden; position: relative;'\n      + ' } \\n'\n      ;\n  var head = document.querySelector('head');\n  head.insertBefore(style, head.firstChild);\n\n})();\n"]}