{"version":3,"sources":["node_modules/@webcomponents/shadydom/src/shady-data.js"," [synthetic:util/global] "," [synthetic:util/defineproperty] "," [synthetic:es6/symbol] "," [synthetic:es6/util/makeiterator] "," [synthetic:es6/util/arrayfromiterator] ","node_modules/@webcomponents/shadydom/src/utils.js","node_modules/@webcomponents/shadydom/src/flush.js","node_modules/@webcomponents/shadydom/src/observe-changes.js","node_modules/@webcomponents/shadydom/src/innerHTML.js","node_modules/@webcomponents/shadydom/src/patch-native.js","node_modules/@webcomponents/shadydom/src/patch-instances.js","node_modules/@webcomponents/shadydom/src/patch-events.js","node_modules/@webcomponents/shadydom/src/array-splice.js","node_modules/@webcomponents/shadydom/src/link-nodes.js","node_modules/@webcomponents/shadydom/src/style-scoping.js","node_modules/@webcomponents/shadydom/src/patches/Node.js","node_modules/@webcomponents/shadydom/src/attach-shadow.js"," [synthetic:es6/util/arrayfromiterable] ","node_modules/@webcomponents/shadydom/src/patches/ParentNode.js","node_modules/@webcomponents/shadydom/src/patches/DocumentOrFragment.js","node_modules/@webcomponents/shadydom/src/patches/DocumentOrShadowRoot.js","node_modules/@webcomponents/shadydom/src/patches/ElementOrShadowRoot.js","node_modules/@webcomponents/shadydom/src/patches/ShadowRoot.js","node_modules/@webcomponents/shadydom/src/patch-shadyRoot.js","node_modules/@webcomponents/shadydom/src/wrapper.js","node_modules/@webcomponents/shadydom/src/patches/EventTarget.js","node_modules/@webcomponents/shadydom/src/patches/Slotable.js","node_modules/@webcomponents/shadydom/src/patches/Element.js","node_modules/@webcomponents/shadydom/src/patches/HTMLElement.js","node_modules/@webcomponents/shadydom/src/patches/Slot.js","node_modules/@webcomponents/shadydom/src/patches/Document.js","node_modules/@webcomponents/shadydom/src/patches/Window.js","node_modules/@webcomponents/shadydom/src/patch-prototypes.js","node_modules/@webcomponents/shadydom/src/shadydom.js","node_modules/@webcomponents/shadycss/src/css-parse.js","node_modules/@webcomponents/shadycss/src/style-settings.js","node_modules/@webcomponents/shadycss/src/common-regex.js","node_modules/@webcomponents/shadycss/src/unscoped-style-handler.js","node_modules/@webcomponents/shadycss/src/style-util.js","node_modules/@webcomponents/shadycss/src/style-transformer.js","node_modules/@webcomponents/shadycss/src/scoping-shim.js","node_modules/@webcomponents/shadycss/src/document-watcher.js","node_modules/@webcomponents/shadycss/src/style-properties.js","node_modules/@webcomponents/shadycss/src/style-info.js","node_modules/@webcomponents/shadycss/src/style-placeholder.js","node_modules/@webcomponents/shadycss/src/style-cache.js","node_modules/@webcomponents/shadycss/src/template-map.js","node_modules/@webcomponents/shadycss/src/apply-shim-utils.js","node_modules/@webcomponents/shadycss/src/common-utils.js","node_modules/@webcomponents/shadycss/entrypoints/scoping-shim.js","entrypoints/webcomponents-sd-index.js"],"names":["$jscomp.global","$jscomp.defineProperty","$jscomp.initSymbol","$jscomp.Symbol","$jscomp.SYMBOL_PREFIX","$jscomp.arrayIterator","$jscomp.initSymbolIterator","$jscomp.iteratorPrototype","constructor","ShadyData","publicRoot","root","dirty","flattenedNodes","_prevAssignedSlot","_previouslyAssignedNodes","assignedSlot","assignedNodes","observer","childNodes","nextSibling","previousSibling","lastChild","firstChild","parentNode","ownerShadyRoot","undefined","__insideAccessors","__outsideAccessors","__onCallbackListeners","toJSON","ensureShadyDataForNode","node","__shady","shadyDataForNode","settings","window","hasNativeShadowDOM","attachShadow","Element","prototype","getRootNode","Node","desc","Object","getOwnPropertyDescriptor","hasDescriptors","configurable","get","inUse","noPatch","preferPerformance","isTrackingLogicalChildNodes","nodeData","isShadyRoot","obj","_localName","hasShadowRootWithSlot","_hasInsertionPoint","p","matches","matchesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector","webkitMatchesSelector","twiddle","document","createTextNode","content","queue","observe","MutationObserver","length","shift","e","textContent","characterData","microtask","callback","push","hasDocumentContains","contains","container","createPolyfilledHTMLCollection","nodes","l","name","getAttribute","isNaN","item","nodes.item","index","namedItem","nodes.namedItem","$jscomp.makeIterator","patchProperties","proto","descriptors","prefix","disallowedPatches","newDescriptor","indexOf","value","defineProperty","getOwnPropertyDescriptors","getOwnPropertyNames","forEach","flushList","scheduled","enqueue","flush","didFlush","AsyncObserver","_scheduled","addedNodes","removedNodes","callbacks","Set","schedule","mutations","takeRecords","cb","observeChildren","sd","add","_callback","_observer","_node","unobserveChildren","handle","delete","size","filterMutations","target","targetRootNode","map","mutation","mutationInScope","Array","from","filter","n","create","m","escapeAttrRegExp","escapeDataRegExp","escapeReplace","c","makeSet","arr","set","i","voidElements","plaintextParents","getInnerHTML","localName","s","c$","child","nodeType","ELEMENT_NODE","tagName","attrs","attributes","attr","replace","TEXT_NODE","data","COMMENT_NODE","console","error","Error","nativeMethods","querySelector","selector","querySelectorAll","nativeTree","installNativeAccessor","NATIVE_PREFIX","defineNativeAccessors","prop","copyProperties","list","descriptor","nodeWalker","createTreeWalker","NodeFilter","SHOW_ALL","elementWalker","SHOW_ELEMENT","inertDoc","implementation","createHTMLDocument","clearNode","ParentNodeAccessors","ParentNodeMethods","addNativePrefixedProperties","eventProps","EventTarget","Window","currentNode","parentElement","DOCUMENT_FRAGMENT_NODE","textWalker","SHOW_TEXT","nextNode","nodeValue","ParentNodeWalkerDescriptors","firstElementChild","lastElementChild","children","childElementCount","HTMLElement","previousElementSibling","nextElementSibling","innerHTML","containerName","htmlContainer","namespaceURI","createElementNS","createElement","newContent","HTMLTemplateElement","DocumentFragment","Document","InsideDescriptors","shadowRoot","OutsideDescriptors","className","enumerable","noInstancePatching","patchOutsideElementAccessors","element","patchInsideElementAccessors","eventWrappersName","Date","now","composedGetter","composedProp","Event","ev","call","alwaysComposed","unpatchedEvents","getRootNodeWithFallback","eventTarget","pathComposer","startNode","composed","composedPath","current","startRoot","host","event","__composedPath","retarget","refNode","path","refNodePath","ancestor","lastRoot","rootIdx","mixinComposedFlag","Base","klazz","type","options","__composed","__proto__","nonBubblingEventsToRetarget","hasRetargeted","__relatedTarget","relatedTarget","fireHandlers","phase","hs","__handlers","fn","__immediatePropagationStopped","retargetNonBubblingEvent","__propagationStopped","AT_TARGET","lastFiredRoot","findListener","wrappers","capture","once","passive","savedType","savedListener","savedCapture","savedOnce","savedPassive","savedNode","addEventListener","fnOrObj","optionsOrCapture","handlerType","handleEvent","__shadyTarget","wrapperFn","patchEvent","lastCurrentTargetDesc","eventPhase","BUBBLING_PHASE","stopImmediatePropagation","CAPTURING_PHASE","bubbles","ret","removeEventListener","idx","splice","activateFocusEventOverrides","EventPatchesDescriptors","EventPatches","isTrusted","currentTarget","__relatedTargetComposedPath","stopPropagation","getPrototypeOf","hasOwnProperty","SHADY_PROTO","patchedProto","PatchedEvent","PatchedCustomEvent","CustomEvent","PatchedMouseEvent","MouseEvent","patchClick","composedClickFn","cancelable","click","eventPropertyNames","substring","newSplice","addedCount","removed","calcSplices","currentEnd","old","oldEnd","currentStart","oldStart","prefixCount","suffixCount","minLength","Math","min","currentValue","previousValue","index1","index2","count","equals","rowCount","columnCount","distances","j","north","west","edits","EDIT_ADD","EDIT_DELETE","northWest","EDIT_LEAVE","EDIT_UPDATE","reverse","splices","oldIndex","linkNode","ref_node","containerData","ref_nodeData","psd","nsd","recordInsertBefore","resetTo","recordRemoveChild","recordChildNodes","first","previous","scopingShim","getScopingShim","removeShadyScoping","currentScopeName","currentScopeIsCorrect","newScopeName","correctScope","currentScope","currentScopeForNode","treeVisitor","visitorFn","doc","nativeIsConnectedAccessors","nativeIsConnected","removeOwnerShadyRoot","firstComposedNode","flattened","scheduleObserver","addedNode","removedNode","NodePatches","childNodes.item","isConnected","ownerDocument","documentElement","tc","cn","join","insertBefore","refData","slotsAdded","ownerRoot","ownerShadyRootForNode","oldScopeName","allowNativeInsert","needsScoping","needsSlotFinding","_pendingSlots","_addSlots","_ensureSlotData","_slotList","_slotMap","$jscomp.arrayFromIterator","_asyncRender","parentData","adoptNode","appendChild","removeChild","skipUnscoping","removingInsertionPoint","_removeContainedSlots","preventNativeRemove","changeSlotContent","replaceChild","cloneNode","deep","ATTRIBUTE_NODE","nc","parent","query","matcher","halter","queryElements","elements","result","ParentNodePatches","QueryPatches","useNative","o","slice","ParentNodeDocumentOrFragmentPatches","assign","DocumentOrFragmentPatches","getElementById","id","DocumentOrShadowRootPatches","activeElement","active","activeRoot","ElementOrShadowRootPatches","ShadowRootPatches","patchShadyAccessors","ShadyRootConstructionToken","isRendering","readyState","rootRendered","ancestorList","ancestors","unshift","ShadyRoot","token","TypeError","SHADYROOT_NAME","mode","hostData","MODE_CLOSED","rootData","_hasRendered","_renderPending","_render","_getPendingDistributionRoot","renderRoot","_getDistributionParent","__childSlotCount","_renderSelf","wasRendering","_validateSlots","_distribute","slot","_clearSlotAssignedNodes","slotData","n$","_distributeNodeToSlot","slotParentRoot","slotParentData","_addAssignedToFlattenedNodes","prevAssignedNodes","_fireSlotChange","slots","composeList","_compose","_composeNode","_isInsertionPoint","_updateChildNodes","d","next","forcedSlot","oldSlot","CATCHALL_NAME","assigned","nestedAssigned","_mapSlots","slotNamesToSort","slotParent","_nameForSlot","_sortSlots","__slotName","sort","a","b","listA","listB","nA","nB","x","_removeFlattenedNodes","didRemove","patchShadyRoot","SHADY_PREFIX","defineProperties","nodeName","connectMap","Map","r","v","k","clear","__shadydom_connectedCallback","__shadydom_disconnectedCallback","ManageConnect","base","connected","disconnected","counter","connectFlag","connectedCallback","base.prototype.__shadydom_connectedCallback","disconnectedCallback","base.prototype.__shadydom_disconnectedCallback","define","Wrapper","addEventListener.prototype","removeEventListener.prototype","appendChild.prototype","insertBefore.prototype","removeChild.prototype","replaceChild.prototype","cloneNode.prototype","getRootNode.prototype","contains.prototype","dispatchEvent.prototype","dispatchEvent","setAttribute.prototype","setAttribute","getAttribute.prototype","removeAttribute.prototype","removeAttribute","attachShadow.prototype","focus.prototype","focus","blur.prototype","blur","importNode.prototype","importNode","DOCUMENT_NODE","getElementById.prototype","querySelector.prototype","querySelectorAll.prototype","assignedNodes.prototype","$jscomp.global.Object.defineProperties","_activeElement","wrapperMap","WeakMap","wrap","wrapper","EventTargetPatches","SlotablePatches","distributeAttributeChange","_updateSlotName","oldName","ElementPatches","HTMLElementPatches","shadowActive","property","shadyData","eventName","SlotPatches","flatten","DocumentPatches","WindowPatches","bind","NonStandardHTMLElement","patchMap","Text","HTMLSlotElement","disallowedNativePatches","applyPatches","disallowed","patch","ShadyDOM","flushInitial","_flushInitial","ShadowRoot","StyleNode","parse","text","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.comments","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.port","parseCss","OPEN_BRACE","CLOSE_BRACE","t","trim","ss","_expandUnicodeEscapes","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.multipleSpaces","lastIndexOf","AT_START","MEDIA_START","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.MEDIA_RULE","match","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.keyframesRule","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.KEYFRAMES_RULE","split","pop","VAR_START","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.MIXIN_RULE","types$$module$node_modules$$webcomponents$shadycss$src$css_parse.STYLE_RULE","r$","code","repeat","stringify","preserveProperties","cssText","rules","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.customProp","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.mixinProp","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.mixinApply","RX$$module$node_modules$$webcomponents$shadycss$src$css_parse.varApply","STYLE_RULE","KEYFRAMES_RULE","MEDIA_RULE","MIXIN_RULE","comments","port","customProp","mixinProp","mixinApply","varApply","keyframesRule","multipleSpaces","nativeShadow","nativeCssVariables_","calcCssVariables","navigator","userAgent","CSS","supports","cssBuild","ShadyCSS","disableRuntime","nativeCss","nativeCssVariables","module$node_modules$$webcomponents$shadycss$src$style_settings.cssBuild","VAR_ASSIGN","MIXIN_MATCH","VAR_CONSUMED","ANIMATION_MATCH","MEDIA_MATCH","BRACKETED","styleTextSet","toCssText","forEachRule","rulesForStyle","style","isKeyframesSelector","rule","styleRuleCallback","keyframesRuleCallback","onlyActiveRules","skipRules","matchMedia","applyCss","moniker","contextNode","applyStyle","lastHeadApplyNode","applyStylePlaceHolder","placeHolder","createComment","scope","head","after","compareDocumentPosition","position","DOCUMENT_POSITION_PRECEDING","findMatchingParen","start","level","processVariableAndFallback","str","end","inner","suffix","comma","fallback","setElementClassRaw","getIsExtends","typeExtension","is","extends","splitSelectorList","parts","part","getCssBuild","__cssBuild","attrValue","CSS_BUILD_ATTR","buildComment","Comment","commentParts","isOptimalCssBuild","StyleTransformer","domAddScope","_transformDom","transformer","_content","shouldRemoveScope","classList","remove","SCOPE_NAME","CLASS","newValue","domReplaceScope","oldScope","newScope","domRemoveScope","elementStyles","styleRules","css","ext","hostScope","_calcHostScope","_calcElementScope","CSS_CLASS_PREFIX","isScoped","_transformRule","transformedSelector","_transformRuleCss","_transformComplexSelector","p$","COMPLEX_SELECTOR_SEP","_twiddleNthPlus","NTH","inside","_preserveMatchesPseudo","MATCHES","input","MATCHES_REPLACEMENT","_replaceMatchesPseudo","reduce","acc","cur","stop","isNth","test","isMatches","SLOTTED_START","SIMPLE_SELECTOR_SEP","info","_transformCompoundSelector","combinator","slottedIndex","SLOTTED","HOST","_transformHostSelector","_transformSimpleSelector","slotted","SLOTTED_PAREN","paren","DIR_PAREN","before","dir","output","PSEUDO_PREFIX","HOST_PAREN","SIMPLE_SELECTOR_PREFIX","SELECTOR_NO_MATCH","normalizeRootSelector","ROOT","_transformDocumentSelector","SCOPE_DOC_SELECTOR","$jscompDefaultExport","StyleInfo","ast","placeholder","ownStylePropertyNames","overrideStyleProperties","customStyle","scopeSelector","styleProperties","styleInfo","_getStyleRules","method","IS_IE","StyleProperties","decorateStyles","props","keyframes","ruleIndex","decorateRule","propertyInfo","collectPropertiesInCssText","exec","onKeyframesRule","_keyframes","names","properties","collectProperties","collectCssText","collectConsumingCssText","any","valueForProperty","valueForProperties","propertyValue","lastIndex","colon","pp","propertyDataFromStyles","selectorToMatch","parseInt","key","whenHostOrRootRule","parsedSelector","isRoot","isHost","hostAndRootPropertiesForScope","hostProps","rootProps","_element","transformStyles","hostSelector","hostRx","RegExp","StyleInfo$$module$node_modules$$webcomponents$shadycss$src$style_info.get","keyframeTransforms","_elementKeyframeTransforms","applyProperties","applyKeyframeTransforms","hasAnimations","keyframeNamesToTransform","keyframe","transform","_scopeSelector","keyframesRules","keyframesNameRx","_scopeKeyframes","transformedKeyframesName","scopeId","_keyframesRuleTransformer","applyCustomStyle","XSCOPE_NAME","placeholderMap","ce","origDefine","wrappedDefine","clazz","StyleCache","cache","store","tagname","styleElement","typeMax","scopeRegExp","getCurrentScope","getOwnerScope","handler","mxns","mxn","unscopedNodes","unscopedNode","scopeForPreviouslyUnscopedNode","childList","subtree","delayedStart","body","requestAnimationFrame","listener","module$node_modules$$webcomponents$shadycss$src$document_watcher.flush","templateMap","promise","Promise","resolve","invalidate","elementName","template","templateIsValid","startValidatingTemplate","_validating","then","adoptedCssTextMap","styleCache","ScopingShim","_scopeCounter","_documentOwner","_documentOwnerStyleInfo","StyleInfo$$module$node_modules$$webcomponents$shadycss$src$style_info.set","_elementsHaveApplied","_customStyleInterface","_applyShim","flush.prototype","getStyleAst.prototype","getStyleAst","styleAstToString.prototype","styleAstToString","prepareTemplate.prototype","prepareTemplate","prepareTemplateDom","prepareTemplateStyles","prepareTemplateStyles.prototype","_prepared","optimalBuild","styleTextParts","styles","hasAttribute","scopingAttribute","has","newStyle","_gatherStyles","_ensure","hasMixins","ownPropertyNames","_generateStaticStyle","shadowroot","_style","_ownPropertyNames","prepareAdoptedCssText.prototype","prepareAdoptedCssText","cssTextArray","prepareTemplateDom.prototype","_domPrepared","_prepareHost","_ensureCustomStyleInterface","CustomStyleInterface","transformCustomStyleForDocument","flushCustomStyles","_ensureApplyShim","ApplyShim","flushCustomStyles.prototype","customStyles","_revalidateCustomStyleApplyShim","_revalidateApplyShim","_updateProperties","_applyCustomStyles","styleDocument","styleElement.prototype","overrideProps","_mixOverrideStyleProps","styleElementNativeVariables","styleElementShimVariables","_applyStyleProperties","cacheEntry","fetch","entry","_validate","pn","cachedStyle","oldScopeSelector","_generateScopeSelector","applyElementStyle","applyElementScopeSelector","removeProperty","setProperty","_styleOwnerForNode","owner","ownerStyleInfo","ownerProperties","hostAndRootProps","propertiesMatchingHost","_mixinOverrideStyles","overrides","reify","styleDocument.prototype","styleSubtree","styleSubtree.prototype","wrappedHost","shadowChildren","transformCustomStyleForDocument.prototype","documentRule","getComputedStyleValue.prototype","getComputedStyleValue","getComputedStyle","getPropertyValue","setElementClass.prototype","setElementClass","classString","classes","scopeName","classAttr","k$","_styleInfoForNode.prototype","_styleInfoForNode","scopeNode.prototype","scopeNode","unscopeNode.prototype","unscopeNode","scopeForNode.prototype","scopeForNode","currentScopeForNode.prototype","elementExtends","WebComponents","fire","ready","wait"],"mappings":"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","file":"webcomponents-sd.js","sourcesContent":["/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n\nexport class ShadyData {\n  constructor() {\n    /** @type {ShadowRoot} */\n    this.root = null;\n    /** @type {ShadowRoot} */\n    this.publicRoot = null;\n    this.dirty = false;\n    this.observer = null;\n    /** @type {Array<Node>} */\n    this.assignedNodes = null;\n    /** @type {Element} */\n    this.assignedSlot = null;\n    /** @type {Array<Node>} */\n    this._previouslyAssignedNodes = null;\n    /** @type {Element} */\n    this._prevAssignedSlot = null;\n    /** @type {Array<Node>} */\n    this.flattenedNodes = null;\n    this.ownerShadyRoot = undefined;\n    /** @type {Node|undefined} */\n    this.parentNode = undefined;\n    /** @type {Node|undefined} */\n    this.firstChild = undefined;\n    /** @type {Node|undefined} */\n    this.lastChild = undefined;\n    /** @type {Node|undefined} */\n    this.previousSibling = undefined;\n    /** @type {Node|undefined} */\n    this.nextSibling = undefined;\n    /** @type {Array<Node>|undefined} */\n    this.childNodes = undefined;\n    this.__outsideAccessors = false;\n    this.__insideAccessors = false;\n    this.__onCallbackListeners = {};\n  }\n\n  /** @override */\n  toJSON() {\n    return {};\n  }\n}\n\nexport function ensureShadyDataForNode(node) {\n  if (!node.__shady) {\n    node.__shady = new ShadyData();\n  }\n  return node.__shady;\n}\n\nexport function shadyDataForNode(node) {\n  return node && node.__shady;\n}\n",null,null,null,null,null,"/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport {shadyDataForNode} from './shady-data.js';\n\n/** @type {!Object} */\nexport const settings = window['ShadyDOM'] || {};\n\nsettings.hasNativeShadowDOM = Boolean(Element.prototype.attachShadow && Node.prototype.getRootNode);\n\nconst desc = Object.getOwnPropertyDescriptor(Node.prototype, 'firstChild');\n\nsettings.hasDescriptors = Boolean(desc && desc.configurable && desc.get);\nsettings.inUse = settings['force'] || !settings.hasNativeShadowDOM;\nsettings.noPatch = settings['noPatch'] || false;\nsettings.preferPerformance = settings['preferPerformance'];\n\nexport const isTrackingLogicalChildNodes = (node) => {\n  const nodeData = shadyDataForNode(node);\n  return (nodeData && nodeData.firstChild !== undefined);\n}\n\nexport const isShadyRoot = (obj) => {\n  return Boolean(obj._localName === 'ShadyRoot');\n}\n\nexport const hasShadowRootWithSlot = (node) => {\n  const nodeData = shadyDataForNode(node);\n  let root = nodeData && nodeData.root;\n  return (root && root._hasInsertionPoint());\n}\n\nlet p = Element.prototype;\nlet matches = p.matches || p.matchesSelector ||\n  p.mozMatchesSelector || p.msMatchesSelector ||\n  p.oMatchesSelector || p.webkitMatchesSelector;\n\nexport const matchesSelector = (element, selector) => {\n  return matches.call(element, selector);\n}\n\nexport const mixin = (target, source) => {\n  for (var i in source) {\n    target[i] = source[i];\n  }\n  return target;\n}\n\n// NOTE, prefer MutationObserver over Promise for microtask timing\n// for consistency x-platform.\nlet twiddle = document.createTextNode('');\nlet content = 0;\nlet queue = [];\nnew MutationObserver(() => {\n  while (queue.length) {\n    // catch errors in user code...\n    try {\n      queue.shift()();\n    } catch(e) {\n      // enqueue another record and throw\n      twiddle.textContent = content++;\n      throw(e);\n    }\n  }\n}).observe(twiddle, {characterData: true});\n\n// use MutationObserver to get microtask async timing.\nexport const microtask = (callback) => {\n  queue.push(callback);\n  twiddle.textContent = content++;\n}\n\nexport const hasDocumentContains = Boolean(document.contains);\n\nexport const contains = (container, node) => {\n  while (node) {\n    if (node == container) {\n      return true;\n    }\n    node = node[SHADY_PREFIX + 'parentNode'];\n  }\n  return false;\n}\n\nconst getNodeHTMLCollectionName = (node) =>\n    node.getAttribute('id') || node.getAttribute('name');\n\nconst isValidHTMLCollectionName = (name) => name !== 'length' && isNaN(name);\n\nexport const createPolyfilledHTMLCollection = (nodes) => {\n  // Note: loop in reverse so that the first named item matches the named property\n  for (let l = nodes.length - 1; l >= 0; l--) {\n    const node = nodes[l];\n    const name = getNodeHTMLCollectionName(node);\n\n    if (name && isValidHTMLCollectionName(name)) {\n      nodes[name] = node;\n    }\n  }\n  nodes.item = function(index) {\n    return nodes[index];\n  }\n  nodes.namedItem = function(name) {\n    if (isValidHTMLCollectionName(name) && nodes[name]) {\n      return nodes[name];\n    }\n\n    for (const node of nodes) {\n      const nodeName = getNodeHTMLCollectionName(node);\n\n      if (nodeName == name) {\n        return node;\n      }\n    }\n\n    return null;\n  };\n  return nodes;\n}\n\nexport const NATIVE_PREFIX = '__shady_native_';\nexport const SHADY_PREFIX = '__shady_';\n\n\n\n/**\n * Patch a group of accessors on an object only if it exists or if the `force`\n * argument is true.\n * @param {!Object} proto\n * @param {!Object} descriptors\n * @param {string=} prefix\n * @param {Array=} disallowedPatches\n */\nexport const patchProperties = (proto, descriptors, prefix = '', disallowedPatches) => {\n  for (let p in descriptors) {\n    const newDescriptor = descriptors[p];\n    if (disallowedPatches && disallowedPatches.indexOf(p) >= 0) {\n      continue;\n    }\n    newDescriptor.configurable = true;\n    const name = prefix + p;\n    // NOTE: we prefer writing directly because some browsers\n    // have descriptors that are writable but not configurable (e.g.\n    // `appendChild` on older browsers)\n    if (newDescriptor.value) {\n      proto[name] = newDescriptor.value;\n    } else {\n      // NOTE: this can throw if 'force' is used so catch the error.\n      try {\n        Object.defineProperty(proto, name, newDescriptor);\n      } catch(e) {\n        // this error is harmless so we just trap it.\n      }\n    }\n  }\n}\n\n/** @type {!function(new:HTMLElement)} */\nexport const NativeHTMLElement =\n    (window['customElements'] && window['customElements']['nativeHTMLElement']) ||\n    HTMLElement;\n\n// note, this is not a perfect polyfill since it doesn't include symbols\n/** @return {!Object<!ObjectPropertyDescriptor>} */\nexport const getOwnPropertyDescriptors = (obj) => {\n  const descriptors = {};\n  Object.getOwnPropertyNames(obj).forEach((name) => {\n    descriptors[name] = Object.getOwnPropertyDescriptor(obj, name);\n  });\n  return descriptors;\n};\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\n\n// render enqueuer/flusher\nlet flushList = [];\nlet scheduled;\nexport function enqueue(callback) {\n  if (!scheduled) {\n    scheduled = true;\n    utils.microtask(flush);\n  }\n  flushList.push(callback);\n}\n\nexport function flush() {\n  scheduled = false;\n  let didFlush = Boolean(flushList.length);\n  while (flushList.length) {\n    flushList.shift()();\n  }\n  return didFlush;\n}\n\nflush['list'] = flushList;\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\nimport {ensureShadyDataForNode} from './shady-data.js';\n\nclass AsyncObserver {\n\n  constructor() {\n    this._scheduled = false;\n    this.addedNodes = [];\n    this.removedNodes = [];\n    this.callbacks = new Set();\n  }\n\n  schedule() {\n    if (!this._scheduled) {\n      this._scheduled = true;\n      utils.microtask(() => {\n        this.flush();\n      });\n    }\n  }\n\n  flush() {\n    if (this._scheduled) {\n      this._scheduled = false;\n      let mutations = this.takeRecords();\n      if (mutations.length) {\n        this.callbacks.forEach(function(cb) {\n          cb(mutations);\n        });\n      }\n    }\n  }\n\n  takeRecords() {\n    if (this.addedNodes.length || this.removedNodes.length) {\n      let mutations = [{\n        addedNodes: this.addedNodes,\n        removedNodes: this.removedNodes\n      }];\n      this.addedNodes = [];\n      this.removedNodes = [];\n      return mutations;\n    }\n    return [];\n  }\n\n}\n\n// TODO(sorvell): consider instead polyfilling MutationObserver\n// directly so that users do not have to fork their code.\n// Supporting the entire api may be challenging: e.g. filtering out\n// removed nodes in the wrong scope and seeing non-distributing\n// subtree child mutations.\nexport let observeChildren = function(node, callback) {\n  const sd = ensureShadyDataForNode(node);\n  if (!sd.observer) {\n    sd.observer = new AsyncObserver();\n  }\n  sd.observer.callbacks.add(callback);\n  let observer = sd.observer;\n  return {\n    _callback: callback,\n    _observer: observer,\n    _node: node,\n    takeRecords() {\n      return observer.takeRecords()\n    }\n  };\n}\n\nexport let unobserveChildren = function(handle) {\n  let observer = handle && handle._observer;\n  if (observer) {\n    observer.callbacks.delete(handle._callback);\n    if (!observer.callbacks.size) {\n      ensureShadyDataForNode(handle._node).observer = null;\n    }\n  }\n}\n\nexport function filterMutations(mutations, target) {\n  /** @const {Node} */\n  const targetRootNode = target.getRootNode();\n  return mutations.map(function(mutation) {\n    /** @const {boolean} */\n    const mutationInScope = (targetRootNode === mutation.target.getRootNode());\n    if (mutationInScope && mutation.addedNodes) {\n      let nodes = Array.from(mutation.addedNodes).filter(function(n) {\n        return (targetRootNode === n.getRootNode());\n      });\n      if (nodes.length) {\n        mutation = Object.create(mutation);\n        Object.defineProperty(mutation, 'addedNodes', {\n          value: nodes,\n          configurable: true\n        });\n        return mutation;\n      }\n    } else if (mutationInScope) {\n      return mutation;\n    }\n  }).filter(function(m) { return m});\n}\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n// Cribbed from ShadowDOM polyfill\n// https://github.com/webcomponents/webcomponentsjs/blob/master/src/ShadowDOM/wrappers/HTMLElement.js#L28\n/////////////////////////////////////////////////////////////////////////////\n// innerHTML and outerHTML\n\n// http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#escapingString\nlet escapeAttrRegExp = /[&\\u00A0\"]/g;\nlet escapeDataRegExp = /[&\\u00A0<>]/g;\n\nfunction escapeReplace(c) {\n  switch (c) {\n    case '&':\n      return '&amp;';\n    case '<':\n      return '&lt;';\n    case '>':\n      return '&gt;';\n    case '\"':\n      return '&quot;';\n    case '\\u00A0':\n      return '&nbsp;';\n  }\n}\n\nfunction escapeAttr(s) {\n  return s.replace(escapeAttrRegExp, escapeReplace);\n}\n\nfunction escapeData(s) {\n  return s.replace(escapeDataRegExp, escapeReplace);\n}\n\nfunction makeSet(arr) {\n  let set = {};\n  for (let i = 0; i < arr.length; i++) {\n    set[arr[i]] = true;\n  }\n  return set;\n}\n\n// http://www.whatwg.org/specs/web-apps/current-work/#void-elements\nlet voidElements = makeSet([\n  'area',\n  'base',\n  'br',\n  'col',\n  'command',\n  'embed',\n  'hr',\n  'img',\n  'input',\n  'keygen',\n  'link',\n  'meta',\n  'param',\n  'source',\n  'track',\n  'wbr'\n]);\n\nlet plaintextParents = makeSet([\n  'style',\n  'script',\n  'xmp',\n  'iframe',\n  'noembed',\n  'noframes',\n  'plaintext',\n  'noscript'\n]);\n\n/**\n * @param {Node} node\n * @param {Node} parentNode\n * @param {Function=} callback\n */\nexport function getOuterHTML(node, parentNode, callback) {\n  switch (node.nodeType) {\n    case Node.ELEMENT_NODE: {\n      let tagName = node.localName;\n      let s = '<' + tagName;\n      let attrs = node.attributes;\n      for (let i = 0, attr; (attr = attrs[i]); i++) {\n        s += ' ' + attr.name + '=\"' + escapeAttr(attr.value) + '\"';\n      }\n      s += '>';\n      if (voidElements[tagName]) {\n        return s;\n      }\n      return s + getInnerHTML(node, callback) + '</' + tagName + '>';\n    }\n    case Node.TEXT_NODE: {\n      let data = /** @type {Text} */ (node).data;\n      if (parentNode && plaintextParents[parentNode.localName]) {\n        return data;\n      }\n      return escapeData(data);\n    }\n    case Node.COMMENT_NODE: {\n      return '<!--' + /** @type {Comment} */ (node).data + '-->';\n    }\n    default: {\n      window.console.error(node);\n      throw new Error('not implemented');\n    }\n  }\n}\n\n/**\n * @param {Node} node\n * @param {Function=} callback\n */\nexport function getInnerHTML(node, callback) {\n  if (node.localName === 'template') {\n    node =  /** @type {HTMLTemplateElement} */ (node).content;\n  }\n  let s = '';\n  let c$ = callback ? callback(node) : node.childNodes;\n  for (let i=0, l=c$.length, child; (i<l) && (child=c$[i]); i++) {\n    s += getOuterHTML(child, node, callback);\n  }\n  return s;\n}\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport * as utils from './utils.js';\nimport {patchProperties} from './utils.js';\nimport {getInnerHTML} from './innerHTML.js';\n\nconst hasDescriptors = utils.settings.hasDescriptors;\nexport const NATIVE_PREFIX = utils.NATIVE_PREFIX;\n\n// Object on which raw native methods are stored.\n// e.g. `nativeMethods.querySelector.call(node, selector)`\n// same as `node.querySelector(selector)`\nexport const nativeMethods = {\n  /** @this {Element} */\n  querySelector(selector) {\n    return this[NATIVE_PREFIX + 'querySelector'](selector);\n  },\n  /** @this {Element} */\n  querySelectorAll(selector) {\n    return this[NATIVE_PREFIX + 'querySelectorAll'](selector);\n  }\n};\n// Object on which raw native accessors are available via `accessorName(node)`.\n// e.g. `nativeTree.firstChild(node)`\n// same as `node.firstChild`\nexport const nativeTree = {};\n\nconst installNativeAccessor = (name) => {\n  nativeTree[name] = (node) => node[NATIVE_PREFIX + name];\n}\n\nconst installNativeMethod = (name, fn) => {\n  if (!nativeMethods[name]) {\n    nativeMethods[name] = fn;\n  }\n}\n\n\nconst defineNativeAccessors = (proto, descriptors) => {\n  patchProperties(proto, descriptors, NATIVE_PREFIX);\n  // make native accessors available to users\n  for (let prop in descriptors) {\n    installNativeAccessor(prop);\n  }\n}\n\nconst copyProperties = (proto, list = []) => {\n  for (let i = 0; i < list.length; i++) {\n    const name = list[i];\n    const descriptor = Object.getOwnPropertyDescriptor(proto, name);\n    if (descriptor) {\n      Object.defineProperty(proto, NATIVE_PREFIX + name, descriptor);\n      // make native methods/accessors available to users\n      if (descriptor.value) {\n        installNativeMethod(name, descriptor.value);\n      } else {\n        installNativeAccessor(name);\n\n      }\n    }\n  }\n}\n\n/** @type {!TreeWalker} */\nconst nodeWalker = document.createTreeWalker(document, NodeFilter.SHOW_ALL,\n  null, false);\n\n/** @type {!TreeWalker} */\nconst elementWalker = document.createTreeWalker(document, NodeFilter.SHOW_ELEMENT,\n  null, false);\n\n/** @type {!Document} */\nconst inertDoc = document.implementation.createHTMLDocument('inert');\n\nconst clearNode = node => {\n  let firstChild;\n  while ((firstChild = node[NATIVE_PREFIX + 'firstChild'])) {\n    node[NATIVE_PREFIX + 'removeChild'](firstChild);\n  }\n}\n\nconst ParentNodeAccessors = [\n  'firstElementChild',\n  'lastElementChild',\n  'children',\n  'childElementCount',\n];\n\nconst ParentNodeMethods = [\n  'querySelector',\n  'querySelectorAll'\n  // 'append', 'prepend'\n];\n\nexport const addNativePrefixedProperties = () => {\n\n  // EventTarget\n  const eventProps = [\n    'dispatchEvent',\n    'addEventListener',\n    'removeEventListener'\n  ];\n  if (window.EventTarget) {\n    copyProperties(window.EventTarget.prototype, eventProps);\n  } else {\n    copyProperties(Node.prototype, eventProps);\n    copyProperties(Window.prototype, eventProps);\n  }\n\n\n  // Node\n  if (hasDescriptors) {\n    copyProperties(Node.prototype, [\n      'parentNode',\n      'firstChild',\n      'lastChild',\n      'previousSibling',\n      'nextSibling',\n      'childNodes',\n      'parentElement',\n      'textContent',\n    ]);\n  } else {\n    defineNativeAccessors(Node.prototype, {\n      parentNode: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.parentNode();\n        }\n      },\n      firstChild: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.firstChild();\n        }\n      },\n      lastChild: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.lastChild();\n        }\n\n      },\n      previousSibling: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.previousSibling();\n        }\n      },\n      nextSibling: {\n        /** @this {Node} */\n        get() {\n          nodeWalker.currentNode = this;\n          return nodeWalker.nextSibling();\n        }\n      },\n      // TODO(sorvell): make this a NodeList or whatever\n      childNodes: {\n        /** @this {Node} */\n        get() {\n          const nodes = [];\n          nodeWalker.currentNode = this;\n          let n = nodeWalker.firstChild();\n          while (n) {\n            nodes.push(n);\n            n = nodeWalker.nextSibling();\n          }\n          return nodes;\n        }\n      },\n      parentElement: {\n        /** @this {Node} */\n        get() {\n          elementWalker.currentNode = this;\n          return elementWalker.parentNode();\n        }\n      },\n      textContent: {\n        /** @this {Node} */\n        get() {\n          /* eslint-disable no-case-declarations */\n          switch (this.nodeType) {\n            case Node.ELEMENT_NODE:\n            case Node.DOCUMENT_FRAGMENT_NODE:\n              // TODO(sorvell): This cannot be a single TreeWalker that's reused\n              // at least for Safari 9, but it's unclear why.\n              const textWalker = document.createTreeWalker(this, NodeFilter.SHOW_TEXT,\n                null, false);\n              let content = '', n;\n              while ( (n = textWalker.nextNode()) ) {\n                // TODO(sorvell): can't use textContent since we patch it on Node.prototype!\n                // However, should probably patch it only on element.\n                content += n.nodeValue;\n              }\n              return content;\n            default:\n              return this.nodeValue;\n          }\n        },\n        // Needed on browsers that do not proper accessors (e.g. old versions of Chrome)\n        /** @this {Node} */\n        set(value) {\n          if (typeof value === 'undefined' || value === null) {\n            value = ''\n          }\n          switch (this.nodeType) {\n            case Node.ELEMENT_NODE:\n            case Node.DOCUMENT_FRAGMENT_NODE:\n              clearNode(this);\n              // Document fragments must have no childnodes if setting a blank string\n              if (value.length > 0 || this.nodeType === Node.ELEMENT_NODE) {\n                // Note: old Chrome versions require 2nd argument here\n                this[NATIVE_PREFIX + 'insertBefore'](document.createTextNode(value), undefined);\n              }\n              break;\n            default:\n              // TODO(sorvell): can't do this if patch nodeValue.\n              this.nodeValue = value;\n              break;\n          }\n        }\n      }\n    });\n  }\n\n  copyProperties(Node.prototype, [\n    'appendChild',\n    'insertBefore',\n    'removeChild',\n    'replaceChild',\n    'cloneNode',\n    'contains'\n  ]);\n\n  const ParentNodeWalkerDescriptors = {\n    firstElementChild: {\n      /** @this {ParentNode} */\n      get() {\n        elementWalker.currentNode = this;\n        return elementWalker.firstChild();\n      }\n    },\n    lastElementChild: {\n      /** @this {ParentNode} */\n      get() {\n        elementWalker.currentNode = this;\n        return elementWalker.lastChild();\n      }\n    },\n    children: {\n      /** @this {ParentNode} */\n      get() {\n        let nodes = [];\n        elementWalker.currentNode = this;\n        let n = elementWalker.firstChild();\n        while (n) {\n          nodes.push(n);\n          n = elementWalker.nextSibling();\n        }\n        return utils.createPolyfilledHTMLCollection(nodes);\n      }\n    },\n    childElementCount: {\n      /** @this {ParentNode} */\n      get() {\n        if (this.children) {\n          return this.children.length;\n        }\n        return 0;\n      }\n    }\n  };\n\n  // Element\n  if (hasDescriptors) {\n    copyProperties(Element.prototype, ParentNodeAccessors);\n\n    copyProperties(Element.prototype, [\n      'previousElementSibling',\n      'nextElementSibling',\n      'innerHTML'\n    ]);\n\n    // NOTE, on IE 11 / Edge 15 children and/or innerHTML are on HTMLElement instead of Element\n    if (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'children')) {\n      copyProperties(HTMLElement.prototype, [\n        'children'\n      ]);\n    }\n    if (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'innerHTML')) {\n      copyProperties(HTMLElement.prototype, [\n        'innerHTML'\n      ]);\n    }\n  } else {\n    defineNativeAccessors(Element.prototype, ParentNodeWalkerDescriptors);\n    defineNativeAccessors(Element.prototype, {\n      previousElementSibling: {\n        /** @this {Element} */\n        get() {\n          elementWalker.currentNode = this;\n          return elementWalker.previousSibling();\n        }\n      },\n      nextElementSibling: {\n        /** @this {Element} */\n        get() {\n          elementWalker.currentNode = this;\n          return elementWalker.nextSibling();\n        }\n      },\n      innerHTML: {\n        /** @this {Element} */\n        get() {\n          return getInnerHTML(this, n => n[NATIVE_PREFIX + 'childNodes']);\n        },\n        // Needed on browsers that do not proper accessors (e.g. old versions of Chrome)\n        /** @this {Element} */\n        set(value) {\n          const content = this.localName === 'template' ?\n          /** @type {HTMLTemplateElement} */(this).content : this;\n          clearNode(content);\n          const containerName = this.localName || 'div';\n          let htmlContainer;\n          if (!this.namespaceURI || this.namespaceURI === inertDoc.namespaceURI) {\n            htmlContainer = inertDoc.createElement(containerName);\n          } else {\n            htmlContainer = inertDoc.createElementNS(this.namespaceURI, containerName);\n          }\n          htmlContainer.innerHTML = value;\n          const newContent = this.localName === 'template' ?\n            /** @type {HTMLTemplateElement} */(htmlContainer).content : htmlContainer;\n          let firstChild;\n          while ((firstChild = newContent[NATIVE_PREFIX + 'firstChild'])) {\n            // Note: old Chrome versions require 2nd argument here\n            content[NATIVE_PREFIX + 'insertBefore'](firstChild, undefined);\n          }\n        }\n      }\n    });\n  }\n\n  copyProperties(Element.prototype, [\n    'setAttribute',\n    'getAttribute',\n    'hasAttribute',\n    'removeAttribute',\n    // on older Safari, these are on Element.\n    'focus',\n    'blur',\n  ]);\n  copyProperties(Element.prototype, ParentNodeMethods);\n\n  // HTMLElement\n  copyProperties(HTMLElement.prototype, [\n    'focus',\n    'blur',\n    // On IE these are on HTMLElement\n    'contains'\n  ]);\n\n  if (hasDescriptors) {\n    copyProperties(HTMLElement.prototype, [\n      'parentElement',\n      'children',\n      'innerHTML'\n    ]);\n  }\n\n  // HTMLTemplateElement\n  if (window.HTMLTemplateElement) {\n    copyProperties(window.HTMLTemplateElement.prototype, ['innerHTML']);\n  }\n\n  // DocumentFragment\n  if (hasDescriptors) {\n    // NOTE, IE 11 does not have on DocumentFragment\n    // firstElementChild\n    // lastElementChild\n    copyProperties(DocumentFragment.prototype, ParentNodeAccessors);\n  } else {\n    defineNativeAccessors(DocumentFragment.prototype, ParentNodeWalkerDescriptors);\n  }\n\n  copyProperties(DocumentFragment.prototype, ParentNodeMethods);\n\n  // Document\n  if (hasDescriptors) {\n    copyProperties(Document.prototype, ParentNodeAccessors);\n    copyProperties(Document.prototype, [\n      'activeElement'\n    ]);\n  } else {\n    defineNativeAccessors(Document.prototype, ParentNodeWalkerDescriptors);\n  }\n\n  copyProperties(Document.prototype, [\n    'importNode',\n    'getElementById'\n  ]);\n  copyProperties(Document.prototype, ParentNodeMethods);\n\n};\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\nimport {ensureShadyDataForNode} from './shady-data.js';\n\nexport const InsideDescriptors = utils.getOwnPropertyDescriptors({\n\n  /** @this {Node} */\n  get childNodes() {\n    return this[utils.SHADY_PREFIX + 'childNodes'];\n  },\n\n  /** @this {Node} */\n  get firstChild() {\n    return this[utils.SHADY_PREFIX + 'firstChild'];\n  },\n\n  /** @this {Node} */\n  get lastChild() {\n    return this[utils.SHADY_PREFIX + 'lastChild'];\n  },\n\n  /** @this {Node} */\n  get textContent() {\n    return this[utils.SHADY_PREFIX + 'textContent'];\n  },\n\n  /** @this {Node} */\n  set textContent(value) {\n    this[utils.SHADY_PREFIX + 'textContent'] = value;\n  },\n\n  /** @this {Node} */\n  get childElementCount() {\n    return this[utils.SHADY_PREFIX + 'childElementCount'];\n  },\n\n  /** @this {Node} */\n  get children() {\n    return this[utils.SHADY_PREFIX + 'children'];\n  },\n\n  /** @this {Node} */\n  get firstElementChild() {\n    return this[utils.SHADY_PREFIX + 'firstElementChild'];\n  },\n\n  /** @this {Node} */\n  get lastElementChild() {\n    return this[utils.SHADY_PREFIX + 'lastElementChild'];\n  },\n\n  /** @this {Node} */\n  get innerHTML() {\n    return this[utils.SHADY_PREFIX + 'innerHTML'];\n  },\n\n  /** @this {Node} */\n  set innerHTML(value) {\n    return this[utils.SHADY_PREFIX + 'innerHTML'] = value;\n  },\n\n  /** @this {Node} */\n  get shadowRoot() {\n    return this[utils.SHADY_PREFIX + 'shadowRoot'];\n  }\n\n});\n\nexport const OutsideDescriptors = utils.getOwnPropertyDescriptors({\n\n  /** @this {Node} */\n  get parentElement() {\n    return this[utils.SHADY_PREFIX + 'parentElement'];\n  },\n\n  /** @this {Node} */\n  get parentNode() {\n    return this[utils.SHADY_PREFIX + 'parentNode'];\n  },\n\n  /** @this {Node} */\n  get nextSibling() {\n    return this[utils.SHADY_PREFIX + 'nextSibling'];\n  },\n\n  /** @this {Node} */\n  get previousSibling() {\n    return this[utils.SHADY_PREFIX + 'previousSibling'];\n  },\n\n  /** @this {Node} */\n  get nextElementSibling() {\n    return this[utils.SHADY_PREFIX + 'nextElementSibling'];\n  },\n\n  /** @this {Node} */\n  get previousElementSibling() {\n    return this[utils.SHADY_PREFIX + 'previousElementSibling'];\n  },\n\n  /** @this {Node} */\n  get className() {\n    return this[utils.SHADY_PREFIX + 'className'];\n  },\n\n  /** @this {Node} */\n  set className(value) {\n    return this[utils.SHADY_PREFIX + 'className'] = value;\n  }\n\n});\n\nfor (let prop in InsideDescriptors) {\n  InsideDescriptors[prop].enumerable = false;\n}\n\nfor (let prop in OutsideDescriptors) {\n  OutsideDescriptors[prop].enumerable = false;\n}\n\nconst noInstancePatching = utils.settings.hasDescriptors || utils.settings.noPatch;\n\n// ensure an element has patched \"outside\" accessors; no-op when not needed\nexport let patchOutsideElementAccessors = noInstancePatching ?\n  function() {} : function(element) {\n    const sd = ensureShadyDataForNode(element);\n    if (!sd.__outsideAccessors) {\n      sd.__outsideAccessors = true;\n      utils.patchProperties(element, OutsideDescriptors);\n    }\n  }\n\n// ensure an element has patched \"inside\" accessors; no-op when not needed\nexport let patchInsideElementAccessors = noInstancePatching ?\n  function() {} : function(element) {\n    const sd = ensureShadyDataForNode(element);\n    if (!sd.__insideAccessors) {\n      sd.__insideAccessors = true;\n      utils.patchProperties(element, InsideDescriptors);\n    }\n  }","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\nimport {shadyDataForNode} from './shady-data.js';\n\n/*\nMake this name unique so it is unlikely to conflict with properties on objects passed to `addEventListener`\nhttps://github.com/webcomponents/shadydom/issues/173\n*/\nconst /** string */ eventWrappersName = `__eventWrappers${Date.now()}`;\n\n/** @type {?function(!Event): boolean} */\nconst composedGetter = (() => {\n  const composedProp = Object.getOwnPropertyDescriptor(Event.prototype, 'composed');\n  return composedProp ? (ev) => composedProp.get.call(ev) : null;\n})();\n\n// https://github.com/w3c/webcomponents/issues/513#issuecomment-224183937\nconst alwaysComposed = {\n  'blur': true,\n  'focus': true,\n  'focusin': true,\n  'focusout': true,\n  'click': true,\n  'dblclick': true,\n  'mousedown': true,\n  'mouseenter': true,\n  'mouseleave': true,\n  'mousemove': true,\n  'mouseout': true,\n  'mouseover': true,\n  'mouseup': true,\n  'wheel': true,\n  'beforeinput': true,\n  'input': true,\n  'keydown': true,\n  'keyup': true,\n  'compositionstart': true,\n  'compositionupdate': true,\n  'compositionend': true,\n  'touchstart': true,\n  'touchend': true,\n  'touchmove': true,\n  'touchcancel': true,\n  'pointerover': true,\n  'pointerenter': true,\n  'pointerdown': true,\n  'pointermove': true,\n  'pointerup': true,\n  'pointercancel': true,\n  'pointerout': true,\n  'pointerleave': true,\n  'gotpointercapture': true,\n  'lostpointercapture': true,\n  'dragstart': true,\n  'drag': true,\n  'dragenter': true,\n  'dragleave': true,\n  'dragover': true,\n  'drop': true,\n  'dragend': true,\n  'DOMActivate': true,\n  'DOMFocusIn': true,\n  'DOMFocusOut': true,\n  'keypress': true\n};\n\nconst unpatchedEvents = {\n  'DOMAttrModified': true,\n  'DOMAttributeNameChanged': true,\n  'DOMCharacterDataModified': true,\n  'DOMElementNameChanged': true,\n  'DOMNodeInserted': true,\n  'DOMNodeInsertedIntoDocument': true,\n  'DOMNodeRemoved': true,\n  'DOMNodeRemovedFromDocument': true,\n  'DOMSubtreeModified': true\n}\n\n/**\n * Some EventTarget subclasses are not Node subclasses, and you cannot call\n * `getRootNode()` on them.\n *\n * @param {!(Node|EventTarget)} eventTarget\n * @return {!(Node|EventTarget)}\n */\nfunction getRootNodeWithFallback(eventTarget) {\n  if (eventTarget instanceof Node) {\n    return eventTarget[utils.SHADY_PREFIX + 'getRootNode']();\n  } else {\n    return eventTarget;\n  }\n}\n\nfunction pathComposer(startNode, composed) {\n  let composedPath = [];\n  let current = startNode;\n  let startRoot = getRootNodeWithFallback(startNode);\n  while (current) {\n    composedPath.push(current);\n    if (current[utils.SHADY_PREFIX + 'assignedSlot']) {\n      current = current[utils.SHADY_PREFIX + 'assignedSlot'];\n    } else if (current.nodeType === Node.DOCUMENT_FRAGMENT_NODE && current.host && (composed || current !== startRoot)) {\n      current = current.host;\n    } else {\n      current = current[utils.SHADY_PREFIX + 'parentNode'];\n    }\n  }\n  // event composedPath includes window when startNode's ownerRoot is document\n  if (composedPath[composedPath.length - 1] === document) {\n    composedPath.push(window);\n  }\n  return composedPath;\n}\n\nexport const composedPath = (event) => {\n  if (!event.__composedPath) {\n    event.__composedPath = pathComposer(event.target, true);\n  }\n  return event.__composedPath;\n}\n\nfunction retarget(refNode, path) {\n  if (!utils.isShadyRoot) {\n    return refNode;\n  }\n  // If ANCESTOR's root is not a shadow root or ANCESTOR's root is BASE's\n  // shadow-including inclusive ancestor, return ANCESTOR.\n  let refNodePath = pathComposer(refNode, true);\n  let p$ = path;\n  for (let i=0, ancestor, lastRoot, root, rootIdx; i < p$.length; i++) {\n    ancestor = p$[i];\n    root = getRootNodeWithFallback(ancestor);\n    if (root !== lastRoot) {\n      rootIdx = refNodePath.indexOf(root);\n      lastRoot = root;\n    }\n    if (!utils.isShadyRoot(root) || rootIdx > -1) {\n      return ancestor;\n    }\n  }\n}\n\nlet EventPatches = {\n\n  /**\n   * @this {Event}\n   */\n  get composed() {\n    if (this.__composed === undefined) {\n      // if there's an original `composed` getter on the Event prototype, use that\n      if (composedGetter) {\n        // TODO(web-padawan): see https://github.com/webcomponents/shadydom/issues/275\n        this.__composed = this.type === 'focusin' || this.type === 'focusout' || composedGetter(this);\n      // If the event is trusted, or `isTrusted` is not supported, check the list of always composed events\n      } else if (this.isTrusted !== false) {\n        this.__composed = alwaysComposed[this.type];\n      }\n    }\n    return /** @type {!Event} */(this).__composed || false;\n  },\n\n  /**\n   * @this {Event}\n   */\n  composedPath() {\n    if (!this.__composedPath) {\n      this.__composedPath = pathComposer(this['__target'], this.composed);\n    }\n    return /** @type {!Event} */(this).__composedPath;\n  },\n\n  /**\n   * @this {Event}\n   */\n  get target() {\n    return retarget(this.currentTarget || this['__previousCurrentTarget'], this.composedPath());\n  },\n\n  // http://w3c.github.io/webcomponents/spec/shadow/#event-relatedtarget-retargeting\n  /**\n   * @this {Event}\n   */\n  get relatedTarget() {\n    if (!this.__relatedTarget) {\n      return null;\n    }\n    if (!this.__relatedTargetComposedPath) {\n      this.__relatedTargetComposedPath = pathComposer(this.__relatedTarget, true);\n    }\n    // find the deepest node in relatedTarget composed path that is in the same root with the currentTarget\n    return retarget(this.currentTarget || this['__previousCurrentTarget'], /** @type {!Event} */(this).__relatedTargetComposedPath);\n  },\n  /**\n   * @this {Event}\n   */\n  stopPropagation() {\n    Event.prototype.stopPropagation.call(this);\n    this.__propagationStopped = true;\n  },\n  /**\n   * @this {Event}\n   */\n  stopImmediatePropagation() {\n    Event.prototype.stopImmediatePropagation.call(this);\n    this.__immediatePropagationStopped = true;\n    this.__propagationStopped = true;\n  }\n\n};\n\nfunction mixinComposedFlag(Base) {\n  // NOTE: avoiding use of `class` here so that transpiled output does not\n  // try to do `Base.call` with a dom construtor.\n  let klazz = function(type, options) {\n    let event = new Base(type, options);\n    event.__composed = options && Boolean(options['composed']);\n    return event;\n  }\n  // put constructor properties on subclass\n  klazz.__proto__ = Base;\n  klazz.prototype = Base.prototype;\n  return klazz;\n}\n\nlet nonBubblingEventsToRetarget = {\n  'focus': true,\n  'blur': true\n};\n\n\n/**\n * Check if the event has been retargeted by comparing original `target`, and calculated `target`\n * @param {Event} event\n * @return {boolean} True if the original target and calculated target are the same\n */\nfunction hasRetargeted(event) {\n  return event['__target'] !== event.target || event.__relatedTarget !== event.relatedTarget;\n}\n\n/**\n *\n * @param {Event} event\n * @param {Node} node\n * @param {string} phase\n */\nfunction fireHandlers(event, node, phase) {\n  let hs = node.__handlers && node.__handlers[event.type] &&\n    node.__handlers[event.type][phase];\n  if (hs) {\n    for (let i = 0, fn; (fn = hs[i]); i++) {\n      if (hasRetargeted(event) && event.target === event.relatedTarget) {\n        return;\n      }\n      fn.call(node, event);\n      if (event.__immediatePropagationStopped) {\n        return;\n      }\n    }\n  }\n}\n\nfunction retargetNonBubblingEvent(e) {\n  let path = e.composedPath();\n  let node;\n  // override `currentTarget` to let patched `target` calculate correctly\n  Object.defineProperty(e, 'currentTarget', {\n    get: function() {\n      return node;\n    },\n    configurable: true\n  });\n  for (let i = path.length - 1; i >= 0; i--) {\n    node = path[i];\n    // capture phase fires all capture handlers\n    fireHandlers(e, node, 'capture');\n    if (e.__propagationStopped) {\n      return;\n    }\n  }\n\n  // set the event phase to `AT_TARGET` as in spec\n  Object.defineProperty(e, 'eventPhase', {get() { return Event.AT_TARGET }});\n\n  // the event only needs to be fired when owner roots change when iterating the event path\n  // keep track of the last seen owner root\n  let lastFiredRoot;\n  for (let i = 0; i < path.length; i++) {\n    node = path[i];\n    const nodeData = shadyDataForNode(node);\n    const root = nodeData && nodeData.root;\n    if (i === 0 || (root && root === lastFiredRoot)) {\n      fireHandlers(e, node, 'bubble');\n      // don't bother with window, it doesn't have `getRootNode` and will be last in the path anyway\n      if (node !== window) {\n        lastFiredRoot = node[utils.SHADY_PREFIX + 'getRootNode']();\n      }\n      if (e.__propagationStopped) {\n        return;\n      }\n    }\n  }\n}\n\nfunction listenerSettingsEqual(savedListener, node, type, capture, once, passive) {\n  let {\n    node: savedNode,\n    type: savedType,\n    capture: savedCapture,\n    once: savedOnce,\n    passive: savedPassive\n  } = savedListener;\n  return node === savedNode &&\n    type === savedType &&\n    capture === savedCapture &&\n    once === savedOnce &&\n    passive === savedPassive;\n}\n\nexport function findListener(wrappers, node, type, capture, once, passive) {\n  for (let i = 0; i < wrappers.length; i++) {\n    if (listenerSettingsEqual(wrappers[i], node, type, capture, once, passive)) {\n      return i;\n    }\n  }\n  return -1;\n}\n\n/**\n * Firefox can throw on accessing eventWrappers inside of `removeEventListener` during a selenium run\n * Try/Catch accessing eventWrappers to work around\n * https://bugzilla.mozilla.org/show_bug.cgi?id=1353074\n */\nfunction getEventWrappers(eventLike) {\n  let wrappers = null;\n  try {\n    wrappers = eventLike[eventWrappersName];\n  } catch (e) {} // eslint-disable-line no-empty\n  return wrappers;\n}\n\n/**\n * @this {EventTarget}\n */\nexport function addEventListener(type, fnOrObj, optionsOrCapture) {\n  if (!fnOrObj) {\n    return;\n  }\n\n  const handlerType = typeof fnOrObj;\n\n  // bail if `fnOrObj` is not a function, not an object\n  if (handlerType !== 'function' && handlerType !== 'object') {\n    return;\n  }\n\n  // bail if `fnOrObj` is an object without a `handleEvent` method\n  if (handlerType === 'object' && (!fnOrObj.handleEvent || typeof fnOrObj.handleEvent !== 'function')) {\n    return;\n  }\n\n  if (unpatchedEvents[type]) {\n    return this[utils.NATIVE_PREFIX + 'addEventListener'](type, fnOrObj, optionsOrCapture);\n  }\n\n  // The callback `fn` might be used for multiple nodes/events. Since we generate\n  // a wrapper function, we need to keep track of it when we remove the listener.\n  // It's more efficient to store the node/type/options information as Array in\n  // `fn` itself rather than the node (we assume that the same callback is used\n  // for few nodes at most, whereas a node will likely have many event listeners).\n  // NOTE(valdrin) invoking external functions is costly, inline has better perf.\n  let capture, once, passive;\n  if (optionsOrCapture && typeof optionsOrCapture === 'object') {\n    capture = Boolean(optionsOrCapture.capture);\n    once = Boolean(optionsOrCapture.once);\n    passive = Boolean(optionsOrCapture.passive);\n  } else {\n    capture = Boolean(optionsOrCapture);\n    once = false;\n    passive = false;\n  }\n  // hack to let ShadyRoots have event listeners\n  // event listener will be on host, but `currentTarget`\n  // will be set to shadyroot for event listener\n  let target = (optionsOrCapture && optionsOrCapture.__shadyTarget) || this;\n\n  let wrappers = fnOrObj[eventWrappersName];\n  if (wrappers) {\n    // Stop if the wrapper function has already been created.\n    if (findListener(wrappers, target, type, capture, once, passive) > -1) {\n      return;\n    }\n  } else {\n    fnOrObj[eventWrappersName] = [];\n  }\n\n  /**\n   * @this {HTMLElement}\n   * @param {Event} e\n   */\n  const wrapperFn = function(e) {\n    // Support `once` option.\n    if (once) {\n      this[utils.SHADY_PREFIX + 'removeEventListener'](type, fnOrObj, optionsOrCapture);\n    }\n    if (!e['__target']) {\n      patchEvent(e);\n    }\n    let lastCurrentTargetDesc;\n    if (target !== this) {\n      // replace `currentTarget` to make `target` and `relatedTarget` correct for inside the shadowroot\n      lastCurrentTargetDesc = Object.getOwnPropertyDescriptor(e, 'currentTarget');\n      Object.defineProperty(e, 'currentTarget', {get() { return target }, configurable: true});\n    }\n    e['__previousCurrentTarget'] = e['currentTarget'];\n    // Always check if a shadowRoot is in the current event path.\n    // If it is not, the event was generated on either the host of the shadowRoot\n    // or a children of the host.\n    if (utils.isShadyRoot(target) && e.composedPath().indexOf(target) == -1) {\n      return;\n    }\n    // There are two critera that should stop events from firing on this node\n    // 1. the event is not composed and the current node is not in the same root as the target\n    // 2. when bubbling, if after retargeting, relatedTarget and target point to the same node\n    if (e.composed || e.composedPath().indexOf(target) > -1) {\n      if (hasRetargeted(e) && e.target === e.relatedTarget) {\n        if (e.eventPhase === Event.BUBBLING_PHASE) {\n          e.stopImmediatePropagation();\n        }\n        return;\n      }\n      // prevent non-bubbling events from triggering bubbling handlers on shadowroot, but only if not in capture phase\n      if (e.eventPhase !== Event.CAPTURING_PHASE && !e.bubbles && e.target !== target && !(target instanceof Window)) {\n        return;\n      }\n      let ret = handlerType === 'function' ?\n        fnOrObj.call(target, e) :\n        (fnOrObj.handleEvent && fnOrObj.handleEvent(e));\n      if (target !== this) {\n        // replace the \"correct\" `currentTarget`\n        if (lastCurrentTargetDesc) {\n          Object.defineProperty(e, 'currentTarget', lastCurrentTargetDesc);\n          lastCurrentTargetDesc = null;\n        } else {\n          delete e['currentTarget'];\n        }\n      }\n      return ret;\n    }\n  };\n\n  // Store the wrapper information.\n  fnOrObj[eventWrappersName].push({\n    // note: use target here which is either a shadowRoot\n    // (when the host element is proxy'ing the event) or this element\n    node: target,\n    type: type,\n    capture: capture,\n    once: once,\n    passive: passive,\n    wrapperFn: wrapperFn\n  });\n\n  if (nonBubblingEventsToRetarget[type]) {\n    this.__handlers = this.__handlers || {};\n    this.__handlers[type] = this.__handlers[type] ||\n      {'capture': [], 'bubble': []};\n    this.__handlers[type][capture ? 'capture' : 'bubble'].push(wrapperFn);\n  } else {\n    this[utils.NATIVE_PREFIX + 'addEventListener'](type, wrapperFn, optionsOrCapture);\n  }\n}\n\n/**\n * @this {EventTarget}\n */\nexport function removeEventListener(type, fnOrObj, optionsOrCapture) {\n  if (!fnOrObj) {\n    return;\n  }\n  if (unpatchedEvents[type]) {\n    return this[utils.NATIVE_PREFIX + 'removeEventListener'](type, fnOrObj, optionsOrCapture);\n  }\n  // NOTE(valdrin) invoking external functions is costly, inline has better perf.\n  let capture, once, passive;\n  if (optionsOrCapture && typeof optionsOrCapture === 'object') {\n    capture = Boolean(optionsOrCapture.capture);\n    once = Boolean(optionsOrCapture.once);\n    passive = Boolean(optionsOrCapture.passive);\n  } else {\n    capture = Boolean(optionsOrCapture);\n    once = false;\n    passive = false;\n  }\n  let target = (optionsOrCapture && optionsOrCapture.__shadyTarget) || this;\n  // Search the wrapped function.\n  let wrapperFn = undefined;\n  let wrappers = getEventWrappers(fnOrObj);\n  if (wrappers) {\n    let idx = findListener(wrappers, target, type, capture, once, passive);\n    if (idx > -1) {\n      wrapperFn = wrappers.splice(idx, 1)[0].wrapperFn;\n      // Cleanup.\n      if (!wrappers.length) {\n        fnOrObj[eventWrappersName] = undefined;\n      }\n    }\n  }\n  this[utils.NATIVE_PREFIX + 'removeEventListener'](type, wrapperFn || fnOrObj, optionsOrCapture);\n  if (wrapperFn && nonBubblingEventsToRetarget[type] &&\n      this.__handlers && this.__handlers[type]) {\n    const arr = this.__handlers[type][capture ? 'capture' : 'bubble'];\n    const idx = arr.indexOf(wrapperFn);\n    if (idx > -1) {\n      arr.splice(idx, 1);\n    }\n  }\n}\n\nfunction activateFocusEventOverrides() {\n  for (let ev in nonBubblingEventsToRetarget) {\n    window[utils.NATIVE_PREFIX + 'addEventListener'](ev, function(e) {\n      if (!e['__target']) {\n        patchEvent(e);\n        retargetNonBubblingEvent(e);\n      }\n    }, true);\n  }\n}\n\nconst EventPatchesDescriptors = utils.getOwnPropertyDescriptors(EventPatches);\n\nconst SHADY_PROTO = '__shady_patchedProto';\nconst SHADY_SOURCE_PROTO = '__shady_sourceProto';\n\nfunction patchEvent(event) {\n  event['__target'] = event.target;\n  event.__relatedTarget = event.relatedTarget;\n  // attempt to patch prototype (via cache)\n  if (utils.settings.hasDescriptors) {\n    const proto = Object.getPrototypeOf(event);\n    if (!Object.hasOwnProperty(proto, SHADY_PROTO)) {\n      const patchedProto = Object.create(proto);\n      patchedProto[SHADY_SOURCE_PROTO] = proto;\n      utils.patchProperties(patchedProto, EventPatchesDescriptors);\n      proto[SHADY_PROTO] = patchedProto;\n    }\n    event.__proto__ = proto[SHADY_PROTO];\n  // and fallback to patching instance\n  } else {\n    utils.patchProperties(event, EventPatchesDescriptors);\n  }\n}\n\nlet PatchedEvent = mixinComposedFlag(Event);\nlet PatchedCustomEvent = mixinComposedFlag(CustomEvent);\nlet PatchedMouseEvent = mixinComposedFlag(MouseEvent);\n\n\nexport function patchEvents() {\n  activateFocusEventOverrides();\n  window.Event = PatchedEvent;\n  window.CustomEvent = PatchedCustomEvent;\n  window.MouseEvent = PatchedMouseEvent;\n}\n\nexport function patchClick() {\n  // Fix up `Element.prototype.click()` if `isTrusted` is supported, but `composed` isn't\n  if (!composedGetter && Object.getOwnPropertyDescriptor(Event.prototype, 'isTrusted')) {\n    /** @this {Element} */\n    const composedClickFn = function() {\n      const ev = new MouseEvent('click', {\n        bubbles: true,\n        cancelable: true,\n        composed: true\n      });\n      this[utils.SHADY_PREFIX + 'dispatchEvent'](ev);\n    };\n    if (Element.prototype.click) {\n      Element.prototype.click = composedClickFn;\n    } else if (HTMLElement.prototype.click) {\n      HTMLElement.prototype.click = composedClickFn;\n    }\n  }\n}\n\nexport const eventPropertyNames = Object.getOwnPropertyNames(Document.prototype)\n    .filter(name => name.substring(0,2) === 'on');\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nfunction newSplice(index, removed, addedCount) {\n  return {\n    index: index,\n    removed: removed,\n    addedCount: addedCount\n  };\n}\n\nconst EDIT_LEAVE = 0;\nconst EDIT_UPDATE = 1;\nconst EDIT_ADD = 2;\nconst EDIT_DELETE = 3;\n\n// Note: This function is *based* on the computation of the Levenshtein\n// \"edit\" distance. The one change is that \"updates\" are treated as two\n// edits - not one. With Array splices, an update is really a delete\n// followed by an add. By retaining this, we optimize for \"keeping\" the\n// maximum array items in the original array. For example:\n//\n//   'xxxx123' -> '123yyyy'\n//\n// With 1-edit updates, the shortest path would be just to update all seven\n// characters. With 2-edit updates, we delete 4, leave 3, and add 4. This\n// leaves the substring '123' intact.\nfunction calcEditDistances(current, currentStart, currentEnd,\n                            old, oldStart, oldEnd) {\n  // \"Deletion\" columns\n  let rowCount = oldEnd - oldStart + 1;\n  let columnCount = currentEnd - currentStart + 1;\n  let distances = new Array(rowCount);\n\n  // \"Addition\" rows. Initialize null column.\n  for (let i = 0; i < rowCount; i++) {\n    distances[i] = new Array(columnCount);\n    distances[i][0] = i;\n  }\n\n  // Initialize null row\n  for (let j = 0; j < columnCount; j++)\n    distances[0][j] = j;\n\n  for (let i = 1; i < rowCount; i++) {\n    for (let j = 1; j < columnCount; j++) {\n      if (equals(current[currentStart + j - 1], old[oldStart + i - 1]))\n        distances[i][j] = distances[i - 1][j - 1];\n      else {\n        let north = distances[i - 1][j] + 1;\n        let west = distances[i][j - 1] + 1;\n        distances[i][j] = north < west ? north : west;\n      }\n    }\n  }\n\n  return distances;\n}\n\n// This starts at the final weight, and walks \"backward\" by finding\n// the minimum previous weight recursively until the origin of the weight\n// matrix.\nfunction spliceOperationsFromEditDistances(distances) {\n  let i = distances.length - 1;\n  let j = distances[0].length - 1;\n  let current = distances[i][j];\n  let edits = [];\n  while (i > 0 || j > 0) {\n    if (i == 0) {\n      edits.push(EDIT_ADD);\n      j--;\n      continue;\n    }\n    if (j == 0) {\n      edits.push(EDIT_DELETE);\n      i--;\n      continue;\n    }\n    let northWest = distances[i - 1][j - 1];\n    let west = distances[i - 1][j];\n    let north = distances[i][j - 1];\n\n    let min;\n    if (west < north)\n      min = west < northWest ? west : northWest;\n    else\n      min = north < northWest ? north : northWest;\n\n    if (min == northWest) {\n      if (northWest == current) {\n        edits.push(EDIT_LEAVE);\n      } else {\n        edits.push(EDIT_UPDATE);\n        current = northWest;\n      }\n      i--;\n      j--;\n    } else if (min == west) {\n      edits.push(EDIT_DELETE);\n      i--;\n      current = west;\n    } else {\n      edits.push(EDIT_ADD);\n      j--;\n      current = north;\n    }\n  }\n\n  edits.reverse();\n  return edits;\n}\n\n/**\n * Splice Projection functions:\n *\n * A splice map is a representation of how a previous array of items\n * was transformed into a new array of items. Conceptually it is a list of\n * tuples of\n *\n *   <index, removed, addedCount>\n *\n * which are kept in ascending index order of. The tuple represents that at\n * the |index|, |removed| sequence of items were removed, and counting forward\n * from |index|, |addedCount| items were added.\n */\n\n/**\n * Lacking individual splice mutation information, the minimal set of\n * splices can be synthesized given the previous state and final state of an\n * array. The basic approach is to calculate the edit distance matrix and\n * choose the shortest path through it.\n *\n * Complexity: O(l * p)\n *   l: The length of the current array\n *   p: The length of the old array\n */\nfunction calcSplices(current, currentStart, currentEnd,\n                      old, oldStart, oldEnd) {\n  let prefixCount = 0;\n  let suffixCount = 0;\n  let splice;\n\n  let minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart);\n  if (currentStart == 0 && oldStart == 0)\n    prefixCount = sharedPrefix(current, old, minLength);\n\n  if (currentEnd == current.length && oldEnd == old.length)\n    suffixCount = sharedSuffix(current, old, minLength - prefixCount);\n\n  currentStart += prefixCount;\n  oldStart += prefixCount;\n  currentEnd -= suffixCount;\n  oldEnd -= suffixCount;\n\n  if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0)\n    return [];\n\n  if (currentStart == currentEnd) {\n    splice = newSplice(currentStart, [], 0);\n    while (oldStart < oldEnd)\n      splice.removed.push(old[oldStart++]);\n\n    return [ splice ];\n  } else if (oldStart == oldEnd)\n    return [ newSplice(currentStart, [], currentEnd - currentStart) ];\n\n  let ops = spliceOperationsFromEditDistances(\n      calcEditDistances(current, currentStart, currentEnd,\n                             old, oldStart, oldEnd));\n\n  splice = undefined;\n  let splices = [];\n  let index = currentStart;\n  let oldIndex = oldStart;\n  for (let i = 0; i < ops.length; i++) {\n    switch(ops[i]) {\n      case EDIT_LEAVE:\n        if (splice) {\n          splices.push(splice);\n          splice = undefined;\n        }\n\n        index++;\n        oldIndex++;\n        break;\n      case EDIT_UPDATE:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.addedCount++;\n        index++;\n\n        splice.removed.push(old[oldIndex]);\n        oldIndex++;\n        break;\n      case EDIT_ADD:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.addedCount++;\n        index++;\n        break;\n      case EDIT_DELETE:\n        if (!splice)\n          splice = newSplice(index, [], 0);\n\n        splice.removed.push(old[oldIndex]);\n        oldIndex++;\n        break;\n    }\n  }\n\n  if (splice) {\n    splices.push(splice);\n  }\n  return splices;\n}\n\nfunction sharedPrefix(current, old, searchLength) {\n  for (let i = 0; i < searchLength; i++)\n    if (!equals(current[i], old[i]))\n      return i;\n  return searchLength;\n}\n\nfunction sharedSuffix(current, old, searchLength) {\n  let index1 = current.length;\n  let index2 = old.length;\n  let count = 0;\n  while (count < searchLength && equals(current[--index1], old[--index2]))\n    count++;\n\n  return count;\n}\n\nfunction equals(currentValue, previousValue) {\n  return currentValue === previousValue;\n}\n\nexport function calculateSplices(current, previous) {\n  return calcSplices(current, 0, current.length, previous, 0,\n                          previous.length);\n}\n\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\nimport {shadyDataForNode, ensureShadyDataForNode} from './shady-data.js';\nimport {patchInsideElementAccessors, patchOutsideElementAccessors} from './patch-instances.js';\n\nfunction linkNode(node, container, ref_node) {\n  patchOutsideElementAccessors(node);\n  ref_node = ref_node || null;\n  const nodeData = ensureShadyDataForNode(node);\n  const containerData = ensureShadyDataForNode(container);\n  const ref_nodeData = ref_node ? ensureShadyDataForNode(ref_node) : null;\n  // update ref_node.previousSibling <-> node\n  nodeData.previousSibling = ref_node ? ref_nodeData.previousSibling :\n    container[utils.SHADY_PREFIX + 'lastChild'];\n  let psd = shadyDataForNode(nodeData.previousSibling);\n  if (psd) {\n    psd.nextSibling = node;\n  }\n  // update node <-> ref_node\n  let nsd = shadyDataForNode(nodeData.nextSibling = ref_node);\n  if (nsd) {\n    nsd.previousSibling = node;\n  }\n  // update node <-> container\n  nodeData.parentNode = container;\n  if (ref_node) {\n    if (ref_node === containerData.firstChild) {\n      containerData.firstChild = node;\n    }\n  } else {\n    containerData.lastChild = node;\n    if (!containerData.firstChild) {\n      containerData.firstChild = node;\n    }\n  }\n  // remove caching of childNodes\n  containerData.childNodes = null;\n}\n\nexport const recordInsertBefore = (node, container, ref_node) => {\n  patchInsideElementAccessors(container);\n  const containerData = ensureShadyDataForNode(container);\n  if (containerData.firstChild !== undefined) {\n    containerData.childNodes = null;\n  }\n  // handle document fragments\n  if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n    let c$ = node[utils.SHADY_PREFIX + 'childNodes'];\n    for (let i=0; i < c$.length; i++) {\n      linkNode(c$[i], container, ref_node);\n    }\n    // cleanup logical dom in doc fragment.\n    const nodeData = ensureShadyDataForNode(node);\n    let resetTo = (nodeData.firstChild !== undefined) ? null : undefined;\n    nodeData.firstChild = nodeData.lastChild = resetTo;\n    nodeData.childNodes = resetTo;\n  } else {\n    linkNode(node, container, ref_node);\n  }\n}\n\nexport const recordRemoveChild = (node, container) => {\n  const nodeData = ensureShadyDataForNode(node);\n  const containerData = ensureShadyDataForNode(container);\n  if (node === containerData.firstChild) {\n    containerData.firstChild = nodeData.nextSibling;\n  }\n  if (node === containerData.lastChild) {\n    containerData.lastChild = nodeData.previousSibling;\n  }\n  let p = nodeData.previousSibling;\n  let n = nodeData.nextSibling;\n  if (p) {\n    ensureShadyDataForNode(p).nextSibling = n;\n  }\n  if (n) {\n    ensureShadyDataForNode(n).previousSibling = p;\n  }\n  // When an element is removed, logical data is no longer tracked.\n  // Explicitly set `undefined` here to indicate this. This is disginguished\n  // from `null` which is set if info is null.\n  nodeData.parentNode = nodeData.previousSibling =\n  nodeData.nextSibling = undefined;\n  if (containerData.childNodes !== undefined) {\n    // remove caching of childNodes\n    containerData.childNodes = null;\n  }\n}\n\n/**\n * @param  {!Node} node\n */\nexport const recordChildNodes = (node) => {\n  const nodeData = ensureShadyDataForNode(node);\n  if (nodeData.firstChild === undefined) {\n    // remove caching of childNodes\n    nodeData.childNodes = null;\n    const first = nodeData.firstChild = node[utils.NATIVE_PREFIX + 'firstChild'] || null;\n    nodeData.lastChild = node[utils.NATIVE_PREFIX + 'lastChild'] || null;\n    patchInsideElementAccessors(node);\n    for (let n = first, previous; n; (n = n[utils.NATIVE_PREFIX + 'nextSibling'])) {\n      const sd = ensureShadyDataForNode(n);\n      sd.parentNode = node;\n      sd.nextSibling = n[utils.NATIVE_PREFIX + 'nextSibling'] || null;\n      sd.previousSibling = previous || null;\n      previous = n;\n      patchOutsideElementAccessors(n);\n    }\n  }\n}\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\n\nlet scopingShim = null;\n\nexport function getScopingShim() {\n  if (!scopingShim) {\n    scopingShim = window['ShadyCSS'] && window['ShadyCSS']['ScopingShim'];\n  }\n  return scopingShim || null;\n}\n\n/**\n * @param {!Node} node\n * @param {string} attr\n * @param {string} value\n */\nexport function scopeClassAttribute(node, attr, value) {\n  const scopingShim = getScopingShim();\n  if (scopingShim && attr === 'class') {\n    scopingShim['setElementClass'](node, value);\n    return true;\n  }\n  return false;\n}\n\n/**\n * @param {!Node} node\n * @param {string} newScopeName\n */\nexport function addShadyScoping(node, newScopeName) {\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return;\n  }\n  scopingShim['scopeNode'](node, newScopeName);\n}\n\n/**\n * @param {!Node} node\n * @param {string} currentScopeName\n */\nexport function removeShadyScoping(node, currentScopeName) {\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return;\n  }\n  scopingShim['unscopeNode'](node, currentScopeName);\n}\n\n/**\n * @param {!Node} node\n * @param {string} newScopeName\n * @param {string} oldScopeName\n */\nexport function replaceShadyScoping(node, newScopeName, oldScopeName) {\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return;\n  }\n  if (oldScopeName) {\n    removeShadyScoping(node, oldScopeName);\n  }\n  addShadyScoping(node, newScopeName);\n}\n\n/**\n * @param {!Node} node\n * @param {string} newScopeName\n * @return {boolean}\n */\nexport function currentScopeIsCorrect(node, newScopeName) {\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return true;\n  }\n  if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n    // NOTE: as an optimization, only check that all the top-level children\n    // have the correct scope.\n    let correctScope = true;\n    const childNodes = node[utils.SHADY_PREFIX + 'childNodes'];\n    for (let idx = 0; correctScope && (idx < childNodes.length); idx++) {\n      correctScope = correctScope &&\n        currentScopeIsCorrect(childNodes[idx], newScopeName);\n    }\n    return correctScope;\n  }\n  if (node.nodeType !== Node.ELEMENT_NODE) {\n    return true;\n  }\n  const currentScope = scopingShim['currentScopeForNode'](node);\n  return currentScope === newScopeName;\n}\n\n/**\n * @param {!Node} node\n * @return {string}\n */\nexport function currentScopeForNode(node) {\n  if (node.nodeType !== Node.ELEMENT_NODE) {\n    return '';\n  }\n  const scopingShim = getScopingShim();\n  if (!scopingShim) {\n    return '';\n  }\n  return scopingShim['currentScopeForNode'](node);\n}\n\n/**\n * Walk over a node's tree and apply visitorFn to each element node\n *\n * @param {Node} node\n * @param {function(!Node):void} visitorFn\n */\nexport function treeVisitor(node, visitorFn) {\n  if (!node) {\n    return;\n  }\n  // this check is necessary if `node` is a Document Fragment\n  if (node.nodeType === Node.ELEMENT_NODE) {\n    visitorFn(node);\n  }\n  const childNodes = node[utils.SHADY_PREFIX + 'childNodes'];\n  for (let idx = 0, n; idx < childNodes.length; idx++) {\n    n = childNodes[idx];\n    if (n.nodeType === Node.ELEMENT_NODE) {\n      treeVisitor(n, visitorFn);\n    }\n  }\n}","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {getScopingShim, removeShadyScoping, replaceShadyScoping,\n  treeVisitor, currentScopeForNode, currentScopeIsCorrect } from '../style-scoping.js';\nimport {shadyDataForNode, ensureShadyDataForNode} from '../shady-data.js';\nimport {recordInsertBefore, recordRemoveChild} from '../link-nodes.js';\nimport {ownerShadyRootForNode} from '../attach-shadow.js';\n\nconst doc = window.document;\n\nconst preferPerformance = utils.settings.preferPerformance;\n\nconst nativeIsConnectedAccessors =\n/** @type {ObjectPropertyDescriptor} */(\n  Object.getOwnPropertyDescriptor(Node.prototype, 'isConnected')\n);\n\nconst nativeIsConnected = nativeIsConnectedAccessors && nativeIsConnectedAccessors.get;\n\nexport function clearNode(node) {\n  let firstChild;\n  while ((firstChild = node[utils.SHADY_PREFIX + 'firstChild'])) {\n    node[utils.SHADY_PREFIX + 'removeChild'](firstChild);\n  }\n}\n\nfunction removeOwnerShadyRoot(node) {\n  // optimization: only reset the tree if node is actually in a root\n  if (hasCachedOwnerRoot(node)) {\n    let c$ = node[utils.SHADY_PREFIX + 'childNodes'];\n    for (let i=0, l=c$.length, n; (i<l) && (n=c$[i]); i++) {\n      removeOwnerShadyRoot(n);\n    }\n  }\n  const nodeData = shadyDataForNode(node);\n  if (nodeData) {\n    nodeData.ownerShadyRoot = undefined;\n  }\n}\n\nfunction hasCachedOwnerRoot(node) {\n  const nodeData = shadyDataForNode(node);\n  return Boolean(nodeData && nodeData.ownerShadyRoot !== undefined);\n}\n\n/**\n * Finds the first flattened node that is composed in the node's parent.\n * If the given node is a slot, then the first flattened node is returned\n * if it exists, otherwise advance to the node's nextSibling.\n * @param {Node} node within which to find first composed node\n * @returns {Node} first composed node\n */\nfunction firstComposedNode(node) {\n  let composed = node;\n  if (node && node.localName === 'slot') {\n    const nodeData = shadyDataForNode(node);\n    const flattened = nodeData && nodeData.flattenedNodes;\n    composed = flattened && flattened.length ? flattened[0] :\n      firstComposedNode(node[utils.SHADY_PREFIX + 'nextSibling']);\n  }\n  return composed;\n}\n\n/**\n * @param {Node} node\n * @param {Node=} addedNode\n * @param {Node=} removedNode\n */\nfunction scheduleObserver(node, addedNode, removedNode) {\n  const nodeData = shadyDataForNode(node);\n  const observer = nodeData && nodeData.observer;\n  if (observer) {\n    if (addedNode) {\n      observer.addedNodes.push(addedNode);\n    }\n    if (removedNode) {\n      observer.removedNodes.push(removedNode);\n    }\n    observer.schedule();\n  }\n}\n\nexport const NodePatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Node} */\n  get parentNode() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.parentNode;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'parentNode'];\n  },\n\n  /** @this {Node} */\n  get firstChild() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.firstChild;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'firstChild'];\n  },\n\n  /** @this {Node} */\n  get lastChild() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.lastChild;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'lastChild'];\n  },\n\n  /** @this {Node} */\n  get nextSibling() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.nextSibling;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'nextSibling'];\n  },\n\n  /** @this {Node} */\n  get previousSibling() {\n    const nodeData = shadyDataForNode(this);\n    const l = nodeData && nodeData.previousSibling;\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'previousSibling'];\n  },\n\n  /** @this {Node} */\n  get childNodes() {\n    let childNodes;\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      const nodeData = shadyDataForNode(this);\n      if (!nodeData.childNodes) {\n        nodeData.childNodes = [];\n        for (let n=this[utils.SHADY_PREFIX + 'firstChild']; n; n=n[utils.SHADY_PREFIX + 'nextSibling']) {\n          nodeData.childNodes.push(n);\n        }\n      }\n      childNodes = nodeData.childNodes;\n    } else {\n      childNodes = this[utils.NATIVE_PREFIX + 'childNodes'];\n    }\n    childNodes.item = function(index) {\n      return childNodes[index];\n    }\n    return childNodes;\n  },\n\n  /** @this {Node} */\n  get parentElement() {\n    const nodeData = shadyDataForNode(this);\n    let l = nodeData && nodeData.parentNode;\n    if (l && l.nodeType !== Node.ELEMENT_NODE) {\n      l = null;\n    }\n    return l !== undefined ? l : this[utils.NATIVE_PREFIX + 'parentElement'];\n  },\n\n  /** @this {Node} */\n  get isConnected() {\n    if (nativeIsConnected && nativeIsConnected.call(this)) {\n      return true;\n    }\n    if (this.nodeType == Node.DOCUMENT_FRAGMENT_NODE) {\n      return false;\n    }\n    // Fast path for distributed nodes.\n    const ownerDocument = this.ownerDocument;\n    if (utils.hasDocumentContains) {\n      if (ownerDocument[utils.NATIVE_PREFIX + 'contains'](this)) {\n        return true;\n      }\n    } else if (ownerDocument.documentElement &&\n      ownerDocument.documentElement[utils.NATIVE_PREFIX + 'contains'](this)) {\n      return true;\n    }\n    // Slow path for non-distributed nodes.\n    let node = this;\n    while (node && !(node instanceof Document)) {\n      node = node[utils.SHADY_PREFIX + 'parentNode'] || (utils.isShadyRoot(node) ? /** @type {ShadowRoot} */(node).host : undefined);\n    }\n    return !!(node && node instanceof Document);\n  },\n\n  /** @this {Node} */\n  get textContent() {\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      let tc = [];\n      for (let i = 0, cn = this[utils.SHADY_PREFIX + 'childNodes'], c; (c = cn[i]); i++) {\n        if (c.nodeType !== Node.COMMENT_NODE) {\n          tc.push(c[utils.SHADY_PREFIX + 'textContent']);\n        }\n      }\n      return tc.join('');\n    } else {\n      return this[utils.NATIVE_PREFIX + 'textContent'];\n    }\n  },\n\n  /**\n   * @this {Node}\n   * @param {string} value\n   */\n  set textContent(value) {\n    if (typeof value === 'undefined' || value === null) {\n      value = ''\n    }\n    switch (this.nodeType) {\n      case Node.ELEMENT_NODE:\n      case Node.DOCUMENT_FRAGMENT_NODE:\n        if (!utils.isTrackingLogicalChildNodes(this) && utils.settings.hasDescriptors) {\n          // may be removing a nested slot but fast path if we know we are not.\n          const firstChild = this[utils.SHADY_PREFIX + 'firstChild'];\n          if (firstChild != this[utils.SHADY_PREFIX + 'lastChild'] ||\n            (firstChild && firstChild.nodeType != Node.TEXT_NODE)) {\n            clearNode(this);\n          }\n          this[utils.NATIVE_PREFIX + 'textContent'] = value;\n        } else {\n          clearNode(this);\n          // Document fragments must have no childNodes if setting a blank string\n          if (value.length > 0 || this.nodeType === Node.ELEMENT_NODE) {\n            this[utils.SHADY_PREFIX + 'insertBefore'](document.createTextNode(value))\n          }\n        }\n        break;\n      default:\n        // Note, be wary of patching `nodeValue`.\n        this.nodeValue = value;\n        break;\n    }\n  },\n\n  // Patched `insertBefore`. Note that all mutations that add nodes are routed\n  // here. When a <slot> is added or a node is added to a host with a shadowRoot\n  // with a slot, a standard dom `insert` call is aborted and `_asyncRender`\n  // is called on the relevant shadowRoot. In all other cases, a standard dom\n  // `insert` can be made, but the location and ref_node may need to be changed.\n  /**\n   * @this {Node}\n   * @param {Node} node\n   * @param {Node=} ref_node\n   */\n  insertBefore(node, ref_node) {\n    // optimization: assume native insertBefore is ok if the nodes are not in the document.\n    if (this.ownerDocument !== doc && node.ownerDocument !== doc) {\n      this[utils.NATIVE_PREFIX + 'insertBefore'](node, ref_node);\n      return node;\n    }\n    if (node === this) {\n      throw Error(`Failed to execute 'appendChild' on 'Node': The new child element contains the parent.`);\n    }\n    if (ref_node) {\n      const refData = shadyDataForNode(ref_node);\n      const p = refData && refData.parentNode;\n      if ((p !== undefined && p !== this) ||\n        (p === undefined && ref_node[utils.NATIVE_PREFIX + 'parentNode'] !== this)) {\n        throw Error(`Failed to execute 'insertBefore' on 'Node': The node ` +\n        `before which the new node is to be inserted is not a child of this node.`);\n      }\n    }\n    if (ref_node === node) {\n      return node;\n    }\n    /** @type {!Array<!HTMLSlotElement>} */\n    const slotsAdded = [];\n    const ownerRoot = ownerShadyRootForNode(this);\n    /** @type {string} */\n    const newScopeName = ownerRoot ? ownerRoot.host.localName : currentScopeForNode(this);\n    /** @type {string} */\n    let oldScopeName;\n    // remove from existing location\n    const parentNode = node[utils.SHADY_PREFIX + 'parentNode'];\n    if (parentNode) {\n      oldScopeName = currentScopeForNode(node);\n      parentNode[utils.SHADY_PREFIX + 'removeChild'](node,\n        Boolean(ownerRoot) || !ownerShadyRootForNode(node));\n    }\n    // add to new parent\n    let allowNativeInsert = true;\n    const needsScoping = (!preferPerformance || node['__noInsertionPoint'] === undefined) &&\n        !currentScopeIsCorrect(node, newScopeName);\n    const needsSlotFinding = ownerRoot && !node['__noInsertionPoint'] &&\n        (!preferPerformance || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE);\n    if (needsSlotFinding || needsScoping) {\n      // NOTE: avoid node.removeChild as this *can* trigger another patched\n      // method (e.g. custom elements) and we want only the shady method to run.\n      // The following table describes what style scoping actions should happen as a result of this insertion.\n      // document -> shadowRoot: replace\n      // shadowRoot -> shadowRoot: replace\n      // shadowRoot -> shadowRoot of same type: do nothing\n      // shadowRoot -> document: allow unscoping\n      // document -> document: do nothing\n      // The \"same type of shadowRoot\" and \"document to document cases rely on `currentScopeIsCorrect` returning true\n      if (needsScoping) {\n        // in a document or disconnected tree, replace scoping if necessary\n        oldScopeName = oldScopeName || currentScopeForNode(node);\n      }\n      treeVisitor(node, (node) => {\n        if (needsSlotFinding && node.localName === 'slot') {\n          slotsAdded.push(/** @type {!HTMLSlotElement} */(node));\n        }\n        if (needsScoping) {\n          replaceShadyScoping(node, newScopeName, oldScopeName);\n        }\n      });\n    }\n    // if a slot is added, must render containing root.\n    if (this.localName === 'slot' || slotsAdded.length) {\n      if (slotsAdded.length) {\n        ownerRoot._addSlots(slotsAdded);\n      }\n      if (ownerRoot) {\n        ownerRoot._asyncRender();\n      }\n    }\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      recordInsertBefore(node, this, ref_node);\n      // when inserting into a host with a shadowRoot with slot, use\n      // `shadowRoot._asyncRender()` via `attach-shadow` module\n      const parentData = shadyDataForNode(this);\n      if (utils.hasShadowRootWithSlot(this)) {\n        parentData.root._asyncRender();\n        allowNativeInsert = false;\n      // when inserting into a host with shadowRoot with NO slot, do nothing\n      // as the node should not be added to composed dome anywhere.\n      } else if (parentData.root) {\n        allowNativeInsert = false;\n      }\n    }\n    if (allowNativeInsert) {\n      // if adding to a shadyRoot, add to host instead\n      let container = utils.isShadyRoot(this) ?\n        /** @type {ShadowRoot} */(this).host : this;\n      // if ref_node, get the ref_node that's actually in composed dom.\n      if (ref_node) {\n        ref_node = firstComposedNode(ref_node);\n        container[utils.NATIVE_PREFIX + 'insertBefore'](node, ref_node);\n      } else {\n        container[utils.NATIVE_PREFIX + 'appendChild'](node);\n      }\n    // Since ownerDocument is not patched, it can be incorrect after this call\n    // if the node is physically appended via distribution. This can result\n    // in the custom elements polyfill not upgrading the node if it's in an inert doc.\n    // We correct this by calling `adoptNode`.\n    } else if (node.ownerDocument !== this.ownerDocument) {\n      this.ownerDocument.adoptNode(node);\n    }\n    scheduleObserver(this, node);\n    return node;\n  },\n\n  /**\n   * @this {Node}\n   * @param {Node} node\n   */\n  appendChild(node) {\n    return this[utils.SHADY_PREFIX + 'insertBefore'](node);\n  },\n\n  /**\n   * Patched `removeChild`. Note that all dom \"removals\" are routed here.\n   * Removes the given `node` from the element's `children`.\n   * This method also performs dom composition.\n   * @this {Node}\n   * @param {Node} node\n   * @param {boolean=} skipUnscoping\n   */\n  removeChild(node, skipUnscoping = false) {\n    if (this.ownerDocument !== doc) {\n      return this[utils.NATIVE_PREFIX + 'removeChild'](node);\n    }\n    if (node[utils.SHADY_PREFIX + 'parentNode'] !== this) {\n      throw Error('The node to be removed is not a child of this node: ' +\n        node);\n    }\n    let preventNativeRemove;\n    let ownerRoot = ownerShadyRootForNode(node);\n    const removingInsertionPoint = ownerRoot && ownerRoot._removeContainedSlots(node);\n    const parentData = shadyDataForNode(this);\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      recordRemoveChild(node, this);\n      if (utils.hasShadowRootWithSlot(this)) {\n        parentData.root._asyncRender();\n        preventNativeRemove = true;\n      }\n    }\n    // unscope a node leaving a ShadowRoot if ShadyCSS is present, and this node\n    // is not going to be rescoped in `insertBefore`\n    if (getScopingShim() && !skipUnscoping && ownerRoot) {\n      const oldScopeName = currentScopeForNode(node);\n      treeVisitor(node, (node) => {\n        removeShadyScoping(node, oldScopeName);\n      });\n    }\n    removeOwnerShadyRoot(node);\n    // if removing slot, must render containing root\n    if (ownerRoot) {\n      let changeSlotContent = this && this.localName === 'slot';\n      if (changeSlotContent) {\n        preventNativeRemove = true;\n      }\n      if (removingInsertionPoint || changeSlotContent) {\n        ownerRoot._asyncRender();\n      }\n    }\n    if (!preventNativeRemove) {\n      // if removing from a shadyRoot, remove from host instead\n      let container = utils.isShadyRoot(this) ?\n        /** @type {ShadowRoot} */(this).host :\n        this;\n      // not guaranteed to physically be in container; e.g.\n      // (1) if parent has a shadyRoot, element may or may not at distributed\n      // location (could be undistributed)\n      // (2) if parent is a slot, element may not ben in composed dom\n      if (!(parentData.root || node.localName === 'slot') ||\n        (container === node[utils.NATIVE_PREFIX + 'parentNode'])) {\n        container[utils.NATIVE_PREFIX + 'removeChild'](node);\n      }\n    }\n    scheduleObserver(this, null, node);\n    return node;\n  },\n\n  /**\n   * @this {Node}\n   * @param {Node} node\n   * @param {Node=} ref_node\n   */\n  replaceChild(node, ref_node) {\n    this[utils.SHADY_PREFIX + 'insertBefore'](node, ref_node);\n    this[utils.SHADY_PREFIX + 'removeChild'](ref_node);\n    return node;\n  },\n\n  /**\n   * @this {Node}\n   * @param {boolean=} deep\n   */\n  cloneNode(deep) {\n    if (this.localName == 'template') {\n      return this[utils.NATIVE_PREFIX + 'cloneNode'](deep);\n    } else {\n      const n = this[utils.NATIVE_PREFIX + 'cloneNode'](false);\n      // Attribute nodes historically had childNodes, but they have later\n      // been removed from the spec.\n      // Make sure we do not do a deep clone on them for old browsers (IE11)\n      if (deep && n.nodeType !== Node.ATTRIBUTE_NODE) {\n        let c$ = this[utils.SHADY_PREFIX + 'childNodes'];\n        for (let i=0, nc; i < c$.length; i++) {\n          nc = c$[i][utils.SHADY_PREFIX + 'cloneNode'](true);\n          n[utils.SHADY_PREFIX + 'appendChild'](nc);\n        }\n      }\n      return n;\n    }\n  },\n\n  /**\n   * @this {Node}\n   * @param {Object=} options\n   */\n  // TODO(sorvell): implement `options` e.g. `{ composed: boolean }`\n  getRootNode(options) { // eslint-disable-line no-unused-vars\n    if (!this || !this.nodeType) {\n      return;\n    }\n    const nodeData = ensureShadyDataForNode(this);\n    let root = nodeData.ownerShadyRoot;\n    if (root === undefined) {\n      if (utils.isShadyRoot(this)) {\n        root = this;\n        nodeData.ownerShadyRoot = root;\n      } else {\n        let parent = this[utils.SHADY_PREFIX + 'parentNode'];\n        root = parent ? parent[utils.SHADY_PREFIX + 'getRootNode'](options) : this;\n        // memo-ize result for performance but only memo-ize\n        // result if node is in the document. This avoids a problem where a root\n        // can be cached while an element is inside a fragment.\n        // If this happens and we cache the result, the value can become stale\n        // because for perf we avoid processing the subtree of added fragments.\n        if (document.documentElement[utils.NATIVE_PREFIX + 'contains'](this)) {\n          nodeData.ownerShadyRoot = root;\n        }\n      }\n\n    }\n    return root;\n  },\n\n  /** @this {Node} */\n  contains(node) {\n    return utils.contains(this, node);\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport {calculateSplices} from './array-splice.js';\nimport * as utils from './utils.js';\nimport {enqueue} from './flush.js';\nimport {ensureShadyDataForNode, shadyDataForNode} from './shady-data.js';\nimport {recordChildNodes} from './link-nodes.js';\nimport {patchShadyRoot} from './patch-shadyRoot.js';\n\n// Do not export this object. It must be passed as the first argument to the\n// ShadyRoot constructor in `attachShadow` to prevent the constructor from\n// throwing. This prevents the user from being able to manually construct a\n// ShadyRoot (i.e. `new ShadowRoot()`).\nconst ShadyRootConstructionToken = {};\n\nconst CATCHALL_NAME = '__catchall';\nconst SHADYROOT_NAME = 'ShadyRoot';\n\nconst MODE_CLOSED = 'closed';\n\nlet isRendering = utils.settings['deferConnectionCallbacks'] && document.readyState === 'loading';\nlet rootRendered;\n\nfunction ancestorList(node) {\n  let ancestors = [];\n  do {\n    ancestors.unshift(node);\n  } while ((node = node[utils.SHADY_PREFIX + 'parentNode']));\n  return ancestors;\n}\n\n/**\n * @extends {ShadowRoot}\n */\nclass ShadyRoot {\n\n  constructor(token, host, options) {\n    if (token !== ShadyRootConstructionToken) {\n      throw new TypeError('Illegal constructor');\n    }\n    // NOTE: set a fake local name so this element can be\n    // distinguished from a DocumentFragment when patching.\n    // FF doesn't allow this to be `localName`\n    this._localName = SHADYROOT_NAME;\n    // root <=> host\n    this.host = host;\n    /** @type {!string|undefined} */\n    this.mode = options && options.mode;\n    recordChildNodes(host);\n    const hostData = ensureShadyDataForNode(host);\n    /** @type {!ShadyRoot} */\n    hostData.root = this;\n    hostData.publicRoot = this.mode !== MODE_CLOSED ? this : null;\n    // setup root\n    const rootData = ensureShadyDataForNode(this);\n    rootData.firstChild = rootData.lastChild =\n        rootData.parentNode = rootData.nextSibling =\n        rootData.previousSibling = null;\n    rootData.childNodes = [];\n    // state flags\n    this._renderPending = false;\n    this._hasRendered = false;\n    // marsalled lazily\n    this._slotList = null;\n    /** @type {Object<string, Array<HTMLSlotElement>>} */\n    this._slotMap = null;\n    this._pendingSlots = null;\n    // NOTE: optimization flag, only require an asynchronous render\n    // to record parsed children if flag is not set.\n    if (utils.settings['preferPerformance']) {\n      let n;\n      while ((n = host[utils.NATIVE_PREFIX + 'firstChild'])) {\n        host[utils.NATIVE_PREFIX + 'removeChild'](n);\n      }\n    } else {\n      this._asyncRender();\n    }\n  }\n\n  _asyncRender() {\n    if (!this._renderPending) {\n      this._renderPending = true;\n      enqueue(() => this._render());\n    }\n  }\n\n  // returns the oldest renderPending ancestor root.\n  _getPendingDistributionRoot() {\n    let renderRoot;\n    let root = this;\n    while (root) {\n      if (root._renderPending) {\n        renderRoot = root;\n      }\n      root = root._getDistributionParent();\n    }\n    return renderRoot;\n  }\n\n  // Returns the shadyRoot `this.host` if `this.host`\n  // has children that require distribution.\n  _getDistributionParent() {\n    let root = this.host[utils.SHADY_PREFIX + 'getRootNode']();\n    if (!utils.isShadyRoot(root)) {\n      return;\n    }\n    const nodeData = shadyDataForNode(this.host);\n    if (nodeData && nodeData.__childSlotCount > 0) {\n      return root;\n    }\n  }\n\n  // Renders the top most render pending shadowRoot in the distribution tree.\n  // This is safe because when a distribution parent renders, all children render.\n  _render() {\n    // If this root is not pending, it needs no rendering work. Any pending\n    // parent that needs to render wll cause this root to render.\n    const root = this._renderPending && this._getPendingDistributionRoot();\n    if (root) {\n      root._renderSelf();\n    }\n  }\n\n  _flushInitial() {\n    if (!this._hasRendered && this._renderPending) {\n      this._render();\n    }\n  }\n\n  /** @override */\n  _renderSelf() {\n    // track rendering state.\n    const wasRendering = isRendering;\n    isRendering = true;\n    this._renderPending = false;\n    if (this._slotList) {\n      this._distribute();\n      this._compose();\n    }\n    // NOTE: optimization flag, only process parsed children\n    // if optimization flag is not set.\n    // on initial render remove any undistributed children.\n    if (!utils.settings['preferPerformance'] && !this._hasRendered) {\n      const c$ = this.host[utils.SHADY_PREFIX + 'childNodes'];\n      for (let i=0, l=c$.length; i < l; i++) {\n        const child = c$[i];\n        const data = shadyDataForNode(child);\n        if (child[utils.NATIVE_PREFIX + 'parentNode'] === this.host &&\n            (child.localName === 'slot' || !data.assignedSlot)) {\n          this.host[utils.NATIVE_PREFIX + 'removeChild'](child);\n        }\n      }\n    }\n    this._hasRendered = true;\n    isRendering = wasRendering;\n    if (rootRendered) {\n      rootRendered();\n    }\n  }\n\n  _distribute() {\n    this._validateSlots();\n    // capture # of previously assigned nodes to help determine if dirty.\n    for (let i=0, slot; i < this._slotList.length; i++) {\n      slot = this._slotList[i];\n      this._clearSlotAssignedNodes(slot);\n    }\n    // distribute host children.\n    for (let n=this.host[utils.SHADY_PREFIX + 'firstChild']; n; n=n[utils.SHADY_PREFIX + 'nextSibling']) {\n      this._distributeNodeToSlot(n);\n    }\n    // fallback content, slotchange, and dirty roots\n    for (let i=0; i < this._slotList.length; i++) {\n      const slot = this._slotList[i];\n      const slotData = shadyDataForNode(slot);\n      // distribute fallback content\n      if (!slotData.assignedNodes.length) {\n        for (let n=slot[utils.SHADY_PREFIX + 'firstChild']; n; n=n[utils.SHADY_PREFIX + 'nextSibling']) {\n          this._distributeNodeToSlot(n, slot);\n        }\n      }\n      const slotParentData = shadyDataForNode(slot[utils.SHADY_PREFIX + 'parentNode']);\n      const slotParentRoot = slotParentData && slotParentData.root;\n      if (slotParentRoot && (slotParentRoot._hasInsertionPoint() || slotParentRoot._renderPending)) {\n        slotParentRoot._renderSelf();\n      }\n      this._addAssignedToFlattenedNodes(slotData.flattenedNodes,\n        slotData.assignedNodes);\n      let prevAssignedNodes = slotData._previouslyAssignedNodes;\n      if (prevAssignedNodes) {\n        for (let i=0; i < prevAssignedNodes.length; i++) {\n          shadyDataForNode(prevAssignedNodes[i])._prevAssignedSlot = null;\n        }\n        slotData._previouslyAssignedNodes = null;\n        // dirty if previously less assigned nodes than previously assigned.\n        if (prevAssignedNodes.length > slotData.assignedNodes.length) {\n          slotData.dirty = true;\n        }\n      }\n      /* Note: A slot is marked dirty whenever a node is newly assigned to it\n      or a node is assigned to a different slot (done in `_distributeNodeToSlot`)\n      or if the number of nodes assigned to the slot has decreased (done above);\n      */\n      if (slotData.dirty) {\n        slotData.dirty = false;\n        this._fireSlotChange(slot);\n      }\n    }\n  }\n\n  /**\n   * Distributes given `node` to the appropriate slot based on its `slot`\n   * attribute. If `forcedSlot` is given, then the node is distributed to the\n   * `forcedSlot`.\n   * Note: slot to which the node is assigned will be marked dirty for firing\n   * `slotchange`.\n   * @param {Node} node\n   * @param {Node=} forcedSlot\n   *\n   */\n  _distributeNodeToSlot(node, forcedSlot) {\n    const nodeData = ensureShadyDataForNode(node);\n    let oldSlot = nodeData._prevAssignedSlot;\n    nodeData._prevAssignedSlot = null;\n    let slot = forcedSlot;\n    if (!slot) {\n      let name = node[utils.SHADY_PREFIX + 'slot'] || CATCHALL_NAME;\n      const list = this._slotMap[name];\n      slot = list && list[0];\n    }\n    if (slot) {\n      const slotData = ensureShadyDataForNode(slot);\n      slotData.assignedNodes.push(node);\n      nodeData.assignedSlot = slot;\n    } else {\n      nodeData.assignedSlot = undefined;\n    }\n    if (oldSlot !== nodeData.assignedSlot) {\n      if (nodeData.assignedSlot) {\n        ensureShadyDataForNode(nodeData.assignedSlot).dirty = true;\n      }\n    }\n  }\n\n  /**\n   * Clears the assignedNodes tracking data for a given `slot`. Note, the current\n   * assigned node data is tracked (via _previouslyAssignedNodes and\n   * _prevAssignedSlot) to see if `slotchange` should fire. This data may be out\n   *  of date at this time because the assigned nodes may have already been\n   * distributed to another root. This is ok since this data is only used to\n   * track changes.\n   * @param {HTMLSlotElement} slot\n   */\n  _clearSlotAssignedNodes(slot) {\n    const slotData = shadyDataForNode(slot);\n    let n$ = slotData.assignedNodes;\n    slotData.assignedNodes = [];\n    slotData.flattenedNodes = [];\n    slotData._previouslyAssignedNodes = n$;\n    if (n$) {\n      for (let i=0; i < n$.length; i++) {\n        let n = shadyDataForNode(n$[i]);\n        n._prevAssignedSlot = n.assignedSlot;\n        // only clear if it was previously set to this slot;\n        // this helps ensure that if the node has otherwise been distributed\n        // ignore it.\n        if (n.assignedSlot === slot) {\n          n.assignedSlot = null;\n        }\n      }\n    }\n  }\n\n  _addAssignedToFlattenedNodes(flattened, assigned) {\n    for (let i=0, n; (i<assigned.length) && (n=assigned[i]); i++) {\n      if (n.localName == 'slot') {\n        const nestedAssigned = shadyDataForNode(n).assignedNodes;\n        if (nestedAssigned && nestedAssigned.length) {\n          this._addAssignedToFlattenedNodes(flattened, nestedAssigned);\n        }\n      } else {\n        flattened.push(assigned[i]);\n      }\n    }\n  }\n\n  _fireSlotChange(slot) {\n    // NOTE: cannot bubble correctly here so not setting bubbles: true\n    // Safari tech preview does not bubble but chrome does\n    // Spec says it bubbles (https://dom.spec.whatwg.org/#mutation-observers)\n    slot[utils.NATIVE_PREFIX + 'dispatchEvent'](new Event('slotchange'));\n    const slotData = shadyDataForNode(slot);\n    if (slotData.assignedSlot) {\n      this._fireSlotChange(slotData.assignedSlot);\n    }\n  }\n\n  // Reify dom such that it is at its correct rendering position\n  // based on logical distribution.\n  // NOTE: here we only compose parents of <slot> elements and not the\n  // shadowRoot into the host. The latter is performend via a fast path\n  // in the `logical-mutation`.insertBefore.\n  _compose() {\n    const slots = this._slotList;\n    let composeList = [];\n    for (let i=0; i < slots.length; i++) {\n      const parent = slots[i][utils.SHADY_PREFIX + 'parentNode'];\n      /* compose node only if:\n        (1) parent does not have a shadowRoot since shadowRoot has already\n        composed into the host\n        (2) we're not already composing it\n        [consider (n^2) but rare better than Set]\n      */\n      const parentData = shadyDataForNode(parent);\n      if (!(parentData && parentData.root) &&\n        composeList.indexOf(parent) < 0) {\n        composeList.push(parent);\n      }\n    }\n    for (let i=0; i < composeList.length; i++) {\n      const node = composeList[i];\n      const targetNode = node === this ? this.host : node;\n      this._updateChildNodes(targetNode, this._composeNode(node));\n    }\n  }\n\n  // Returns the list of nodes which should be rendered inside `node`.\n  _composeNode(node) {\n    let children = [];\n    let c$ = node[utils.SHADY_PREFIX + 'childNodes'];\n    for (let i = 0; i < c$.length; i++) {\n      let child = c$[i];\n      // Note: if we see a slot here, the nodes are guaranteed to need to be\n      // composed here. This is because if there is redistribution, it has\n      // already been handled by this point.\n      if (this._isInsertionPoint(child)) {\n        let flattenedNodes = shadyDataForNode(child).flattenedNodes;\n        for (let j = 0; j < flattenedNodes.length; j++) {\n          let distributedNode = flattenedNodes[j];\n            children.push(distributedNode);\n        }\n      } else {\n        children.push(child);\n      }\n    }\n    return children;\n  }\n\n  _isInsertionPoint(node) {\n      return node.localName == 'slot';\n    }\n\n  // Ensures that the rendered node list inside `container` is `children`.\n  _updateChildNodes(container, children) {\n    let composed = Array.prototype.slice.call(container[utils.NATIVE_PREFIX + 'childNodes']);\n    let splices = calculateSplices(children, composed);\n    // process removals\n    for (let i=0, d=0, s; (i<splices.length) && (s=splices[i]); i++) {\n      for (let j=0, n; (j < s.removed.length) && (n=s.removed[j]); j++) {\n        // check if the node is still where we expect it is before trying\n        // to remove it; this can happen if we move a node and\n        // then schedule its previous host for distribution resulting in\n        // the node being removed here.\n        if (n[utils.NATIVE_PREFIX + 'parentNode'] === container) {\n          container[utils.NATIVE_PREFIX + 'removeChild'](n);\n        }\n        // TODO(sorvell): avoid the need for splicing here.\n        composed.splice(s.index + d, 1);\n      }\n      d -= s.addedCount;\n    }\n    // process adds\n    for (let i=0, s, next; (i<splices.length) && (s=splices[i]); i++) { //eslint-disable-line no-redeclare\n      next = composed[s.index];\n      for (let j=s.index, n; j < s.index + s.addedCount; j++) {\n        n = children[j];\n        container[utils.NATIVE_PREFIX + 'insertBefore'](n, next);\n        composed.splice(j, 0, n);\n      }\n    }\n  }\n\n  _ensureSlotData() {\n    this._pendingSlots = this._pendingSlots || [];\n    this._slotList = this._slotList || [];\n    this._slotMap = this._slotMap || {};\n  }\n\n  _addSlots(slots) {\n    this._ensureSlotData();\n    this._pendingSlots.push(...slots);\n  }\n\n  _validateSlots() {\n    if (this._pendingSlots && this._pendingSlots.length) {\n      this._mapSlots(this._pendingSlots);\n      this._pendingSlots = [];\n    }\n  }\n\n  /**\n   * Adds the given slots. Slots are maintained in an dom-ordered list.\n   * In addition a map of name to slot is updated.\n   */\n  _mapSlots(slots) {\n    let slotNamesToSort;\n    for (let i=0; i < slots.length; i++) {\n      const slot = slots[i];\n      // ensure insertionPoints's and their parents have logical dom info.\n      // save logical tree info\n      // a. for shadyRoot\n      // b. for insertion points (fallback)\n      // c. for parents of insertion points\n      recordChildNodes(slot);\n      const slotParent = slot[utils.SHADY_PREFIX + 'parentNode'];\n      recordChildNodes(slotParent);\n      const slotParentData = shadyDataForNode(slotParent);\n      slotParentData.__childSlotCount = (slotParentData.__childSlotCount || 0) + 1;\n      let name = this._nameForSlot(slot);\n      if (this._slotMap[name]) {\n        slotNamesToSort = slotNamesToSort || {};\n        slotNamesToSort[name] = true;\n        this._slotMap[name].push(slot);\n      } else {\n        this._slotMap[name] = [slot];\n      }\n      this._slotList.push(slot);\n    }\n    if (slotNamesToSort) {\n      for (let n in slotNamesToSort) {\n        this._slotMap[n] = this._sortSlots(this._slotMap[n]);\n      }\n    }\n  }\n\n  _nameForSlot(slot) {\n    const name = slot['name'] || slot.getAttribute('name') || CATCHALL_NAME;\n    slot.__slotName = name;\n    return name;\n  }\n\n  /**\n   * Slots are kept in an ordered list. Slots with the same name\n   * are sorted here by tree order.\n   */\n  _sortSlots(slots) {\n    // NOTE: Cannot use `compareDocumentPosition` because it's not polyfilled,\n    // but the code here could be used to polyfill the preceeding/following info\n    // in `compareDocumentPosition`.\n    return slots.sort((a, b) => {\n      let listA = ancestorList(a);\n      let listB = ancestorList(b);\n      for (var i=0; i < listA.length; i++) {\n        let nA = listA[i];\n        let nB = listB[i];\n        if (nA !== nB) {\n          let c$ = Array.from(nA[utils.SHADY_PREFIX + 'parentNode'][utils.SHADY_PREFIX + 'childNodes']);\n          return c$.indexOf(nA) - c$.indexOf(nB);\n        }\n      }\n    });\n  }\n\n  /**\n   * Removes from tracked slot data any slots contained within `container` and\n   * then updates the tracked data (_slotList and _slotMap).\n   * Any removed slots also have their `assignedNodes` removed from comopsed dom.\n   */\n  _removeContainedSlots(container) {\n    if (!this._slotList) {\n      return;\n    }\n    this._validateSlots();\n    let didRemove;\n    const map = this._slotMap;\n    for (let n in map) {\n      const slots = map[n];\n      for (let i=0; i < slots.length; i++) {\n        const slot = slots[i];\n        if (utils.contains(container, slot)) {\n          slots.splice(i, 1);\n          const x = this._slotList.indexOf(slot);\n          if (x >= 0) {\n            this._slotList.splice(x, 1);\n            const slotParentData = shadyDataForNode(slot[utils.SHADY_PREFIX + 'parentNode']);\n            if (slotParentData && slotParentData.__childSlotCount) {\n              slotParentData.__childSlotCount--;\n            }\n          }\n          i--;\n          this._removeFlattenedNodes(slot);\n          didRemove = true;\n        }\n      }\n    }\n    return didRemove;\n  }\n\n  _updateSlotName(slot) {\n    if (!this._slotList) {\n      return;\n    }\n    // make sure slotMap is initialized with this slot\n    this._validateSlots();\n    const oldName = slot.__slotName;\n    const name = this._nameForSlot(slot);\n    if (name === oldName) {\n      return;\n    }\n    // remove from existing tracking\n    let slots = this._slotMap[oldName];\n    const i = slots.indexOf(slot);\n    if (i >= 0) {\n      slots.splice(i, 1);\n    }\n    // add to new location and sort if nedessary\n    let list = this._slotMap[name] || (this._slotMap[name] = []);\n    list.push(slot);\n    if (list.length > 1) {\n      this._slotMap[name] = this._sortSlots(list);\n    }\n  }\n\n  _removeFlattenedNodes(slot) {\n    const data = shadyDataForNode(slot);\n    let n$ = data.flattenedNodes;\n    if (n$) {\n      for (let i=0; i<n$.length; i++) {\n        let node = n$[i];\n        let parent = node[utils.NATIVE_PREFIX + 'parentNode'];\n        if (parent) {\n          parent[utils.NATIVE_PREFIX + 'removeChild'](node);\n        }\n      }\n    }\n    data.flattenedNodes = [];\n    data.assignedNodes = [];\n  }\n\n  _hasInsertionPoint() {\n    this._validateSlots();\n    return Boolean(this._slotList && this._slotList.length);\n  }\n}\n\npatchShadyRoot(ShadyRoot.prototype);\nexport {ShadyRoot};\n\n/**\n  Implements a pared down version of ShadowDOM's scoping, which is easy to\n  polyfill across browsers.\n*/\nexport const attachShadow = (host, options) => {\n  if (!host) {\n    throw new Error('Must provide a host.');\n  }\n  if (!options) {\n    throw new Error('Not enough arguments.');\n  }\n  return new ShadyRoot(ShadyRootConstructionToken, host, options);\n}\n\n// Mitigate connect/disconnect spam by wrapping custom element classes.\nif (window['customElements'] && utils.settings.inUse && !utils.settings['preferPerformance']) {\n\n  // process connect/disconnect after roots have rendered to avoid\n  // issues with reaction stack.\n  let connectMap = new Map();\n  rootRendered = function() {\n    // allow elements to connect\n    // save map state (without needing polyfills on IE11)\n    const r = [];\n    connectMap.forEach((v, k) => {\n      r.push([k, v]);\n    });\n    connectMap.clear();\n    for (let i=0; i < r.length; i++) {\n      const e = r[i][0], value = r[i][1];\n      if (value) {\n        e.__shadydom_connectedCallback();\n      } else {\n        e.__shadydom_disconnectedCallback();\n      }\n    }\n  }\n\n  // Document is in loading state and flag is set (deferConnectionCallbacks)\n  // so process connection stack when `readystatechange` fires.\n  if (isRendering) {\n    document.addEventListener('readystatechange', () => {\n      isRendering = false;\n      rootRendered();\n    }, {once: true});\n  }\n\n  /*\n   * (1) elements can only be connected/disconnected if they are in the expected\n   * state.\n   * (2) never run connect/disconnect during rendering to avoid reaction stack issues.\n   */\n  const ManageConnect = (base, connected, disconnected) => {\n    let counter = 0;\n    const connectFlag = `__isConnected${counter++}`;\n    if (connected || disconnected) {\n\n      /** @this {!HTMLElement} */\n      base.prototype.connectedCallback = base.prototype.__shadydom_connectedCallback = function() {\n        // if rendering defer connected\n        // otherwise connect only if we haven't already\n        if (isRendering) {\n          connectMap.set(this, true);\n        } else if (!this[connectFlag]) {\n          this[connectFlag] = true;\n          if (connected) {\n            connected.call(this);\n          }\n        }\n      }\n\n      /** @this {!HTMLElement} */\n      base.prototype.disconnectedCallback = base.prototype.__shadydom_disconnectedCallback = function() {\n        // if rendering, cancel a pending connection and queue disconnect,\n        // otherwise disconnect only if a connection has been allowed\n        if (isRendering) {\n          // This is necessary only because calling removeChild\n          // on a node that requires distribution leaves it in the DOM tree\n          // until distribution.\n          // NOTE: remember this is checking the patched isConnected to determine\n          // if the node is in the logical tree.\n          if (!this.isConnected) {\n            connectMap.set(this, false);\n          }\n        } else if (this[connectFlag]) {\n          this[connectFlag] = false;\n          if (disconnected) {\n            disconnected.call(this);\n          }\n        }\n      }\n    }\n\n    return base;\n  }\n\n  const define = window['customElements']['define'];\n  // NOTE: Instead of patching customElements.define,\n  // re-define on the CustomElementRegistry.prototype.define\n  // for Safari 10 compatibility (it's flakey otherwise).\n  Object.defineProperty(window['CustomElementRegistry'].prototype, 'define', {\n    value: function(name, constructor) {\n      const connected = constructor.prototype.connectedCallback;\n      const disconnected = constructor.prototype.disconnectedCallback;\n      define.call(window['customElements'], name,\n          ManageConnect(constructor, connected, disconnected));\n      // unpatch connected/disconnected on class; custom elements tears this off\n      // so the patch is maintained, but if the user calls these methods for\n      // e.g. testing, they will be as expected.\n      constructor.prototype.connectedCallback = connected;\n      constructor.prototype.disconnectedCallback = disconnected;\n    }\n  });\n\n}\n\n/** @return {!ShadyRoot|undefined} */\nexport const ownerShadyRootForNode = (node) => {\n  let root = node[utils.SHADY_PREFIX + 'getRootNode']();\n  if (utils.isShadyRoot(root)) {\n    return root;\n  }\n}\n",null,"/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {shadyDataForNode} from '../shady-data.js';\n\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[utils.SHADY_PREFIX + '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[utils.SHADY_PREFIX + 'childNodes'], matcher,\n    halter, list);\n}\n\n// Needed on Element, DocumentFragment, Document\nexport const ParentNodePatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Element} */\n  get firstElementChild() {\n    const nodeData = shadyDataForNode(this);\n    if (nodeData && nodeData.firstChild !== undefined) {\n      let n = this[utils.SHADY_PREFIX + 'firstChild'];\n      while (n && n.nodeType !== Node.ELEMENT_NODE) {\n        n = n[utils.SHADY_PREFIX + 'nextSibling'];\n      }\n      return n;\n    } else {\n      return this[utils.NATIVE_PREFIX + 'firstElementChild'];\n    }\n  },\n\n  /** @this {Element} */\n  get lastElementChild() {\n    const nodeData = shadyDataForNode(this);\n    if (nodeData && nodeData.lastChild !== undefined) {\n      let n = this[utils.SHADY_PREFIX + 'lastChild'];\n      while (n && n.nodeType !== Node.ELEMENT_NODE) {\n        n = n[utils.SHADY_PREFIX + 'previousSibling'];\n      }\n      return n;\n    } else {\n      return this[utils.NATIVE_PREFIX + 'lastElementChild'];\n    }\n  },\n\n  /** @this {Element} */\n  get children() {\n    if (!utils.isTrackingLogicalChildNodes(this)) {\n      return this[utils.NATIVE_PREFIX + 'children'];\n    }\n    return utils.createPolyfilledHTMLCollection(Array.prototype.filter.call(\n        this[utils.SHADY_PREFIX + 'childNodes'], function(n) {\n      return (n.nodeType === Node.ELEMENT_NODE);\n    }));\n  },\n\n  /** @this {Element} */\n  get childElementCount() {\n    let children = this[utils.SHADY_PREFIX + 'children'];\n    if(children) {\n      return children.length;\n    }\n    return 0;\n  }\n\n});\n\nexport const QueryPatches = utils.getOwnPropertyDescriptors({\n  // TODO(sorvell): consider doing native QSA and filtering results.\n  /**\n   * @this {Element}\n   * @param  {string} selector\n   */\n  querySelector(selector) {\n    // match selector and halt on first result.\n    let result = query(this, function(n) {\n      return utils.matchesSelector(n, selector);\n    }, function(n) {\n      return Boolean(n);\n    })[0];\n    return result || null;\n  },\n\n  /**\n   * @this {Element}\n   * @param  {string} selector\n   * @param  {boolean} useNative\n   */\n  // TODO(sorvell): `useNative` option relies on native querySelectorAll and\n  // misses distributed nodes, see\n  // https://github.com/webcomponents/shadydom/pull/210#issuecomment-361435503\n  querySelectorAll(selector, useNative) {\n    if (useNative) {\n      const o = Array.prototype.slice.call(this[utils.NATIVE_PREFIX + 'querySelectorAll'](selector));\n      const root = this[utils.SHADY_PREFIX + 'getRootNode']();\n      return o.filter(e => e[utils.SHADY_PREFIX + 'getRootNode']() == root);\n    }\n    return query(this, function(n) {\n      return utils.matchesSelector(n, selector);\n    });\n  }\n\n});\n\n// Create a custom `ParentNodeDocumentOrFragment` that optionally does not\n// mixin querySelector/All; this is a performance optimization.\nexport const ParentNodeDocumentOrFragmentPatches = utils.settings.preferPerformance ?\n  Object.assign({}, ParentNodePatches) : ParentNodePatches;\n\nObject.assign(ParentNodePatches, QueryPatches);","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport * as utils from '../utils.js';\nimport { query } from './ParentNode.js';\n\nexport const DocumentOrFragmentPatches = utils.getOwnPropertyDescriptors({\n\n  /**\n   * @this {Element}\n   * @param {string} id\n   */\n  getElementById(id) {\n    if (id === '') {\n      return null;\n    }\n    let result = query(this, function(n) {\n      return n.id == id;\n    }, function(n) {\n      return Boolean(n);\n    })[0];\n    return result || null;\n  }\n\n});","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {ownerShadyRootForNode} from '../attach-shadow.js';\n\nfunction getDocumentActiveElement() {\n  if (utils.settings.hasDescriptors) {\n    return document[utils.NATIVE_PREFIX + 'activeElement'];\n  } else {\n    return document.activeElement;\n  }\n}\n\nexport const DocumentOrShadowRootPatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Document|ShadowRoot} */\n  get activeElement() {\n    let active = getDocumentActiveElement();\n    // In IE11, activeElement might be an empty object if the document is\n    // contained in an iframe.\n    // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/10998788/\n    if (!active || !active.nodeType) {\n      return null;\n    }\n    let isShadyRoot = !!(utils.isShadyRoot(this));\n    if (this !== document) {\n      // If this node isn't a document or shady root, then it doesn't have\n      // an active element.\n      if (!isShadyRoot) {\n        return null;\n      }\n      // If this shady root's host is the active element or the active\n      // element is not a descendant of the host (in the composed tree),\n      // then it doesn't have an active element.\n      if (this.host === active ||\n          !this.host[utils.NATIVE_PREFIX + 'contains'](active)) {\n        return null;\n      }\n    }\n    // This node is either the document or a shady root of which the active\n    // element is a (composed) descendant of its host; iterate upwards to\n    // find the active element's most shallow host within it.\n    let activeRoot = ownerShadyRootForNode(active);\n    while (activeRoot && activeRoot !== this) {\n      active = activeRoot.host;\n      activeRoot = ownerShadyRootForNode(active);\n    }\n    if (this === document) {\n      // This node is the document, so activeRoot should be null.\n      return activeRoot ? null : active;\n    } else {\n      // This node is a non-document shady root, and it should be\n      // activeRoot.\n      return activeRoot === this ? active : null;\n    }\n  }\n});\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {getInnerHTML} from '../innerHTML.js';\nimport {clearNode} from './Node.js';\n\n/** @type {!Document} */\nconst inertDoc = document.implementation.createHTMLDocument('inert');\n\nexport const ElementOrShadowRootPatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Element} */\n  get innerHTML() {\n    if (utils.isTrackingLogicalChildNodes(this)) {\n      const content = this.localName === 'template' ?\n      /** @type {HTMLTemplateElement} */(this).content : this;\n      return getInnerHTML(content, (e) => e[utils.SHADY_PREFIX + 'childNodes']);\n    } else {\n      return this[utils.NATIVE_PREFIX + 'innerHTML'];\n    }\n  },\n\n  /**\n   * @this {Element}\n   * @param {string} value\n   */\n  set innerHTML(value) {\n    if (this.localName === 'template') {\n      this[utils.NATIVE_PREFIX + 'innerHTML'] = value;\n    } else {\n      clearNode(this);\n      const containerName = this.localName || 'div';\n      let htmlContainer;\n      if (!this.namespaceURI || this.namespaceURI === inertDoc.namespaceURI) {\n        htmlContainer = inertDoc.createElement(containerName);\n      } else {\n        htmlContainer = inertDoc.createElementNS(this.namespaceURI, containerName);\n      }\n      if (utils.settings.hasDescriptors) {\n        htmlContainer[utils.NATIVE_PREFIX + 'innerHTML'] = value;\n      } else {\n        htmlContainer.innerHTML = value;\n      }\n      let firstChild;\n      while ((firstChild = htmlContainer[utils.SHADY_PREFIX + 'firstChild'])) {\n        this[utils.SHADY_PREFIX + 'insertBefore'](firstChild);\n      }\n    }\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\n\nexport const ShadowRootPatches = utils.getOwnPropertyDescriptors({\n\n  /**\n   * @this {ShadowRoot}\n   * @param {string} type\n   * @param {Function} fn\n   * @param {Object|boolean=} optionsOrCapture\n   */\n  addEventListener(type, fn, optionsOrCapture) {\n    if (typeof optionsOrCapture !== 'object') {\n      optionsOrCapture = {\n        capture: Boolean(optionsOrCapture)\n      }\n    }\n    optionsOrCapture.__shadyTarget = this;\n    this.host[utils.SHADY_PREFIX + 'addEventListener'](type, fn, optionsOrCapture);\n  },\n\n  /**\n   * @this {ShadowRoot}\n   * @param {string} type\n   * @param {Function} fn\n   * @param {Object|boolean=} optionsOrCapture\n   */\n  removeEventListener(type, fn, optionsOrCapture) {\n    if (typeof optionsOrCapture !== 'object') {\n      optionsOrCapture = {\n        capture: Boolean(optionsOrCapture)\n      }\n    }\n    optionsOrCapture.__shadyTarget = this;\n    this.host[utils.SHADY_PREFIX + 'removeEventListener'](type, fn, optionsOrCapture);\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\nimport {NodePatches} from './patches/Node.js';\nimport {OutsideDescriptors, InsideDescriptors} from './patch-instances.js';\nimport {ParentNodePatches} from './patches/ParentNode.js';\nimport {DocumentOrFragmentPatches} from './patches/DocumentOrFragment.js';\nimport {DocumentOrShadowRootPatches} from './patches/DocumentOrShadowRoot.js';\nimport {ElementOrShadowRootPatches} from './patches/ElementOrShadowRoot.js';\nimport {ShadowRootPatches} from './patches/ShadowRoot.js';\n\n/**\n * @param {!Object} proto\n * @param {string=} prefix\n */\nconst patchShadyAccessors = (proto, prefix) => {\n  utils.patchProperties(proto, ShadowRootPatches, prefix);\n  utils.patchProperties(proto, DocumentOrShadowRootPatches, prefix);\n  utils.patchProperties(proto, ElementOrShadowRootPatches, prefix);\n  // We ensure ParentNode accessors since these do not exist in Edge/IE on DocumentFragments.\n  utils.patchProperties(proto, ParentNodePatches, prefix);\n  // Ensure `shadowRoot` has basic descriptors when we cannot rely\n  // on them coming from DocumentFragment.\n  //\n  // Case 1, noPatching: Because we want noPatch ShadyRoots to have native property\n  // names so that they do not have to be wrapped...\n  // When we do *not* patch Node/DocumentFragment.prototype\n  // we must manually install those properties on ShadyRoot's prototype.\n  // Note, it's important to only install these in this mode so as not to stomp\n  // over CustomElements polyfill's patches on Node/DocumentFragment methods.\n  if (utils.settings.noPatch && !prefix) {\n    utils.patchProperties(proto, NodePatches, prefix);\n    utils.patchProperties(proto, DocumentOrFragmentPatches, prefix);\n  // Case 2, bad descriptors: Ensure accessors are on ShadowRoot.\n  // These descriptors are normally used for instance patching but because\n  // ShadyRoot can always be patched, just do it to the prototype.\n  } else if (!utils.settings.hasDescriptors) {\n    utils.patchProperties(proto, OutsideDescriptors);\n    utils.patchProperties(proto, InsideDescriptors);\n  }\n}\n\nexport const patchShadyRoot = (proto) => {\n  proto.__proto__ = DocumentFragment.prototype;\n\n  // patch both prefixed and not, even when noPatch == true.\n  patchShadyAccessors(proto, utils.SHADY_PREFIX);\n  patchShadyAccessors(proto);\n\n  // Ensure native properties are all safely wrapped since ShadowRoot is not an\n  // actual DocumentFragment instance.\n  Object.defineProperties(proto, {\n    nodeType: {\n      value: Node.DOCUMENT_FRAGMENT_NODE,\n      configurable: true\n    },\n    nodeName: {\n      value: '#document-fragment',\n      configurable: true\n    },\n    nodeValue: {\n      value: null,\n      configurable: true\n    }\n  });\n\n  // make undefined\n  [\n    'localName',\n    'namespaceURI',\n    'prefix'\n  ].forEach((prop) => {\n    Object.defineProperty(proto, prop, {\n      value: undefined,\n      configurable: true\n    });\n  });\n\n  // defer properties to host\n  [\n    'ownerDocument',\n    'baseURI',\n    'isConnected'\n  ].forEach((prop) => {\n    Object.defineProperty(proto, prop, {\n      /** @this {ShadowRoot} */\n      get() {\n        return this.host[prop];\n      },\n      configurable: true\n    });\n  });\n}\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\nimport {eventPropertyNames} from './patch-events.js';\n\n/** @implements {IWrapper} */\nclass Wrapper {\n\n  /** @param {!Node} node */\n  constructor(node) {\n    this.node = node;\n  }\n\n  // node\n  addEventListener(name, fn, options) {\n    return this.node[utils.SHADY_PREFIX + 'addEventListener'](name, fn, options);\n  }\n\n  removeEventListener(name, fn, options) {\n    return this.node[utils.SHADY_PREFIX + 'removeEventListener'](name, fn, options);\n  }\n\n  appendChild(node) {\n    return this.node[utils.SHADY_PREFIX + 'appendChild'](node);\n  }\n\n  insertBefore(node, ref_node) {\n    return this.node[utils.SHADY_PREFIX + 'insertBefore'](node, ref_node);\n  }\n\n  removeChild(node) {\n    return this.node[utils.SHADY_PREFIX + 'removeChild'](node);\n  }\n\n  replaceChild(node, ref_node) {\n    return this.node[utils.SHADY_PREFIX + 'replaceChild'](node, ref_node);\n  }\n\n  cloneNode(deep) {\n    return this.node[utils.SHADY_PREFIX + 'cloneNode'](deep);\n  }\n\n  getRootNode(options) {\n    return this.node[utils.SHADY_PREFIX + 'getRootNode'](options);\n  }\n\n  contains(node) {\n    return this.node[utils.SHADY_PREFIX + 'contains'](node);\n  }\n\n  dispatchEvent(event) {\n    return this.node[utils.SHADY_PREFIX + 'dispatchEvent'](event);\n  }\n\n  // element\n  setAttribute(name, value) {\n    this.node[utils.SHADY_PREFIX + 'setAttribute'](name, value);\n  }\n\n  // NOTE: not needed, just here for balance\n  getAttribute(name) {\n    return this.node[utils.NATIVE_PREFIX + 'getAttribute'](name);\n  }\n\n  // NOTE: not needed, just here for balance\n  hasAttribute(name) {\n    return this.node[utils.NATIVE_PREFIX + 'hasAttribute'](name);\n  }\n\n  removeAttribute(name) {\n    this.node[utils.SHADY_PREFIX + 'removeAttribute'](name);\n  }\n\n  attachShadow(options) {\n    return this.node[utils.SHADY_PREFIX + 'attachShadow'](options);\n  }\n\n  /** @return {!Node|undefined} */\n  get activeElement() {\n    if (utils.isShadyRoot(this.node) || this.node.nodeType === Node.DOCUMENT_NODE) {\n      const e = this.node[utils.SHADY_PREFIX + 'activeElement'];\n      return e;\n    }\n  }\n\n  /**\n   * Installed for compatibility with browsers (older Chrome/Safari) that do\n   * not have a configurable `activeElement` accessor. Enables noPatch and\n   * patch mode both to consistently use ShadyDOM.wrap(document)._activeElement.\n   * @override\n   * @return {!Node|undefined}\n   */\n  get _activeElement() {\n    return this.activeElement;\n  }\n\n  // NOTE: not needed, just here for balance\n  /** @override */\n  focus() {\n    this.node[utils.NATIVE_PREFIX + 'focus']();\n  }\n\n  blur() {\n    this.node[utils.SHADY_PREFIX + 'blur']();\n  }\n\n  // document\n  importNode(node, deep) {\n    if (this.node.nodeType === Node.DOCUMENT_NODE) {\n      return this.node[utils.SHADY_PREFIX + 'importNode'](node, deep);\n    }\n  }\n\n  getElementById(id) {\n    if (this.node.nodeType === Node.DOCUMENT_NODE) {\n      return this.node[utils.SHADY_PREFIX + 'getElementById'](id);\n    }\n  }\n\n  // query\n  querySelector(selector) {\n    return this.node[utils.SHADY_PREFIX + 'querySelector'](selector);\n  }\n\n  querySelectorAll(selector, useNative) {\n    return this.node[utils.SHADY_PREFIX + 'querySelectorAll'](selector, useNative);\n  }\n\n  // slot\n  assignedNodes(options) {\n    if (this.node.localName === 'slot') {\n      return this.node[utils.SHADY_PREFIX + 'assignedNodes'](options);\n    }\n  }\n\n  get host() {\n    if (utils.isShadyRoot(this.node)) {\n      return /** @type {!ShadowRoot} */(this.node).host;\n    }\n  }\n\n  get parentNode() {\n    return this.node[utils.SHADY_PREFIX + 'parentNode'];\n  }\n\n  get firstChild() {\n    return this.node[utils.SHADY_PREFIX + 'firstChild'];\n  }\n\n  get lastChild() {\n    return this.node[utils.SHADY_PREFIX + 'lastChild'];\n  }\n\n  get nextSibling() {\n    return this.node[utils.SHADY_PREFIX + 'nextSibling'];\n  }\n\n  get previousSibling() {\n    return this.node[utils.SHADY_PREFIX + 'previousSibling'];\n  }\n\n  get childNodes() {\n    return this.node[utils.SHADY_PREFIX + 'childNodes'];\n  }\n\n  get parentElement() {\n    return this.node[utils.SHADY_PREFIX + 'parentElement'];\n  }\n\n  get firstElementChild() {\n    return this.node[utils.SHADY_PREFIX + 'firstElementChild'];\n  }\n\n  get lastElementChild() {\n    return this.node[utils.SHADY_PREFIX + 'lastElementChild'];\n  }\n\n  get nextElementSibling() {\n    return this.node[utils.SHADY_PREFIX + 'nextElementSibling'];\n  }\n\n  get previousElementSibling() {\n    return this.node[utils.SHADY_PREFIX + 'previousElementSibling'];\n  }\n\n  get children() {\n    return this.node[utils.SHADY_PREFIX + 'children'];\n  }\n\n  get childElementCount() {\n    return this.node[utils.SHADY_PREFIX + 'childElementCount'];\n  }\n\n  get shadowRoot() {\n    return this.node[utils.SHADY_PREFIX + 'shadowRoot'];\n  }\n\n  get assignedSlot() {\n    return this.node[utils.SHADY_PREFIX + 'assignedSlot'];\n  }\n\n  get isConnected() {\n    return this.node[utils.SHADY_PREFIX + 'isConnected'];\n  }\n\n  get innerHTML() {\n    return this.node[utils.SHADY_PREFIX + 'innerHTML'];\n  }\n\n  set innerHTML(value) {\n    this.node[utils.SHADY_PREFIX + 'innerHTML'] = value;\n  }\n\n  get textContent() {\n    return this.node[utils.SHADY_PREFIX + 'textContent'];\n  }\n\n  set textContent(value) {\n    this.node[utils.SHADY_PREFIX + 'textContent'] = value;\n  }\n\n  get slot() {\n    return this.node[utils.SHADY_PREFIX + 'slot'];\n  }\n\n  set slot(value) {\n    this.node[utils.SHADY_PREFIX + 'slot'] = value;\n  }\n\n}\n\neventPropertyNames.forEach(name => {\n  Object.defineProperty(Wrapper.prototype, name, {\n    /** @this {Wrapper} */\n    get() {\n      return this.node[utils.SHADY_PREFIX + name];\n    },\n    /** @this {Wrapper} */\n    set(value) {\n      this.node[utils.SHADY_PREFIX + name] = value;\n    },\n    configurable: true\n  });\n\n});\n\nexport {Wrapper};\n\nconst wrapperMap = new WeakMap();\n\nexport function wrap(obj) {\n  if (utils.isShadyRoot(obj) || obj instanceof Wrapper) {\n    return obj;\n  }\n  let wrapper = wrapperMap.get(obj)\n  if (!wrapper) {\n    wrapper = new Wrapper(obj);\n    wrapperMap.set(obj, wrapper);\n  }\n  return wrapper;\n}\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {flush} from '../flush.js';\nimport {addEventListener, removeEventListener} from '../patch-events.js';\n\nexport const EventTargetPatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Node} */\n  dispatchEvent(event) {\n    flush();\n    return this[utils.NATIVE_PREFIX + 'dispatchEvent'](event);\n  },\n\n  addEventListener,\n\n  removeEventListener\n\n});","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {shadyDataForNode} from '../shady-data.js';\n\nexport const SlotablePatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Node} */\n  get assignedSlot() {\n    // Force any parent's shadowRoot to flush so that distribution occurs\n    // and this node has an assignedSlot.\n    const parent = this[utils.SHADY_PREFIX + 'parentNode'];\n    const ownerRoot = parent && parent[utils.SHADY_PREFIX + 'shadowRoot'];\n    if (ownerRoot) {\n      ownerRoot._render();\n    }\n    const nodeData = shadyDataForNode(this);\n    return nodeData && nodeData.assignedSlot || null;\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {scopeClassAttribute} from '../style-scoping.js';\nimport {shadyDataForNode} from '../shady-data.js';\nimport {attachShadow, ownerShadyRootForNode} from '../attach-shadow.js';\n\nconst doc = window.document;\n\n/**\n * Should be called whenever an attribute changes. If the `slot` attribute\n * changes, provokes rendering if necessary. If a `<slot>` element's `name`\n * attribute changes, updates the root's slot map and renders.\n * @param {Node} node\n * @param {string} name\n */\nfunction distributeAttributeChange(node, name) {\n  if (name === 'slot') {\n    const parent = node[utils.SHADY_PREFIX + 'parentNode'];\n    if (utils.hasShadowRootWithSlot(parent)) {\n      shadyDataForNode(parent).root._asyncRender();\n    }\n  } else if (node.localName === 'slot' && name === 'name') {\n    let root = ownerShadyRootForNode(node);\n    if (root) {\n      root._updateSlotName(node);\n      root._asyncRender();\n    }\n  }\n}\n\nexport const ElementPatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {Element} */\n  get previousElementSibling() {\n    const nodeData = shadyDataForNode(this);\n    if (nodeData && nodeData.previousSibling !== undefined) {\n      let n = this[utils.SHADY_PREFIX + 'previousSibling'];\n      while (n && n.nodeType !== Node.ELEMENT_NODE) {\n        n = n[utils.SHADY_PREFIX + 'previousSibling'];\n      }\n      return n;\n    } else {\n      return this[utils.NATIVE_PREFIX + 'previousElementSibling'];\n    }\n  },\n\n  /** @this {Element} */\n  get nextElementSibling() {\n    const nodeData = shadyDataForNode(this);\n    if (nodeData && nodeData.nextSibling !== undefined) {\n      let n = this[utils.SHADY_PREFIX + 'nextSibling'];\n      while (n && n.nodeType !== Node.ELEMENT_NODE) {\n        n = n[utils.SHADY_PREFIX + 'nextSibling'];\n      }\n      return n;\n    } else {\n      return this[utils.NATIVE_PREFIX + 'nextElementSibling'];\n    }\n  },\n\n  /** @this {Element} */\n  get slot() {\n    return this.getAttribute('slot');\n  },\n\n  /** @this {Element} */\n  set slot(value) {\n    this[utils.SHADY_PREFIX + 'setAttribute']('slot', value);\n  },\n\n  // Note: Can be patched on element prototype on all browsers.\n  // Must be patched on instance on browsers that support native Shadow DOM\n  // but do not have builtin accessors (old Chrome).\n  /** @this {Element} */\n  get shadowRoot() {\n    const nodeData = shadyDataForNode(this);\n    return nodeData && nodeData.publicRoot || null;\n  },\n\n  /** @this {Element} */\n  get className() {\n    return this.getAttribute('class') || '';\n  },\n\n  /**\n   * @this {Element}\n   * @param {string} value\n   */\n  set className(value) {\n    this[utils.SHADY_PREFIX + 'setAttribute']('class', value);\n  },\n\n  /**\n   * @this {Element}\n   * @param {string} attr\n   * @param {string} value\n   */\n  setAttribute(attr, value) {\n    if (this.ownerDocument !== doc) {\n      this[utils.NATIVE_PREFIX + 'setAttribute'](attr, value);\n    } else if (!scopeClassAttribute(this, attr, value)) {\n      this[utils.NATIVE_PREFIX + 'setAttribute'](attr, value);\n      distributeAttributeChange(this, attr);\n    }\n  },\n\n  /**\n   * @this {Element}\n   * @param {string} attr\n   */\n  removeAttribute(attr) {\n    this[utils.NATIVE_PREFIX + 'removeAttribute'](attr);\n    distributeAttributeChange(this, attr);\n  },\n\n  /**\n   * @this {Element}\n   * @param {!{mode: string}} options\n   */\n  attachShadow(options) {\n    return attachShadow(this, options);\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {eventPropertyNames} from '../patch-events.js';\nimport {shadyDataForNode, ensureShadyDataForNode} from '../shady-data.js';\n\nexport const HTMLElementPatches = utils.getOwnPropertyDescriptors({\n\n  /** @this {HTMLElement} */\n  blur() {\n    const nodeData = shadyDataForNode(this);\n    let root = nodeData && nodeData.root;\n    let shadowActive = root && root.activeElement;\n    if (shadowActive) {\n      shadowActive[utils.SHADY_PREFIX + 'blur']();\n    } else {\n      this[utils.NATIVE_PREFIX + 'blur']();\n    }\n  }\n\n});\n\neventPropertyNames.forEach(property => {\n  HTMLElementPatches[property] = {\n    /** @this {HTMLElement} */\n    set: function(fn) {\n      const shadyData = ensureShadyDataForNode(this);\n      const eventName = property.substring(2);\n      shadyData.__onCallbackListeners[property] && this.removeEventListener(eventName, shadyData.__onCallbackListeners[property]);\n      this[utils.SHADY_PREFIX + 'addEventListener'](eventName, fn);\n      shadyData.__onCallbackListeners[property] = fn;\n    },\n    /** @this {HTMLElement} */\n    get() {\n      const shadyData = shadyDataForNode(this);\n      return shadyData && shadyData.__onCallbackListeners[property];\n    },\n    configurable: true\n  };\n});\n\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\nimport {shadyDataForNode} from '../shady-data.js';\n\nexport const SlotPatches = utils.getOwnPropertyDescriptors({\n\n  /**\n   * @this {HTMLSlotElement}\n   * @param {Object=} options\n   */\n  assignedNodes(options) {\n    if (this.localName === 'slot') {\n      // Force any containing shadowRoot to flush so that distribution occurs\n      // and this node has assignedNodes.\n      const root = this[utils.SHADY_PREFIX + 'getRootNode']();\n      if (root && utils.isShadyRoot(root)) {\n        root._render();\n      }\n      const nodeData = shadyDataForNode(this);\n      return nodeData ?\n        ((options && options.flatten ? nodeData.flattenedNodes :\n          nodeData.assignedNodes) || []) :\n        [];\n    }\n  }\n\n});\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from '../utils.js';\n\nconst doc = window.document;\n\nexport const DocumentPatches = utils.getOwnPropertyDescriptors({\n\n  // note: Though not technically correct, we fast path `importNode`\n  // when called on a node not owned by the main document.\n  // This allows, for example, elements that cannot\n  // contain custom elements and are therefore not likely to contain shadowRoots\n  // to cloned natively. This is a fairly significant performance win.\n  /**\n   * @this {Document}\n   * @param {Node} node\n   * @param {boolean} deep\n   */\n  importNode(node, deep) {\n    // A template element normally has no children with shadowRoots, so make\n    // sure we always make a deep copy to correctly construct the template.content\n    if (node.ownerDocument !== doc || node.localName === 'template') {\n      return this[utils.NATIVE_PREFIX + 'importNode'](node, deep);\n    }\n    let n = this[utils.NATIVE_PREFIX + 'importNode'](node, false);\n    if (deep) {\n      let c$ = node[utils.SHADY_PREFIX + 'childNodes'];\n      for (let i=0, nc; i < c$.length; i++) {\n        nc = this[utils.SHADY_PREFIX + 'importNode'](c$[i], true);\n        n[utils.SHADY_PREFIX + 'appendChild'](nc);\n      }\n    }\n    return n;\n  }\n\n});","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\nimport * as utils from '../utils.js';\nimport {addEventListener, removeEventListener} from '../patch-events.js';\n\nexport const WindowPatches = utils.getOwnPropertyDescriptors({\n\n  // NOTE: ensure these methods are bound to `window` so that `this` is correct\n  // when called directly from global context without a receiver; e.g.\n  // `addEventListener(...)`.\n  addEventListener: addEventListener.bind(window),\n\n  removeEventListener: removeEventListener.bind(window)\n\n});","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nimport * as utils from './utils.js';\nimport {EventTargetPatches} from './patches/EventTarget.js';\nimport {NodePatches} from './patches/Node.js';\nimport {SlotablePatches} from './patches/Slotable.js';\nimport {ParentNodePatches, ParentNodeDocumentOrFragmentPatches} from './patches/ParentNode.js';\nimport {ElementPatches} from './patches/Element.js';\nimport {ElementOrShadowRootPatches} from './patches/ElementOrShadowRoot.js';\nimport {HTMLElementPatches} from './patches/HTMLElement.js';\nimport {SlotPatches} from './patches/Slot.js';\nimport {DocumentOrFragmentPatches} from './patches/DocumentOrFragment.js';\nimport {DocumentOrShadowRootPatches} from './patches/DocumentOrShadowRoot.js';\nimport {DocumentPatches} from './patches/Document.js';\nimport {WindowPatches} from './patches/Window.js';\n\n// Some browsers (IE/Edge) have non-standard HTMLElement accessors.\nconst NonStandardHTMLElement = {};\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'parentElement')) {\n  NonStandardHTMLElement.parentElement = NodePatches.parentElement;\n}\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'contains')) {\n  NonStandardHTMLElement.contains = NodePatches.contains;\n}\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'children')) {\n  NonStandardHTMLElement.children = ParentNodePatches.children;\n}\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'innerHTML')) {\n  NonStandardHTMLElement.innerHTML = ElementOrShadowRootPatches.innerHTML;\n}\n\nif (Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'className')) {\n  NonStandardHTMLElement.className = ElementPatches.className;\n}\n\n// Avoid patching `innerHTML` if it does not exist on Element (IE)\n// and we can patch accessors (hasDescriptors).\nconst ElementShouldHaveInnerHTML = !utils.settings.hasDescriptors || 'innerHTML' in Element.prototype;\n\n// setup patching\nconst patchMap = {\n  EventTarget: [EventTargetPatches],\n  Node: [NodePatches, !window.EventTarget ? EventTargetPatches : null],\n  Text: [SlotablePatches],\n  Element: [ElementPatches, ParentNodePatches, SlotablePatches,\n    ElementShouldHaveInnerHTML ? ElementOrShadowRootPatches : null,\n    !window.HTMLSlotElement ? SlotPatches : null],\n  HTMLElement: [HTMLElementPatches, NonStandardHTMLElement],\n  HTMLSlotElement: [SlotPatches],\n  DocumentFragment: [ParentNodeDocumentOrFragmentPatches, DocumentOrFragmentPatches],\n  Document: [DocumentPatches, ParentNodeDocumentOrFragmentPatches, DocumentOrFragmentPatches, DocumentOrShadowRootPatches],\n  Window: [WindowPatches]\n}\n\nconst getPatchPrototype = (name) => window[name] && window[name].prototype;\n\n// Note, must avoid patching accessors on prototypes when descriptors are not correct\n// because the CustomElements polyfill checks if these exist before patching instances.\n// CustomElements polyfill *only* cares about these accessors.\nconst disallowedNativePatches = utils.settings.hasDescriptors ? null : ['innerHTML', 'textContent'];\n\n/** @param {string=} prefix */\nexport const applyPatches = (prefix) => {\n  const disallowed = prefix ? null : disallowedNativePatches;\n  for (let p in patchMap) {\n    const proto = getPatchPrototype(p);\n    patchMap[p].forEach(patch => proto && patch &&\n        utils.patchProperties(proto, patch, prefix, disallowed));\n  }\n}\n\nexport const addShadyPrefixedProperties = () => {\n  // perform shady patches\n  applyPatches(utils.SHADY_PREFIX);\n\n  // install `_activeElement` because some browsers (older Chrome/Safari) do not have\n  // a 'configurable' `activeElement` accesssor.\n  const descriptor = DocumentOrShadowRootPatches.activeElement;\n  Object.defineProperty(document, '_activeElement', descriptor);\n\n  // On Window, we're patching `addEventListener` which is a weird auto-bound\n  // property that is not directly on the Window prototype.\n  utils.patchProperties(Window.prototype, WindowPatches, utils.SHADY_PREFIX);\n};\n","/**\n@license\nCopyright (c) 2016 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n/**\n * Patches elements that interacts with ShadyDOM\n * such that tree traversal and mutation apis act like they would under\n * ShadowDOM.\n *\n * This import enables seemless interaction with ShadyDOM powered\n * custom elements, enabling better interoperation with 3rd party code,\n * libraries, and frameworks that use DOM tree manipulation apis.\n */\n\nimport * as utils from './utils.js';\nimport {flush, enqueue} from './flush.js';\nimport {observeChildren, unobserveChildren, filterMutations} from './observe-changes.js';\nimport {addNativePrefixedProperties, nativeMethods, nativeTree} from './patch-native.js';\nimport {patchInsideElementAccessors, patchOutsideElementAccessors} from './patch-instances.js';\nimport {patchEvents, patchClick, composedPath} from './patch-events.js';\nimport {ShadyRoot} from './attach-shadow.js';\nimport {wrap, Wrapper} from './wrapper.js';\nimport {addShadyPrefixedProperties, applyPatches} from './patch-prototypes.js';\n\nif (utils.settings.inUse) {\n  let ShadyDOM = {\n    // TODO(sorvell): remove when Polymer does not depend on this.\n    'inUse': utils.settings.inUse,\n    // NOTE: old browsers without prototype accessors (very old Chrome\n    // and Safari) need manually patched accessors to properly set\n    // `innerHTML` and `textContent` when an element is:\n    // (1) inside a shadowRoot\n    // (2) does not have special (slot) children itself\n    // (3) and setting the property needs to provoke distribution (because\n    // a nested slot is added/removed)\n    'patch': (node) => {\n      patchInsideElementAccessors(node);\n      patchOutsideElementAccessors(node);\n      return node;\n    },\n    'isShadyRoot': utils.isShadyRoot,\n    'enqueue': enqueue,\n    'flush': flush,\n    'flushInitial': (root) => {\n      root._flushInitial();\n    },\n    'settings': utils.settings,\n    'filterMutations': filterMutations,\n    'observeChildren': observeChildren,\n    'unobserveChildren': unobserveChildren,\n    // Set to true to defer native custom elements connection until the\n    // document has fully parsed. This enables custom elements that create\n    // shadowRoots to be defined while the document is loading. Elements\n    // customized as they are created by the parser will successfully\n    // render with this flag on.\n    'deferConnectionCallbacks': utils.settings['deferConnectionCallbacks'],\n    // Set to true to speed up the polyfill slightly at the cost of correctness\n    // * does not patch querySelector/All on Document or DocumentFragment\n    // * does not wrap connected/disconnected callbacks to de-dup these\n    // when using native customElements\n    // * does not wait to process children of elements with shadowRoots\n    // meaning shadowRoots should not be created while an element is parsing\n    // (e.g. if a custom element that creates a shadowRoot is defined before\n    // a candidate element in the document below it.\n    'preferPerformance': utils.settings['preferPerformance'],\n    // Integration point with ShadyCSS to disable styling MutationObserver,\n    // as ShadyDOM will now handle dynamic scoping.\n    'handlesDynamicScoping': true,\n    'wrap': utils.settings.noPatch ? wrap : (n) => n,\n    'Wrapper': Wrapper,\n    'composedPath': composedPath,\n    // Set to true to avoid patching regular platform property names. When set,\n    // Shadow DOM compatible behavior is only available when accessing DOM\n    // API using `ShadyDOM.wrap`, e.g. `ShadyDOM.wrap(element).shadowRoot`.\n    // This setting provides a small performance boost, but requires all DOM API\n    // access that requires Shadow DOM behavior to be proxied via `ShadyDOM.wrap`.\n    'noPatch': utils.settings.noPatch,\n    'nativeMethods': nativeMethods,\n    'nativeTree': nativeTree\n  };\n\n  window['ShadyDOM'] = ShadyDOM;\n\n  // Modifies native prototypes for Node, Element, etc. to\n  // make native platform behavior available at prefixed names, e.g.\n  // `utils.NATIVE_PREFIX + 'firstChild'` or `__shady_native_firstChild`.\n  // This allows the standard names to be safely patched while retaining the\n  // ability for native behavior to be used. This polyfill manipulates DOM\n  // by using this saved native behavior.\n  // Note, some browsers do not have proper element descriptors for\n  // accessors; in this case, native behavior for these accessors is simulated\n  // via a TreeWalker.\n  addNativePrefixedProperties();\n\n  // Modifies native prototypes for Node, Element, etc. to make ShadowDOM\n  // behavior available at prefixed names, e.g.\n  // `utils.SHADY_PREFIX + 'firstChild` or `__shady_firstChild`. This is done\n  // so this polyfill can perform Shadow DOM style DOM manipulation.\n  // Because patching normal platform property names is optional, these prefixed\n  // names are used internally.\n  addShadyPrefixedProperties();\n\n  // Modifies native prototypes for Node, Element, etc. to patch\n  // regular platform property names to have Shadow DOM compatible API behavior.\n  // This applies the utils.SHADY_PREFIX behavior to normal names. For example,\n  // if `noPatch` is not set, then `el.__shady_firstChild` is equivalent to\n  // `el.firstChild`.\n  // NOTE, on older browsers (old Chrome/Safari) native accessors cannot be\n  // patched on prototypes (e.g. Node.prototype.firstChild cannot be modified).\n  // On these browsers, instance level patching is performed where needed; this\n  // instance patching is only done when `noPatch` is *not* set.\n  if (!utils.settings.noPatch) {\n    applyPatches();\n    // Patch click event behavior only if we're patching\n    patchClick()\n  }\n\n  // For simplicity, patch events unconditionally.\n  // Patches the event system to have Shadow DOM compatible behavior (e.g.\n  // event retargeting). When `noPatch` is set, retargeting is only available\n  // when adding event listeners and dispatching events via `ShadyDOM.wrap`\n  // (e.g. `ShadyDOM.wrap(element).addEventListener(...)`).\n  patchEvents();\n\n  window.ShadowRoot = /** @type {function(new:ShadowRoot)} */(ShadyRoot);\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n/*\nExtremely simple css parser. Intended to be not more than what we need\nand definitely not necessarily correct =).\n*/\n\n'use strict';\n\n/** @unrestricted */\nclass StyleNode {\n  constructor() {\n    /** @type {number} */\n    this['start'] = 0;\n    /** @type {number} */\n    this['end'] = 0;\n    /** @type {StyleNode} */\n    this['previous'] = null;\n    /** @type {StyleNode} */\n    this['parent'] = null;\n    /** @type {Array<StyleNode>} */\n    this['rules'] = null;\n    /** @type {string} */\n    this['parsedCssText'] = '';\n    /** @type {string} */\n    this['cssText'] = '';\n    /** @type {boolean} */\n    this['atRule'] = false;\n    /** @type {number} */\n    this['type'] = 0;\n    /** @type {string} */\n    this['keyframesName'] = '';\n    /** @type {string} */\n    this['selector'] = '';\n    /** @type {string} */\n    this['parsedSelector'] = '';\n  }\n}\n\nexport {StyleNode}\n\n// given a string of css, return a simple rule tree\n/**\n * @param {string} text\n * @return {StyleNode}\n */\nexport function parse(text) {\n  text = clean(text);\n  return parseCss(lex(text), text);\n}\n\n// remove stuff we don't care about that may hinder parsing\n/**\n * @param {string} cssText\n * @return {string}\n */\nfunction clean(cssText) {\n  return cssText.replace(RX.comments, '').replace(RX.port, '');\n}\n\n// super simple {...} lexer that returns a node tree\n/**\n * @param {string} text\n * @return {StyleNode}\n */\nfunction lex(text) {\n  let root = new StyleNode();\n  root['start'] = 0;\n  root['end'] = text.length\n  let n = root;\n  for (let i = 0, l = text.length; i < l; i++) {\n    if (text[i] === OPEN_BRACE) {\n      if (!n['rules']) {\n        n['rules'] = [];\n      }\n      let p = n;\n      let previous = p['rules'][p['rules'].length - 1] || null;\n      n = new StyleNode();\n      n['start'] = i + 1;\n      n['parent'] = p;\n      n['previous'] = previous;\n      p['rules'].push(n);\n    } else if (text[i] === CLOSE_BRACE) {\n      n['end'] = i + 1;\n      n = n['parent'] || root;\n    }\n  }\n  return root;\n}\n\n// add selectors/cssText to node tree\n/**\n * @param {StyleNode} node\n * @param {string} text\n * @return {StyleNode}\n */\nfunction parseCss(node, text) {\n  let t = text.substring(node['start'], node['end'] - 1);\n  node['parsedCssText'] = node['cssText'] = t.trim();\n  if (node['parent']) {\n    let ss = node['previous'] ? node['previous']['end'] : node['parent']['start'];\n    t = text.substring(ss, node['start'] - 1);\n    t = _expandUnicodeEscapes(t);\n    t = t.replace(RX.multipleSpaces, ' ');\n    // TODO(sorvell): ad hoc; make selector include only after last ;\n    // helps with mixin syntax\n    t = t.substring(t.lastIndexOf(';') + 1);\n    let s = node['parsedSelector'] = node['selector'] = t.trim();\n    node['atRule'] = (s.indexOf(AT_START) === 0);\n    // note, support a subset of rule types...\n    if (node['atRule']) {\n      if (s.indexOf(MEDIA_START) === 0) {\n        node['type'] = types.MEDIA_RULE;\n      } else if (s.match(RX.keyframesRule)) {\n        node['type'] = types.KEYFRAMES_RULE;\n        node['keyframesName'] =\n          node['selector'].split(RX.multipleSpaces).pop();\n      }\n    } else {\n      if (s.indexOf(VAR_START) === 0) {\n        node['type'] = types.MIXIN_RULE;\n      } else {\n        node['type'] = types.STYLE_RULE;\n      }\n    }\n  }\n  let r$ = node['rules'];\n  if (r$) {\n    for (let i = 0, l = r$.length, r;\n      (i < l) && (r = r$[i]); i++) {\n      parseCss(r, text);\n    }\n  }\n  return node;\n}\n\n/**\n * conversion of sort unicode escapes with spaces like `\\33 ` (and longer) into\n * expanded form that doesn't require trailing space `\\000033`\n * @param {string} s\n * @return {string}\n */\nfunction _expandUnicodeEscapes(s) {\n  return s.replace(/\\\\([0-9a-f]{1,6})\\s/gi, function() {\n    let code = arguments[1],\n      repeat = 6 - code.length;\n    while (repeat--) {\n      code = '0' + code;\n    }\n    return '\\\\' + code;\n  });\n}\n\n/**\n * stringify parsed css.\n * @param {StyleNode} node\n * @param {boolean=} preserveProperties\n * @param {string=} text\n * @return {string}\n */\nexport function stringify(node, preserveProperties, text = '') {\n  // calc rule cssText\n  let cssText = '';\n  if (node['cssText'] || node['rules']) {\n    let r$ = node['rules'];\n    if (r$ && !_hasMixinRules(r$)) {\n      for (let i = 0, l = r$.length, r;\n        (i < l) && (r = r$[i]); i++) {\n        cssText = stringify(r, preserveProperties, cssText);\n      }\n    } else {\n      cssText = preserveProperties ? node['cssText'] :\n        removeCustomProps(node['cssText']);\n      cssText = cssText.trim();\n      if (cssText) {\n        cssText = '  ' + cssText + '\\n';\n      }\n    }\n  }\n  // emit rule if there is cssText\n  if (cssText) {\n    if (node['selector']) {\n      text += node['selector'] + ' ' + OPEN_BRACE + '\\n';\n    }\n    text += cssText;\n    if (node['selector']) {\n      text += CLOSE_BRACE + '\\n\\n';\n    }\n  }\n  return text;\n}\n\n/**\n * @param {Array<StyleNode>} rules\n * @return {boolean}\n */\nfunction _hasMixinRules(rules) {\n  let r = rules[0];\n  return Boolean(r) && Boolean(r['selector']) && r['selector'].indexOf(VAR_START) === 0;\n}\n\n/**\n * @param {string} cssText\n * @return {string}\n */\nfunction removeCustomProps(cssText) {\n  cssText = removeCustomPropAssignment(cssText);\n  return removeCustomPropApply(cssText);\n}\n\n/**\n * @param {string} cssText\n * @return {string}\n */\nexport function removeCustomPropAssignment(cssText) {\n  return cssText\n    .replace(RX.customProp, '')\n    .replace(RX.mixinProp, '');\n}\n\n/**\n * @param {string} cssText\n * @return {string}\n */\nfunction removeCustomPropApply(cssText) {\n  return cssText\n    .replace(RX.mixinApply, '')\n    .replace(RX.varApply, '');\n}\n\n/** @enum {number} */\nexport const types = {\n  STYLE_RULE: 1,\n  KEYFRAMES_RULE: 7,\n  MEDIA_RULE: 4,\n  MIXIN_RULE: 1000\n}\n\nconst OPEN_BRACE = '{';\nconst CLOSE_BRACE = '}';\n\n// helper regexp's\nconst RX = {\n  comments: /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//gim,\n  port: /@import[^;]*;/gim,\n  customProp: /(?:^[^;\\-\\s}]+)?--[^;{}]*?:[^{};]*?(?:[;\\n]|$)/gim,\n  mixinProp: /(?:^[^;\\-\\s}]+)?--[^;{}]*?:[^{};]*?{[^}]*?}(?:[;\\n]|$)?/gim,\n  mixinApply: /@apply\\s*\\(?[^);]*\\)?\\s*(?:[;\\n]|$)?/gim,\n  varApply: /[^;:]*?:[^;]*?var\\([^;]*\\)(?:[;\\n]|$)?/gim,\n  keyframesRule: /^@[^\\s]*keyframes/,\n  multipleSpaces: /\\s+/g\n}\n\nconst VAR_START = '--';\nconst MEDIA_START = '@media';\nconst AT_START = '@';\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nexport const nativeShadow = !(window['ShadyDOM'] && window['ShadyDOM']['inUse']);\nlet nativeCssVariables_;\n\n/**\n * @param {(ShadyCSSOptions | ShadyCSSInterface)=} settings\n */\nfunction calcCssVariables(settings) {\n  if (settings && settings['shimcssproperties']) {\n    nativeCssVariables_ = false;\n  } else {\n    // chrome 49 has semi-working css vars, check if box-shadow works\n    // safari 9.1 has a recalc bug: https://bugs.webkit.org/show_bug.cgi?id=155782\n    // However, shim css custom properties are only supported with ShadyDOM enabled,\n    // so fall back on native if we do not detect ShadyDOM\n    // Edge 15: custom properties used in ::before and ::after will also be used in the parent element\n    // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12414257/\n    nativeCssVariables_ = nativeShadow || Boolean(!navigator.userAgent.match(/AppleWebKit\\/601|Edge\\/15/) &&\n      window.CSS && CSS.supports && CSS.supports('box-shadow', '0 0 0 var(--foo)'));\n  }\n}\n\n/** @type {string | undefined} */\nexport let cssBuild;\nif (window.ShadyCSS && window.ShadyCSS.cssBuild !== undefined) {\n  cssBuild = window.ShadyCSS.cssBuild;\n}\n\n/** @type {boolean} */\nexport const disableRuntime = Boolean(window.ShadyCSS && window.ShadyCSS.disableRuntime);\n\nif (window.ShadyCSS && window.ShadyCSS.nativeCss !== undefined) {\n  nativeCssVariables_ = window.ShadyCSS.nativeCss;\n} else if (window.ShadyCSS) {\n  calcCssVariables(window.ShadyCSS);\n  // reset window variable to let ShadyCSS API take its place\n  window.ShadyCSS = undefined;\n} else {\n  calcCssVariables(window['WebComponents'] && window['WebComponents']['flags']);\n}\n\n// Hack for type error under new type inference which doesn't like that\n// nativeCssVariables is updated in a function and assigns the type\n// `function(): ?` instead of `boolean`.\nexport const nativeCssVariables = /** @type {boolean} */(nativeCssVariables_);","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nexport const VAR_ASSIGN = /(?:^|[;\\s{]\\s*)(--[\\w-]*?)\\s*:\\s*(?:((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^)]*?\\)|[^};{])+)|\\{([^}]*)\\}(?:(?=[;\\s}])|$))/gi;\nexport const MIXIN_MATCH = /(?:^|\\W+)@apply\\s*\\(?([^);\\n]*)\\)?/gi;\nexport const VAR_CONSUMED = /(--[\\w-]+)\\s*([:,;)]|$)/gi;\nexport const ANIMATION_MATCH = /(animation\\s*:)|(animation-name\\s*:)/;\nexport const MEDIA_MATCH = /@media\\s(.*)/;\nexport const IS_VAR = /^--/;\nexport const BRACKETED = /\\{[^}]*\\}/g;\nexport const HOST_PREFIX = '(?:^|[^.#[:])';\nexport const HOST_SUFFIX = '($|[.:[\\\\s>+~])';\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\n/** @type {!Set<string>} */\nconst styleTextSet = new Set();\n\nexport const scopingAttribute = 'shady-unscoped';\n\n/**\n * Add a specifically-marked style to the document directly, and only one copy of that style.\n *\n * @param {!HTMLStyleElement} style\n * @return {undefined}\n */\nexport function processUnscopedStyle(style) {\n  const text = style.textContent;\n  if (!styleTextSet.has(text)) {\n    styleTextSet.add(text);\n    const newStyle = style.cloneNode(true);\n    document.head.appendChild(newStyle);\n  }\n}\n\n/**\n * Check if a style is supposed to be unscoped\n * @param {!HTMLStyleElement} style\n * @return {boolean} true if the style has the unscoping attribute\n */\nexport function isUnscopedStyle(style) {\n  return style.hasAttribute(scopingAttribute);\n}","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {nativeShadow, nativeCssVariables, cssBuild} from './style-settings.js';\nimport {parse, stringify, types, StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\nimport {MEDIA_MATCH} from './common-regex.js';\nimport {processUnscopedStyle, isUnscopedStyle} from './unscoped-style-handler.js';\n\n/**\n * @param {string|StyleNode} rules\n * @param {function(StyleNode)=} callback\n * @return {string}\n */\nexport function toCssText (rules, callback) {\n  if (!rules) {\n    return '';\n  }\n  if (typeof rules === 'string') {\n    rules = parse(rules);\n  }\n  if (callback) {\n    forEachRule(rules, callback);\n  }\n  return stringify(rules, nativeCssVariables);\n}\n\n/**\n * @param {HTMLStyleElement} style\n * @return {StyleNode}\n */\nexport function rulesForStyle(style) {\n  if (!style['__cssRules'] && style.textContent) {\n    style['__cssRules'] = parse(style.textContent);\n  }\n  return style['__cssRules'] || null;\n}\n\n// Tests if a rule is a keyframes selector, which looks almost exactly\n// like a normal selector but is not (it has nothing to do with scoping\n// for example).\n/**\n * @param {StyleNode} rule\n * @return {boolean}\n */\nexport function isKeyframesSelector(rule) {\n  return Boolean(rule['parent']) &&\n  rule['parent']['type'] === types.KEYFRAMES_RULE;\n}\n\n/**\n * @param {StyleNode} node\n * @param {Function=} styleRuleCallback\n * @param {Function=} keyframesRuleCallback\n * @param {boolean=} onlyActiveRules\n */\nexport function forEachRule(node, styleRuleCallback, keyframesRuleCallback, onlyActiveRules) {\n  if (!node) {\n    return;\n  }\n  let skipRules = false;\n  let type = node['type'];\n  if (onlyActiveRules) {\n    if (type === types.MEDIA_RULE) {\n      let matchMedia = node['selector'].match(MEDIA_MATCH);\n      if (matchMedia) {\n        // if rule is a non matching @media rule, skip subrules\n        if (!window.matchMedia(matchMedia[1]).matches) {\n          skipRules = true;\n        }\n      }\n    }\n  }\n  if (type === types.STYLE_RULE) {\n    styleRuleCallback(node);\n  } else if (keyframesRuleCallback &&\n    type === types.KEYFRAMES_RULE) {\n    keyframesRuleCallback(node);\n  } else if (type === types.MIXIN_RULE) {\n    skipRules = true;\n  }\n  let r$ = node['rules'];\n  if (r$ && !skipRules) {\n    for (let i=0, l=r$.length, r; (i<l) && (r=r$[i]); i++) {\n      forEachRule(r, styleRuleCallback, keyframesRuleCallback, onlyActiveRules);\n    }\n  }\n}\n\n// add a string of cssText to the document.\n/**\n * @param {string} cssText\n * @param {string} moniker\n * @param {Node} target\n * @param {Node} contextNode\n * @return {HTMLStyleElement}\n */\nexport function applyCss(cssText, moniker, target, contextNode) {\n  let style = createScopeStyle(cssText, moniker);\n  applyStyle(style, target, contextNode);\n  return style;\n}\n\n/**\n * @param {string} cssText\n * @param {string} moniker\n * @return {HTMLStyleElement}\n */\nexport function createScopeStyle(cssText, moniker) {\n  let style = /** @type {HTMLStyleElement} */(document.createElement('style'));\n  if (moniker) {\n    style.setAttribute('scope', moniker);\n  }\n  style.textContent = cssText;\n  return style;\n}\n\n/**\n * Track the position of the last added style for placing placeholders\n * @type {Node}\n */\nlet lastHeadApplyNode = null;\n\n// insert a comment node as a styling position placeholder.\n/**\n * @param {string} moniker\n * @return {!Comment}\n */\nexport function applyStylePlaceHolder(moniker) {\n  let placeHolder = document.createComment(' Shady DOM styles for ' +\n    moniker + ' ');\n  let after = lastHeadApplyNode ?\n    lastHeadApplyNode['nextSibling'] : null;\n  let scope = document.head;\n  scope.insertBefore(placeHolder, after || scope.firstChild);\n  lastHeadApplyNode = placeHolder;\n  return placeHolder;\n}\n\n/**\n * @param {HTMLStyleElement} style\n * @param {?Node} target\n * @param {?Node} contextNode\n */\nexport function applyStyle(style, target, contextNode) {\n  target = target || document.head;\n  let after = (contextNode && contextNode.nextSibling) ||\n    target.firstChild;\n  target.insertBefore(style, after);\n  if (!lastHeadApplyNode) {\n    lastHeadApplyNode = style;\n  } else {\n    // only update lastHeadApplyNode if the new style is inserted after the old lastHeadApplyNode\n    let position = style.compareDocumentPosition(lastHeadApplyNode);\n    if (position === Node.DOCUMENT_POSITION_PRECEDING) {\n      lastHeadApplyNode = style;\n    }\n  }\n}\n\n/**\n * @param {string} buildType\n * @return {boolean}\n */\nexport function isTargetedBuild(buildType) {\n  return nativeShadow ? buildType === 'shadow' : buildType === 'shady';\n}\n\n/**\n * Walk from text[start] matching parens and\n * returns position of the outer end paren\n * @param {string} text\n * @param {number} start\n * @return {number}\n */\nexport function findMatchingParen(text, start) {\n  let level = 0;\n  for (let i=start, l=text.length; i < l; i++) {\n    if (text[i] === '(') {\n      level++;\n    } else if (text[i] === ')') {\n      if (--level === 0) {\n        return i;\n      }\n    }\n  }\n  return -1;\n}\n\n/**\n * @param {string} str\n * @param {function(string, string, string, string)} callback\n */\nexport function processVariableAndFallback(str, callback) {\n  // find 'var('\n  let start = str.indexOf('var(');\n  if (start === -1) {\n    // no var?, everything is prefix\n    return callback(str, '', '', '');\n  }\n  //${prefix}var(${inner})${suffix}\n  let end = findMatchingParen(str, start + 3);\n  let inner = str.substring(start + 4, end);\n  let prefix = str.substring(0, start);\n  // suffix may have other variables\n  let suffix = processVariableAndFallback(str.substring(end + 1), callback);\n  let comma = inner.indexOf(',');\n  // value and fallback args should be trimmed to match in property lookup\n  if (comma === -1) {\n    // variable, no fallback\n    return callback(prefix, inner.trim(), '', suffix);\n  }\n  // var(${value},${fallback})\n  let value = inner.substring(0, comma).trim();\n  let fallback = inner.substring(comma + 1).trim();\n  return callback(prefix, value, fallback, suffix);\n}\n\n/**\n * @param {Element} element\n * @param {string} value\n */\nexport function setElementClassRaw(element, value) {\n  // use native setAttribute provided by ShadyDOM when setAttribute is patched\n  if (nativeShadow) {\n    element.setAttribute('class', value);\n  } else {\n    window['ShadyDOM']['nativeMethods']['setAttribute'].call(element, 'class', value);\n  }\n}\n\n/**\n * @type {function(*):*}\n */\nexport const wrap = window['ShadyDOM'] && window['ShadyDOM']['wrap'] || ((node) => node);\n\n/**\n * @param {Element | {is: string, extends: string}} element\n * @return {{is: string, typeExtension: string}}\n */\nexport function getIsExtends(element) {\n  let localName = element['localName'];\n  let is = '', typeExtension = '';\n  /*\n  NOTE: technically, this can be wrong for certain svg elements\n  with `-` in the name like `<font-face>`\n  */\n  if (localName) {\n    if (localName.indexOf('-') > -1) {\n      is = localName;\n    } else {\n      typeExtension = localName;\n      is = (element.getAttribute && element.getAttribute('is')) || '';\n    }\n  } else {\n    is = /** @type {?} */(element).is;\n    typeExtension = /** @type {?} */(element).extends;\n  }\n  return {is, typeExtension};\n}\n\n/**\n * @param {Element|DocumentFragment} element\n * @return {string}\n */\nexport function gatherStyleText(element) {\n  /** @type {!Array<string>} */\n  const styleTextParts = [];\n  const styles = /** @type {!NodeList<!HTMLStyleElement>} */(element.querySelectorAll('style'));\n  for (let i = 0; i < styles.length; i++) {\n    const style = styles[i];\n    if (isUnscopedStyle(style)) {\n      if (!nativeShadow) {\n        processUnscopedStyle(style);\n        style.parentNode.removeChild(style);\n      }\n    } else {\n      styleTextParts.push(style.textContent);\n      style.parentNode.removeChild(style);\n    }\n  }\n  return styleTextParts.join('').trim();\n}\n\n/**\n * Split a selector separated by commas into an array in a smart way\n * @param {string} selector\n * @return {!Array<string>}\n */\nexport function splitSelectorList(selector) {\n  const parts = [];\n  let part = '';\n  for (let i = 0; i >= 0 && i < selector.length; i++) {\n    // A selector with parentheses will be one complete part\n    if (selector[i] === '(') {\n      // find the matching paren\n      const end = findMatchingParen(selector, i);\n      // push the paren block into the part\n      part += selector.slice(i, end + 1);\n      // move the index to after the paren block\n      i = end;\n    } else if (selector[i] === ',') {\n      parts.push(part);\n      part = '';\n    } else {\n      part += selector[i];\n    }\n  }\n  // catch any pieces after the last comma\n  if (part) {\n    parts.push(part);\n  }\n  return parts;\n}\n\nconst CSS_BUILD_ATTR = 'css-build';\n\n/**\n * Return the polymer-css-build \"build type\" applied to this element\n *\n * @param {!HTMLElement} element\n * @return {string} Can be \"\", \"shady\", or \"shadow\"\n */\nexport function getCssBuild(element) {\n  if (cssBuild !== undefined) {\n    return /** @type {string} */(cssBuild);\n  }\n  if (element.__cssBuild === undefined) {\n    // try attribute first, as it is the common case\n    const attrValue = element.getAttribute(CSS_BUILD_ATTR);\n    if (attrValue) {\n      element.__cssBuild = attrValue;\n    } else {\n      const buildComment = getBuildComment(element);\n      if (buildComment !== '') {\n        // remove build comment so it is not needlessly copied into every element instance\n        removeBuildComment(element);\n      }\n      element.__cssBuild = buildComment;\n    }\n  }\n  return element.__cssBuild || '';\n}\n\n/**\n * Check if the given element, either a <template> or <style>, has been processed\n * by polymer-css-build.\n *\n * If so, then we can make a number of optimizations:\n * - polymer-css-build will decompose mixins into individual CSS Custom Properties,\n * so the ApplyShim can be skipped entirely.\n * - Under native ShadowDOM, the style text can just be copied into each instance\n * without modification\n * - If the build is \"shady\" and ShadyDOM is in use, the styling does not need\n * scoping beyond the shimming of CSS Custom Properties\n *\n * @param {!HTMLElement} element\n * @return {boolean}\n */\nexport function elementHasBuiltCss(element) {\n  return getCssBuild(element) !== '';\n}\n\n/**\n * For templates made with tagged template literals, polymer-css-build will\n * insert a comment of the form `<!--css-build:shadow-->`\n *\n * @param {!HTMLElement} element\n * @return {string}\n */\nexport function getBuildComment(element) {\n  const buildComment = element.localName === 'template' ?\n      /** @type {!HTMLTemplateElement} */ (element).content.firstChild :\n      element.firstChild;\n  if (buildComment instanceof Comment) {\n    const commentParts = buildComment.textContent.trim().split(':');\n    if (commentParts[0] === CSS_BUILD_ATTR) {\n      return commentParts[1];\n    }\n  }\n  return '';\n}\n\n/**\n * Check if the css build status is optimal, and do no unneeded work.\n *\n * @param {string=} cssBuild CSS build status\n * @return {boolean} css build is optimal or not\n */\nexport function isOptimalCssBuild(cssBuild = '') {\n  // CSS custom property shim always requires work\n  if (cssBuild === '' || !nativeCssVariables) {\n    return false;\n  }\n  return nativeShadow ? cssBuild === 'shadow' : cssBuild === 'shady';\n}\n\n/**\n * @param {!HTMLElement} element\n */\nfunction removeBuildComment(element) {\n  const buildComment = element.localName === 'template' ?\n      /** @type {!HTMLTemplateElement} */ (element).content.firstChild :\n      element.firstChild;\n  buildComment.parentNode.removeChild(buildComment);\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\nimport * as StyleUtil from './style-util.js';\nimport {nativeShadow} from './style-settings.js';\n\n/* Transforms ShadowDOM styling into ShadyDOM styling\n\n* scoping:\n\n  * elements in scope get scoping selector class=\"x-foo-scope\"\n  * selectors re-written as follows:\n\n    div button -> div.x-foo-scope button.x-foo-scope\n\n* :host -> scopeName\n\n* :host(...) -> scopeName...\n\n* ::slotted(...) -> scopeName > ...\n\n* ...:dir(ltr|rtl) -> [dir=\"ltr|rtl\"] ..., ...[dir=\"ltr|rtl\"]\n\n* :host(:dir[rtl]) -> scopeName:dir(rtl) -> [dir=\"rtl\"] scopeName, scopeName[dir=\"rtl\"]\n\n*/\nconst SCOPE_NAME = 'style-scope';\n\nclass StyleTransformer {\n  get SCOPE_NAME() {\n    return SCOPE_NAME;\n  }\n  /**\n   * Given a node and scope name, add a scoping class to each node\n   * in the tree. This facilitates transforming css into scoped rules.\n   * @param {!Node} node\n   * @param {string} scope\n   * @param {boolean=} shouldRemoveScope\n   * @deprecated\n   */\n  dom(node, scope, shouldRemoveScope) {\n    const fn = (node) => {\n      this.element(node, scope || '', shouldRemoveScope);\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * Given a node and scope name, add a scoping class to each node in the tree.\n   * @param {!Node} node\n   * @param {string} scope\n   */\n  domAddScope(node, scope) {\n    const fn = (node) => {\n      this.element(node, scope || '');\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * @param {!Node} startNode\n   * @param {!function(!Node)} transformer\n   */\n  _transformDom(startNode, transformer) {\n    if (startNode.nodeType === Node.ELEMENT_NODE) {\n      transformer(startNode)\n    }\n    let c$;\n    if (startNode.localName === 'template') {\n      const template = /** @type {!HTMLTemplateElement} */ (startNode);\n      // In case the template is in svg context, fall back to the node\n      // since it won't be an HTMLTemplateElement with a .content property\n      c$ = (template.content || template._content || template).childNodes;\n    } else {\n      c$ = /** @type {!ParentNode} */ (startNode).children ||\n          startNode.childNodes;\n    }\n    if (c$) {\n      for (let i = 0; i < c$.length; i++) {\n        this._transformDom(c$[i], transformer);\n      }\n    }\n  }\n\n  /**\n   * @param {?} element\n   * @param {?} scope\n   * @param {?=} shouldRemoveScope\n   */\n  element(element, scope, shouldRemoveScope) {\n    // note: if using classes, we add both the general 'style-scope' class\n    // as well as the specific scope. This enables easy filtering of all\n    // `style-scope` elements\n    if (scope) {\n      // note: svg on IE does not have classList so fallback to class\n      if (element.classList) {\n        if (shouldRemoveScope) {\n          element.classList.remove(SCOPE_NAME);\n          element.classList.remove(scope);\n        } else {\n          element.classList.add(SCOPE_NAME);\n          element.classList.add(scope);\n        }\n      } else if (element.getAttribute) {\n        let c = element.getAttribute(CLASS);\n        if (shouldRemoveScope) {\n          if (c) {\n            let newValue = c.replace(SCOPE_NAME, '').replace(scope, '');\n            StyleUtil.setElementClassRaw(element, newValue);\n          }\n        } else {\n          let newValue = (c ? c + ' ' : '') + SCOPE_NAME + ' ' + scope;\n          StyleUtil.setElementClassRaw(element, newValue);\n        }\n      }\n    }\n  }\n\n  /**\n   * Given a node, replace the scoping class to each subnode in the tree.\n   * @param {!Node} node\n   * @param {string} oldScope\n   * @param {string} newScope\n   */\n  domReplaceScope(node, oldScope, newScope) {\n    const fn = (node) => {\n      this.element(node, oldScope, true);\n      this.element(node, newScope);\n    };\n    this._transformDom(node, fn);\n  }\n  /**\n   * Given a node, remove the scoping class to each subnode in the tree.\n   * @param {!Node} node\n   * @param {string} oldScope\n   */\n  domRemoveScope(node, oldScope) {\n    const fn = (node) => {\n      this.element(node, oldScope || '', true);\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * @param {?} element\n   * @param {?} styleRules\n   * @param {?=} callback\n   * @param {string=} cssBuild\n   * @param {string=} cssText\n   * @return {string}\n   */\n  elementStyles(element, styleRules, callback, cssBuild = '', cssText = '') {\n    // no need to shim selectors if settings.useNativeShadow, also\n    // a shady css build will already have transformed selectors\n    // NOTE: This method may be called as part of static or property shimming.\n    // When there is a targeted build it will not be called for static shimming,\n    // but when the property shim is used it is called and should opt out of\n    // static shimming work when a proper build exists.\n    if (cssText === '') {\n      if (nativeShadow || cssBuild === 'shady') {\n        cssText = StyleUtil.toCssText(styleRules, callback);\n      } else {\n        let {is, typeExtension} = StyleUtil.getIsExtends(element);\n        cssText = this.css(styleRules, is, typeExtension, callback) + '\\n\\n';\n      }\n    }\n    return cssText.trim();\n  }\n\n  // Given a string of cssText and a scoping string (scope), returns\n  // a string of scoped css where each selector is transformed to include\n  // a class created from the scope. ShadowDOM selectors are also transformed\n  // (e.g. :host) to use the scoping selector.\n  css(rules, scope, ext, callback) {\n    let hostScope = this._calcHostScope(scope, ext);\n    scope = this._calcElementScope(scope);\n    let self = this;\n    return StyleUtil.toCssText(rules, function(/** StyleNode */rule) {\n      if (!rule.isScoped) {\n        self.rule(rule, scope, hostScope);\n        rule.isScoped = true;\n      }\n      if (callback) {\n        callback(rule, scope, hostScope);\n      }\n    });\n  }\n\n  _calcElementScope(scope) {\n    if (scope) {\n      return CSS_CLASS_PREFIX + scope;\n    } else {\n      return '';\n    }\n  }\n\n  _calcHostScope(scope, ext) {\n    return ext ? `[is=${scope}]` : scope;\n  }\n\n  rule(rule, scope, hostScope) {\n    this._transformRule(rule, this._transformComplexSelector,\n      scope, hostScope);\n  }\n\n  /**\n   * transforms a css rule to a scoped rule.\n   *\n   * @param {StyleNode} rule\n   * @param {Function} transformer\n   * @param {string=} scope\n   * @param {string=} hostScope\n   */\n  _transformRule(rule, transformer, scope, hostScope) {\n    // NOTE: save transformedSelector for subsequent matching of elements\n    // against selectors (e.g. when calculating style properties)\n    rule['selector'] = rule.transformedSelector =\n      this._transformRuleCss(rule, transformer, scope, hostScope);\n  }\n\n  /**\n   * @param {StyleNode} rule\n   * @param {Function} transformer\n   * @param {string=} scope\n   * @param {string=} hostScope\n   */\n  _transformRuleCss(rule, transformer, scope, hostScope) {\n    let p$ = StyleUtil.splitSelectorList(rule['selector']);\n    // we want to skip transformation of rules that appear in keyframes,\n    // because they are keyframe selectors, not element selectors.\n    if (!StyleUtil.isKeyframesSelector(rule)) {\n      for (let i=0, l=p$.length, p; (i<l) && (p=p$[i]); i++) {\n        p$[i] = transformer.call(this, p, scope, hostScope);\n      }\n    }\n    return p$.filter((part) => Boolean(part)).join(COMPLEX_SELECTOR_SEP);\n  }\n\n  /**\n   * @param {string} selector\n   * @return {string}\n   */\n  _twiddleNthPlus(selector) {\n    return selector.replace(NTH, (m, type, inside) => {\n      if (inside.indexOf('+') > -1) {\n        inside = inside.replace(/\\+/g, '___');\n      } else if (inside.indexOf('___') > -1) {\n        inside = inside.replace(/___/g, '+');\n      }\n      return `:${type}(${inside})`;\n    });\n  }\n\n  /**\n   * Preserve `:matches()` selectors by replacing them with MATCHES_REPLACMENT\n   * and returning an array of `:matches()` selectors.\n   * Use `_replacesMatchesPseudo` to replace the `:matches()` parts\n   *\n   * @param {string} selector\n   * @return {{selector: string, matches: !Array<string>}}\n   */\n  _preserveMatchesPseudo(selector) {\n    /** @type {!Array<string>} */\n    const matches = [];\n    let match;\n    while ((match = selector.match(MATCHES))) {\n      const start = match.index;\n      const end = StyleUtil.findMatchingParen(selector, start);\n      if (end === -1) {\n        throw new Error(`${match.input} selector missing ')'`)\n      }\n      const part = selector.slice(start, end + 1);\n      selector = selector.replace(part, MATCHES_REPLACEMENT);\n      matches.push(part);\n    }\n    return {selector, matches};\n  }\n\n  /**\n   * Replace MATCHES_REPLACMENT character with the given set of `:matches()`\n   * selectors.\n   *\n   * @param {string} selector\n   * @param {!Array<string>} matches\n   * @return {string}\n   */\n  _replaceMatchesPseudo(selector, matches) {\n    const parts = selector.split(MATCHES_REPLACEMENT);\n    return matches.reduce((acc, cur, idx) => acc + cur + parts[idx + 1], parts[0]);\n  }\n\n/**\n * @param {string} selector\n * @param {string} scope\n * @param {string=} hostScope\n */\n  _transformComplexSelector(selector, scope, hostScope) {\n    let stop = false;\n    selector = selector.trim();\n    // Remove spaces inside of selectors like `:nth-of-type` because it confuses SIMPLE_SELECTOR_SEP\n    let isNth = NTH.test(selector);\n    if (isNth) {\n      selector = selector.replace(NTH, (m, type, inner) => `:${type}(${inner.replace(/\\s/g, '')})`)\n      selector = this._twiddleNthPlus(selector);\n    }\n    // Preserve selectors like `:-webkit-any` so that SIMPLE_SELECTOR_SEP does\n    // not get confused by spaces inside the pseudo selector\n    const isMatches = MATCHES.test(selector);\n    /** @type {!Array<string>} */\n    let matches;\n    if (isMatches) {\n      ({selector, matches} = this._preserveMatchesPseudo(selector));\n    }\n    selector = selector.replace(SLOTTED_START, `${HOST} $1`);\n    selector = selector.replace(SIMPLE_SELECTOR_SEP, (m, c, s) => {\n      if (!stop) {\n        let info = this._transformCompoundSelector(s, c, scope, hostScope);\n        stop = stop || info.stop;\n        c = info.combinator;\n        s = info.value;\n      }\n      return c + s;\n    });\n    // replace `:matches()` selectors\n    if (isMatches) {\n      selector = this._replaceMatchesPseudo(selector, matches);\n    }\n    if (isNth) {\n      selector = this._twiddleNthPlus(selector);\n    }\n    return selector;\n  }\n\n  _transformCompoundSelector(selector, combinator, scope, hostScope) {\n    // replace :host with host scoping class\n    let slottedIndex = selector.indexOf(SLOTTED);\n    if (selector.indexOf(HOST) >= 0) {\n      selector = this._transformHostSelector(selector, hostScope);\n    // replace other selectors with scoping class\n    } else if (slottedIndex !== 0) {\n      selector = scope ? this._transformSimpleSelector(selector, scope) :\n        selector;\n    }\n    // mark ::slotted() scope jump to replace with descendant selector + arg\n    // also ignore left-side combinator\n    let slotted = false;\n    if (slottedIndex >= 0) {\n      combinator = '';\n      slotted = true;\n    }\n    // process scope jumping selectors up to the scope jump and then stop\n    let stop;\n    if (slotted) {\n      stop = true;\n      if (slotted) {\n        // .zonk ::slotted(.foo) -> .zonk.scope > .foo\n        selector = selector.replace(SLOTTED_PAREN, (m, paren) => ` > ${paren}`);\n      }\n    }\n    selector = selector.replace(DIR_PAREN, (m, before, dir) =>\n      `[dir=\"${dir}\"] ${before}, ${before}[dir=\"${dir}\"]`);\n    return {value: selector, combinator, stop};\n  }\n\n  _transformSimpleSelector(selector, scope) {\n    const attributes = selector.split(/(\\[.+?\\])/);\n\n    const output = [];\n    for (let i = 0; i < attributes.length; i++) {\n      // Do not attempt to transform any attribute selector content\n      if ((i % 2) === 1) {\n        output.push(attributes[i]);\n      } else {\n        const part = attributes[i];\n\n        if (!(part === '' && i === attributes.length - 1)) {\n          let p$ = part.split(PSEUDO_PREFIX);\n          p$[0] += scope;\n          output.push(p$.join(PSEUDO_PREFIX));\n        }\n      }\n    }\n\n    return output.join('');\n  }\n\n  // :host(...) -> scopeName...\n  _transformHostSelector(selector, hostScope) {\n    let m = selector.match(HOST_PAREN);\n    let paren = m && m[2].trim() || '';\n    if (paren) {\n      if (!paren[0].match(SIMPLE_SELECTOR_PREFIX)) {\n        // paren starts with a type selector\n        let typeSelector = paren.split(SIMPLE_SELECTOR_PREFIX)[0];\n        // if the type selector is our hostScope then avoid pre-pending it\n        if (typeSelector === hostScope) {\n          return paren;\n        // otherwise, this selector should not match in this scope so\n        // output a bogus selector.\n        } else {\n          return SELECTOR_NO_MATCH;\n        }\n      } else {\n        // make sure to do a replace here to catch selectors like:\n        // `:host(.foo)::before`\n        return selector.replace(HOST_PAREN, function(m, host, paren) {\n          return hostScope + paren;\n        });\n      }\n    // if no paren, do a straight :host replacement.\n    // TODO(sorvell): this should not strictly be necessary but\n    // it's needed to maintain support for `:host[foo]` type selectors\n    // which have been improperly used under Shady DOM. This should be\n    // deprecated.\n    } else {\n      return selector.replace(HOST, hostScope);\n    }\n  }\n\n  /**\n   * @param {StyleNode} rule\n   */\n  documentRule(rule) {\n    // reset selector in case this is redone.\n    rule['selector'] = rule['parsedSelector'];\n    this.normalizeRootSelector(rule);\n    this._transformRule(rule, this._transformDocumentSelector);\n  }\n\n  /**\n   * @param {StyleNode} rule\n   */\n  normalizeRootSelector(rule) {\n    if (rule['selector'] === ROOT) {\n      rule['selector'] = 'html';\n    }\n  }\n\n/**\n * @param {string} selector\n */\n  _transformDocumentSelector(selector) {\n    if (selector.match(HOST)) {\n      // remove ':host' type selectors in document rules\n      return '';\n    } else if (selector.match(SLOTTED)) {\n      return this._transformComplexSelector(selector, SCOPE_DOC_SELECTOR)\n    } else {\n      return this._transformSimpleSelector(selector.trim(), SCOPE_DOC_SELECTOR);\n    }\n  }\n}\n\nconst NTH = /:(nth[-\\w]+)\\(([^)]+)\\)/;\nconst SCOPE_DOC_SELECTOR = `:not(.${SCOPE_NAME})`;\nconst COMPLEX_SELECTOR_SEP = ',';\nconst SIMPLE_SELECTOR_SEP = /(^|[\\s>+~]+)((?:\\[.+?\\]|[^\\s>+~=[])+)/g;\nconst SIMPLE_SELECTOR_PREFIX = /[[.:#*]/;\nconst HOST = ':host';\nconst ROOT = ':root';\nconst SLOTTED = '::slotted';\nconst SLOTTED_START = new RegExp(`^(${SLOTTED})`);\n// NOTE: this supports 1 nested () pair for things like\n// :host(:not([selected]), more general support requires\n// parsing which seems like overkill\nconst HOST_PAREN = /(:host)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))/;\n// similar to HOST_PAREN\nconst SLOTTED_PAREN = /(?:::slotted)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))/;\nconst DIR_PAREN = /(.*):dir\\((?:(ltr|rtl))\\)/;\nconst CSS_CLASS_PREFIX = '.';\nconst PSEUDO_PREFIX = ':';\nconst CLASS = 'class';\nconst SELECTOR_NO_MATCH = 'should_not_match';\nconst MATCHES = /:(?:matches|any|-(?:webkit|moz)-any)/;\nconst MATCHES_REPLACEMENT = '\\u{e000}';\n\nexport default new StyleTransformer()\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {parse, StyleNode} from './css-parse.js';\nimport {nativeShadow, nativeCssVariables, disableRuntime} from './style-settings.js';\nimport StyleTransformer from './style-transformer.js';\nimport * as StyleUtil from './style-util.js';\nimport StyleProperties from './style-properties.js';\nimport {ensureStylePlaceholder, getStylePlaceholder} from './style-placeholder.js';\nimport StyleInfo from './style-info.js';\nimport StyleCache from './style-cache.js';\nimport {flush as watcherFlush, getOwnerScope, getCurrentScope} from './document-watcher.js';\nimport templateMap from './template-map.js';\nimport * as ApplyShimUtils from './apply-shim-utils.js';\nimport {updateNativeProperties, detectMixin} from './common-utils.js';\nimport {CustomStyleInterfaceInterface} from './custom-style-interface.js'; // eslint-disable-line no-unused-vars\n\n/** @type {!Object<string, string>} */\nconst adoptedCssTextMap = {};\n\n/**\n * @const {StyleCache}\n */\nconst styleCache = new StyleCache();\n\nexport default class ScopingShim {\n  constructor() {\n    this._scopeCounter = {};\n    this._documentOwner = /** @type {!HTMLElement} */(document.documentElement);\n    let ast = new StyleNode();\n    ast['rules'] = [];\n    this._documentOwnerStyleInfo = StyleInfo.set(this._documentOwner, new StyleInfo(ast));\n    this._elementsHaveApplied = false;\n    /** @type {?Object} */\n    this._applyShim = null;\n    /** @type {?CustomStyleInterfaceInterface} */\n    this._customStyleInterface = null;\n  }\n  flush() {\n    watcherFlush();\n  }\n  _generateScopeSelector(name) {\n    let id = this._scopeCounter[name] = (this._scopeCounter[name] || 0) + 1;\n    return `${name}-${id}`;\n  }\n  getStyleAst(style) {\n    return StyleUtil.rulesForStyle(style);\n  }\n  styleAstToString(ast) {\n    return StyleUtil.toCssText(ast);\n  }\n  _gatherStyles(template) {\n    return StyleUtil.gatherStyleText(template.content);\n  }\n  /**\n   * Prepare the styling and template for the given element type\n   *\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} typeExtension\n   */\n  prepareTemplate(template, elementName, typeExtension) {\n    this.prepareTemplateDom(template, elementName);\n    this.prepareTemplateStyles(template, elementName, typeExtension);\n  }\n  /**\n   * Prepare styling for the given element type\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} typeExtension\n   */\n  prepareTemplateStyles(template, elementName, typeExtension) {\n    if (template._prepared || disableRuntime) {\n      return;\n    }\n    // style placeholders are only used when ShadyDOM is active\n    if (!nativeShadow) {\n      ensureStylePlaceholder(elementName);\n    }\n    template._prepared = true;\n    template.name = elementName;\n    template.extends = typeExtension;\n    templateMap[elementName] = template;\n    let cssBuild = StyleUtil.getCssBuild(template);\n    const optimalBuild = StyleUtil.isOptimalCssBuild(cssBuild);\n    let info = {\n      is: elementName,\n      extends: typeExtension,\n    };\n    let cssText = this._gatherStyles(template) + (adoptedCssTextMap[elementName] || '');\n    // check if the styling has mixin definitions or uses\n    this._ensure();\n    if (!optimalBuild) {\n      let hasMixins = !cssBuild && detectMixin(cssText);\n      let ast = parse(cssText);\n      // only run the applyshim transforms if there is a mixin involved\n      if (hasMixins && nativeCssVariables && this._applyShim) {\n        this._applyShim['transformRules'](ast, elementName);\n      }\n      template['_styleAst'] = ast;\n    }\n    let ownPropertyNames = [];\n    if (!nativeCssVariables) {\n      ownPropertyNames = StyleProperties.decorateStyles(template['_styleAst']);\n    }\n    if (!ownPropertyNames.length || nativeCssVariables) {\n      let root = nativeShadow ? template.content : null;\n      let placeholder = getStylePlaceholder(elementName);\n      let style = this._generateStaticStyle(info, template['_styleAst'], root, placeholder, cssBuild, optimalBuild ? cssText : '');\n      template._style = style;\n    }\n    template._ownPropertyNames = ownPropertyNames;\n  }\n\n  /**\n   * @param {!Array<string>} cssTextArray\n   * @param {string} elementName\n   */\n  prepareAdoptedCssText(cssTextArray, elementName) {\n    adoptedCssTextMap[elementName] = cssTextArray.join(' ');\n  }\n  /**\n   * Prepare template for the given element type\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   */\n  prepareTemplateDom(template, elementName) {\n    if (disableRuntime) {\n      return;\n    }\n    const cssBuild = StyleUtil.getCssBuild(template);\n    if (!nativeShadow && cssBuild !== 'shady' && !template._domPrepared) {\n      template._domPrepared = true;\n      StyleTransformer.domAddScope(template.content, elementName);\n    }\n  }\n  /**\n   * @param {!{is: string, extends: (string|undefined)}} info\n   * @param {!StyleNode} rules\n   * @param {DocumentFragment} shadowroot\n   * @param {Node} placeholder\n   * @param {string} cssBuild\n   * @param {string=} cssText\n   * @return {?HTMLStyleElement}\n   */\n  _generateStaticStyle(info, rules, shadowroot, placeholder, cssBuild, cssText) {\n    cssText = StyleTransformer.elementStyles(info, rules, null, cssBuild, cssText);\n    if (cssText.length) {\n      return StyleUtil.applyCss(cssText, info.is, shadowroot, placeholder);\n    }\n    return null;\n  }\n  _prepareHost(host) {\n    const {is, typeExtension} = StyleUtil.getIsExtends(host);\n    const placeholder = getStylePlaceholder(is);\n    const template = templateMap[is];\n    if (!template) {\n      return;\n    }\n    const ast = template['_styleAst'];\n    const ownStylePropertyNames = template._ownPropertyNames;\n    const cssBuild = StyleUtil.getCssBuild(template);\n    const styleInfo = new StyleInfo(\n      ast,\n      placeholder,\n      ownStylePropertyNames,\n      is,\n      typeExtension,\n      cssBuild\n    );\n    StyleInfo.set(host, styleInfo);\n    return styleInfo;\n  }\n  _ensureApplyShim() {\n    if (this._applyShim) {\n      return;\n    } else if (window.ShadyCSS && window.ShadyCSS.ApplyShim) {\n      this._applyShim = /** @type {!Object} */ (window.ShadyCSS.ApplyShim);\n      this._applyShim['invalidCallback'] = ApplyShimUtils.invalidate;\n    }\n  }\n  _ensureCustomStyleInterface() {\n    if (this._customStyleInterface) {\n      return;\n    } else if (window.ShadyCSS && window.ShadyCSS.CustomStyleInterface) {\n      this._customStyleInterface = /** @type {!CustomStyleInterfaceInterface} */(window.ShadyCSS.CustomStyleInterface);\n      /** @type {function(!HTMLStyleElement)} */\n      this._customStyleInterface['transformCallback'] = (style) => {this.transformCustomStyleForDocument(style)};\n      this._customStyleInterface['validateCallback'] = () => {\n        requestAnimationFrame(() => {\n          if (this._customStyleInterface['enqueued'] || this._elementsHaveApplied) {\n            this.flushCustomStyles();\n          }\n        })\n      };\n    }\n  }\n  _ensure() {\n    this._ensureApplyShim();\n    this._ensureCustomStyleInterface();\n  }\n  /**\n   * Flush and apply custom styles to document\n   */\n  flushCustomStyles() {\n    if (disableRuntime) {\n      return;\n    }\n    this._ensure();\n    if (!this._customStyleInterface) {\n      return;\n    }\n    let customStyles = this._customStyleInterface['processStyles']();\n    // early return if custom-styles don't need validation\n    if (!this._customStyleInterface['enqueued']) {\n      return;\n    }\n    // bail if custom styles are built optimally\n    if (StyleUtil.isOptimalCssBuild(this._documentOwnerStyleInfo.cssBuild)) {\n      return;\n    }\n    if (!nativeCssVariables) {\n      this._updateProperties(this._documentOwner, this._documentOwnerStyleInfo);\n      this._applyCustomStyles(customStyles);\n      if (this._elementsHaveApplied) {\n        // if custom elements have upgraded and there are no native css variables, we must recalculate the whole tree\n        this.styleDocument();\n      }\n    } else if (!this._documentOwnerStyleInfo.cssBuild) {\n      this._revalidateCustomStyleApplyShim(customStyles);\n    }\n    this._customStyleInterface['enqueued'] = false;\n  }\n  /**\n   * Apply styles for the given element\n   *\n   * @param {!HTMLElement} host\n   * @param {Object=} overrideProps\n   */\n  styleElement(host, overrideProps) {\n    if (disableRuntime) {\n      if (overrideProps) {\n        if (!StyleInfo.get(host)) {\n          StyleInfo.set(host, new StyleInfo(null));\n        }\n        const styleInfo = /** @type {!StyleInfo} */(StyleInfo.get(host));\n        this._mixOverrideStyleProps(styleInfo, overrideProps);\n        this.styleElementNativeVariables(host, styleInfo);\n      }\n      return;\n    }\n    const styleInfo = StyleInfo.get(host) || this._prepareHost(host);\n    // if there is no style info at this point, bail\n    if (!styleInfo) {\n      return;\n    }\n    // Only trip the `elementsHaveApplied` flag if a node other that the root document has `applyStyle` called\n    if (!this._isRootOwner(host)) {\n      this._elementsHaveApplied = true;\n    }\n    if (overrideProps) {\n      this._mixOverrideStyleProps(styleInfo, overrideProps);\n    }\n    if (!nativeCssVariables) {\n      this.styleElementShimVariables(host, styleInfo);\n    } else {\n      this.styleElementNativeVariables(host, styleInfo);\n    }\n  }\n  /**\n   * @param {!StyleInfo} styleInfo\n   * @param {Object} overrideProps\n   */\n  _mixOverrideStyleProps(styleInfo, overrideProps) {\n    styleInfo.overrideStyleProperties =\n      styleInfo.overrideStyleProperties || {};\n    Object.assign(styleInfo.overrideStyleProperties, overrideProps);\n  }\n  /**\n   * @param {!HTMLElement} host\n   * @param {!StyleInfo} styleInfo\n   */\n  styleElementShimVariables(host, styleInfo) {\n    this.flush();\n    this._updateProperties(host, styleInfo);\n    if (styleInfo.ownStylePropertyNames && styleInfo.ownStylePropertyNames.length) {\n      this._applyStyleProperties(host, styleInfo);\n    }\n  }\n  /**\n   * @param {!HTMLElement} host\n   * @param {!StyleInfo} styleInfo\n   */\n  styleElementNativeVariables(host, styleInfo) {\n    const { is } = StyleUtil.getIsExtends(host);\n    if (styleInfo.overrideStyleProperties) {\n      updateNativeProperties(host, styleInfo.overrideStyleProperties);\n    }\n    const template = templateMap[is];\n    // bail early if there is no shadowroot for this element\n    if (!template && !this._isRootOwner(host)) {\n      return;\n    }\n    // bail early if the template was built with polymer-css-build\n    if (template && StyleUtil.elementHasBuiltCss(template)) {\n      return;\n    }\n    if (template && template._style && !ApplyShimUtils.templateIsValid(template)) {\n      // update template\n      if (!ApplyShimUtils.templateIsValidating(template)) {\n        this._ensure();\n        this._applyShim && this._applyShim['transformRules'](template['_styleAst'], is);\n        template._style.textContent = StyleTransformer.elementStyles(host, styleInfo.styleRules);\n        ApplyShimUtils.startValidatingTemplate(template);\n      }\n      // update instance if native shadowdom\n      if (nativeShadow) {\n        let root = host.shadowRoot;\n        if (root) {\n          let style = root.querySelector('style');\n          if (style) {\n            style.textContent = StyleTransformer.elementStyles(host, styleInfo.styleRules);\n          }\n        }\n      }\n      styleInfo.styleRules = template['_styleAst'];\n    }\n  }\n  _styleOwnerForNode(node) {\n    let root = StyleUtil.wrap(node).getRootNode();\n    let host = root.host;\n    if (host) {\n      if (StyleInfo.get(host) || this._prepareHost(host)) {\n        return host;\n      } else {\n        return this._styleOwnerForNode(host);\n      }\n    }\n    return this._documentOwner;\n  }\n  _isRootOwner(node) {\n    return (node === this._documentOwner);\n  }\n  _applyStyleProperties(host, styleInfo) {\n    let is = StyleUtil.getIsExtends(host).is;\n    let cacheEntry = styleCache.fetch(is, styleInfo.styleProperties, styleInfo.ownStylePropertyNames);\n    let cachedScopeSelector = cacheEntry && cacheEntry.scopeSelector;\n    let cachedStyle = cacheEntry ? cacheEntry.styleElement : null;\n    let oldScopeSelector = styleInfo.scopeSelector;\n    // only generate new scope if cached style is not found\n    styleInfo.scopeSelector = cachedScopeSelector || this._generateScopeSelector(is);\n    let style = StyleProperties.applyElementStyle(host, styleInfo.styleProperties, styleInfo.scopeSelector, cachedStyle);\n    if (!nativeShadow) {\n      StyleProperties.applyElementScopeSelector(host, styleInfo.scopeSelector, oldScopeSelector);\n    }\n    if (!cacheEntry) {\n      styleCache.store(is, styleInfo.styleProperties, style, styleInfo.scopeSelector);\n    }\n    return style;\n  }\n  _updateProperties(host, styleInfo) {\n    let owner = this._styleOwnerForNode(host);\n    let ownerStyleInfo = StyleInfo.get(owner);\n    let ownerProperties = ownerStyleInfo.styleProperties;\n    // style owner has not updated properties yet\n    // go up the chain and force property update,\n    // except if the owner is the document\n    if (owner !== this._documentOwner && !ownerProperties) {\n      this._updateProperties(owner, ownerStyleInfo);\n      ownerProperties = ownerStyleInfo.styleProperties;\n    }\n    let props = Object.create(ownerProperties || null);\n    let hostAndRootProps = StyleProperties.hostAndRootPropertiesForScope(host, styleInfo.styleRules, styleInfo.cssBuild);\n    let propertyData = StyleProperties.propertyDataFromStyles(ownerStyleInfo.styleRules, host);\n    let propertiesMatchingHost = propertyData.properties\n    Object.assign(\n      props,\n      hostAndRootProps.hostProps,\n      propertiesMatchingHost,\n      hostAndRootProps.rootProps\n    );\n    this._mixinOverrideStyles(props, styleInfo.overrideStyleProperties);\n    StyleProperties.reify(props);\n    styleInfo.styleProperties = props;\n  }\n  _mixinOverrideStyles(props, overrides) {\n    for (let p in overrides) {\n      let v = overrides[p];\n      // skip override props if they are not truthy or 0\n      // in order to fall back to inherited values\n      if (v || v === 0) {\n        props[p] = v;\n      }\n    }\n  }\n  /**\n   * Update styles of the whole document\n   *\n   * @param {Object=} properties\n   */\n  styleDocument(properties) {\n    this.styleSubtree(this._documentOwner, properties);\n  }\n  /**\n   * Update styles of a subtree\n   *\n   * @param {!HTMLElement} host\n   * @param {Object=} properties\n   */\n  styleSubtree(host, properties) {\n    const wrappedHost = StyleUtil.wrap(host);\n    let root = wrappedHost.shadowRoot;\n    if (root || this._isRootOwner(host)) {\n      this.styleElement(host, properties);\n    }\n    // process the shadowdom children of `host`\n    let shadowChildren =\n        root && (/** @type {!ParentNode} */ (root).children || root.childNodes);\n    if (shadowChildren) {\n      for (let i = 0; i < shadowChildren.length; i++) {\n        let c = /** @type {!HTMLElement} */(shadowChildren[i]);\n        this.styleSubtree(c);\n      }\n    } else {\n      // process the lightdom children of `host`\n      let children = wrappedHost.children || wrappedHost.childNodes;\n      if (children) {\n        for (let i = 0; i < children.length; i++) {\n          let c = /** @type {!HTMLElement} */(children[i]);\n          this.styleSubtree(c);\n        }\n      }\n    }\n  }\n  /* Custom Style operations */\n  _revalidateCustomStyleApplyShim(customStyles) {\n    for (let i = 0; i < customStyles.length; i++) {\n      let c = customStyles[i];\n      let s = this._customStyleInterface['getStyleForCustomStyle'](c);\n      if (s) {\n        this._revalidateApplyShim(s);\n      }\n    }\n  }\n  _applyCustomStyles(customStyles) {\n    for (let i = 0; i < customStyles.length; i++) {\n      let c = customStyles[i];\n      let s = this._customStyleInterface['getStyleForCustomStyle'](c);\n      if (s) {\n        StyleProperties.applyCustomStyle(s, this._documentOwnerStyleInfo.styleProperties);\n      }\n    }\n  }\n  transformCustomStyleForDocument(style) {\n    const cssBuild = StyleUtil.getCssBuild(style);\n    if (cssBuild !== this._documentOwnerStyleInfo.cssBuild) {\n      this._documentOwnerStyleInfo.cssBuild = cssBuild;\n    }\n    if (StyleUtil.isOptimalCssBuild(cssBuild)) {\n      return;\n    }\n    let ast = StyleUtil.rulesForStyle(style);\n    StyleUtil.forEachRule(ast, (rule) => {\n      if (nativeShadow) {\n        StyleTransformer.normalizeRootSelector(rule);\n      } else {\n        StyleTransformer.documentRule(rule);\n      }\n      if (nativeCssVariables && cssBuild === '') {\n        this._ensure();\n        this._applyShim && this._applyShim['transformRule'](rule);\n      }\n    });\n    if (nativeCssVariables) {\n      style.textContent = StyleUtil.toCssText(ast);\n    } else {\n      this._documentOwnerStyleInfo.styleRules['rules'].push(ast);\n    }\n  }\n  _revalidateApplyShim(style) {\n    if (nativeCssVariables && this._applyShim) {\n      let ast = StyleUtil.rulesForStyle(style);\n      this._ensure();\n      this._applyShim['transformRules'](ast);\n      style.textContent = StyleUtil.toCssText(ast);\n    }\n  }\n  getComputedStyleValue(element, property) {\n    let value;\n    if (!nativeCssVariables) {\n      // element is either a style host, or an ancestor of a style host\n      let styleInfo = StyleInfo.get(element) || StyleInfo.get(this._styleOwnerForNode(element));\n      value = styleInfo.styleProperties[property];\n    }\n    // fall back to the property value from the computed styling\n    value = value || window.getComputedStyle(element).getPropertyValue(property);\n    // trim whitespace that can come after the `:` in css\n    // example: padding: 2px -> \" 2px\"\n    return value ? value.trim() : '';\n  }\n  // given an element and a classString, replaces\n  // the element's class with the provided classString and adds\n  // any necessary ShadyCSS static and property based scoping selectors\n  setElementClass(element, classString) {\n    let root = StyleUtil.wrap(element).getRootNode();\n    let classes = classString ? classString.split(/\\s/) : [];\n    let scopeName = root.host && root.host.localName;\n    // If no scope, try to discover scope name from existing class.\n    // This can occur if, for example, a template stamped element that\n    // has been scoped is manipulated when not in a root.\n    if (!scopeName) {\n      var classAttr = element.getAttribute('class');\n      if (classAttr) {\n        let k$ = classAttr.split(/\\s/);\n        for (let i=0; i < k$.length; i++) {\n          if (k$[i] === StyleTransformer.SCOPE_NAME) {\n            scopeName = k$[i+1];\n            break;\n          }\n        }\n      }\n    }\n    if (scopeName) {\n      classes.push(StyleTransformer.SCOPE_NAME, scopeName);\n    }\n    if (!nativeCssVariables) {\n      let styleInfo = StyleInfo.get(element);\n      if (styleInfo && styleInfo.scopeSelector) {\n        classes.push(StyleProperties.XSCOPE_NAME, styleInfo.scopeSelector);\n      }\n    }\n    StyleUtil.setElementClassRaw(element, classes.join(' '));\n  }\n  _styleInfoForNode(node) {\n    return StyleInfo.get(node);\n  }\n  /**\n   * @param {!Element} node\n   * @param {string} scope\n   */\n  scopeNode(node, scope) {\n    StyleTransformer.element(node, scope);\n  }\n  /**\n   * @param {!Element} node\n   * @param {string} scope\n   */\n  unscopeNode(node, scope) {\n    StyleTransformer.element(node, scope, true);\n  }\n  /**\n   * @param {!Node} node\n   * @return {string}\n   */\n  scopeForNode(node) {\n    return getOwnerScope(node);\n  }\n  /**\n   * @param {!Element} node\n   * @return {string}\n   */\n  currentScopeForNode(node) {\n    return getCurrentScope(node);\n  }\n}\n\n/* exports */\n/* eslint-disable no-self-assign */\nScopingShim.prototype['flush'] = ScopingShim.prototype.flush;\nScopingShim.prototype['prepareTemplate'] = ScopingShim.prototype.prepareTemplate;\nScopingShim.prototype['styleElement'] = ScopingShim.prototype.styleElement;\nScopingShim.prototype['styleDocument'] = ScopingShim.prototype.styleDocument;\nScopingShim.prototype['styleSubtree'] = ScopingShim.prototype.styleSubtree;\nScopingShim.prototype['getComputedStyleValue'] = ScopingShim.prototype.getComputedStyleValue;\nScopingShim.prototype['setElementClass'] = ScopingShim.prototype.setElementClass;\nScopingShim.prototype['_styleInfoForNode'] = ScopingShim.prototype._styleInfoForNode;\nScopingShim.prototype['transformCustomStyleForDocument'] = ScopingShim.prototype.transformCustomStyleForDocument;\nScopingShim.prototype['getStyleAst'] = ScopingShim.prototype.getStyleAst;\nScopingShim.prototype['styleAstToString'] = ScopingShim.prototype.styleAstToString;\nScopingShim.prototype['flushCustomStyles'] = ScopingShim.prototype.flushCustomStyles;\nScopingShim.prototype['scopeNode'] = ScopingShim.prototype.scopeNode;\nScopingShim.prototype['unscopeNode'] = ScopingShim.prototype.unscopeNode;\nScopingShim.prototype['scopeForNode'] = ScopingShim.prototype.scopeForNode;\nScopingShim.prototype['currentScopeForNode'] = ScopingShim.prototype.currentScopeForNode;\nScopingShim.prototype['prepareAdoptedCssText'] = ScopingShim.prototype.prepareAdoptedCssText;\n/* eslint-enable no-self-assign */\nObject.defineProperties(ScopingShim.prototype, {\n  'nativeShadow': {\n    get() {\n      return nativeShadow;\n    }\n  },\n  'nativeCss': {\n    get() {\n      return nativeCssVariables;\n    }\n  }\n});\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {nativeShadow} from './style-settings.js';\nimport StyleTransformer from './style-transformer.js';\nimport {getIsExtends, elementHasBuiltCss, wrap} from './style-util.js';\n\nexport let flush = function() {};\n\n/**\n * @param {!Element} element\n * @return {string}\n */\nfunction getClasses(element) {\n  if (element.classList && element.classList.value) {\n    return element.classList.value;\n  } else {\n    // NOTE: className is patched to remove scoping classes in ShadyDOM\n    // use getAttribute('class') instead, which is unpatched\n    return element.getAttribute('class') || '';\n  }\n}\n\nconst scopeRegExp = new RegExp(`${StyleTransformer.SCOPE_NAME}\\\\s*([^\\\\s]*)`);\n\n/**\n * @param {!Element} element\n * @return {string}\n */\nexport function getCurrentScope(element) {\n  const match = getClasses(element).match(scopeRegExp);\n  if (match) {\n    return match[1];\n  } else {\n    return '';\n  }\n}\n\n/**\n * @param {!Node} node\n */\nexport function getOwnerScope(node) {\n  const ownerRoot = wrap(node).getRootNode();\n  if (ownerRoot === node || ownerRoot === node.ownerDocument) {\n    return '';\n  }\n  const host = /** @type {!ShadowRoot} */(ownerRoot).host;\n  if (!host) {\n    // this may actually be a document fragment\n    return '';\n  }\n  return getIsExtends(host).is;\n}\n\n/**\n * @param {!Element} element\n */\nexport function ensureCorrectScope(element) {\n  const currentScope = getCurrentScope(element);\n  const ownerRoot = wrap(element).getRootNode();\n  if (ownerRoot === element) {\n    return;\n  }\n  if (currentScope && ownerRoot === element.ownerDocument) {\n    // node was scoped, but now is in document\n    StyleTransformer.domRemoveScope(element, currentScope);\n  } else if (ownerRoot instanceof ShadowRoot) {\n    const ownerScope = getOwnerScope(element);\n    if (ownerScope !== currentScope) {\n      // node was scoped, but not by its current owner\n      StyleTransformer.domReplaceScope(element, currentScope, ownerScope);\n    }\n  }\n}\n\n/**\n * @param {!HTMLElement|!HTMLDocument} element\n */\nexport function ensureCorrectSubtreeScoping(element) {\n  // find unscoped subtree nodes\n  const unscopedNodes = window['ShadyDOM']['nativeMethods']['querySelectorAll'].call(\n    element, `:not(.${StyleTransformer.SCOPE_NAME})`);\n\n  for (let j = 0; j < unscopedNodes.length; j++) {\n    // it's possible, during large batch inserts, that nodes that aren't\n    // scoped within the current scope were added.\n    // To make sure that any unscoped nodes that were inserted in the current batch are correctly styled,\n    // query all unscoped nodes and force their style-scope to be applied.\n    // This could happen if a sub-element appended an unscoped node in its shadowroot and this function\n    // runs on a parent element of the host of that unscoped node:\n    // parent-element -> element -> unscoped node\n    // Here unscoped node should have the style-scope element, not parent-element.\n    const unscopedNode = unscopedNodes[j];\n    const scopeForPreviouslyUnscopedNode = getOwnerScope(unscopedNode);\n    if (scopeForPreviouslyUnscopedNode) {\n      StyleTransformer.element(unscopedNode, scopeForPreviouslyUnscopedNode);\n    }\n  }\n}\n\n/**\n * @param {HTMLElement} el\n * @return {boolean}\n */\nfunction isElementWithBuiltCss(el) {\n  if (el.localName === 'style' || el.localName === 'template') {\n    return elementHasBuiltCss(el);\n  }\n  return false;\n}\n\n/**\n * @param {Array<MutationRecord|null>|null} mxns\n */\nfunction handler(mxns) {\n  for (let x=0; x < mxns.length; x++) {\n    let mxn = mxns[x];\n    if (mxn.target === document.documentElement ||\n      mxn.target === document.head) {\n      continue;\n    }\n    for (let i=0; i < mxn.addedNodes.length; i++) {\n      let n = mxn.addedNodes[i];\n      if (n.nodeType !== Node.ELEMENT_NODE) {\n        continue;\n      }\n      n = /** @type {HTMLElement} */(n); // eslint-disable-line no-self-assign\n      let root = n.getRootNode();\n      let currentScope = getCurrentScope(n);\n      // node was scoped, but now is in document\n      // If this element has built css, we must not remove scoping as this node\n      // will be used as a template or style without re - applying scoping as an optimization\n      if (currentScope && root === n.ownerDocument && !isElementWithBuiltCss(n)) {\n        StyleTransformer.domRemoveScope(n, currentScope);\n      } else if (root instanceof ShadowRoot) {\n        const newScope = getOwnerScope(n);\n        // rescope current node and subtree if necessary\n        if (newScope !== currentScope) {\n          StyleTransformer.domReplaceScope(n, currentScope, newScope);\n        }\n        // make sure all the subtree elements are scoped correctly\n        ensureCorrectSubtreeScoping(n);\n      }\n    }\n  }\n}\n\n// if native Shadow DOM is being used, or ShadyDOM handles dynamic scoiping, do not activate the MutationObserver\nif (!nativeShadow && !(window['ShadyDOM'] && window['ShadyDOM']['handlesDynamicScoping'])) {\n  let observer = new MutationObserver(handler);\n  let start = (node) => {\n    observer.observe(node, {childList: true, subtree: true});\n  }\n  let nativeCustomElements = (window['customElements'] &&\n    !window['customElements']['polyfillWrapFlushCallback']);\n  // need to start immediately with native custom elements\n  // TODO(dfreedm): with polyfilled HTMLImports and native custom elements\n  // excessive mutations may be observed; this can be optimized via cooperation\n  // with the HTMLImports polyfill.\n  if (nativeCustomElements) {\n    start(document);\n  } else {\n    let delayedStart = () => {\n      start(document.body);\n    }\n    // use polyfill timing if it's available\n    if (window['HTMLImports']) {\n      window['HTMLImports']['whenReady'](delayedStart);\n    // otherwise push beyond native imports being ready\n    // which requires RAF + readystate interactive.\n    } else {\n      requestAnimationFrame(function() {\n        if (document.readyState === 'loading') {\n          let listener = function() {\n            delayedStart();\n            document.removeEventListener('readystatechange', listener);\n          }\n          document.addEventListener('readystatechange', listener);\n        } else {\n          delayedStart();\n        }\n      });\n    }\n  }\n\n  flush = function() {\n    handler(observer.takeRecords());\n  }\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {removeCustomPropAssignment, StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\nimport {nativeShadow} from './style-settings.js';\nimport StyleTransformer from './style-transformer.js';\nimport * as StyleUtil from './style-util.js';\nimport * as RX from './common-regex.js';\nimport StyleInfo from './style-info.js';\n\n// TODO: dedupe with shady\n/**\n * @param {string} selector\n * @return {boolean}\n * @this {Element}\n */\nconst matchesSelector = function(selector) {\n  const method = this.matches || this.matchesSelector ||\n    this.mozMatchesSelector || this.msMatchesSelector ||\n    this.oMatchesSelector || this.webkitMatchesSelector;\n  return method && method.call(this, selector);\n};\n\nconst IS_IE = navigator.userAgent.match('Trident');\n\nconst XSCOPE_NAME = 'x-scope';\n\nclass StyleProperties {\n  get XSCOPE_NAME() {\n    return XSCOPE_NAME;\n  }\n/**\n * decorates styles with rule info and returns an array of used style property names\n *\n * @param {StyleNode} rules\n * @return {Array<string>}\n */\n  decorateStyles(rules) {\n    let self = this, props = {}, keyframes = [], ruleIndex = 0;\n    StyleUtil.forEachRule(rules, function(rule) {\n      self.decorateRule(rule);\n      // mark in-order position of ast rule in styles block, used for cache key\n      rule.index = ruleIndex++;\n      self.collectPropertiesInCssText(rule.propertyInfo.cssText, props);\n    }, function onKeyframesRule(rule) {\n      keyframes.push(rule);\n    });\n    // Cache all found keyframes rules for later reference:\n    rules._keyframes = keyframes;\n    // return this list of property names *consumes* in these styles.\n    let names = [];\n    for (let i in props) {\n      names.push(i);\n    }\n    return names;\n  }\n\n  // decorate a single rule with property info\n  decorateRule(rule) {\n    if (rule.propertyInfo) {\n      return rule.propertyInfo;\n    }\n    let info = {}, properties = {};\n    let hasProperties = this.collectProperties(rule, properties);\n    if (hasProperties) {\n      info.properties = properties;\n      // TODO(sorvell): workaround parser seeing mixins as additional rules\n      rule['rules'] = null;\n    }\n    info.cssText = this.collectCssText(rule);\n    rule.propertyInfo = info;\n    return info;\n  }\n\n  // collects the custom properties from a rule's cssText\n  collectProperties(rule, properties) {\n    let info = rule.propertyInfo;\n    if (info) {\n      if (info.properties) {\n        Object.assign(properties, info.properties);\n        return true;\n      }\n    } else {\n      let m, rx = RX.VAR_ASSIGN;\n      let cssText = rule['parsedCssText'];\n      let value;\n      let any;\n      while ((m = rx.exec(cssText))) {\n        // note: group 2 is var, 3 is mixin\n        value = (m[2] || m[3]).trim();\n        // value of 'inherit' or 'unset' is equivalent to not setting the property here\n        if (value !== 'inherit' || value !== 'unset') {\n          properties[m[1].trim()] = value;\n        }\n        any = true;\n      }\n      return any;\n    }\n\n  }\n\n  // returns cssText of properties that consume variables/mixins\n  collectCssText(rule) {\n    return this.collectConsumingCssText(rule['parsedCssText']);\n  }\n\n  // NOTE: we support consumption inside mixin assignment\n  // but not production, so strip out {...}\n  collectConsumingCssText(cssText) {\n    return cssText.replace(RX.BRACKETED, '')\n      .replace(RX.VAR_ASSIGN, '');\n  }\n\n  collectPropertiesInCssText(cssText, props) {\n    let m;\n    while ((m = RX.VAR_CONSUMED.exec(cssText))) {\n      let name = m[1];\n      // This regex catches all variable names, and following non-whitespace char\n      // If next char is not ':', then variable is a consumer\n      if (m[2] !== ':') {\n        props[name] = true;\n      }\n    }\n  }\n\n  // turns custom properties into realized values.\n  reify(props) {\n    // big perf optimization here: reify only *own* properties\n    // since this object has __proto__ of the element's scope properties\n    let names = Object.getOwnPropertyNames(props);\n    for (let i=0, n; i < names.length; i++) {\n      n = names[i];\n      props[n] = this.valueForProperty(props[n], props);\n    }\n  }\n\n  // given a property value, returns the reified value\n  // a property value may be:\n  // (1) a literal value like: red or 5px;\n  // (2) a variable value like: var(--a), var(--a, red), or var(--a, --b) or\n  // var(--a, var(--b));\n  // (3) a literal mixin value like { properties }. Each of these properties\n  // can have values that are: (a) literal, (b) variables, (c) @apply mixins.\n  valueForProperty(property, props) {\n    // case (1) default\n    // case (3) defines a mixin and we have to reify the internals\n    if (property) {\n      if (property.indexOf(';') >=0) {\n        property = this.valueForProperties(property, props);\n      } else {\n        // case (2) variable\n        let self = this;\n        let fn = function(prefix, value, fallback, suffix) {\n          if (!value) {\n            return prefix + suffix;\n          }\n          let propertyValue = self.valueForProperty(props[value], props);\n          // if value is \"initial\", then the variable should be treated as unset\n          if (!propertyValue || propertyValue === 'initial') {\n            // fallback may be --a or var(--a) or literal\n            propertyValue = self.valueForProperty(props[fallback] || fallback, props) ||\n            fallback;\n          } else if (propertyValue === 'apply-shim-inherit') {\n            // CSS build will replace `inherit` with `apply-shim-inherit`\n            // for use with native css variables.\n            // Since we have full control, we can use `inherit` directly.\n            propertyValue = 'inherit';\n          }\n          return prefix + (propertyValue || '') + suffix;\n        };\n        property = StyleUtil.processVariableAndFallback(property, fn);\n      }\n    }\n    return property && property.trim() || '';\n  }\n\n  // note: we do not yet support mixin within mixin\n  valueForProperties(property, props) {\n    let parts = property.split(';');\n    for (let i=0, p, m; i<parts.length; i++) {\n      if ((p = parts[i])) {\n        RX.MIXIN_MATCH.lastIndex = 0;\n        m = RX.MIXIN_MATCH.exec(p);\n        if (m) {\n          p = this.valueForProperty(props[m[1]], props);\n        } else {\n          let colon = p.indexOf(':');\n          if (colon !== -1) {\n            let pp = p.substring(colon);\n            pp = pp.trim();\n            pp = this.valueForProperty(pp, props) || pp;\n            p = p.substring(0, colon) + pp;\n          }\n        }\n        parts[i] = (p && p.lastIndexOf(';') === p.length - 1) ?\n          // strip trailing ;\n          p.slice(0, -1) :\n          p || '';\n      }\n    }\n    return parts.join(';');\n  }\n\n  applyProperties(rule, props) {\n    let output = '';\n    // dynamically added sheets may not be decorated so ensure they are.\n    if (!rule.propertyInfo) {\n      this.decorateRule(rule);\n    }\n    if (rule.propertyInfo.cssText) {\n      output = this.valueForProperties(rule.propertyInfo.cssText, props);\n    }\n    rule['cssText'] = output;\n  }\n\n  // Apply keyframe transformations to the cssText of a given rule. The\n  // keyframeTransforms object is a map of keyframe names to transformer\n  // functions which take in cssText and spit out transformed cssText.\n  applyKeyframeTransforms(rule, keyframeTransforms) {\n    let input = rule['cssText'];\n    let output = rule['cssText'];\n    if (rule.hasAnimations == null) {\n      // Cache whether or not the rule has any animations to begin with:\n      rule.hasAnimations = RX.ANIMATION_MATCH.test(input);\n    }\n    // If there are no animations referenced, we can skip transforms:\n    if (rule.hasAnimations) {\n      let transform;\n      // If we haven't transformed this rule before, we iterate over all\n      // transforms:\n      if (rule.keyframeNamesToTransform == null) {\n        rule.keyframeNamesToTransform = [];\n        for (let keyframe in keyframeTransforms) {\n          transform = keyframeTransforms[keyframe];\n          output = transform(input);\n          // If the transform actually changed the CSS text, we cache the\n          // transform name for future use:\n          if (input !== output) {\n            input = output;\n            rule.keyframeNamesToTransform.push(keyframe);\n          }\n        }\n      } else {\n        // If we already have a list of keyframe names that apply to this\n        // rule, we apply only those keyframe name transforms:\n        for (let i = 0; i < rule.keyframeNamesToTransform.length; ++i) {\n          transform = keyframeTransforms[rule.keyframeNamesToTransform[i]];\n          input = transform(input);\n        }\n        output = input;\n      }\n    }\n    rule['cssText'] = output;\n  }\n\n  // Test if the rules in these styles matches the given `element` and if so,\n  // collect any custom properties into `props`.\n  /**\n   * @param {StyleNode} rules\n   * @param {Element} element\n   */\n  propertyDataFromStyles(rules, element) {\n    let props = {};\n    // generates a unique key for these matches\n    let o = [];\n    // note: active rules excludes non-matching @media rules\n    StyleUtil.forEachRule(rules, (rule) => {\n      // TODO(sorvell): we could trim the set of rules at declaration\n      // time to only include ones that have properties\n      if (!rule.propertyInfo) {\n        this.decorateRule(rule);\n      }\n      // match element against transformedSelector: selector may contain\n      // unwanted uniquification and parsedSelector does not directly match\n      // for :host selectors.\n      let selectorToMatch = rule.transformedSelector || rule['parsedSelector'];\n      if (element && rule.propertyInfo.properties && selectorToMatch) {\n        if (matchesSelector.call(element, selectorToMatch)) {\n          this.collectProperties(rule, props);\n          // produce numeric key for these matches for lookup\n          addToBitMask(rule.index, o);\n        }\n      }\n    }, null, true);\n    return {properties: props, key: o};\n  }\n\n  /**\n   * @param {Element} scope\n   * @param {StyleNode} rule\n   * @param {string} cssBuild\n   * @param {function(Object)} callback\n   */\n  whenHostOrRootRule(scope, rule, cssBuild, callback) {\n    if (!rule.propertyInfo) {\n      this.decorateRule(rule);\n    }\n    if (!rule.propertyInfo.properties) {\n      return;\n    }\n    let {is, typeExtension} = StyleUtil.getIsExtends(scope);\n    let hostScope = is ?\n      StyleTransformer._calcHostScope(is, typeExtension) :\n      'html';\n    let parsedSelector = rule['parsedSelector'];\n    let isRoot = (parsedSelector === ':host > *' || parsedSelector === 'html');\n    let isHost = parsedSelector.indexOf(':host') === 0 && !isRoot;\n    // build info is either in scope (when scope is an element) or in the style\n    // when scope is the default scope; note: this allows default scope to have\n    // mixed mode built and unbuilt styles.\n    if (cssBuild === 'shady') {\n      // :root -> x-foo > *.x-foo for elements and html for custom-style\n      isRoot = parsedSelector === (hostScope + ' > *.' + hostScope) || parsedSelector.indexOf('html') !== -1;\n      // :host -> x-foo for elements, but sub-rules have .x-foo in them\n      isHost = !isRoot && parsedSelector.indexOf(hostScope) === 0;\n    }\n    if (!isRoot && !isHost) {\n      return;\n    }\n    let selectorToMatch = hostScope;\n    if (isHost) {\n      // need to transform :host because `:host` does not work with `matches`\n      if (!rule.transformedSelector) {\n        // transform :host into a matchable selector\n        rule.transformedSelector =\n        StyleTransformer._transformRuleCss(\n          rule,\n          StyleTransformer._transformComplexSelector,\n          StyleTransformer._calcElementScope(is),\n          hostScope\n        );\n      }\n      selectorToMatch = rule.transformedSelector || hostScope;\n    }\n    callback({\n      selector: selectorToMatch,\n      isHost: isHost,\n      isRoot: isRoot\n    });\n  }\n/**\n * @param {Element} scope\n * @param {StyleNode} rules\n * @param {string} cssBuild\n * @return {Object}\n */\n  hostAndRootPropertiesForScope(scope, rules, cssBuild) {\n    let hostProps = {}, rootProps = {};\n    // note: active rules excludes non-matching @media rules\n    StyleUtil.forEachRule(rules, (rule) => {\n      // if scope is StyleDefaults, use _element for matchesSelector\n      this.whenHostOrRootRule(scope, rule, cssBuild, (info) => {\n        let element = scope._element || scope;\n        if (matchesSelector.call(element, info.selector)) {\n          if (info.isHost) {\n            this.collectProperties(rule, hostProps);\n          } else {\n            this.collectProperties(rule, rootProps);\n          }\n        }\n      });\n    }, null, true);\n    return {rootProps: rootProps, hostProps: hostProps};\n  }\n\n  /**\n   * @param {Element} element\n   * @param {Object} properties\n   * @param {string} scopeSelector\n   */\n  transformStyles(element, properties, scopeSelector) {\n    let self = this;\n    let {is, typeExtension} = StyleUtil.getIsExtends(element);\n    let hostSelector = StyleTransformer\n      ._calcHostScope(is, typeExtension);\n    let rxHostSelector = element.extends ?\n      '\\\\' + hostSelector.slice(0, -1) + '\\\\]' :\n      hostSelector;\n    let hostRx = new RegExp(RX.HOST_PREFIX + rxHostSelector +\n      RX.HOST_SUFFIX);\n    let {styleRules: rules, cssBuild} = StyleInfo.get(element);\n    let keyframeTransforms =\n      this._elementKeyframeTransforms(element, rules, scopeSelector);\n    return StyleTransformer.elementStyles(element, rules, function(rule) {\n      self.applyProperties(rule, properties);\n      if (!nativeShadow &&\n          !StyleUtil.isKeyframesSelector(rule) &&\n          rule['cssText']) {\n        // NOTE: keyframe transforms only scope munge animation names, so it\n        // is not necessary to apply them in ShadowDOM.\n        self.applyKeyframeTransforms(rule, keyframeTransforms);\n        self._scopeSelector(rule, hostRx, hostSelector, scopeSelector);\n      }\n    }, cssBuild);\n  }\n\n  /**\n   * @param {Element} element\n   * @param {StyleNode} rules\n   * @param {string} scopeSelector\n   * @return {Object}\n   */\n  _elementKeyframeTransforms(element, rules, scopeSelector) {\n    let keyframesRules = rules._keyframes;\n    let keyframeTransforms = {};\n    if (!nativeShadow && keyframesRules) {\n      // For non-ShadowDOM, we transform all known keyframes rules in\n      // advance for the current scope. This allows us to catch keyframes\n      // rules that appear anywhere in the stylesheet:\n      for (let i = 0, keyframesRule = keyframesRules[i];\n           i < keyframesRules.length;\n           keyframesRule = keyframesRules[++i]) {\n        this._scopeKeyframes(keyframesRule, scopeSelector);\n        keyframeTransforms[keyframesRule['keyframesName']] =\n            this._keyframesRuleTransformer(keyframesRule);\n      }\n    }\n    return keyframeTransforms;\n  }\n\n  // Generate a factory for transforming a chunk of CSS text to handle a\n  // particular scoped keyframes rule.\n  /**\n   * @param {StyleNode} keyframesRule\n   * @return {function(string):string}\n   */\n  _keyframesRuleTransformer(keyframesRule) {\n    return function(cssText) {\n      return cssText.replace(\n          keyframesRule.keyframesNameRx,\n          keyframesRule.transformedKeyframesName);\n    };\n  }\n\n/**\n * Transforms `@keyframes` names to be unique for the current host.\n * Example: @keyframes foo-anim -> @keyframes foo-anim-x-foo-0\n *\n * @param {StyleNode} rule\n * @param {string} scopeId\n */\n  _scopeKeyframes(rule, scopeId) {\n    // Animation names are of the form [\\w-], so ensure that the name regex does not partially apply\n    // to similarly named keyframe names by checking for a word boundary at the beginning and\n    // a non-word boundary or `-` at the end.\n    rule.keyframesNameRx = new RegExp(`\\\\b${rule['keyframesName']}(?!\\\\B|-)`, 'g');\n    rule.transformedKeyframesName = rule['keyframesName'] + '-' + scopeId;\n    rule.transformedSelector = rule.transformedSelector || rule['selector'];\n    rule['selector'] = rule.transformedSelector.replace(\n        rule['keyframesName'], rule.transformedKeyframesName);\n  }\n\n  // Strategy: x scope shim a selector e.g. to scope `.x-foo-42` (via classes):\n  // non-host selector: .a.x-foo -> .x-foo-42 .a.x-foo\n  // host selector: x-foo.wide -> .x-foo-42.wide\n  // note: we use only the scope class (.x-foo-42) and not the hostSelector\n  // (x-foo) to scope :host rules; this helps make property host rules\n  // have low specificity. They are overrideable by class selectors but,\n  // unfortunately, not by type selectors (e.g. overriding via\n  // `.special` is ok, but not by `x-foo`).\n  /**\n   * @param {StyleNode} rule\n   * @param {RegExp} hostRx\n   * @param {string} hostSelector\n   * @param {string} scopeId\n   */\n  _scopeSelector(rule, hostRx, hostSelector, scopeId) {\n    rule.transformedSelector = rule.transformedSelector || rule['selector'];\n    let selector = rule.transformedSelector;\n    let scope = '.' + scopeId;\n    let parts = StyleUtil.splitSelectorList(selector);\n    for (let i=0, l=parts.length, p; (i<l) && (p=parts[i]); i++) {\n      parts[i] = p.match(hostRx) ?\n        p.replace(hostSelector, scope) :\n        scope + ' ' + p;\n    }\n    rule['selector'] = parts.join(',');\n  }\n\n  /**\n   * @param {Element} element\n   * @param {string} selector\n   * @param {string} old\n   */\n  applyElementScopeSelector(element, selector, old) {\n    let c = element.getAttribute('class') || '';\n    let v = c;\n    if (old) {\n      v = c.replace(\n        new RegExp('\\\\s*' + XSCOPE_NAME + '\\\\s*' + old + '\\\\s*', 'g'), ' ');\n    }\n    v += (v ? ' ' : '') + XSCOPE_NAME + ' ' + selector;\n    if (c !== v) {\n      StyleUtil.setElementClassRaw(element, v);\n    }\n  }\n\n  /**\n   * @param {HTMLElement} element\n   * @param {Object} properties\n   * @param {string} selector\n   * @param {HTMLStyleElement} style\n   * @return {HTMLStyleElement}\n   */\n  applyElementStyle(element, properties, selector, style) {\n    // calculate cssText to apply\n    let cssText = style ? style.textContent || '' :\n      this.transformStyles(element, properties, selector);\n    // if shady and we have a cached style that is not style, decrement\n    let styleInfo = StyleInfo.get(element);\n    let s = styleInfo.customStyle;\n    if (s && !nativeShadow && (s !== style)) {\n      s['_useCount']--;\n      if (s['_useCount'] <= 0 && s.parentNode) {\n        s.parentNode.removeChild(s);\n      }\n    }\n    // apply styling always under native or if we generated style\n    // or the cached style is not in document(!)\n    if (nativeShadow) {\n      // update existing style only under native\n      if (styleInfo.customStyle) {\n        styleInfo.customStyle.textContent = cssText;\n        style = styleInfo.customStyle;\n      // otherwise, if we have css to apply, do so\n      } else if (cssText) {\n        // apply css after the scope style of the element to help with\n        // style precedence rules.\n        style = StyleUtil.applyCss(cssText, selector, element.shadowRoot,\n          styleInfo.placeholder);\n      }\n    } else {\n      // shady and no cache hit\n      if (!style) {\n        // apply css after the scope style of the element to help with\n        // style precedence rules.\n        if (cssText) {\n          style = StyleUtil.applyCss(cssText, selector, null,\n            styleInfo.placeholder);\n        }\n      // shady and cache hit but not in document\n      } else if (!style.parentNode) {\n        if (IS_IE && cssText.indexOf('@media') > -1) {\n            // @media rules may be stale in IE 10 and 11\n            // refresh the text content of the style to revalidate them.\n          style.textContent = cssText;\n        }\n        StyleUtil.applyStyle(style, null, styleInfo.placeholder);\n      }\n    }\n    // ensure this style is our custom style and increment its use count.\n    if (style) {\n      style['_useCount'] = style['_useCount'] || 0;\n      // increment use count if we changed styles\n      if (styleInfo.customStyle != style) {\n        style['_useCount']++;\n      }\n      styleInfo.customStyle = style;\n    }\n    return style;\n  }\n\n  /**\n   * @param {Element} style\n   * @param {Object} properties\n   */\n  applyCustomStyle(style, properties) {\n    let rules = StyleUtil.rulesForStyle(/** @type {HTMLStyleElement} */(style));\n    let self = this;\n    style.textContent = StyleUtil.toCssText(rules, function(/** StyleNode */rule) {\n      let css = rule['cssText'] = rule['parsedCssText'];\n      if (rule.propertyInfo && rule.propertyInfo.cssText) {\n        // remove property assignments\n        // so next function isn't confused\n        // NOTE: we have 3 categories of css:\n        // (1) normal properties,\n        // (2) custom property assignments (--foo: red;),\n        // (3) custom property usage: border: var(--foo); @apply(--foo);\n        // In elements, 1 and 3 are separated for efficiency; here they\n        // are not and this makes this case unique.\n        css = removeCustomPropAssignment(/** @type {string} */(css));\n        // replace with reified properties, scenario is same as mixin\n        rule['cssText'] = self.valueForProperties(css, properties);\n      }\n    });\n  }\n}\n\n/**\n * @param {number} n\n * @param {Array<number>} bits\n */\nfunction addToBitMask(n, bits) {\n  let o = parseInt(n / 32, 10);\n  let v = 1 << (n % 32);\n  bits[o] = (bits[o] || 0) | v;\n}\n\nexport default new StyleProperties();","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\n\n/** @const {string} */\nconst infoKey = '__styleInfo';\n\nexport default class StyleInfo {\n  /**\n   * @param {Element} node\n   * @return {StyleInfo}\n   */\n  static get(node) {\n    if (node) {\n      return node[infoKey];\n    } else {\n      return null;\n    }\n  }\n  /**\n   * @param {!Element} node\n   * @param {StyleInfo} styleInfo\n   * @return {StyleInfo}\n   */\n  static set(node, styleInfo) {\n    node[infoKey] = styleInfo;\n    return styleInfo;\n  }\n  /**\n   * @param {StyleNode} ast\n   * @param {Node=} placeholder\n   * @param {Array<string>=} ownStylePropertyNames\n   * @param {string=} elementName\n   * @param {string=} typeExtension\n   * @param {string=} cssBuild\n   */\n  constructor(ast, placeholder, ownStylePropertyNames, elementName, typeExtension, cssBuild) {\n    /** @type {StyleNode} */\n    this.styleRules = ast || null;\n    /** @type {Node} */\n    this.placeholder = placeholder || null;\n    /** @type {!Array<string>} */\n    this.ownStylePropertyNames = ownStylePropertyNames || [];\n    /** @type {Object} */\n    this.overrideStyleProperties = null;\n    /** @type {string} */\n    this.elementName = elementName || '';\n    /** @type {string} */\n    this.cssBuild = cssBuild || '';\n    /** @type {string} */\n    this.typeExtension = typeExtension || '';\n    /** @type {Object<string, string>} */\n    this.styleProperties = null;\n    /** @type {?string} */\n    this.scopeSelector = null;\n    /** @type {HTMLStyleElement} */\n    this.customStyle = null;\n  }\n  _getStyleRules() {\n    return this.styleRules;\n  }\n}\n\n/* eslint-disable-next-line no-self-assign */\nStyleInfo.prototype['_getStyleRules'] = StyleInfo.prototype._getStyleRules;\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {applyStylePlaceHolder} from './style-util.js';\nimport {nativeShadow, disableRuntime} from './style-settings.js';\n\n/** @type {!Object<string, !Node>} */\nconst placeholderMap = {};\n\n/**\n * @param {string} elementName\n * @return {Node}\n */\nexport function getStylePlaceholder(elementName) {\n  return placeholderMap[elementName] || null;\n}\n\n/**\n * @param {string} elementName\n */\nexport function ensureStylePlaceholder(elementName) {\n  if (!placeholderMap[elementName]) {\n    placeholderMap[elementName] = applyStylePlaceHolder(elementName);\n  }\n}\n\n/**\n * @const {CustomElementRegistry}\n */\nconst ce = window['customElements'];\nif (ce && !nativeShadow && !disableRuntime) {\n  /**\n   * @const {function(this:CustomElementRegistry, string,function(new:HTMLElement),{extends: string}=)}\n   */\n  const origDefine = ce['define'];\n  /**\n   * @param {string} name\n   * @param {function(new:HTMLElement)} clazz\n   * @param {{extends: string}=} options\n   */\n  const wrappedDefine = (name, clazz, options) => {\n    ensureStylePlaceholder(name);\n    origDefine.call(/** @type {!CustomElementRegistry} */(ce), name, clazz, options);\n  };\n  ce['define'] = wrappedDefine;\n}","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n'use strict';\n\nexport default class StyleCache {\n  constructor(typeMax = 100) {\n    // map element name -> [{properties, styleElement, scopeSelector}]\n    this.cache = {};\n    /** @type {number} */\n    this.typeMax = typeMax;\n  }\n\n  _validate(cacheEntry, properties, ownPropertyNames) {\n    for (let idx = 0; idx < ownPropertyNames.length; idx++) {\n      let pn = ownPropertyNames[idx];\n      if (cacheEntry.properties[pn] !== properties[pn]) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  store(tagname, properties, styleElement, scopeSelector) {\n    let list = this.cache[tagname] || [];\n    list.push({properties, styleElement, scopeSelector});\n    if (list.length > this.typeMax) {\n      list.shift();\n    }\n    this.cache[tagname] = list;\n  }\n\n  fetch(tagname, properties, ownPropertyNames) {\n    let list = this.cache[tagname];\n    if (!list) {\n      return;\n    }\n    // reverse list for most-recent lookups\n    for (let idx = list.length - 1; idx >= 0; idx--) {\n      let entry = list[idx];\n      if (this._validate(entry, properties, ownPropertyNames)) {\n        return entry;\n      }\n    }\n  }\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\n/**\n * @const {!Object<string, !HTMLTemplateElement>}\n */\nconst templateMap = {};\nexport default templateMap;\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\nimport templateMap from './template-map.js';\nimport {StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\n\n/*\n * Utilities for handling invalidating apply-shim mixins for a given template.\n *\n * The invalidation strategy involves keeping track of the \"current\" version of a template's mixins, and updating that count when a mixin is invalidated.\n * The template\n */\n\n/** @const {string} */\nconst CURRENT_VERSION = '_applyShimCurrentVersion';\n\n/** @const {string} */\nconst NEXT_VERSION = '_applyShimNextVersion';\n\n/** @const {string} */\nconst VALIDATING_VERSION = '_applyShimValidatingVersion';\n\n/**\n * @const {Promise<void>}\n */\nconst promise = Promise.resolve();\n\n/**\n * @param {string} elementName\n */\nexport function invalidate(elementName){\n  let template = templateMap[elementName];\n  if (template) {\n    invalidateTemplate(template);\n  }\n}\n\n/**\n * This function can be called multiple times to mark a template invalid\n * and signal that the style inside must be regenerated.\n *\n * Use `startValidatingTemplate` to begin an asynchronous validation cycle.\n * During that cycle, call `templateIsValidating` to see if the template must\n * be revalidated\n * @param {HTMLTemplateElement} template\n */\nexport function invalidateTemplate(template) {\n  // default the current version to 0\n  template[CURRENT_VERSION] = template[CURRENT_VERSION] || 0;\n  // ensure the \"validating for\" flag exists\n  template[VALIDATING_VERSION] = template[VALIDATING_VERSION] || 0;\n  // increment the next version\n  template[NEXT_VERSION] = (template[NEXT_VERSION] || 0) + 1;\n}\n\n/**\n * @param {string} elementName\n * @return {boolean}\n */\nexport function isValid(elementName) {\n  let template = templateMap[elementName];\n  if (template) {\n    return templateIsValid(template);\n  }\n  return true;\n}\n\n/**\n * @param {HTMLTemplateElement} template\n * @return {boolean}\n */\nexport function templateIsValid(template) {\n  return template[CURRENT_VERSION] === template[NEXT_VERSION];\n}\n\n/**\n * @param {string} elementName\n * @return {boolean}\n */\nexport function isValidating(elementName) {\n  let template = templateMap[elementName];\n  if (template) {\n    return templateIsValidating(template);\n  }\n  return false;\n}\n\n/**\n * Returns true if the template is currently invalid and `startValidating` has been called since the last invalidation.\n * If false, the template must be validated.\n * @param {HTMLTemplateElement} template\n * @return {boolean}\n */\nexport function templateIsValidating(template) {\n  return !templateIsValid(template) && template[VALIDATING_VERSION] === template[NEXT_VERSION];\n}\n\n/**\n * the template is marked as `validating` for one microtask so that all instances\n * found in the tree crawl of `applyStyle` will update themselves,\n * but the template will only be updated once.\n * @param {string} elementName\n*/\nexport function startValidating(elementName) {\n  let template = templateMap[elementName];\n  startValidatingTemplate(template);\n}\n\n/**\n * Begin an asynchronous invalidation cycle.\n * This should be called after every validation of a template\n *\n * After one microtask, the template will be marked as valid until the next call to `invalidateTemplate`\n * @param {HTMLTemplateElement} template\n */\nexport function startValidatingTemplate(template) {\n  // remember that the current \"next version\" is the reason for this validation cycle\n  template[VALIDATING_VERSION] = template[NEXT_VERSION];\n  // however, there only needs to be one async task to clear the counters\n  if (!template._validating) {\n    template._validating = true;\n    promise.then(function() {\n      // sync the current version to let future invalidations cause a refresh cycle\n      template[CURRENT_VERSION] = template[NEXT_VERSION];\n      template._validating = false;\n    });\n  }\n}\n\n/**\n * @return {boolean}\n */\nexport function elementsAreInvalid() {\n  for (let elementName in templateMap) {\n    let template = templateMap[elementName];\n    if (!templateIsValid(template)) {\n      return true;\n    }\n  }\n  return false;\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport { MIXIN_MATCH, VAR_ASSIGN } from './common-regex.js';\n\n/**\n * @param {Element} element\n * @param {Object=} properties\n */\nexport function updateNativeProperties(element, properties) {\n  // remove previous properties\n  for (let p in properties) {\n    // NOTE: for bc with shim, don't apply null values.\n    if (p === null) {\n      element.style.removeProperty(p);\n    } else {\n      element.style.setProperty(p, properties[p]);\n    }\n  }\n}\n\n/**\n * @param {Element} element\n * @param {string} property\n * @return {string}\n */\nexport function getComputedStyleValue(element, property) {\n  /**\n   * @const {string}\n   */\n  const value = window.getComputedStyle(element).getPropertyValue(property);\n  if (!value) {\n    return '';\n  } else {\n    return value.trim();\n  }\n}\n\n/**\n * return true if `cssText` contains a mixin definition or consumption\n * @param {string} cssText\n * @return {boolean}\n */\nexport function detectMixin(cssText) {\n  const has = MIXIN_MATCH.test(cssText) || VAR_ASSIGN.test(cssText);\n  // reset state of the regexes\n  MIXIN_MATCH.lastIndex = 0;\n  VAR_ASSIGN.lastIndex = 0;\n  return has;\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport ScopingShim from '../src/scoping-shim.js';\nimport {nativeCssVariables, nativeShadow, cssBuild, disableRuntime} from '../src/style-settings.js';\n\n/** @const {ScopingShim} */\nconst scopingShim = new ScopingShim();\n\nlet ApplyShim, CustomStyleInterface;\n\nif (window['ShadyCSS']) {\n  ApplyShim = window['ShadyCSS']['ApplyShim'];\n  CustomStyleInterface = window['ShadyCSS']['CustomStyleInterface'];\n}\n\nwindow.ShadyCSS = {\n  ScopingShim: scopingShim,\n  /**\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} elementExtends\n   */\n  prepareTemplate(template, elementName, elementExtends) {\n    scopingShim.flushCustomStyles();\n    scopingShim.prepareTemplate(template, elementName, elementExtends)\n  },\n\n  /**\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   */\n  prepareTemplateDom(template, elementName) {\n    scopingShim.prepareTemplateDom(template, elementName);\n  },\n\n  /**\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} elementExtends\n   */\n  prepareTemplateStyles(template, elementName, elementExtends) {\n    scopingShim.flushCustomStyles();\n    scopingShim.prepareTemplateStyles(template, elementName, elementExtends)\n  },\n  /**\n   * @param {!HTMLElement} element\n   * @param {Object=} properties\n   */\n  styleSubtree(element, properties) {\n    scopingShim.flushCustomStyles();\n    scopingShim.styleSubtree(element, properties);\n  },\n\n  /**\n   * @param {!HTMLElement} element\n   */\n  styleElement(element) {\n    scopingShim.flushCustomStyles();\n    scopingShim.styleElement(element);\n  },\n\n  /**\n   * @param {Object=} properties\n   */\n  styleDocument(properties) {\n    scopingShim.flushCustomStyles();\n    scopingShim.styleDocument(properties);\n  },\n\n  flushCustomStyles() {\n    scopingShim.flushCustomStyles();\n  },\n\n  /**\n   * @param {Element} element\n   * @param {string} property\n   * @return {string}\n   */\n  getComputedStyleValue(element, property) {\n    return scopingShim.getComputedStyleValue(element, property);\n  },\n\n  nativeCss: nativeCssVariables,\n\n  nativeShadow: nativeShadow,\n\n  cssBuild: cssBuild,\n\n  disableRuntime: disableRuntime,\n};\n\nif (ApplyShim) {\n  window.ShadyCSS.ApplyShim = ApplyShim;\n}\n\nif (CustomStyleInterface) {\n  window.ShadyCSS.CustomStyleInterface = CustomStyleInterface;\n}","/**\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: Custom Elements, Shady DOM/Shady CSS\n * Used in: Safari 9, Firefox, Edge\n */\n\nimport '../node_modules/@webcomponents/shadydom/src/shadydom.js';\nimport '../node_modules/@webcomponents/shadycss/entrypoints/scoping-shim.js';\n\nlet document = window.document;\n// global for (1) existence means `WebComponentsReady` will file,\n// (2) WebComponents.ready == true means event has fired.\nwindow.WebComponents = window.WebComponents || {};\n\nfunction fire() {\n  window.WebComponents.ready = true;\n  window.document.dispatchEvent(new CustomEvent('WebComponentsReady', { bubbles: true }));\n}\n\nfunction wait() {\n  fire();\n  document.removeEventListener('readystatechange', wait);\n}\n\nif (document.readyState !== 'loading') {\n  fire();\n} else {\n  document.addEventListener('readystatechange', wait);\n}"]}