{"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","__immediatePropagationStopped","retargetNonBubblingEvent","e","__propagationStopped","Event","AT_TARGET","lastFiredRoot","activateFocusEventOverrides","ev","nonBubblingEventsToRetarget","addEventListener","patchEvent","stopImmediatePropagation","__relatedTarget","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","splice","rowCount","columnCount","distances","north","west","edits","northWest","EDIT_LEAVE","EDIT_UPDATE","EDIT_DELETE","EDIT_ADD","reverse","splices","oldIndex","getAssignedSlot","patchBuiltin","d","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","parseSettings","nativeCssVariables","nativeShadow","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","getIsExtends","is","extends","invalidate","template","templateMap","startValidatingTemplate","_validating","promise","then","whenReady","readyPromise","resolveFn","workingDefaultPrevented","createEvent","initEvent","preventDefault","defaultPrevented","origPreventDefault","Event.prototype.preventDefault","cancelable","isIE","navigator","userAgent","CustomEvent","window.CustomEvent","inType","params","initCustomEvent","bubbles","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","dom","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","x","_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","removeEventListener","src","onLoadingDone","rel","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","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","tc","cn","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","children$$1","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","patchShadowRootAccessors","nodeMixin","addEventListener$1","optionsOrCapture","capture","once","passive","__eventWrappers","wrapperFn","eventPhase","BUBBLING_PHASE","removeEventListener$1","idx","nativeParent","ownerDocumentElement","textMixin","fragmentMixin","selector","slotMixin","elementMixin","defineProperties","documentMixin","ShadyDOM","Text","HTMLSlotElement","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","CSS","supports","ShadyCSS","VAR_ASSIGN","MIXIN_MATCH","VAR_CONSUMED","ANIMATION_MATCH","BRACKETED","shouldRemoveScope","_transformDom","_content","classList","SCOPE_NAME","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","StyleTransformer$1","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","handler","mxns","mxn","hasAttribute","classes","classIdx","delayedStart","requestAnimationFrame","transformFn","validateFn","enqueueDocumentValidation","addCustomStyle","getStyleForCustomStyle","processStyles","cs","appliedStyle","styleToTransform","needsEnqueue","styleCache","_generateScopeSelector","id","getStyleAst","styleAstToString","_gatherStyles","styles","_getCssBuild","prepareTemplate","_prepared","__cssBuild","hasMixins","_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","nativeCss","flushCallback","runAndClearCallback","origWhenReady"],"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'\nimport {nativeShadow, nativeCssVariables} from './style-settings'\nimport StyleTransformer from './style-transformer'\nimport * as StyleUtil from './style-util'\nimport StyleProperties from './style-properties'\nimport placeholderMap from './style-placeholder'\nimport StyleInfo from './style-info'\nimport StyleCache from './style-cache'\nimport {flush as watcherFlush} from './document-watcher'\nimport templateMap from './template-map'\nimport * as ApplyShimUtils from './apply-shim-utils'\nimport documentWait from './document-wait'\nimport {updateNativeProperties} from './common-utils'\nimport {CustomStyleInterfaceInterface} from './custom-style-interface' //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 = this._applyShim['detectMixin'](cssText);\n    let ast = parse(cssText);\n    // only run the applyshim transforms if there is a mixin involved\n    if (hasMixins && nativeCssVariables) {\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.ApplyShim) {\n      this._applyShim = window.ShadyCSS.ApplyShim;\n      this._applyShim['invalidCallback'] = ApplyShimUtils.invalidate;\n    } else {\n      this._applyShim = {\n        /* eslint-disable no-unused-vars */\n        ['detectMixin'](str){return false},\n        ['transformRule'](ast){},\n        ['transformRules'](ast, name){},\n        /* eslint-enable no-unused-vars */\n      }\n    }\n  }\n  _ensureCustomStyleInterface() {\n    if (this._customStyleInterface) {\n      return;\n    } else if (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    } else {\n      this._customStyleInterface = /** @type {!CustomStyleInterfaceInterface} */({\n        ['processStyles']() {},\n        ['enqueued']: false,\n        ['getStyleForCustomStyle'](s) { return null } // eslint-disable-line no-unused-vars\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    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['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['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) {\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'\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'\nimport StyleTransformer from './style-transformer'\nimport {getIsExtends} from './style-util'\n\nexport let flush = function() {};\n\nif (!nativeShadow) {\n  let elementNeedsScoping = (element) => {\n    return (element.classList &&\n      !element.classList.contains(StyleTransformer.SCOPE_NAME) ||\n      // note: necessary for IE11\n      (element instanceof window['SVGElement'] && (!element.hasAttribute('class') ||\n      element.getAttribute('class').indexOf(StyleTransformer.SCOPE_NAME) < 0)));\n  }\n\n/**\n * @param {Array<MutationRecord|null>|null} mxns\n */\n  let 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 (elementNeedsScoping(n)) {\n          let root = n.getRootNode();\n          if (root.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n            // may no longer be in a shadowroot\n            let host = /** @type {ShadowRoot} */(root).host;\n            if (host) {\n              let {is: scope} = getIsExtends(host);\n              StyleTransformer.dom(n, scope);\n            }\n          }\n        }\n      }\n      for (let i=0; i < mxn.removedNodes.length; i++) {\n        let n = /** @type {HTMLElement} */(mxn.removedNodes[i]);\n        if (n.nodeType === Node.ELEMENT_NODE) {\n          let classes = undefined;\n          if (n.classList) {\n            classes = Array.from(n.classList);\n          } else if (n.hasAttribute('class')) {\n            classes = n.getAttribute('class').split(/\\s+/);\n          }\n          if (classes !== undefined) {\n            // NOTE: relies on the scoping class always being adjacent to the\n            // SCOPE_NAME class.\n            let classIdx = classes.indexOf(StyleTransformer.SCOPE_NAME);\n            if (classIdx >= 0) {\n              let scope = classes[classIdx + 1];\n              if (scope) {\n                StyleTransformer.dom(n, scope, true);\n              }\n            }\n          }\n        }\n      }\n    }\n  };\n\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']['flush']);\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' // eslint-disable-line no-unused-vars\nimport {nativeShadow} from './style-settings'\nimport StyleTransformer from './style-transformer'\nimport * as StyleUtil from './style-util'\nimport * as RX from './common-regex'\nimport StyleInfo from './style-info'\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        StyleUtil.applyStyle(style, null, styleInfo.placeholder);\n      }\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    // @media rules may be stale in IE 10 and 11\n    if (IS_IE) {\n      style.textContent = style.textContent;\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' // 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' // eslint-disable-line no-unused-vars\nimport * as StyleUtil from './style-util'\nimport {nativeShadow} from './style-settings'\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      if (oldValue !== newValue) {\n        internals.attributeChangedCallback(this, name, oldValue, newValue, null);\n      }\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      if (oldValue !== newValue) {\n        internals.attributeChangedCallback(this, name, oldValue, newValue, namespace);\n      }\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\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} 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    insertionPoint.dispatchEvent(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.parentElement;\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      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        return this.__shady.childNodes;\n      } else {\n        return nativeTree.childNodes(this);\n      }\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        if (text) {\n          this.appendChild(document.createTextNode(text));\n        }\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      if (this.__shady && this.__shady.firstChild !== undefined) {\n        return Array.prototype.filter.call(this.childNodes, function(n) {\n          return (n.nodeType === Node.ELEMENT_NODE);\n        });\n      } else {\n        return nativeTree.children(this);\n      }\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 {addEventListener as nativeAddEventListener,\n  removeEventListener as nativeRemoveEventListener} from './native-methods'\n\n// https://github.com/w3c/webcomponents/issues/513#issuecomment-224183937\nlet alwaysComposed = {\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      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', {value: 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\n/**\n * @this {Event}\n */\nexport function addEventListener(type, fn, optionsOrCapture) {\n  if (!fn) {\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  if (fn.__eventWrappers) {\n    // Stop if the wrapper function has already been created.\n    for (let i = 0; i < fn.__eventWrappers.length; i++) {\n      if (fn.__eventWrappers[i].node === this &&\n          fn.__eventWrappers[i].type === type &&\n          fn.__eventWrappers[i].capture === capture &&\n          fn.__eventWrappers[i].once === once &&\n          fn.__eventWrappers[i].passive === passive) {\n        return;\n      }\n    }\n  } else {\n    fn.__eventWrappers = [];\n  }\n\n  /**\n   * @this {HTMLElement}\n   */\n  const wrapperFn = function(e) {\n    // Support `once` option.\n    if (once) {\n      this.removeEventListener(type, fn, optionsOrCapture);\n    }\n    if (!e['__target']) {\n      patchEvent(e);\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(this) > -1) {\n      if (e.eventPhase === Event.BUBBLING_PHASE) {\n        if (e.target === e.relatedTarget) {\n          e.stopImmediatePropagation();\n          return;\n        }\n      }\n      return fn(e);\n    }\n  };\n  // Store the wrapper information.\n  fn.__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    nativeAddEventListener.call(this, type, wrapperFn, optionsOrCapture);\n  }\n}\n\n/**\n * @this {Event}\n */\nexport function removeEventListener(type, fn, optionsOrCapture) {\n  if (!fn) {\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  // Search the wrapped function.\n  let wrapperFn = undefined;\n  if (fn.__eventWrappers) {\n    for (let i = 0; i < fn.__eventWrappers.length; i++) {\n      if (fn.__eventWrappers[i].node === this &&\n          fn.__eventWrappers[i].type === type &&\n          fn.__eventWrappers[i].capture === capture &&\n          fn.__eventWrappers[i].once === once &&\n          fn.__eventWrappers[i].passive === passive) {\n        wrapperFn = fn.__eventWrappers.splice(i, 1)[0].wrapperFn;\n        // Cleanup.\n        if (!fn.__eventWrappers.length) {\n          fn.__eventWrappers = undefined;\n        }\n        break;\n      }\n    }\n  }\n\n  nativeRemoveEventListener.call(this, type, wrapperFn || fn, 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        e.stopImmediatePropagation();\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 * 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 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\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}, fragmentMixin);\n\nObject.defineProperties(documentMixin, {\n  '_activeElement': ActiveElementAccessor.activeElement\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  // These patches can always be done, for all supported browsers.\n  patchBuiltin(window.Node.prototype, nodeMixin);\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  // 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    let nativeHTMLElement =\n      (window['customElements'] && window['customElements']['nativeHTMLElement']) ||\n      HTMLElement;\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']);\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\nexport let nativeCssVariables = (!navigator.userAgent.match('AppleWebKit/601') &&\nwindow.CSS && CSS.supports && CSS.supports('box-shadow', '0 0 0 var(--foo)'));\n\n/**\n * @param {ShadyCSSOptions | ShadyCSSInterface | undefined} settings\n */\nfunction parseSettings(settings) {\n  if (settings) {\n    nativeCssVariables = nativeCssVariables && !settings['nativeCss'] && !settings['shimcssproperties'];\n  nativeShadow = nativeShadow && !settings['nativeShadow'] && !settings['shimshadow'];\n  }\n}\n\nif (window.ShadyCSS) {\n  parseSettings(window.ShadyCSS);\n} else if (window['WebComponents']) {\n  parseSettings(window['WebComponents']['flags']);\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {nativeShadow, nativeCssVariables} from './style-settings'\nimport {parse, stringify, types, StyleNode} from './css-parse' // eslint-disable-line no-unused-vars\nimport {MEDIA_MATCH} from './common-regex';\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@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'\nimport {StyleNode} from './css-parse' // eslint-disable-line no-unused-vars\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 * @param {HTMLTemplateElement} template\n */\nexport function invalidateTemplate(template) {\n  template['_applyShimInvalid'] = true;\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['_applyShimInvalid'];\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 * @param {HTMLTemplateElement} template\n * @return {boolean}\n */\nexport function templateIsValidating(template) {\n  return template._validating;\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 * @param {HTMLTemplateElement} template\n */\nexport function startValidatingTemplate(template) {\n  if (!template._validating) {\n    template._validating = true;\n    promise.then(function() {\n      template['_applyShimInvalid'] = false;\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  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 * @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      // 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      whenDocumentReady(() => {\n        // Observe changes on <head>.\n        this.dynamicImportsMO.observe(document.head, {\n          childList: true,\n          subtree: true\n        });\n        this.loadImports(document);\n      });\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) {\n        return;\n      }\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          // 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          // Override baseURI so that link.import.baseURI can be used seemlessly\n          // on native or polyfilled html-imports.\n          Object.defineProperty(n, 'baseURI', {\n            get: () => n.href,\n            configurable: true,\n            enumerable: true\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 (isImportLink(element) &&\n      (!useNative && /** @type {!HTMLLinkElement}*/ (element).import === null) ||\n      (element.import && /** @type {!HTMLLinkElement}*/ (element).import.readyState === 'complete')) {\n      // This import has already been loaded but its __loaded property got removed. Ensure\n      // we set it back!\n      element['__loaded'] = true;\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    if (document.readyState !== 'loading') {\n      callback();\n    } else {\n      const stateChanged = () => {\n        if (document.readyState !== 'loading') {\n          document.removeEventListener('readystatechange', stateChanged);\n          callback();\n        }\n      }\n      document.addEventListener('readystatechange', stateChanged);\n    }\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    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;\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n/**\n * Patches elements that interacts with ShadyDOM\n * such that tree traversal and mutation apis act like they would under\n * ShadowDOM.\n *\n * This import enables seemless interaction with ShadyDOM powered\n * custom elements, enabling better interoperation with 3rd party code,\n * libraries, and frameworks that use DOM tree manipulation apis.\n */\n\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@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'\nimport {nativeShadow} from './style-settings'\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\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@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'\nimport {nativeCssVariables, nativeShadow} from '../src/style-settings'\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\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.dispatchEvent(new CustomEvent('WebComponentsReady'));\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"]}