{"version":3,"sources":["src/css-parse.js"," [synthetic:util/global] ","src/style-settings.js","src/common-regex.js","src/unscoped-style-handler.js","src/style-util.js","src/style-transformer.js","src/scoping-shim.js","src/document-watcher.js","src/style-properties.js","src/style-info.js","src/style-placeholder.js","src/style-cache.js","src/template-map.js","src/apply-shim-utils.js","src/common-utils.js","entrypoints/scoping-shim.js"],"names":["$jscomp.global","$jscomp.getGlobal","constructor","StyleNode","parse","text","replace","RX$$module$src$css_parse.comments","RX$$module$src$css_parse.port","root","length","n","i","l","OPEN_BRACE","p","previous","push","CLOSE_BRACE","parseCss","node","t","substring","trim","ss","_expandUnicodeEscapes","RX$$module$src$css_parse.multipleSpaces","lastIndexOf","s","indexOf","AT_START","MEDIA_START","types$$module$src$css_parse.MEDIA_RULE","match","RX$$module$src$css_parse.keyframesRule","types$$module$src$css_parse.KEYFRAMES_RULE","split","pop","VAR_START","types$$module$src$css_parse.MIXIN_RULE","types$$module$src$css_parse.STYLE_RULE","r$","r","code","repeat","stringify","preserveProperties","cssText","rules","RX$$module$src$css_parse.customProp","RX$$module$src$css_parse.mixinProp","RX$$module$src$css_parse.mixinApply","RX$$module$src$css_parse.varApply","STYLE_RULE","KEYFRAMES_RULE","MEDIA_RULE","MIXIN_RULE","comments","port","customProp","mixinProp","mixinApply","varApply","keyframesRule","multipleSpaces","nativeShadow","window","nativeCssVariables_","calcCssVariables","settings","shimcssproperties","navigator","userAgent","CSS","supports","cssBuild","ShadyCSS","undefined","disableRuntime","nativeCss","nativeCssVariables","VAR_ASSIGN","MIXIN_MATCH","VAR_CONSUMED","ANIMATION_MATCH","MEDIA_MATCH","BRACKETED","styleTextSet","Set","toCssText","callback","forEachRule","rulesForStyle","style","textContent","isKeyframesSelector","rule","styleRuleCallback","keyframesRuleCallback","onlyActiveRules","skipRules","type","matchMedia","matches","applyCss","moniker","target","contextNode","document","createElement","setAttribute","applyStyle","lastHeadApplyNode","applyStylePlaceHolder","placeHolder","createComment","scope","head","insertBefore","after","firstChild","nextSibling","position","compareDocumentPosition","Node","DOCUMENT_POSITION_PRECEDING","findMatchingParen","start","level","processVariableAndFallback","str","end","inner","prefix","suffix","comma","value","fallback","setElementClassRaw","element","call","wrap","getIsExtends","localName","typeExtension","is","getAttribute","extends","splitSelectorList","selector","parts","part","slice","getCssBuild","__cssBuild","attrValue","CSS_BUILD_ATTR","buildComment","content","Comment","commentParts","parentNode","removeChild","isOptimalCssBuild","StyleTransformer","domAddScope","_transformDom","fn","startNode","transformer","nodeType","ELEMENT_NODE","c$","_content","childNodes","children","shouldRemoveScope","classList","remove","SCOPE_NAME","add","c","CLASS","newValue","domReplaceScope","oldScope","newScope","domRemoveScope","elementStyles","styleRules","css","ext","hostScope","_calcHostScope","CSS_CLASS_PREFIX","isScoped","transformedSelector","_transformRuleCss","self","_transformComplexSelector","p$","filter","join","COMPLEX_SELECTOR_SEP","_twiddleNthPlus","NTH","m","inside","_preserveMatchesPseudo","MATCHES","index","Error","input","MATCHES_REPLACEMENT","_replaceMatchesPseudo","reduce","acc","cur","idx","stop","isNth","test","isMatches","SLOTTED_START","SIMPLE_SELECTOR_SEP","info","_transformCompoundSelector","combinator","DIR_PAREN","before","dir","slottedIndex","SLOTTED","HOST","_transformHostSelector","_transformSimpleSelector","slotted","SLOTTED_PAREN","paren","attributes","output","PSEUDO_PREFIX","HOST_PAREN","SIMPLE_SELECTOR_PREFIX","host","typeSelector","SELECTOR_NO_MATCH","normalizeRootSelector","ROOT","_transformDocumentSelector","SCOPE_DOC_SELECTOR","$jscomp.global.Object.defineProperties","$jscompDefaultExport","StyleInfo","ast","placeholder","ownStylePropertyNames","overrideStyleProperties","customStyle","scopeSelector","styleProperties","get","infoKey","set","styleInfo","_getStyleRules","prototype","matchesSelector","method","mozMatchesSelector","msMatchesSelector","oMatchesSelector","webkitMatchesSelector","rootSelector","IS_IE","StyleProperties","decorateStyles","props","keyframes","ruleIndex","decorateRule","exec","name","onKeyframesRule","_keyframes","names","propertyInfo","properties","collectProperties","hasProperties","Object","assign","rx","any","valueForProperty","property","valueForProperties","propertyValue","lastIndex","colon","pp","propertyDataFromStyles","o","selectorToMatch","parseInt","key","whenHostOrRootRule","parsedSelector","isHost","isRoot","hostAndRootPropertiesForScope","hostProps","rootProps","_element","transformStyles","hostSelector","hostRx","RegExp","HOST_PREFIX","rxHostSelector","HOST_SUFFIX","StyleInfo$$module$src$style_info.get","keyframeTransforms","_elementKeyframeTransforms","hasAnimations","keyframeNamesToTransform","keyframe","transform","keyframesRules","keyframesNameRx","transformedKeyframesName","scopeId","_keyframesRuleTransformer","applyCustomStyle","XSCOPE_NAME","placeholderMap","ce","origDefine","wrappedDefine","clazz","options","StyleCache","cache","store","tagname","styleElement","list","typeMax","shift","flush","scopeRegExp","getCurrentScope","getOwnerScope","ownerRoot","getRootNode","ownerDocument","handler","mxns","x","mxn","documentElement","addedNodes","currentScope","ShadowRoot","j","unscopedNodes","unscopedNode","scopeForPreviouslyUnscopedNode","observer","MutationObserver","observe","childList","subtree","delayedStart","body","requestAnimationFrame","readyState","listener","removeEventListener","addEventListener","takeRecords","templateMap","promise","Promise","resolve","invalidate","elementName","template","CURRENT_VERSION","VALIDATING_VERSION","NEXT_VERSION","templateIsValid","startValidatingTemplate","_validating","then","adoptedCssTextMap","styleCache","ScopingShim","_scopeCounter","_documentOwner","_documentOwnerStyleInfo","StyleInfo$$module$src$style_info.set","_elementsHaveApplied","_customStyleInterface","_applyShim","?.prototype","watcherFlush","getStyleAst","styleAstToString","prepareTemplate","prepareTemplateDom","prepareTemplateStyles","_prepared","optimalBuild","styleTextParts","styles","querySelectorAll","hasAttribute","scopingAttribute","has","newStyle","appendChild","_ensure","hasMixins","ownPropertyNames","shadowroot","_style","_ownPropertyNames","prepareAdoptedCssText","cssTextArray","_domPrepared","_prepareHost","_ensureCustomStyleInterface","CustomStyleInterface","transformCustomStyleForDocument","flushCustomStyles","_ensureApplyShim","ApplyShim","needsApplyShimUpdate","customStyles","_revalidateCustomStyleApplyShim","_reorderCustomStylesRules","_updateProperties","_applyCustomStyles","styleDocument","map","sort","a","b","DOCUMENT_POSITION_FOLLOWING","overrideProps","styleElementNativeVariables","_isRootOwner","styleElementShimVariables","cacheEntry","entry","pn","cachedStyle","oldScopeSelector","cachedScopeSelector","id","applyElementStyle","shadowRoot","v","removeProperty","setProperty","querySelector","_styleOwnerForNode","owner","ownerStyleInfo","ownerProperties","create","hostAndRootProps","propertiesMatchingHost","propertyData","overrides","reify","getOwnPropertyNames","styleSubtree","wrappedHost","isRootOwner","descendantRoot","descendantHosts","Array","from","documentRule","_transformRule","getComputedStyleValue","getComputedStyle","getPropertyValue","setElementClass","classString","classes","definitelyString","String","scopeName","classAttr","k$","_styleInfoForNode","scopeNode","unscopeNode","scopeForNode","currentScopeForNode","defineProperties","scopingShim","elementExtends"],"mappings":"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","file":"scoping-shim.min.js","sourcesContent":["/**\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']\n      ? node['previous']['end']\n      : 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'] = 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; 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; i < l && (r = r$[i]); i++) {\n        cssText = stringify(r, preserveProperties, cssText);\n      }\n    } else {\n      cssText = preserveProperties\n        ? 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 (\n    Boolean(r) &&\n    Boolean(r['selector']) &&\n    r['selector'].indexOf(VAR_START) === 0\n  );\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.replace(RX.customProp, '').replace(RX.mixinProp, '');\n}\n\n/**\n * @param {string} cssText\n * @return {string}\n */\nfunction removeCustomPropApply(cssText) {\n  return cssText.replace(RX.mixinApply, '').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",null,"/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nexport const nativeShadow = !(\n  window['ShadyDOM'] && window['ShadyDOM']['inUse']\n);\n/** @type {boolean} */\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_ =\n      nativeShadow ||\n      Boolean(\n        !navigator.userAgent.match(/AppleWebKit\\/601|Edge\\/15/) &&\n          window.CSS &&\n          CSS.supports &&\n          CSS.supports('box-shadow', '0 0 0 var(--foo)')\n      );\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(\n  window.ShadyCSS && window.ShadyCSS.disableRuntime\n);\n\nif (window.ShadyCSS && window.ShadyCSS.nativeCss !== undefined) {\n  nativeCssVariables_ = window.ShadyCSS.nativeCss;\n} else if (window.ShadyCSS) {\n  calcCssVariables(window.ShadyCSS);\n  // reset window variable to let ShadyCSS API take its place\n  window.ShadyCSS = undefined;\n} else {\n  calcCssVariables(window['WebComponents'] && window['WebComponents']['flags']);\n}\n\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","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nexport const VAR_ASSIGN = /(?:^|[;\\s{]\\s*)(--[\\w-]*?)\\s*:\\s*(?:((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^)]*?\\)|[^};{])+)|\\{([^}]*)\\}(?:(?=[;\\s}])|$))/gi;\nexport const MIXIN_MATCH = /(?:^|\\W+)@apply\\s*\\(?([^);\\n]*)\\)?/gi;\nexport const VAR_CONSUMED = /(--[\\w-]+)\\s*([:,;)]|$)/gi;\nexport const ANIMATION_MATCH = /(animation\\s*:)|(animation-name\\s*:)/;\nexport const MEDIA_MATCH = /@media\\s(.*)/;\nexport const IS_VAR = /^--/;\nexport const BRACKETED = /\\{[^}]*\\}/g;\nexport const HOST_PREFIX = '(?:^|[^.#[:])';\nexport const HOST_SUFFIX = '($|[.:[\\\\s>+~])';\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\n/** @type {!Set<string>} */\nconst styleTextSet = new Set();\n\nexport const scopingAttribute = 'shady-unscoped';\n\n/**\n * Add a specifically-marked style to the document directly, and only one copy of that style.\n *\n * @param {!HTMLStyleElement} style\n * @return {undefined}\n */\nexport function processUnscopedStyle(style) {\n  const text = style.textContent;\n  if (!styleTextSet.has(text)) {\n    styleTextSet.add(text);\n    const newStyle = document.createElement('style');\n    newStyle.setAttribute('shady-unscoped', '');\n    newStyle.textContent = text;\n    document.head.appendChild(newStyle);\n  }\n}\n\n/**\n * Check if a style is supposed to be unscoped\n * @param {!HTMLStyleElement} style\n * @return {boolean} true if the style has the unscoping attribute\n */\nexport function isUnscopedStyle(style) {\n  return style.hasAttribute(scopingAttribute);\n}\n","/**\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 @typescript-eslint/no-unused-vars\nimport {MEDIA_MATCH} from './common-regex.js';\n// prettier-ignore\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 (\n    Boolean(rule['parent']) && rule['parent']['type'] === types.KEYFRAMES_RULE\n  );\n}\n\n/**\n * @param {StyleNode} node\n * @param {Function=} styleRuleCallback\n * @param {Function=} keyframesRuleCallback\n * @param {boolean=} onlyActiveRules\n */\nexport function forEachRule(\n  node,\n  styleRuleCallback,\n  keyframesRuleCallback,\n  onlyActiveRules\n) {\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 && 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(\n    ' Shady DOM styles for ' + moniker + ' '\n  );\n  let after = lastHeadApplyNode ? 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) || 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(\n      element,\n      'class',\n      value\n    );\n  }\n}\n\n/**\n * @type {function(*):*}\n */\nexport const wrap =\n  (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 = '',\n    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(\n    'style'\n  ));\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 =\n    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 =\n    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 @typescript-eslint/no-unused-vars\nimport * as StyleUtil from './style-util.js';\nimport {nativeShadow} from './style-settings.js';\n\n/* Transforms ShadowDOM styling into ShadyDOM styling\n\n* scoping:\n\n  * elements in scope get scoping selector class=\"x-foo-scope\"\n  * selectors re-written as follows:\n\n    div button -> div.x-foo-scope button.x-foo-scope\n\n* :host -> scopeName\n\n* :host(...) -> scopeName...\n\n* ::slotted(...) -> scopeName > ...\n\n* ...:dir(ltr|rtl) -> [dir=\"ltr|rtl\"] ..., ...[dir=\"ltr|rtl\"]\n\n* :host(:dir[rtl]) -> scopeName:dir(rtl) -> [dir=\"rtl\"] scopeName, scopeName[dir=\"rtl\"]\n\n*/\nconst SCOPE_NAME = 'style-scope';\n\nclass StyleTransformer {\n  /** @return {string} */\n  get SCOPE_NAME() {\n    return SCOPE_NAME;\n  }\n  /**\n   * Given a node and scope name, add a scoping class to each node\n   * in the tree. This facilitates transforming css into scoped rules.\n   * @param {!Node} node\n   * @param {string} scope\n   * @param {boolean=} shouldRemoveScope\n   * @deprecated\n   */\n  dom(node, scope, shouldRemoveScope) {\n    const fn = (node) => {\n      this.element(node, scope || '', shouldRemoveScope);\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * Given a node and scope name, add a scoping class to each node in the tree.\n   * @param {!Node} node\n   * @param {string} scope\n   */\n  domAddScope(node, scope) {\n    const fn = (node) => {\n      this.element(node, scope || '');\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * @param {!Node} startNode\n   * @param {function(!Node)} transformer\n   */\n  _transformDom(startNode, transformer) {\n    if (startNode.nodeType === Node.ELEMENT_NODE) {\n      transformer(startNode);\n    }\n    let c$;\n    if (startNode.localName === 'template') {\n      const template = /** @type {!HTMLTemplateElement} */ (startNode);\n      // In case the template is in svg context, fall back to the node\n      // since it won't be an HTMLTemplateElement with a .content property\n      c$ = (template.content || template._content || template).childNodes;\n    } else {\n      c$ =\n        /** @type {!ParentNode} */ (startNode).children || startNode.childNodes;\n    }\n    if (c$) {\n      for (let i = 0; i < c$.length; i++) {\n        this._transformDom(c$[i], transformer);\n      }\n    }\n  }\n\n  /**\n   * @param {?} element\n   * @param {?} scope\n   * @param {?=} shouldRemoveScope\n   */\n  element(element, scope, shouldRemoveScope) {\n    // note: if using classes, we add both the general 'style-scope' class\n    // as well as the specific scope. This enables easy filtering of all\n    // `style-scope` elements\n    if (scope) {\n      // note: svg on IE does not have classList so fallback to class\n      if (element.classList) {\n        if (shouldRemoveScope) {\n          element.classList.remove(SCOPE_NAME);\n          element.classList.remove(scope);\n        } else {\n          element.classList.add(SCOPE_NAME);\n          element.classList.add(scope);\n        }\n      } else if (element.getAttribute) {\n        let c = element.getAttribute(CLASS);\n        if (shouldRemoveScope) {\n          if (c) {\n            let newValue = c.replace(SCOPE_NAME, '').replace(scope, '');\n            StyleUtil.setElementClassRaw(element, newValue);\n          }\n        } else {\n          let newValue = (c ? c + ' ' : '') + SCOPE_NAME + ' ' + scope;\n          StyleUtil.setElementClassRaw(element, newValue);\n        }\n      }\n    }\n  }\n\n  /**\n   * Given a node, replace the scoping class to each subnode in the tree.\n   * @param {!Node} node\n   * @param {string} oldScope\n   * @param {string} newScope\n   */\n  domReplaceScope(node, oldScope, newScope) {\n    const fn = (node) => {\n      this.element(node, oldScope, true);\n      this.element(node, newScope);\n    };\n    this._transformDom(node, fn);\n  }\n  /**\n   * Given a node, remove the scoping class to each subnode in the tree.\n   * @param {!Node} node\n   * @param {string} oldScope\n   */\n  domRemoveScope(node, oldScope) {\n    const fn = (node) => {\n      this.element(node, oldScope || '', true);\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * @param {?} element\n   * @param {?} styleRules\n   * @param {?=} callback\n   * @param {string=} cssBuild\n   * @param {string=} cssText\n   * @return {string}\n   */\n  elementStyles(element, styleRules, callback, cssBuild = '', cssText = '') {\n    // no need to shim selectors if settings.useNativeShadow, also\n    // a shady css build will already have transformed selectors\n    // NOTE: This method may be called as part of static or property shimming.\n    // When there is a targeted build it will not be called for static shimming,\n    // but when the property shim is used it is called and should opt out of\n    // static shimming work when a proper build exists.\n    if (cssText === '') {\n      if (nativeShadow || cssBuild === 'shady') {\n        cssText = StyleUtil.toCssText(styleRules, callback);\n      } else {\n        let {is, typeExtension} = StyleUtil.getIsExtends(element);\n        cssText = this.css(styleRules, is, typeExtension, callback) + '\\n\\n';\n      }\n    }\n    return cssText.trim();\n  }\n\n  // Given a string of cssText and a scoping string (scope), returns\n  // a string of scoped css where each selector is transformed to include\n  // a class created from the scope. ShadowDOM selectors are also transformed\n  // (e.g. :host) to use the scoping selector.\n  css(rules, scope, ext, callback) {\n    let hostScope = this._calcHostScope(scope, ext);\n    scope = this._calcElementScope(scope);\n    let self = this;\n    return StyleUtil.toCssText(rules, function (/** StyleNode */ rule) {\n      if (!(/** @type {?} */ (rule.isScoped))) {\n        self.rule(rule, scope, hostScope);\n        rule.isScoped = true;\n      }\n      if (callback) {\n        callback(rule, scope, hostScope);\n      }\n    });\n  }\n\n  _calcElementScope(scope) {\n    if (scope) {\n      return CSS_CLASS_PREFIX + scope;\n    } else {\n      return '';\n    }\n  }\n\n  _calcHostScope(scope, ext) {\n    return ext ? `[is=${scope}]` : scope;\n  }\n\n  rule(rule, scope, hostScope) {\n    this._transformRule(rule, this._transformComplexSelector, 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[\n      'selector'\n    ] = /** @type {?} */ (rule).transformedSelector = this._transformRuleCss(\n      rule,\n      transformer,\n      scope,\n      hostScope\n    );\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(\n      (acc, cur, idx) => acc + cur + parts[idx + 1],\n      parts[0]\n    );\n  }\n\n  /**\n   * @param {string} selector\n   * @param {string} scope\n   * @param {string=} hostScope\n   */\n  _transformComplexSelector(selector, scope, hostScope) {\n    let stop = false;\n    selector = selector.trim();\n    // Remove spaces inside of selectors like `:nth-of-type` because it confuses SIMPLE_SELECTOR_SEP\n    let isNth = NTH.test(selector);\n    if (isNth) {\n      selector = selector.replace(\n        NTH,\n        (m, type, inner) => `:${type}(${inner.replace(/\\s/g, '')})`\n      );\n      selector = this._twiddleNthPlus(selector);\n    }\n    // Preserve selectors like `:-webkit-any` so that SIMPLE_SELECTOR_SEP does\n    // not get confused by spaces inside the pseudo selector\n    const isMatches = MATCHES.test(selector);\n    /** @type {!Array<string>} */\n    let matches;\n    if (isMatches) {\n      ({selector, matches} = this._preserveMatchesPseudo(selector));\n    }\n    selector = selector.replace(SLOTTED_START, `${HOST} $1`);\n    selector = selector.replace(SIMPLE_SELECTOR_SEP, (m, c, s) => {\n      if (!stop) {\n        let info = this._transformCompoundSelector(s, c, scope, hostScope);\n        stop = stop || info.stop;\n        c = info.combinator;\n        s = info.value;\n      }\n      return c + s;\n    });\n    // replace `:matches()` selectors\n    if (isMatches) {\n      selector = this._replaceMatchesPseudo(selector, matches);\n    }\n    if (isNth) {\n      selector = this._twiddleNthPlus(selector);\n    }\n    selector = selector.replace(\n      DIR_PAREN,\n      (m, before, dir, after) =>\n        `[dir=\"${dir}\"] ${before}${after}, ${before}[dir=\"${dir}\"]${after}`\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\n        ? this._transformSimpleSelector(selector, scope)\n        : selector;\n    }\n    // mark ::slotted() scope jump to replace with descendant selector + arg\n    // also ignore left-side combinator\n    let slotted = false;\n    if (slottedIndex >= 0) {\n      combinator = '';\n      slotted = true;\n    }\n    // process scope jumping selectors up to the scope jump and then stop\n    let stop;\n    if (slotted) {\n      stop = true;\n      if (slotted) {\n        // .zonk ::slotted(.foo) -> .zonk.scope > .foo\n        selector = selector.replace(SLOTTED_PAREN, (m, paren) => ` > ${paren}`);\n      }\n    }\n    return {value: selector, combinator, stop};\n  }\n\n  _transformSimpleSelector(selector, scope) {\n    const attributes = selector.split(/(\\[.+?\\])/);\n\n    const output = [];\n    for (let i = 0; i < attributes.length; i++) {\n      // Do not attempt to transform any attribute selector content\n      if (i % 2 === 1) {\n        output.push(attributes[i]);\n      } else {\n        const part = attributes[i];\n\n        if (!(part === '' && i === attributes.length - 1)) {\n          let p$ = part.split(PSEUDO_PREFIX);\n          p$[0] += scope;\n          output.push(p$.join(PSEUDO_PREFIX));\n        }\n      }\n    }\n\n    return output.join('');\n  }\n\n  // :host(...) -> scopeName...\n  _transformHostSelector(selector, hostScope) {\n    let m = selector.match(HOST_PAREN);\n    let paren = (m && m[2].trim()) || '';\n    if (paren) {\n      if (!paren[0].match(SIMPLE_SELECTOR_PREFIX)) {\n        // paren starts with a type selector\n        let typeSelector = paren.split(SIMPLE_SELECTOR_PREFIX)[0];\n        // if the type selector is our hostScope then avoid pre-pending it\n        if (typeSelector === hostScope) {\n          return paren;\n        }\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    }\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';\n// prettier-ignore\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';\n// prettier-ignore\nimport {ensureStylePlaceholder, getStylePlaceholder} from './style-placeholder.js';\nimport StyleInfo from './style-info.js';\nimport StyleCache from './style-cache.js';\n// prettier-ignore\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';\n// prettier-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport {CustomStyleInterfaceInterface, CustomStyleProvider} from './custom-style-interface.js';\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(\n      this._documentOwner,\n      new StyleInfo(ast)\n    );\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 =\n      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(\n        info,\n        template['_styleAst'],\n        root,\n        placeholder,\n        cssBuild,\n        optimalBuild ? cssText : ''\n      );\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(\n    info,\n    rules,\n    shadowroot,\n    placeholder,\n    cssBuild,\n    cssText\n  ) {\n    cssText = StyleTransformer.elementStyles(\n      info,\n      rules,\n      null,\n      cssBuild,\n      cssText\n    );\n    if (cssText.length) {\n      return StyleUtil.applyCss(cssText, info.is, shadowroot, placeholder);\n    }\n    return null;\n  }\n  _prepareHost(host) {\n    const {is, typeExtension} = StyleUtil.getIsExtends(host);\n    const placeholder = getStylePlaceholder(is);\n    const template = templateMap[is];\n    if (!template) {\n      return;\n    }\n    const ast = template['_styleAst'];\n    const ownStylePropertyNames = template._ownPropertyNames;\n    const cssBuild = StyleUtil.getCssBuild(template);\n    const styleInfo = new StyleInfo(\n      ast,\n      placeholder,\n      ownStylePropertyNames,\n      is,\n      typeExtension,\n      cssBuild\n    );\n    StyleInfo.set(host, styleInfo);\n    return styleInfo;\n  }\n  /**\n   * Returns a boolean that indicates if styles need to be reprocessed because\n   * the apply shim is now available.\n   * @return {boolean}\n   */\n  _ensureApplyShim() {\n    if (!this._applyShim && window.ShadyCSS && window.ShadyCSS.ApplyShim) {\n      this._applyShim = /** @type {!Object} */ (window.ShadyCSS.ApplyShim);\n      this._applyShim['invalidCallback'] = ApplyShimUtils.invalidate;\n      return true;\n    }\n    return false;\n  }\n  _ensureCustomStyleInterface() {\n    if (this._customStyleInterface) {\n      return;\n    } else if (window.ShadyCSS && window.ShadyCSS.CustomStyleInterface) {\n      this._customStyleInterface = /** @type {!CustomStyleInterfaceInterface} */ (window\n        .ShadyCSS.CustomStyleInterface);\n      /** @type {function(!HTMLStyleElement)} */\n      this._customStyleInterface['transformCallback'] = (style) => {\n        this.transformCustomStyleForDocument(style);\n      };\n      this._customStyleInterface['validateCallback'] = () => {\n        requestAnimationFrame(() => {\n          if (\n            this._customStyleInterface['enqueued'] ||\n            this._elementsHaveApplied\n          ) {\n            this.flushCustomStyles();\n          }\n        });\n      };\n    }\n  }\n  /**\n   * Returns a boolean that indicates if styles need to be reprocessed because\n   * the apply shim is now available.\n   * @return {boolean}\n   */\n  _ensure() {\n    const needsApplyShimUpdate = this._ensureApplyShim();\n    this._ensureCustomStyleInterface();\n    return needsApplyShimUpdate;\n  }\n  /**\n   * Flush and apply custom styles to document\n   */\n  flushCustomStyles() {\n    if (disableRuntime) {\n      return;\n    }\n    const needsApplyShimUpdate = this._ensure();\n    if (!this._customStyleInterface) {\n      return;\n    }\n    let customStyles = this._customStyleInterface['processStyles']();\n    // early return if custom-styles don't need validation\n    if (!needsApplyShimUpdate && !this._customStyleInterface['enqueued']) {\n      return;\n    }\n    // bail if custom styles are built optimally\n    if (StyleUtil.isOptimalCssBuild(this._documentOwnerStyleInfo.cssBuild)) {\n      return;\n    }\n    if (!nativeCssVariables) {\n      this._reorderCustomStylesRules(customStyles);\n      this._updateProperties(this._documentOwner, this._documentOwnerStyleInfo);\n      this._applyCustomStyles(customStyles);\n      if (this._elementsHaveApplied) {\n        // if custom elements have upgraded and there are no native css variables, we must recalculate the whole tree\n        this.styleDocument();\n      }\n    } else if (!this._documentOwnerStyleInfo.cssBuild) {\n      this._revalidateCustomStyleApplyShim(customStyles);\n    }\n    this._customStyleInterface['enqueued'] = false;\n  }\n  /**\n   * Reorder of custom styles for Custom Property shim\n   * @param {!Array<!CustomStyleProvider>} customStyles\n   */\n  _reorderCustomStylesRules(customStyles) {\n    const styles = customStyles\n      .map((c) => this._customStyleInterface['getStyleForCustomStyle'](c))\n      .filter((s) => !!s);\n    // sort styles in document order\n    styles.sort((a, b) => {\n      // use `b.compare(a)` to be more straightforward\n      const position = b.compareDocumentPosition(a);\n      if (position & Node.DOCUMENT_POSITION_FOLLOWING) {\n        // A is after B, A should be higher sorted\n        return 1;\n      } else if (position & Node.DOCUMENT_POSITION_PRECEDING) {\n        // A is before B, A should be lower sorted\n        return -1;\n      } else {\n        return 0;\n      }\n    });\n    // sort ast ordering for document\n    this._documentOwnerStyleInfo.styleRules['rules'] = styles.map((s) =>\n      StyleUtil.rulesForStyle(s)\n    );\n  }\n  /**\n   * Apply styles for the given element\n   *\n   * @param {!HTMLElement} host\n   * @param {Object=} overrideProps\n   */\n  styleElement(host, overrideProps) {\n    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 = 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 (\n      styleInfo.ownStylePropertyNames &&\n      styleInfo.ownStylePropertyNames.length\n    ) {\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 (\n      template &&\n      template._style &&\n      !ApplyShimUtils.templateIsValid(template)\n    ) {\n      // update template\n      if (!ApplyShimUtils.templateIsValidating(template)) {\n        this._ensure();\n        this._applyShim &&\n          this._applyShim['transformRules'](template['_styleAst'], is);\n        template._style.textContent = StyleTransformer.elementStyles(\n          host,\n          styleInfo.styleRules\n        );\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(\n              host,\n              styleInfo.styleRules\n            );\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(\n      is,\n      styleInfo.styleProperties,\n      styleInfo.ownStylePropertyNames\n    );\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 =\n      cachedScopeSelector || this._generateScopeSelector(is);\n    let style = StyleProperties.applyElementStyle(\n      host,\n      styleInfo.styleProperties,\n      styleInfo.scopeSelector,\n      cachedStyle\n    );\n    if (!nativeShadow) {\n      StyleProperties.applyElementScopeSelector(\n        host,\n        styleInfo.scopeSelector,\n        oldScopeSelector\n      );\n    }\n    if (!cacheEntry) {\n      styleCache.store(\n        is,\n        styleInfo.styleProperties,\n        style,\n        styleInfo.scopeSelector\n      );\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(\n      host,\n      styleInfo.styleRules,\n      styleInfo.cssBuild\n    );\n    let propertyData = StyleProperties.propertyDataFromStyles(\n      ownerStyleInfo.styleRules,\n      host\n    );\n    let propertiesMatchingHost = propertyData.properties;\n    Object.assign(\n      props,\n      hostAndRootProps.hostProps,\n      propertiesMatchingHost,\n      hostAndRootProps.rootProps\n    );\n    this._mixinOverrideStyles(props, styleInfo.overrideStyleProperties);\n    StyleProperties.reify(props);\n    styleInfo.styleProperties = props;\n  }\n  _mixinOverrideStyles(props, overrides) {\n    for (let p in overrides) {\n      let v = overrides[p];\n      // skip override props if they are not truthy or 0\n      // in order to fall back to inherited values\n      if (v || v === 0) {\n        props[p] = v;\n      }\n    }\n  }\n  /**\n   * Update styles of the whole document\n   *\n   * @param {Object=} properties\n   */\n  styleDocument(properties) {\n    this.styleSubtree(this._documentOwner, properties);\n  }\n  /**\n   * Update styles of a subtree\n   *\n   * @param {!HTMLElement} host\n   * @param {Object=} properties\n   */\n  styleSubtree(host, properties) {\n    const wrappedHost = StyleUtil.wrap(host);\n    const root = wrappedHost.shadowRoot;\n    const isRootOwner = this._isRootOwner(host);\n    if (root || isRootOwner) {\n      this.styleElement(host, properties);\n    }\n    const descendantRoot = isRootOwner ? wrappedHost : root;\n    if (descendantRoot) {\n      const descendantHosts = Array.from(\n        descendantRoot.querySelectorAll('*')\n      ).filter((x) => StyleUtil.wrap(x).shadowRoot);\n      for (let i = 0; i < descendantHosts.length; i++) {\n        this.styleSubtree(descendantHosts[i]);\n      }\n    }\n  }\n  /* Custom Style operations */\n  _revalidateCustomStyleApplyShim(customStyles) {\n    for (let i = 0; i < customStyles.length; i++) {\n      let c = customStyles[i];\n      let s = this._customStyleInterface['getStyleForCustomStyle'](c);\n      if (s) {\n        this._revalidateApplyShim(s);\n      }\n    }\n  }\n  _applyCustomStyles(customStyles) {\n    for (let i = 0; i < customStyles.length; i++) {\n      let c = customStyles[i];\n      let s = this._customStyleInterface['getStyleForCustomStyle'](c);\n      if (s) {\n        StyleProperties.applyCustomStyle(\n          s,\n          this._documentOwnerStyleInfo.styleProperties\n        );\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 =\n        StyleInfo.get(element) ||\n        StyleInfo.get(this._styleOwnerForNode(element));\n      value = styleInfo.styleProperties[property];\n    }\n    // fall back to the property value from the computed styling\n    value =\n      value || window.getComputedStyle(element).getPropertyValue(property);\n    // trim whitespace that can come after the `:` in css\n    // example: padding: 2px -> \" 2px\"\n    return value ? value.trim() : '';\n  }\n  // given an element and a classString, replaces\n  // the element's class with the provided classString and adds\n  // any necessary ShadyCSS static and property based scoping selectors\n  setElementClass(element, classString) {\n    let root = StyleUtil.wrap(element).getRootNode();\n    let classes;\n    if (classString) {\n      let definitelyString =\n        typeof classString === 'string' ? classString : String(classString);\n      classes = definitelyString.split(/\\s/);\n    } else {\n      classes = [];\n    }\n    let scopeName = root.host && root.host.localName;\n    // If no scope, try to discover scope name from existing class.\n    // This can occur if, for example, a template stamped element that\n    // has been scoped is manipulated when not in a root.\n    if (!scopeName) {\n      var classAttr = element.getAttribute('class');\n      if (classAttr) {\n        let k$ = classAttr.split(/\\s/);\n        for (let i = 0; i < k$.length; i++) {\n          if (k$[i] === StyleTransformer.SCOPE_NAME) {\n            scopeName = k$[i + 1];\n            break;\n          }\n        }\n      }\n    }\n    if (scopeName) {\n      classes.push(StyleTransformer.SCOPE_NAME, scopeName);\n    }\n    if (!nativeCssVariables) {\n      let styleInfo = StyleInfo.get(element);\n      if (styleInfo && styleInfo.scopeSelector) {\n        classes.push(StyleProperties.XSCOPE_NAME, styleInfo.scopeSelector);\n      }\n    }\n    StyleUtil.setElementClassRaw(element, classes.join(' '));\n  }\n  _styleInfoForNode(node) {\n    return StyleInfo.get(node);\n  }\n  /**\n   * @param {!Element} node\n   * @param {string} scope\n   */\n  scopeNode(node, scope) {\n    StyleTransformer.element(node, scope);\n  }\n  /**\n   * @param {!Element} node\n   * @param {string} scope\n   */\n  unscopeNode(node, scope) {\n    StyleTransformer.element(node, scope, true);\n  }\n  /**\n   * @param {!Node} node\n   * @return {string}\n   */\n  scopeForNode(node) {\n    return getOwnerScope(node);\n  }\n  /**\n   * @param {!Element} node\n   * @return {string}\n   */\n  currentScopeForNode(node) {\n    return getCurrentScope(node);\n  }\n}\n\n/* exports */\n/* eslint-disable no-self-assign */\nScopingShim.prototype['flush'] = ScopingShim.prototype.flush;\nScopingShim.prototype['prepareTemplate'] =\n  ScopingShim.prototype.prepareTemplate;\nScopingShim.prototype['styleElement'] = ScopingShim.prototype.styleElement;\nScopingShim.prototype['styleDocument'] = ScopingShim.prototype.styleDocument;\nScopingShim.prototype['styleSubtree'] = ScopingShim.prototype.styleSubtree;\nScopingShim.prototype['getComputedStyleValue'] =\n  ScopingShim.prototype.getComputedStyleValue;\nScopingShim.prototype['setElementClass'] =\n  ScopingShim.prototype.setElementClass;\nScopingShim.prototype['_styleInfoForNode'] =\n  ScopingShim.prototype._styleInfoForNode;\nScopingShim.prototype['transformCustomStyleForDocument'] =\n  ScopingShim.prototype.transformCustomStyleForDocument;\nScopingShim.prototype['getStyleAst'] = ScopingShim.prototype.getStyleAst;\nScopingShim.prototype['styleAstToString'] =\n  ScopingShim.prototype.styleAstToString;\nScopingShim.prototype['flushCustomStyles'] =\n  ScopingShim.prototype.flushCustomStyles;\nScopingShim.prototype['scopeNode'] = ScopingShim.prototype.scopeNode;\nScopingShim.prototype['unscopeNode'] = ScopingShim.prototype.unscopeNode;\nScopingShim.prototype['scopeForNode'] = ScopingShim.prototype.scopeForNode;\nScopingShim.prototype['currentScopeForNode'] =\n  ScopingShim.prototype.currentScopeForNode;\nScopingShim.prototype['prepareAdoptedCssText'] =\n  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'][\n    'querySelectorAll'\n  ].call(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 (\n      mxn.target === document.documentElement ||\n      mxn.target === document.head\n    ) {\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 (\n        currentScope &&\n        root === n.ownerDocument &&\n        !isElementWithBuiltCss(n)\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 (\n  !nativeShadow &&\n  !(window['ShadyDOM'] && window['ShadyDOM']['handlesDynamicScoping'])\n) {\n  let observer = new MutationObserver(handler);\n  let start = (node) => {\n    observer.observe(node, {childList: true, subtree: true});\n  };\n  let nativeCustomElements =\n    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 @typescript-eslint/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 =\n    this.matches ||\n    this.matchesSelector ||\n    this.mozMatchesSelector ||\n    this.msMatchesSelector ||\n    this.oMatchesSelector ||\n    this.webkitMatchesSelector;\n  return method && method.call(this, selector);\n};\n\nconst rootSelector = /:host\\s*>\\s*/;\n\nfunction checkRoot(hostScope, selector) {\n  return (\n    Boolean(selector.match(rootSelector)) ||\n    (hostScope === 'html' && selector.indexOf('html') > -1)\n  );\n}\n\nconst IS_IE = navigator.userAgent.match('Trident');\n\nconst XSCOPE_NAME = 'x-scope';\n\nclass StyleProperties {\n  /** @return {string} */\n  get XSCOPE_NAME() {\n    return XSCOPE_NAME;\n  }\n  /**\n   * decorates styles with rule info and returns an array of used style property names\n   *\n   * @param {StyleNode} rules\n   * @return {!Array<string>}\n   */\n  decorateStyles(rules) {\n    let self = this,\n      props = {},\n      keyframes = [],\n      ruleIndex = 0;\n    StyleUtil.forEachRule(\n      rules,\n      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      },\n      function onKeyframesRule(rule) {\n        keyframes.push(rule);\n      }\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 = {},\n      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,\n        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  // 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, '').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 =\n              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] =\n          p && p.lastIndexOf(';') === p.length - 1\n            ? p.slice(0, -1) // strip trailing ;\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(\n      rules,\n      (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 =\n          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      },\n      null,\n      true\n    );\n    return {properties: props, key: o};\n  }\n\n  /**\n   * @param {Element} scope\n   * @param {StyleNode} rule\n   * @param {string} cssBuild\n   * @param {function(Object)} callback\n   */\n  whenHostOrRootRule(scope, rule, cssBuild, callback) {\n    if (!(/** @type {?} */ (rule.propertyInfo))) {\n      this.decorateRule(rule);\n    }\n    if (!(/** @type {?} */ (rule.propertyInfo).properties)) {\n      return;\n    }\n    let {is, typeExtension} = StyleUtil.getIsExtends(scope);\n    let hostScope = is\n      ? StyleTransformer._calcHostScope(is, typeExtension)\n      : 'html';\n    let parsedSelector = rule['parsedSelector'];\n    let isRoot = checkRoot(hostScope, parsedSelector);\n    let isHost = parsedSelector.indexOf(':host') === 0 && !isRoot;\n    // build info is either in scope (when scope is an element) or in the style\n    // when scope is the default scope; note: this allows default scope to have\n    // mixed mode built and unbuilt styles.\n    if (cssBuild === 'shady') {\n      // :root -> x-foo > *.x-foo for elements and html for custom-style\n      isRoot =\n        parsedSelector === hostScope + ' > *.' + hostScope ||\n        parsedSelector.indexOf('html') !== -1;\n      // :host -> x-foo for elements, but sub-rules have .x-foo in them\n      isHost = !isRoot && parsedSelector.indexOf(hostScope) === 0;\n    }\n    if (!isRoot && !isHost) {\n      return;\n    }\n    let selectorToMatch = hostScope;\n    if (isHost) {\n      // need to transform :host because `:host` does not work with `matches`\n      if (!(/** @type {?} */ (rule.transformedSelector))) {\n        // transform :host into a matchable selector\n        rule.transformedSelector = StyleTransformer._transformRuleCss(\n          rule,\n          StyleTransformer._transformComplexSelector,\n          StyleTransformer._calcElementScope(is),\n          hostScope\n        );\n      }\n      selectorToMatch =\n        /** @type {?} */ (rule.transformedSelector) || hostScope;\n    }\n    if (isRoot && hostScope === 'html') {\n      selectorToMatch =\n        /** @type {?} */ (rule.transformedSelector) ||\n        /** @type {?} */ (rule.parsedSelector);\n    }\n    callback({\n      selector: selectorToMatch,\n      isHost: isHost,\n      isRoot: isRoot,\n    });\n  }\n  /**\n   * @param {Element} scope\n   * @param {StyleNode} rules\n   * @param {string} cssBuild\n   * @return {!Object}\n   */\n  hostAndRootPropertiesForScope(scope, rules, cssBuild) {\n    let hostProps = {},\n      rootProps = {};\n    // note: active rules excludes non-matching @media rules\n    StyleUtil.forEachRule(\n      rules,\n      (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      },\n      null,\n      true\n    );\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._calcHostScope(is, typeExtension);\n    let rxHostSelector = element.extends\n      ? '\\\\' + hostSelector.slice(0, -1) + '\\\\]'\n      : hostSelector;\n    let hostRx = new RegExp(RX.HOST_PREFIX + rxHostSelector + RX.HOST_SUFFIX);\n    let {styleRules: rules, cssBuild} = StyleInfo.get(element);\n    let keyframeTransforms = this._elementKeyframeTransforms(\n      element,\n      rules,\n      scopeSelector\n    );\n    return StyleTransformer.elementStyles(\n      element,\n      rules,\n      function (rule) {\n        self.applyProperties(rule, properties);\n        if (\n          !nativeShadow &&\n          !StyleUtil.isKeyframesSelector(rule) &&\n          rule['cssText']\n        ) {\n          // NOTE: keyframe transforms only scope munge animation names, so it\n          // is not necessary to apply them in ShadowDOM.\n          self.applyKeyframeTransforms(rule, keyframeTransforms);\n          self._scopeSelector(rule, hostRx, hostSelector, scopeSelector);\n        }\n      },\n      cssBuild\n    );\n  }\n\n  /**\n   * @param {Element} element\n   * @param {StyleNode} rules\n   * @param {string} scopeSelector\n   * @return {!Object}\n   */\n  _elementKeyframeTransforms(element, rules, scopeSelector) {\n    let keyframesRules = rules._keyframes;\n    let keyframeTransforms = {};\n    if (!nativeShadow && keyframesRules) {\n      // For non-ShadowDOM, we transform all known keyframes rules in\n      // advance for the current scope. This allows us to catch keyframes\n      // rules that appear anywhere in the stylesheet:\n      for (\n        let i = 0, keyframesRule = keyframesRules[i];\n        i < keyframesRules.length;\n        keyframesRule = keyframesRules[++i]\n      ) {\n        this._scopeKeyframes(keyframesRule, scopeSelector);\n        keyframeTransforms[\n          keyframesRule['keyframesName']\n        ] = this._keyframesRuleTransformer(keyframesRule);\n      }\n    }\n    return keyframeTransforms;\n  }\n\n  // Generate a factory for transforming a chunk of CSS text to handle a\n  // particular scoped keyframes rule.\n  /**\n   * @param {StyleNode} keyframesRule\n   * @return {function(string):string}\n   */\n  _keyframesRuleTransformer(keyframesRule) {\n    return function (cssText) {\n      return cssText.replace(\n        /** @type {?} */ (keyframesRule.keyframesNameRx),\n        /** @type {?} */ (keyframesRule.transformedKeyframesName)\n      );\n    };\n  }\n\n  /**\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(\n      `\\\\b${rule['keyframesName']}(?!\\\\B|-)`,\n      'g'\n    );\n    rule.transformedKeyframesName = rule['keyframesName'] + '-' + scopeId;\n    rule.transformedSelector =\n      /** @type {?} */ (rule.transformedSelector) || rule['selector'];\n    rule['selector'] = /** @type {?} */ (rule.transformedSelector).replace(\n      rule['keyframesName'],\n      rule.transformedKeyframesName\n    );\n  }\n\n  // Strategy: x scope shim a selector e.g. to scope `.x-foo-42` (via classes):\n  // non-host selector: .a.x-foo -> .x-foo-42 .a.x-foo\n  // host selector: x-foo.wide -> .x-foo-42.wide\n  // note: we use only the scope class (.x-foo-42) and not the hostSelector\n  // (x-foo) to scope :host rules; this helps make property host rules\n  // have low specificity. They are overrideable by class selectors but,\n  // unfortunately, not by type selectors (e.g. overriding via\n  // `.special` is ok, but not by `x-foo`).\n  /**\n   * @param {StyleNode} rule\n   * @param {RegExp} hostRx\n   * @param {string} hostSelector\n   * @param {string} scopeId\n   */\n  _scopeSelector(rule, hostRx, hostSelector, scopeId) {\n    rule.transformedSelector =\n      /** @type {?} */ (rule.transformedSelector) || rule['selector'];\n    let selector = rule.transformedSelector;\n    let scope = '.' + scopeId;\n    let parts = StyleUtil.splitSelectorList(selector);\n    for (let i = 0, l = parts.length, p; i < l && (p = parts[i]); i++) {\n      parts[i] = p.match(hostRx)\n        ? p.replace(hostSelector, scope)\n        : scope + ' ' + p;\n    }\n    rule['selector'] = parts.join(',');\n  }\n\n  /**\n   * @param {Element} element\n   * @param {string} selector\n   * @param {string} old\n   */\n  applyElementScopeSelector(element, selector, old) {\n    let c = element.getAttribute('class') || '';\n    let v = c;\n    if (old) {\n      v = c.replace(\n        new RegExp('\\\\s*' + XSCOPE_NAME + '\\\\s*' + old + '\\\\s*', 'g'),\n        ' '\n      );\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\n      ? 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(\n          cssText,\n          selector,\n          element.shadowRoot,\n          styleInfo.placeholder\n        );\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(\n            cssText,\n            selector,\n            null,\n            styleInfo.placeholder\n          );\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(\n      /** @type {HTMLStyleElement} */ (style)\n    );\n    let self = this;\n    style.textContent = StyleUtil.toCssText(rules, function (\n      /** StyleNode */ rule\n    ) {\n      let css = (rule['cssText'] = rule['parsedCssText']);\n      if (\n        /** @type {?} */ (rule.propertyInfo) &&\n        /** @type {?} */ (rule.propertyInfo).cssText\n      ) {\n        // remove property assignments\n        // so next function isn't confused\n        // NOTE: we have 3 categories of css:\n        // (1) normal properties,\n        // (2) custom property assignments (--foo: red;),\n        // (3) custom property usage: border: var(--foo); @apply(--foo);\n        // In elements, 1 and 3 are separated for efficiency; here they\n        // are not and this makes this case unique.\n        css = removeCustomPropAssignment(/** @type {string} */ (css));\n        // replace with reified properties, scenario is same as mixin\n        rule['cssText'] = self.valueForProperties(css, properties);\n      }\n    });\n  }\n}\n\n/**\n * @param {number} n\n * @param {Array<number>} bits\n */\nfunction addToBitMask(n, bits) {\n  let o = parseInt(n / 32, 10);\n  let v = 1 << n % 32;\n  bits[o] = (bits[o] || 0) | v;\n}\n\nexport default new StyleProperties();\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {StyleNode} from './css-parse.js'; // eslint-disable-line @typescript-eslint/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(\n    ast,\n    placeholder,\n    ownStylePropertyNames,\n    elementName,\n    typeExtension,\n    cssBuild\n  ) {\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(\n      /** @type {!CustomElementRegistry} */ (ce),\n      name,\n      clazz,\n      options\n    );\n  };\n  ce['define'] = wrappedDefine;\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n'use strict';\n\nexport default class StyleCache {\n  constructor(typeMax = 100) {\n    // map element name -> [{properties, styleElement, scopeSelector}]\n    this.cache = {};\n    /** @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 @typescript-eslint/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 (\n    !templateIsValid(template) &&\n    template[VALIDATING_VERSION] === template[NEXT_VERSION]\n  );\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';\n// prettier-ignore\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"]}