{"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","constructor","StyleNode","parse","text","replace","RX$$module$src$css_parse.comments","RX$$module$src$css_parse.port","parseCss","root","length","n","i","l","OPEN_BRACE","p","previous","push","CLOSE_BRACE","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","navigator","userAgent","CSS","supports","cssBuild","ShadyCSS","undefined","nativeCss","nativeCssVariables","module$src$style_settings.cssBuild","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","compareDocumentPosition","position","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$","childNodes","_content","children","shouldRemoveScope","classList","remove","SCOPE_NAME","add","c","CLASS","newValue","domReplaceScope","oldScope","newScope","domRemoveScope","elementStyles","styleRules","css","ext","hostScope","_calcHostScope","_calcElementScope","CSS_CLASS_PREFIX","isScoped","_transformRule","transformedSelector","_transformRuleCss","_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","slottedIndex","SLOTTED","HOST","_transformHostSelector","_transformSimpleSelector","slotted","SLOTTED_PAREN","paren","DIR_PAREN","before","dir","attributes","output","PSEUDO_PREFIX","HOST_PAREN","SIMPLE_SELECTOR_PREFIX","host","SELECTOR_NO_MATCH","normalizeRootSelector","ROOT","_transformDocumentSelector","SCOPE_DOC_SELECTOR","$jscomp.global.Object.defineProperties","$jscompDefaultExport","StyleInfo","ast","placeholder","ownStylePropertyNames","overrideStyleProperties","customStyle","scopeSelector","styleProperties","get","set","styleInfo","_getStyleRules","prototype","matchesSelector","method","mozMatchesSelector","msMatchesSelector","oMatchesSelector","webkitMatchesSelector","IS_IE","StyleProperties","decorateStyles","props","keyframes","ruleIndex","decorateRule","propertyInfo","collectPropertiesInCssText","exec","name","onKeyframesRule","_keyframes","names","properties","collectProperties","collectCssText","collectConsumingCssText","Object","assign","any","valueForProperty","property","valueForProperties","propertyValue","lastIndex","colon","pp","propertyDataFromStyles","o","selectorToMatch","parseInt","key","whenHostOrRootRule","parsedSelector","isRoot","isHost","hostAndRootPropertiesForScope","hostProps","rootProps","_element","transformStyles","hostSelector","hostRx","RegExp","StyleInfo$$module$src$style_info.get","keyframeTransforms","_elementKeyframeTransforms","applyProperties","applyKeyframeTransforms","hasAnimations","keyframeNamesToTransform","keyframe","transform","_scopeSelector","keyframesRules","keyframesNameRx","_scopeKeyframes","transformedKeyframesName","scopeId","_keyframesRuleTransformer","applyCustomStyle","XSCOPE_NAME","placeholderMap","ce","origDefine","wrappedDefine","clazz","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","module$src$document_watcher.flush","templateMap","promise","Promise","resolve","invalidate","elementName","template","templateIsValid","startValidatingTemplate","_validating","then","styleCache","ScopingShim","_scopeCounter","_documentOwner","_documentOwnerStyleInfo","StyleInfo$$module$src$style_info.set","_elementsHaveApplied","_customStyleInterface","_applyShim","flush.prototype","getStyleAst.prototype","getStyleAst","styleAstToString.prototype","styleAstToString","prepareTemplate.prototype","prepareTemplate","prepareTemplateDom","prepareTemplateStyles","prepareTemplateStyles.prototype","_prepared","optimalBuild","styleTextParts","styles","querySelectorAll","hasAttribute","scopingAttribute","has","newStyle","cloneNode","appendChild","_ensure","hasMixins","ownPropertyNames","_generateStaticStyle","shadowroot","_style","_ownPropertyNames","prepareTemplateDom.prototype","_domPrepared","_prepareHost","_ensureCustomStyleInterface","CustomStyleInterface","transformCustomStyleForDocument","flushCustomStyles","_ensureApplyShim","ApplyShim","flushCustomStyles.prototype","customStyles","_revalidateCustomStyleApplyShim","_revalidateApplyShim","_updateProperties","_applyCustomStyles","styleDocument","styleElement.prototype","overrideProps","styleElementNativeVariables","removeProperty","setProperty","shadowRoot","querySelector","styleElementShimVariables","_applyStyleProperties","fetch","entry","_validate","pn","cachedStyle","cacheEntry","oldScopeSelector","id","_generateScopeSelector","applyElementStyle","applyElementScopeSelector","v","_styleOwnerForNode","owner","ownerStyleInfo","ownerProperties","create","hostAndRootProps","propertiesMatchingHost","_mixinOverrideStyles","overrides","reify","getOwnPropertyNames","styleDocument.prototype","styleSubtree","styleSubtree.prototype","shadowChildren","transformCustomStyleForDocument.prototype","documentRule","getComputedStyleValue.prototype","getComputedStyleValue","getComputedStyle","getPropertyValue","setElementClass.prototype","setElementClass","classString","classes","scopeName","classAttr","k$","_styleInfoForNode.prototype","_styleInfoForNode","scopeNode.prototype","scopeNode","unscopeNode.prototype","unscopeNode","scopeForNode.prototype","scopeForNode","currentScopeForNode.prototype","currentScopeForNode","defineProperties","scopingShim","elementExtends"],"mappings":"A;;;;;;;;;aAeA,IAAA,CAAA,CC4BAA,GAb2B,WAAlB,EAAC,MAAO,OAAR,EAAiC,MAAjC,GAa0B,IAb1B,CAa0B,IAb1B,CAEe,WAAlB,EAAC,MAAO,OAAR,EAA2C,IAA3C,EAAiC,MAAjC,CAAmD,MAAnD,CAW6B,IDxBjCC,SADIC,EACO,EAAG,CAIZ,IAAA,IAAA,CAFA,IAAA,MAEA,CAFgB,CAQhB,KAAA,MAAA,CAFA,IAAA,OAEA,CAJA,IAAA,SAIA,CAJmB,IAQnB,KAAA,QAAA,CAFA,IAAA,cAEA,CAFwB,EAIxB,KAAA,OAAA,CAAiB,CAAA,CAEjB,KAAA,KAAA,CAAe,CAMf,KAAA,eAAA,CAFA,IAAA,SAEA,CAJA,IAAA,cAIA,CAJwB,EApBZ;AAmCTC,QAASA,EAAK,CAACC,CAAD,CAAO,CAC1BA,CAAA,CAAaA,CAUNC,QAAA,CAAgBC,EAAhB,CAA6B,EAA7B,CAAAD,QAAA,CAAyCE,EAAzC,CAAkD,EAAlD,CATAC,KAAAA,EAAAA,EAAAA,CAAaJ,EAAAA,CAAbI,CAkBHC,EAAO,IAAIP,CACfO,EAAA,MAAA,CAAgB,CAChBA,EAAA,IAAA,CAAcL,CAAAM,OAEd,KADA,IAAIC,EAAIF,CAAR,CACSG,EAAI,CADb,CACgBC,EAAIT,CAAAM,OAApB,CAAiCE,CAAjC,CAAqCC,CAArC,CAAwCD,CAAA,EAAxC,CACE,GAuKeE,GAvKf,GAAIV,CAAA,CAAKQ,CAAL,CAAJ,CAA4B,CACrBD,CAAA,MAAL,GACEA,CAAA,MADF,CACe,EADf,CAGA,KAAII,EAAIJ,CAAR,CACIK,EAAWD,CAAA,MAAA,CAAWA,CAAA,MAAAL,OAAX,CAA+B,CAA/B,CAAXM,EAAgD,IACpDL,EAAA,CAAI,IAAIT,CACRS,EAAA,MAAA,CAAaC,CAAb,CAAiB,CACjBD,EAAA,OAAA,CAAcI,CACdJ,EAAA,SAAA,CAAgBK,CAChBD,EAAA,MAAAE,KAAA,CAAgBN,CAAhB,CAV0B,CAA5B,IAwKgBO,GA7JT,GAAId,CAAA,CAAKQ,CAAL,CAAJ,GACLD,CAAA,IACA,CADWC,CACX,CADe,CACf,CAAAD,CAAA,CAAIA,CAAA,OAAJ,EAAmBF,CAFd,CAlCT,OAAOD,EAAA,CAuCAC,CAvCA,CAAoBL,CAApB,CAFmB;AAkD5BI,QAASA,GAAQ,CAACW,CAAD,CAAOf,CAAP,CAAa,CAC5B,IAAIgB,EAAIhB,CAAAiB,UAAA,CAAeF,CAAA,MAAf,CAA8BA,CAAA,IAA9B,CAA4C,CAA5C,CACRA,EAAA,cAAA,CAAwBA,CAAA,QAAxB,CAA0CC,CAAAE,KAAA,EACtCH,EAAA,OAAJ,GAEEC,CASA,CATIhB,CAAAiB,UAAA,CADKF,CAAA,SAAAI,CAAmBJ,CAAA,SAAA,IAAnBI,CAA6CJ,CAAA,OAAA,MAClD,CAAmBA,CAAA,MAAnB,CAAmC,CAAnC,CASJ,CARAC,CAQA,CARII,EAAA,CAAsBJ,CAAtB,CAQJ,CAPAA,CAOA,CAPIA,CAAAf,QAAA,CAAUoB,EAAV,CAA6B,GAA7B,CAOJ,CAJAL,CAIA,CAJIA,CAAAC,UAAA,CAAYD,CAAAM,YAAA,CAAc,GAAd,CAAZ,CAAiC,CAAjC,CAIJ,CAHIC,CAGJ,CAHQR,CAAA,eAGR,CAHiCA,CAAA,SAGjC,CAHoDC,CAAAE,KAAA,EAGpD,CAFAH,CAAA,OAEA,CAF0C,CAE1C,GAFkBQ,CAAAC,QAAA,CAmJLC,GAnJK,CAElB,CAAIV,CAAA,OAAJ,CACiC,CAA/B,GAAIQ,CAAAC,QAAA,CA+IUE,QA/IV,CAAJ,CACEX,CAAA,KADF,CACiBY,EADjB,CAEWJ,CAAAK,MAAA,CAAQC,EAAR,CAFX,GAGEd,CAAA,KACA,CADee,CACf,CAAAf,CAAA,cAAA,CACEA,CAAA,SAAAgB,MAAA,CAAuBV,EAAvB,CAAAW,IAAA,EALJ,CADF,CAUIjB,CAAA,KAVJ,CAS+B,CAA7B,GAAIQ,CAAAC,QAAA,CAsIQS,IAtIR,CAAJ,CACiBC,EADjB,CAGiBC,EAvBrB,CA4BA,IADIC,CACJ,CADSrB,CAAA,MACT,CACE,IADM,IACGP,EAAI,CADP,CACUC,EAAI2B,CAAA9B,OADd,CACyB+B,EAAAA,IAAAA,EAA/B,CACG7B,CADH,CACOC,CADP,GACc4B,CADd,CACkBD,CAAA,CAAG5B,CAAH,CADlB,EAC0BA,CAAA,EAD1B,CAEEJ,EAAA,CAASiC,CAAT;AAAYrC,CAAZ,CAGJ,OAAOe,EArCqB,CA8C9BK,QAASA,GAAqB,CAACG,CAAD,CAAI,CAChC,MAAOA,EAAAtB,QAAA,CAAU,uBAAV,CAAmC,QAAQ,CAAA,CAAA,CAAA,CAAA,CAAG,CAC/CqC,CAAAA,CAAO,CAEX,KADEC,CACF,CADW,CACX,CADeD,CAAAhC,OACf,CAAOiC,CAAA,EAAP,CAAA,CACED,CAAA,CAAO,GAAP,CAAaA,CAEf,OAAO,IAAP,CAAcA,CANqC,CAA9C,CADyB;AAkB3BE,QAASA,GAAS,CAACzB,CAAD,CAAO0B,CAAP,CAA2BzC,CAA3B,CAAsC,CAAXA,CAAA,CAAA,IAAA,EAAA,GAAAA,CAAA,CAAO,EAAP,CAAAA,CAElD,KAAI0C,EAAU,EACd,IAAI3B,CAAA,QAAJ,EAAuBA,CAAA,MAAvB,CAAsC,CACpC,IAAIqB,EAAKrB,CAAA,MAAT,CACI,CAAA,IAAAqB,CAAA,CAAAA,CAAA,CAgCFC,CAhCQ,CAAAM,CAgCJ,CAAM,CAAN,CAhCI,CAAA,CAAA,CAAA,EAiCGN,CAjCH,EAiCiBA,CAAA,SAjCjB,EAiCwE,CAjCxE,GAiCmCA,CAAA,SAAAb,QAAA,CAuD/BS,IAvD+B,CAjCnC,CAAV,IAAI,CAAJ,CAA+B,CACpBzB,CAAAA,CAAI,CAAb,KAD6B,IACbC,EAAI2B,CAAA9B,OADS,CACE+B,EAAAA,IAAAA,EAA/B,CACG7B,CADH,CACOC,CADP,GACc4B,CADd,CACkBD,CAAA,CAAG5B,CAAH,CADlB,EAC0BA,CAAA,EAD1B,CAEEkC,CAAA,CAAUF,EAAA,CAAUH,CAAV,CAAaI,CAAb,CAAiCC,CAAjC,CAHiB,CAA/B,IAMYD,EAAA,CAAqB,CAArB,CAAqB,CAAA,QAArB,EACR,CAmCN,CAnCM,CAAA,QAmCN,CADAC,CACA,CADqCA,CAS9BzC,QAAA,CACI2C,EADJ,CACmB,EADnB,CAAA3C,QAAA,CAEI4C,EAFJ,CAEkB,EAFlB,CARP,CAAA,CAAA,CAA6BH,CAkBtBzC,QAAA,CACI6C,EADJ,CACmB,EADnB,CAAA7C,QAAA,CAEI8C,EAFJ,CAEiB,EAFjB,CAtDO,CAGV,EADAL,CACA,CAHUA,CAEAxB,KAAA,EACV,IACEwB,CADF,CACY,IADZ,CACmBA,CADnB,CAC6B,IAD7B,CAXkC,CAiBlCA,CAAJ,GACM3B,CAAA,SAIJ,GAHEf,CAGF,EAHUe,CAAA,SAGV,CAHgD,MAGhD,EADAf,CACA,EADQ0C,CACR,CAAI3B,CAAA,SAAJ,GACEf,CADF,EACU,OADV,CALF,CASA,OAAOA,EA7BsD;AAwE7DgD,IAAAA,GAAYA,CAAZA,CACAC,EAAgBA,CADhBD,CAEAE,GAAYA,CAFZF,CAGAG,GAAYA,GAHZH,CAWAI,GAAUA,mCAXVJ,CAYAK,GAAMA,kBAZNL,CAaAM,GAAYA,mDAbZN,CAcAO,GAAWA,4DAdXP,CAeAQ,GAAYA,yCAfZR,CAgBAS,GAAUA,2CAhBVT,CAiBAU,GAAeA,mBAjBfV,CAkBAW,GAAgBA,M,CEtPX,IAAMC,EAAe,EAAEC,MAAA,SAAF,EAAwBA,MAAA,SAAA,MAAxB,CAArB,CACHC,CAKJC,SAASA,GAAgB,CAACC,CAAD,CAAW,CAEhCF,CAAA,CADEE,CAAJ,EAAgBA,CAAA,kBAAhB,CACwB,CAAA,CADxB,CASwBJ,CATxB,EASwC,EAASK,SAAAC,UAAAtC,MAAA,CAA0B,2BAA1B,CAAT,EACpCuC,CAAAN,MAAAM,IADoC,EACtBC,CAAAD,GAAAC,SADsB,EACN,CAAAD,GAAAC,SAAA,CAAa,YAAb,CAA2B,kBAA3B,CADM,CAVN,CAgB7B,IAAIC,EACPR,OAAAS,SAAJ,EAAoDC,IAAAA,EAApD,GAAuBV,MAAAS,SAAAD,SAAvB,GACEA,EADF,CACaR,MAAAS,SAAAD,SADb,CAIIR,OAAAS,SAAJ,EAAqDC,IAAAA,EAArD,GAAuBV,MAAAS,SAAAE,UAAvB,CACEV,CADF,CACwBD,MAAAS,SAAAE,UADxB,CAEWX,MAAAS,SAAJ,EACLP,EAAA,CAAiBF,MAAAS,SAAjB,CAEA,CAAAT,MAAAS,SAAA,CAAkBC,IAAAA,EAHb,EAKLR,EAAA,CAAiBF,MAAA,cAAjB,EAA4CA,MAAA,cAAA,MAA5C,CAMK;IAAMY,EAA4CX,CAAlD,CAlBIY,EAAAL,E,CCxBJ,IAAMM,EAAa,yHAAnB,CACMC,EAAc,sCADpB,CAEMC,GAAe,2BAFrB,CAGMC,GAAkB,sCAHxB,CAIMC,GAAc,cAJpB,CAMMC,GAAY,Y,CCHzB,IAAMC,GAAe,IAAIC,G,CCSlBC,QAASA,EAAU,CAACxC,CAAD,CAAQyC,CAAR,CAAkB,CAC1C,GAAI,CAACzC,CAAL,CACE,MAAO,EAEY,SAArB,GAAI,MAAOA,EAAX,GACEA,CADF,CACU5C,CAAA,CAAM4C,CAAN,CADV,CAGIyC,EAAJ,EACEC,CAAA,CAAY1C,CAAZ,CAAmByC,CAAnB,CAEF,OAAO5C,GAAA,CAAUG,CAAV,CAAiB8B,CAAjB,CAVmC,CAiBrCa,QAASA,EAAa,CAACC,CAAD,CAAQ,CAC/B,CAACA,CAAA,WAAL,EAA4BA,CAAAC,YAA5B,GACED,CAAA,WADF,CACwBxF,CAAA,CAAMwF,CAAAC,YAAN,CADxB,CAGA,OAAOD,EAAA,WAAP,EAA8B,IAJK,CAc9BE,QAASA,GAAmB,CAACC,CAAD,CAAO,CACxC,MAAO,CAAA,CAAQA,CAAA,OAAf,EACAA,CAAA,OAAA,KADA,GAC2B5D,CAFa,CAWnCuD,QAASA,EAAW,CAACtE,CAAD,CAAO4E,CAAP,CAA0BC,CAA1B,CAAiDC,CAAjD,CAAkE,CAC3F,GAAK9E,CAAL,CAAA,CAGA,IAAI+E,EAAY,CAAA,CAAhB,CACIC,EAAOhF,CAAA,KACX,IAAI8E,CAAJ,EACME,CADN,GACepE,EADf,CACiC,CAC7B,IAAIqE,EAAajF,CAAA,SAAAa,MAAA,CAAuBmD,EAAvB,CACbiB,EAAJ,GAEOnC,MAAAmC,WAAA,CAAkBA,CAAA,CAAW,CAAX,CAAlB,CAAAC,QAFP,GAGIH,CAHJ,CAGgB,CAAA,CAHhB,EAF6B,CAU7BC,CAAJ,GAAa5D,EAAb,CACEwD,CAAA,CAAkB5E,CAAlB,CADF,CAEW6E,CAAJ,EACLG,CADK,GACIjE,CADJ,CAEL8D,CAAA,CAAsB7E,CAAtB,CAFK,CAGIgF,CAHJ,GAGa7D,EAHb,GAIL4D,CAJK,CAIO,CAAA,CAJP,CAOP,KADI1D,CACJ,CADSrB,CAAA,MACT,GAAU,CAAC+E,CAAX,CACE,IAAStF,CAAkB6B,CAAhB,CAAgBA,CAAb5B,CAAa4B,CAAXD,CAAA9B,OAAW+B,CAAAA,CAAAA,CAAAA,IAAAA,EAA3B,CAA+B7B,CAA/B,CAAiCC,CAAjC,GAAwC4B,CAAxC,CAA0CD,CAAA,CAAG5B,CAAH,CAA1C,EAAkDA,CAAA,EAAlD,CACE6E,CAAA,CAAYhD,CAAZ,CAAesD,CAAf,CAAkCC,CAAlC,CAAyDC,CAAzD,CA3BJ,CAD2F;AAyCtFK,QAASA,EAAQ,CAACxD,CAAD,CAAUyD,CAAV,CAAmBC,CAAnB,CAA2BC,CAA3B,CAAwC,CAY9D,IAAId,EAAwCe,QAAAC,cAAA,CAAuB,OAAvB,CAXNJ,EAYtC,EACEZ,CAAAiB,aAAA,CAAmB,OAAnB,CAboCL,CAapC,CAEFZ,EAAAC,YAAA,CAf6B9C,CAC7B+D,GAAA,CAeOlB,CAfP,CAAkBa,CAAlB,CAA0BC,CAA1B,CACA,OAcOd,EAjBuD,CAwBhE,IAAImB,EAAoB,IAOjBC,SAASA,GAAqB,CAACR,CAAD,CAAU,CACzCS,CAAAA,CAAcN,QAAAO,cAAA,CAAuB,wBAAvB,CAChBV,CADgB,CACN,GADM,CAIlB,KAAIW,EAAQR,QAAAS,KACZD,EAAAE,aAAA,CAAmBJ,CAAnB,EAHYF,CAAAO,CACVP,CAAA,YADUO,CACyB,IAErC,GAAyCH,CAAAI,WAAzC,CAEA,OADAR,EACA,CADoBE,CAPyB,CAgBxCH,QAASA,GAAU,CAAClB,CAAD,CAAQa,CAAR,CAAgBC,CAAhB,CAA6B,CACrDD,CAAA,CAASA,CAAT,EAAmBE,QAAAS,KAGnBX,EAAAY,aAAA,CAAoBzB,CAApB,CAFac,CAEb,EAF4BA,CAAAc,YAE5B,EADEf,CAAAc,WACF,CACKR,EAAL,CAIiBnB,CAAA6B,wBAAAC,CAA8BX,CAA9BW,CAJjB,GAKmBC,IAAAC,4BALnB,GAMIb,CANJ,CAMwBnB,CANxB,EACEmB,CADF,CACsBnB,CAN+B;AA+BhDiC,QAASA,EAAiB,CAACxH,CAAD,CAAOyH,CAAP,CAAc,CAE7C,IADA,IAAIC,EAAQ,CAAZ,CACkBjH,EAAET,CAAAM,OAApB,CAAiCE,CAAjC,CAAqCC,CAArC,CAAwCD,CAAA,EAAxC,CACE,GAAgB,GAAhB,GAAIR,CAAA,CAAKQ,CAAL,CAAJ,CACEkH,CAAA,EADF,KAEO,IAAgB,GAAhB,GAAI1H,CAAA,CAAKQ,CAAL,CAAJ,EACW,CADX,GACD,EAAEkH,CADD,CAEH,MAAOlH,EAIb,OAAQ,EAXqC,CAkBxCmH,QAASA,GAA0B,CAACC,CAAD,CAAMxC,CAAN,CAAgB,CAExD,IAAIqC,EAAQG,CAAApG,QAAA,CAAY,MAAZ,CACZ,IAAe,EAAf,GAAIiG,CAAJ,CAEE,MAAOrC,EAAA,CAASwC,CAAT,CAAc,EAAd,CAAkB,EAAlB,CAAsB,EAAtB,CAGT,KAAIC,EAAML,CAAA,CAAkBI,CAAlB,CAAuBH,CAAvB,CAA+B,CAA/B,CAAV,CACIK,EAAQF,CAAA3G,UAAA,CAAcwG,CAAd,CAAsB,CAAtB,CAAyBI,CAAzB,CACRE,EAAAA,CAASH,CAAA3G,UAAA,CAAc,CAAd,CAAiBwG,CAAjB,CAETO,EAAAA,CAASL,EAAA,CAA2BC,CAAA3G,UAAA,CAAc4G,CAAd,CAAoB,CAApB,CAA3B,CAAmDzC,CAAnD,CACT6C,EAAAA,CAAQH,CAAAtG,QAAA,CAAc,GAAd,CAEZ,OAAe,EAAf,GAAIyG,CAAJ,CAES7C,CAAA,CAAS2C,CAAT,CAAiBD,CAAA5G,KAAA,EAAjB,CAA+B,EAA/B,CAAmC8G,CAAnC,CAFT,CAOO5C,CAAA,CAAS2C,CAAT,CAFKD,CAAA7G,UAAA,CAAgB,CAAhB,CAAmBgH,CAAnB,CAAA/G,KAAAgH,EAEL,CADQJ,CAAA7G,UAAA,CAAgBgH,CAAhB,CAAwB,CAAxB,CAAA/G,KAAAiH,EACR,CAAkCH,CAAlC,CAtBiD,CA6BnDI,QAASA,EAAkB,CAACC,CAAD,CAAUH,CAAV,CAAiB,CAE7CtE,CAAJ,CACEyE,CAAA7B,aAAA,CAAqB,OAArB,CAA8B0B,CAA9B,CADF,CAGErE,MAAA,SAAA,cAAA,aAAAyE,KAAA,CAAyDD,CAAzD,CAAkE,OAAlE,CAA2EH,CAA3E,CAL+C;AAS5C,IAAMK,EAAO1E,MAAA,SAAP0E,EAA6B1E,MAAA,SAAA,KAA7B0E,EAA4D,QAAA,CAACxH,CAAD,CAAUA,CAAAA,MAAAA,EAAAA,CAM5EyH,SAASA,EAAY,CAACH,CAAD,CAAU,CACpC,IAAII,EAAYJ,CAAA,UAAhB,CACaK,EAAgB,EAKzBD,EAAJ,CACgC,EADhC,CACMA,CAAAjH,QAAA,CAAkB,GAAlB,CADN,GAIIkH,CACA,CADgBD,CAChB,CAAAE,CAAA,CAAMN,CAAAO,aAAN,EAA8BP,CAAAO,aAAA,CAAqB,IAArB,CAA9B,EAA6D,EALjE,GAQED,CACA,CADsBN,CAADM,GACrB,CAAAD,CAAA,CAAiCL,CAADQ,QATlC,CAWA,OAAO,CAACF,GAAAA,CAAD,CAAKD,EAAAA,CAAL,CAlB6B,CAiD/BI,QAASA,GAAiB,CAACC,CAAD,CAAW,CAG1C,IAFA,IAAMC,EAAQ,EAAd,CACIC,EAAO,EADX,CAESzI,EAAI,CAAb,CAAqB,CAArB,EAAgBA,CAAhB,EAA0BA,CAA1B,CAA8BuI,CAAAzI,OAA9B,CAA+CE,CAAA,EAA/C,CAEE,GAAoB,GAApB,GAAIuI,CAAA,CAASvI,CAAT,CAAJ,CAAyB,CAEvB,IAAMqH,EAAML,CAAA,CAAkBuB,CAAlB,CAA4BvI,CAA5B,CAEZyI,EAAA,EAAQF,CAAAG,MAAA,CAAe1I,CAAf,CAAkBqH,CAAlB,CAAwB,CAAxB,CAERrH,EAAA,CAAIqH,CANmB,CAAzB,IAO2B,GAApB,GAAIkB,CAAA,CAASvI,CAAT,CAAJ,EACLwI,CAAAnI,KAAA,CAAWoI,CAAX,CACA,CAAAA,CAAA,CAAO,EAFF,EAILA,CAJK,EAIGF,CAAA,CAASvI,CAAT,CAIRyI,EAAJ,EACED,CAAAnI,KAAA,CAAWoI,CAAX,CAEF,OAAOD,EAvBmC;AAkCrCG,QAASA,EAAW,CAACd,CAAD,CAAU,CACnC,GAAiB9D,IAAAA,EAAjB,GAAIG,CAAJ,CACE,MAA6BA,EAE/B,IAA2BH,IAAAA,EAA3B,GAAI8D,CAAAe,WAAJ,CAAsC,CAEpC,IAAMC,EAAYhB,CAAAO,aAAA,CAdCU,WAcD,CAClB,IAAID,CAAJ,CACEhB,CAAAe,WAAA,CAAqBC,CADvB,KAEO,CAsC8B,CAAA,CAAA,CACjCE,CAAAA,CAAqC,UAAtB,GAtCoBlB,CAsCpBI,UAAA,CAtCoBJ,CAuCDmB,QAAAtC,WADnB,CAtCoBmB,CAwCrCnB,WACJ,IAAIqC,CAAJ,WAA4BE,QAA5B,GACQC,CACF,CADiBH,CAAA/D,YAAAtE,KAAA,EAAAa,MAAA,CAAsC,GAAtC,CACjB,CA7DeuH,WA6Df,GAAAI,CAAA,CAAa,CAAb,CAFN,EAE0C,CACtC,CAAA,CAAOA,CAAA,CAAa,CAAb,CAAP,OAAA,CADsC,CAI1C,CAAA,CAAO,EAVgC,CApCnC,GAAqB,EAArB,GAAIH,CAAJ,CAAA,CAmEJ,IAAMA,EAAqC,UAAtB,GAjEIlB,CAiEJI,UAAA,CAjEIJ,CAkEemB,QAAAtC,WADnB,CAjEImB,CAmErBnB,WACJqC,EAAAI,WAAAC,YAAA,CAAoCL,CAApC,CAtEI,CAIAlB,CAAAe,WAAA,CAAqBG,CANhB,CAL6B,CActC,MAAOlB,EAAAe,WAAP,EAA6B,EAlBM;AAkE9BS,QAASA,GAAiB,CAACxF,CAAD,CAAgB,CAAfA,CAAA,CAAA,IAAA,EAAA,GAAAA,CAAA,CAAW,EAAX,CAAAA,CAEhC,OAAiB,EAAjB,GAAIA,CAAJ,EAAwBI,CAAxB,CAGOb,CAAA,CAA4B,QAA5B,GAAeS,CAAf,CAAoD,OAApD,GAAuCA,CAH9C,CACS,CAAA,CAHsC,C,CCpWjD,QAAMyF,EAAN,EAAA,EAwBEC,QAAAA,GAAWA,CAAChJ,CAADgJ,CAAOjD,CAAPiD,CAAcA,CAIvBC,CAAAD,CC8DED,CD9DFC,CAAmBhJ,CAAnBgJ,CAHWE,QAAAF,CAAChJ,CAADgJ,CAAUA,CACnB1B,CAAA0B,CAAahJ,CAAbgJ,CAAmBjD,CAAnBiD,EAA4BA,EAA5BA,CADmBA,CAGrBA,CAJuBA,CAWzBC,QAAAA,EAAaA,CAAbA,CAAaA,CAACE,CAADF,CAAYG,CAAZH,CAAyBA,CAChCE,CAAAE,SAAJJ,GAA2B1C,IAAA+C,aAA3BL,EACEG,CAAAH,CAAYE,CAAZF,CAEFA,KAAIM,CACwBN,WAA5BA,GAAIE,CAAAzB,UAAJuB,CAIEM,CAJFN,CAIOO,CAHiDL,CAGhDV,QAADe,EAHiDL,CAG5BM,SAArBD,EAHiDL,CAGjDK,YAJPP,CAMEM,CANFN,CAMmCE,CAADO,SANlCT,EAOME,CAAAK,WAENP,IAAIM,CAAJN,CACEA,IAASxJ,CAATwJ,CAAaA,CAAbA,CAAgBxJ,CAAhBwJ,CAAoBM,CAAAhK,OAApB0J,CAA+BxJ,CAAAwJ,EAA/BA,CACEA,CAAAA,CAAAA,CAAAA,CAAmBM,CAAAN,CAAGxJ,CAAHwJ,CAAnBA,CAA0BG,CAA1BH,CAhBgCA;AA0BtC3B,QAAAA,EAAOA,CAACA,CAADA,CAAUvB,CAAVuB,CAAiBqC,CAAjBrC,CAAoCA,CAIzCA,GAAIvB,CAAJuB,CAEEA,GAAIA,CAAAsC,UAAJtC,CACMqC,CAAJrC,EACEA,CAAAsC,UAAAC,OAAAvC,CAvESwC,aAuETxC,CACAA,CAAAA,CAAAsC,UAAAC,OAAAvC,CAAyBvB,CAAzBuB,CAFFA,GAIEA,CAAAsC,UAAAG,IAAAzC,CA1ESwC,aA0ETxC,CACAA,CAAAA,CAAAsC,UAAAG,IAAAzC,CAAsBvB,CAAtBuB,CALFA,CADFA,KAQOA,IAAIA,CAAAO,aAAJP,CAA0BA,CAC/BA,IAAI0C,EAAI1C,CAAAO,aAAAP,CA+WF2C,OA/WE3C,CACJqC,EAAJrC,CACM0C,CADN1C,GAEQ4C,CACJ5C,CADe0C,CAAA9K,QAAAoI,CAjFRwC,aAiFQxC,CAAsBA,EAAtBA,CAAApI,QAAAoI,CAAkCvB,CAAlCuB,CAAyCA,EAAzCA,CACfA,CAAUA,CAAVA,CAA6BA,CAA7BA,CAAsC4C,CAAtC5C,CAHJA,EAOYA,CAAVA,CAA6BA,CAA7BA,EADgB0C,CAAA1C,CAAI0C,CAAJ1C,CAAQA,GAARA,CAAcA,EAC9BA,EADiDA,cACjDA,CADuDvB,CACvDuB,CAT6BA,CAdMA,CAmC3C6C,QAAAA,GAAeA,CAACnK,CAADmK,CAAOC,CAAPD,CAAiBE,CAAjBF,CAA2BA,CAKxClB,CAAAkB,CEQMpB,CFRNoB,CAAmBnK,CAAnBmK,CAJWjB,QAAAiB,CAACnK,CAADmK,CAAUA,CACnB7C,CAAA6C,CAAanK,CAAbmK,CAAmBC,CAAnBD,CAA6BA,CAAAA,CAA7BA,CACA7C,EAAA6C,CAAanK,CAAbmK,CAAmBE,CAAnBF,CAFmBA,CAIrBA,CALwCA,CAY1CG,QAAAA,GAAcA,CAACtK,CAADsK,CAAOF,CAAPE,CAAiBA,CAI7BrB,CAAAqB,CERIvB,CFQJuB,CAAmBtK,CAAnBsK,CAHWpB,QAAAoB,CAACtK,CAADsK,CAAUA,CACnBhD,CAAAgD,CAAatK,CAAbsK,CAAmBF,CAAnBE,EAA+BA,EAA/BA,CAAmCA,CAAAA,CAAnCA,CADmBA,CAGrBA,CAJ6BA;AAe/BC,QAAAA,EAAaA,CAACjD,CAADiD,CAAUC,CAAVD,CAAsBlG,CAAtBkG,CAAgCjH,CAAhCiH,CAA+C5I,CAA/C4I,CAA6DA,CAA1EA,IAAAA,EGuOSxB,CHvOmDpH,EAAA4I,CAAAA,IAAAA,EAAAA,GAAA5I,CAAA4I,CAAUA,EAAVA,CAAA5I,CAO1C4I,GAAhBA,GAAI5I,CAAJ4I,GACM1H,CAAJ0H,EAAiCA,OAAjCA,IARyCA,IAAAA,EAAAA,GAAAjH,CAAAiH,CAAWA,EAAXA,CAAAjH,CAQzCiH,EACE5I,CADF4I,CACsBA,CAAVA,CAAoBC,CAApBD,CAAgClG,CAAhCkG,CADZA,EAGMA,CACJA,CADoCA,CAAVA,CAAuBjD,CAAvBiD,CAC1BA,CAAA5I,CAAA4I,CAAUE,EAAAF,CAAAA,CAAAA,CAASC,CAATD,CADLA,CAAAA,GACKA,CADDA,CAAAA,EACCA,CAAwClG,CAAxCkG,CAAVA,CAA8DA,MAJhEA,CADFA,CAQAA,OAAO5I,EAAAxB,KAAAoK,EAfiEA,CAsB1EE,QAAAA,GAAGA,CAAHA,CAAGA,CAAC7I,CAAD6I,CAAQ1E,CAAR0E,CAAeC,CAAfD,CAAoBpG,CAApBoG,CAA8BA,CAC/BA,IAAIE,EAAYC,EAAAH,CAAoB1E,CAApB0E,CAA2BC,CAA3BD,CAChB1E,EAAA0E,CAA+B1E,CAc/B8E,CAwRqBC,GAxRrBD,CAd+B9E,CAc/B8E,CAGSA,EAfTJ,OAAiBA,EAAVA,CAAoB7I,CAApB6I,CAA2BA,QAAQA,CAAiB9F,CAAjB8F,CAAuBA,CAC1D9F,CAAAoG,EAALN,GACY9F,CAqCdqG,SApCIP,CADU9F,CAqCKsG,EApCfR,CAqCFS,EAAAF,CAzCSP,CAyCTO,CAtCYrG,CAsCZqG,CAzCSP,CAyBeU,EAgBxBH,CAtCkBjF,CAsClBiF,CAtCyBL,CAsCzBK,CArCEP,CAAA9F,CAAAoG,EAAAN,CAAgBA,CAAAA,CAFlBA,CAIIpG,EAAJoG,EACEpG,CAAAoG,CAAS9F,CAAT8F,CAAe1E,CAAf0E,CAAsBE,CAAtBF,CAN6DA,CAA1DA,CAJwBA,CAuBjCG,QAAAA,GAAcA,CAAC7E,CAAD6E,CAAQF,CAARE,CAAaA,CACzBA,MAAOF,EAAAE,CAAMA,MAANA,CAAa7E,CAAb6E,CAAkBA,GAAlBA,CAAwB7E,CADN6E,CA8B3BM,QAAAA,GAAiBA,CAAjBA,CAAiBA,CAACvG,CAADuG,CAAO9B,CAAP8B,CAAoBnF,CAApBmF,CAA2BP,CAA3BO,CAAsCA,CACrDA,IAAIE,EAAeF,EAAVA,CAA4BvG,CAAAuG,SAA5BA,CAGTA,IAAIA,CAAWA,EAAVA,CAA8BvG,CAA9BuG,CAALA,CAA0CA,CAC/BzL,CAAAA,CAAEyL,CAAXA,KADwCA,IAC1BxL,EAAE0L,CAAA7L,OADwB2L,CACbtL,EAAAA,IAAAA,EAA3BsL,CAA+BzL,CAA/ByL,CAAiCxL,CAAjCwL,GAAwCtL,CAAxCsL,CAA0CE,CAAAF,CAAGzL,CAAHyL,CAA1CA,EAAkDzL,CAAAyL,EAAlDA,CACEE,CAAAF,CAAGzL,CAAHyL,CAAAA,CAAQ9B,CAAA7B,KAAA2D,CAAiBA,CAAjBA,CAAuBtL,CAAvBsL,CAA0BnF,CAA1BmF,CAAiCP,CAAjCO,CAF8BA,CAK1CA,MAAOE,EAAAC,OAAAH,CAAUA,QAAAA,CAAChD,CAADgD,CAAUA,CAAAA,MAAAA,CAAAA,CAAQhD,CAARgD,CAApBA,CAAAI,KAAAJ,CA4NkBK,GA5NlBL,CAT8CA;AAgBvDM,QAAAA,GAAeA,CAACxD,CAADwD,CAAWA,CACxBA,MAAOxD,EAAA9I,QAAAsM,CAAiBC,EAAjBD,CAAsBA,QAAAA,CAACE,CAADF,CAAIxG,CAAJwG,CAAUG,CAAVH,CAAqBA,CACrBA,EAA3BA,CAAIG,CAAAlL,QAAA+K,CAAeA,GAAfA,CAAJA,CACEG,CADFH,CACWG,CAAAzM,QAAAsM,CAAeA,KAAfA,CAAsBA,KAAtBA,CADXA,CAEoCA,EAFpCA,CAEWG,CAAAlL,QAAA+K,CAAeA,KAAfA,CAFXA,GAGEG,CAHFH,CAGWG,CAAAzM,QAAAsM,CAAeA,MAAfA,CAAuBA,GAAvBA,CAHXA,CAKAA,OAAOA,GAAPA,CAAWxG,CAAXwG,CAAeA,GAAfA,CAAmBG,CAAnBH,CAAyBA,GANuBA,CAA3CA,CADiBA,CAmB1BI,QAAAA,GAAsBA,CAAC5D,CAAD4D,CAAWA,CAI/BA,IAFAA,IAAM1G,EAAU0G,EAAhBA,CACI/K,CACJ+K,CAAQ/K,CAAR+K,CAAgB5D,CAAAnH,MAAA+K,CAAeC,EAAfD,CAAhBA,CAAAA,CAA0CA,CACxCA,IAAMlF,EAAQ7F,CAAAiL,MAAdF,CACM9E,EAAgB8E,CAAVA,CAA4B5D,CAA5B4D,CAAsClF,CAAtCkF,CACZA,IAAaA,EAAbA,GAAI9E,CAAJ8E,CACEA,KAAUG,MAAJH,CAAa/K,CAAAmL,MAAbJ,CAAwBA,uBAAxBA,CAANA,CAEI1D,CAAAA,CAAOF,CAAAG,MAAAyD,CAAelF,CAAfkF,CAAsB9E,CAAtB8E,CAA4BA,CAA5BA,CACb5D,EAAA4D,CAAW5D,CAAA9I,QAAA0M,CAAiB1D,CAAjB0D,CA0MWK,QA1MXL,CACX1G,EAAApF,KAAA8L,CAAa1D,CAAb0D,CARwCA,CAU1CA,MAAOA,CAAC5D,EAAAA,CAAD4D,CAAW1G,QAAAA,CAAX0G,CAdwBA,CAyBjCM,QAAAA,GAAqBA,CAAClE,CAADkE,CAAWhH,CAAXgH,CAAoBA,CACvCA,IAAMjE,EAAQD,CAAAhH,MAAAkL,CA2LUD,QA3LVC,CACdA,OAAOhH,EAAAiH,OAAAD,CAAeA,QAAAA,CAACE,CAADF,CAAMG,CAANH,CAAWI,CAAXJ,CAAmBA,CAAAA,MAAAE,EAAAF,CAAMG,CAANH,CAAYjE,CAAAiE,CAAMI,CAANJ,CAAYA,CAAZA,CAAZA,CAAlCA,CAA8DjE,CAAAiE,CAAMA,CAANA,CAA9DA,CAFgCA;AAUzCf,CAAAA,UAAAA,EAAAA,CAAAA,QAAyBA,CAACnD,CAADmD,CAAWpF,CAAXoF,CAAkBR,CAAlBQ,CAA6BA,CACpDA,IAAIoB,EAAOpB,CAAAA,CACXnD,EAAAmD,CAAWnD,CAAA7H,KAAAgL,EAEXA,KAAIqB,EAAQf,EAAAgB,KAAAtB,CAASnD,CAATmD,CACRqB,EAAJrB,GACEnD,CACAmD,CADWnD,CAAA9I,QAAAiM,CAAiBM,EAAjBN,CAAsBA,QAAAA,CAACO,CAADP,CAAInG,CAAJmG,CAAUpE,CAAVoE,CAAoBA,CAAAA,MAAAA,GAAAA,CAAInG,CAAJmG,CAAQA,GAARA,CAAYpE,CAAA7H,QAAAiM,CAAcA,KAAdA,CAAqBA,EAArBA,CAAZA,CAAoCA,GAApCA,CAA1CA,CACXA,CAAAnD,CAAAmD,CAAWK,EAAAL,CAAqBnD,CAArBmD,CAFbA,CAMAA,KAAMuB,EAAYb,EAAAY,KAAAtB,CAAanD,CAAbmD,CAGlBA,IAAIuB,CAAJvB,CAAeA,CACZA,IAAAA,EAAsBS,EAAAT,CAA4BnD,CAA5BmD,CAArBnD,EAAAmD,CAAAA,CAAAA,EAAUjG,EAAAiG,CAAAA,CAAAA,QADCA,CAGfnD,CAAAmD,CAAWnD,CAAA9I,QAAAiM,CAAiBwB,EAAjBxB,CAAgCA,UAAhCA,CACXnD,EAAAmD,CAAWnD,CAAA9I,QAAAiM,CAAiByB,EAAjBzB,CAAsCA,QAAAA,CAACO,CAADP,CAAInB,CAAJmB,CAAO3K,CAAP2K,CAAaA,CACvDoB,CAALpB,GACM0B,CAGJ1B,CAHW2B,EAAA3B,CAAgC3K,CAAhC2K,CAAmCnB,CAAnCmB,CAAsCpF,CAAtCoF,CAA6CR,CAA7CQ,CAGXA,CAFAoB,CAEApB,CAFOoB,CAEPpB,EAFe0B,CAAAN,KAEfpB,CADAnB,CACAmB,CADI0B,CAAAE,EACJ5B,CAAA3K,CAAA2K,CAAI0B,CAAA1F,MAJNgE,CAMAA,OAAOnB,EAAPmB,CAAW3K,CAPiD2K,CAAnDA,CAUPuB,EAAJvB,GACEnD,CADFmD,CACae,EAAAf,CAA2BnD,CAA3BmD,CAAqCjG,CAArCiG,CADbA,CAGIqB,EAAJrB,GACEnD,CADFmD,CACaK,EAAAL,CAAqBnD,CAArBmD,CADbA,CAGAA,OAAOnD,EAlC6CmD,CAqCtD2B;QAAAA,GAA0BA,CAAC9E,CAAD8E,CAAWC,CAAXD,CAAuB/G,CAAvB+G,CAA8BnC,CAA9BmC,CAAyCA,CAEjEA,IAAIE,EAAehF,CAAAvH,QAAAqM,CA6HPG,WA7HOH,CACWA,EAA9BA,EAAI9E,CAAAvH,QAAAqM,CA0HKI,OA1HLJ,CAAJA,CACE9E,CADF8E,CACaK,EAAAL,CAA4B9E,CAA5B8E,CAAsCnC,CAAtCmC,CADbA,CAG4BA,CAH5BA,GAGWE,CAHXF,GAIE9E,CAJF8E,CAIa/G,CAAA+G,CAAQM,EAAAN,CAA8B9E,CAA9B8E,CAAwC/G,CAAxC+G,CAARA,CACT9E,CALJ8E,CASIO,EAAAA,CAAUP,CAAAA,CACMA,EAApBA,EAAIE,CAAJF,GACEC,CACAD,CADaA,EACbA,CAAAO,CAAAP,CAAUA,CAAAA,CAFZA,CAMAA,IAAIO,CAAJP,CAAaA,CACXA,IAAAP,EAAOO,CAAAA,CACHO,EAAJP,GAEE9E,CAFF8E,CAEa9E,CAAA9I,QAAA4N,CAAiBQ,EAAjBR,CAAgCA,QAAAA,CAACpB,CAADoB,CAAIS,CAAJT,CAAcA,CAAAA,MAAAA,KAAAA,CAAMS,CAANT,CAA9CA,CAFbA,CAFWA,CAOb9E,CAAA8E,CAAW9E,CAAA9I,QAAA4N,CAAiBU,EAAjBV,CAA4BA,QAAAA,CAACpB,CAADoB,CAAIW,CAAJX,CAAYY,CAAZZ,CACrCA,CAAAA,MAAAA,QAAAA,CAASY,CAATZ,CAAYA,KAAZA,CAAkBW,CAAlBX,CAAwBA,IAAxBA,CAA6BW,CAA7BX,CAAmCA,QAAnCA,CAA4CY,CAA5CZ,CAA+CA,IAA/CA,CADSA,CAEXA,OAAOA,CAAC3F,MAAOa,CAAR8E,CAAkBC,EAAAA,CAAlBD,CAA8BP,KAAAA,CAA9BO,CA5B0DA,CA+BnEM,QAAAA,GAAwBA,CAACpF,CAADoF,CAAWrH,CAAXqH,CAAkBA,CAClCO,CAAAA,CAAa3F,CAAAhH,MAAAoM,CAAeA,WAAfA,CAGnBA,KADAA,IAAMQ,EAASR,EAAfA,CACS3N,EAAI2N,CAAbA,CAAgB3N,CAAhB2N,CAAoBO,CAAApO,OAApB6N,CAAuC3N,CAAA2N,EAAvCA,CAEEA,GAAgBA,CAAhBA,GAAK3N,CAAL2N,CAASA,CAATA,CACEQ,CAAA9N,KAAAsN,CAAYO,CAAAP,CAAW3N,CAAX2N,CAAZA,CADFA,KAEOA,CACLA,IAAMlF,EAAOyF,CAAAP,CAAW3N,CAAX2N,CAEbA,IAAeA,EAAfA,GAAMlF,CAANkF,EAAqB3N,CAArB2N,GAA2BO,CAAApO,OAA3B6N,CAA+CA,CAA/CA,CACMhC,CAEJgC,CAFSlF,CAAAlH,MAAAoM,CA8FGS,GA9FHT,CAETA,CADAhC,CAAAgC,CAAGA,CAAHA,CACAA,EADSrH,CACTqH,CAAAQ,CAAA9N,KAAAsN,CAAYhC,CAAAE,KAAA8B,CA4FAS,GA5FAT,CAAZA,CANGA,CAWTA,MAAOQ,EAAAtC,KAAA8B,CAAYA,EAAZA,CAnBiCA;AAuB1CD,QAAAA,GAAsBA,CAACnF,CAADmF,CAAWxC,CAAXwC,CAAsBA,CAC1CA,IAAIzB,EAAI1D,CAAAnH,MAAAsM,CAAeW,EAAfX,CAERA,OAAAA,CADII,CACJJ,CADYzB,CACZyB,EADiBzB,CAAAyB,CAAEA,CAAFA,CAAAhN,KAAAgN,EACjBA,EADgCA,EAChCA,EACOI,CAAAJ,CAAMA,CAANA,CAAAtM,MAAAsM,CAAeY,EAAfZ,CAALA,CAcSnF,CAAA9I,QAAAiO,CAAiBW,EAAjBX,CAA6BA,QAAQA,CAACzB,CAADyB,CAAIa,CAAJb,CAAUI,CAAVJ,CAAiBA,CAC3DA,MAAOxC,EAAPwC,CAAmBI,CADwCJ,CAAtDA,CAdTA,CAEqBI,CAAAvM,MAAAmM,CAAYY,EAAZZ,CAAAA,CAAoCA,CAApCA,CAEnBA,GAAqBxC,CAArBwC,CACSI,CADTJ,CA6EkBc,kBAlFtBd,CAyBSnF,CAAA9I,QAAAiO,CA2CAD,OA3CAC,CAAuBxC,CAAvBwC,CA5BiCA,CA6C5Ce,QAAAA,GAAqBA,CAACvJ,CAADuJ,CAAOA,CA2BjBC,OA1BTD,GAAIvJ,CAAAuJ,SAAJA,GACEvJ,CAAAuJ,SADFA,CACqBA,MADrBA,CAD0BA,CAS5BE,CAAAA,UAAAA,EAAAA,CAAAA,QAA0BA,CAACpG,CAADoG,CAAWA,CACnCA,MAAIpG,EAAAnH,MAAAuN,CAgBKlB,OAhBLkB,CAAJA,CAESA,EAFTA,CAGWpG,CAAAnH,MAAAuN,CAeCnB,WAfDmB,CAAJA,CACEA,IAAAjD,EAAAiD,CAA+BpG,CAA/BoG,CAQcC,oBARdD,CADFA,CAGEhB,EAAAgB,CAA8BpG,CAAA7H,KAAAiO,EAA9BA,CAMcC,oBANdD,CAP0BA,CA7ZvCE,GAAA,OAAA,iBAAA,CAAA,CAAA,UAAA,CAAA,CAAA,EACM,CAAA,aAAA,CAAA,CAAA,CAAA,WAAA,CAAA,CAAA,CAAA,IAAaxE,QAAA,EAAA,CACf,MAJeA,aAGA,CAAb,CADN,CAAA,CAyaA;IAAM2B,GAAM,yBAAZ,CAGMmB,GAAsB,wCAH5B,CAIMmB,GAAyB,SAJ/B,CAQMpB,GAAgB,cARtB,CAYMmB,GAAa,0CAZnB,CAcMR,GAAgB,gDAdtB,CAeME,GAAY,2BAflB,CAoBM3B,GAAU,sCApBhB,CAuBA0C,EAAe,IAAIxF,C,CIxbjBjK,QA7BmB0P,EA6BR,CAACC,CAAD,CAAMC,CAAN,CAAmBC,CAAnB,CAAuDhH,CAAvD,CAAsErE,CAAtE,CAAgF,CAEzF,IAAAkH,EAAA,CAAkBiE,CAAlB,EAAyB,IAEzB,KAAAC,EAAA,CAAmBA,CAAnB,EAAkC,IAElC,KAAAC,EAAA,CAA6BA,CAA7B,EAAsD,EAEtD,KAAAC,EAAA,CAA+B,IAI/B,KAAAtL,SAAA,CAAgBA,CAAhB,EAA4B,EAE5B,KAAAqE,EAAA,CAAqBA,CAArB,EAAsC,EAMtC,KAAAkH,EAAA,CAFA,IAAAC,EAEA,CAJA,IAAAC,EAIA,CAJuB,IAhBkE,CAxB3FC,QAAOA,EAAGA,CAAChP,CAADgP,CAAOA,CACfA,MAAIhP,EAAJgP,CACShP,CAAAgP,YADTA,CAGSA,IAJMA,CAYjBC,QAAOA,GAAGA,CAACjP,CAADiP,CAAOC,CAAPD,CAAkBA,CAE1BA,MADAjP,EAAAiP,YACAA,CADgBC,CADUD,CAkC5BE,CAAAA,UAAAA,EAAAA,CAAAA,QAAcA,EAAGA,CACfA,MAAOA,KAAA3E,EADQ2E,CAMnBX,EAAAY,UAAA,eAAA,CAAwCZ,CAAAY,UAAAD,E,CDjDhBE,QAAA,GAAQ,CAACrH,CAAD,CAAW,CACzC,IAAMsH,EAAS,IAAApK,QAAToK,EAAyB,IAAAD,gBAAzBC,EACJ,IAAAC,mBADID,EACuB,IAAAE,kBADvBF,EAEJ,IAAAG,iBAFIH,EAEqB,IAAAI,sBAC3B,OAAOJ,EAAP,EAAiBA,CAAA/H,KAAA,CAAY,IAAZ,CAAkBS,CAAlB,CAJwB,CAO3C,IAAM2H,GAAQzM,SAAAC,UAAAtC,MAAA,CAA0B,SAA1B,CAId,SAAM+O,GAAN,EAAA,EAUEC,QAAAA,GAAcA,CAACjO,CAADiO,CAAQA,CAAAA,IACHC,EAAQD,EADLA,CACSE,EAAYF,EADrBA,CACyBG,EAAYH,CAC/CA,EAAVA,CAAsBjO,CAAtBiO,CAA6BA,QAAQA,CAAClL,CAADkL,CAAOA,CAC1CI,CAAAJ,CAAkBlL,CAAlBkL,CAEAlL,EAAAmH,MAAA+D,CAAaG,CAAAH,EACmBlO,EAAAA,CAAAgD,CAAAuL,EAAAvO,QAwElCwO,KADAA,IAAIzE,CACJyE,CAAQzE,CAARyE,CAAeA,EAAHC,KAAAD,CAAqBxO,CAArBwO,CAAZA,CAAAA,CAA4CA,CAC1CA,IAAIE,EAAO3E,CAAAyE,CAAEA,CAAFA,CAGEA,IAAbA,GAAIzE,CAAAyE,CAAEA,CAAFA,CAAJA,GA5E2DL,CA6EzDK,CAAME,CAANF,CADFA,CACgBA,CAAAA,CADhBA,CAJ0CA,CA5EAN,CAA5CA,CAKGS,QAAwBT,CAAClL,CAADkL,CAAOA,CAChCE,CAAAjQ,KAAA+P,CAAelL,CAAfkL,CADgCA,CALlCA,CASAjO,EAAA2O,EAAAV,CAAmBE,CAEfS,EAAAA,CAAQX,EACZA,KAAKA,IAAIpQ,CAAToQ,GAAcC,EAAdD,CACEW,CAAA1Q,KAAA+P,CAAWpQ,CAAXoQ,CAEFA,OAAOW,EAjBaX;AAqBtBI,QAAAA,EAAYA,CAACtL,CAADsL,CAAOA,CACjBA,GAAIC,CAAAvL,CAAAuL,EAAJD,CAAAA,CADiBA,IAIbpD,EAAOoD,EAJMA,CAIFQ,EAAaR,EACRS,EAAAT,CAAuBtL,CAAvBsL,CAA6BQ,CAA7BR,CACpBA,GACEpD,CAAA4D,EAEAR,CAFkBQ,CAElBR,CAAAtL,CAAAsL,MAAAA,CAAgBA,IAHlBA,CAKApD,EAAAlL,QAAAsO,CAAmCtL,CAkCCgM,cAM7BzR,QAAA0R,CAAmBA,EAAnBA,CAA8BA,EAA9BA,CAAA1R,QAAA0R,CACOA,CADPA,CACmBA,EADnBA,CAvCPjM,EAAAuL,EAAAD,CAAoBpD,CAXpBoD,CADiBA,CAiBnBS,QAAAA,EAAiBA,CAAC/L,CAAD+L,CAAOD,CAAPC,CAAmBA,CAClCA,IAAI7D,EAAOlI,CAAAuL,EACXQ,IAAI7D,CAAJ6D,CACEA,IAAI7D,CAAA4D,EAAJC,CAEEA,MADAG,OAAAC,OAAAJ,CAAcD,CAAdC,CAA0B7D,CAAA4D,EAA1BC,CACOA,CAAAA,CAAAA,CAFTA,CADFA,IAKOA,CAED/O,CAAAA,CAAUgD,CAAA+L,cAGdA,KAFAA,IAAIvJ,CAEJuJ,CAAQhF,CAARgF,CAJeA,CAIHN,KAAAM,CAAQ/O,CAAR+O,CAAZA,CAAAA,CAA+BA,CAE7BvJ,CAAAuJ,CAAQvQ,CAACuL,CAAAgF,CAAEA,CAAFA,CAADvQ,EAASuL,CAAAgF,CAAEA,CAAFA,CAATvQ,MAAAuQ,EAERA,IAAcA,SAAdA,GAAIvJ,CAAJuJ,EAAqCA,OAArCA,GAA2BvJ,CAA3BuJ,CACED,CAAAC,CAAWhF,CAAAgF,CAAEA,CAAFA,CAAAvQ,KAAAuQ,EAAXA,CAAAA,CAA0BvJ,CAE5B4J,EAAAL,CAAMA,CAAAA,CAPuBA,CAS/BA,MAAOK,EAdFL,CAP2BA;AAoEpCM,QAAAA,EAAgBA,CAAhBA,CAAgBA,CAACC,CAADD,CAAWlB,CAAXkB,CAAkBA,CAG5BC,CAAJD,GAEIC,CAFJD,CAC8BA,CAA5BA,EAAIC,CAAAxQ,QAAAuQ,CAAiBA,GAAjBA,CAAJA,CACaE,EAAAF,CAAAA,CAAAA,CAAwBC,CAAxBD,CAAkClB,CAAlCkB,CADbA,CAuBuBA,EAAVA,CAAqCC,CAArCD,CAlBF9H,QAAQ8H,CAAChK,CAADgK,CAAS7J,CAAT6J,CAAgB5J,CAAhB4J,CAA0B/J,CAA1B+J,CAAkCA,CACjDA,GAAIA,CAAC7J,CAAL6J,CACEA,MAAOhK,EAAPgK,CAAgB/J,CAIlB+J,EAFIG,CAEJH,CAFoBA,CAAAA,CALXA,CAKWA,CAAsBlB,CAAAkB,CAAM7J,CAAN6J,CAAtBA,CAAoClB,CAApCkB,CAEpBA,GAAwCA,SAAxCA,GAAsBG,CAAtBH,CAI6BA,oBAJ7BA,GAIWG,CAJXH,GAQEG,CARFH,CAQkBA,SARlBA,EAEEG,CAFFH,CAEkBA,CAAAA,CATTA,CASSA,CAAsBlB,CAAAkB,CAAM5J,CAAN4J,CAAtBA,EAAyC5J,CAAzC4J,CAAmDlB,CAAnDkB,CAFlBA,EAGE5J,CAOF4J,OAAOhK,EAAPgK,EAAiBG,CAAjBH,EAAkCA,EAAlCA,EAAwC/J,CAhBS+J,CAkBxCA,CAxBfA,CA2BAA,OAAOC,EAAPD,EAAmBC,CAAA9Q,KAAA6Q,EAAnBA,EAAsCA,EA9BNA;AAkClCE,QAAAA,GAAkBA,CAAlBA,CAAkBA,CAACD,CAADC,CAAWpB,CAAXoB,CAAkBA,CAC9BjJ,CAAAA,CAAQgJ,CAAAjQ,MAAAkQ,CAAeA,GAAfA,CACZA,KAFkCA,IAEzBzR,EAAEyR,CAFuBA,CAEpBtR,CAFoBsR,CAEjBxF,CAAjBwF,CAAoBzR,CAApByR,CAAsBjJ,CAAA1I,OAAtB2R,CAAoCzR,CAAAyR,EAApCA,CACEA,GAAKtR,CAALsR,CAASjJ,CAAAiJ,CAAMzR,CAANyR,CAATA,CAAoBA,CACfA,CAAHE,UAAAF,CAA2BA,CAE3BA,IADAxF,CACAwF,CADOA,CAAHd,KAAAc,CAAoBtR,CAApBsR,CACJA,CACEtR,CAAAsR,CAAIF,CAAAE,CAAAA,CAAAA,CAAsBpB,CAAAoB,CAAMxF,CAAAwF,CAAEA,CAAFA,CAANA,CAAtBA,CAAmCpB,CAAnCoB,CADNA,KAIEA,IADIG,CACAH,CADQtR,CAAAa,QAAAyQ,CAAUA,GAAVA,CACRA,CAAWA,EAAXA,GAAAG,CAAJH,CAAkBA,CAChBA,IAAII,EAAK1R,CAAAM,UAAAgR,CAAYG,CAAZH,CACTI,EAAAJ,CAAKI,CAAAnR,KAAA+Q,EACLI,EAAAJ,CAAKF,CAAAE,CAAAA,CAAAA,CAAsBI,CAAtBJ,CAA0BpB,CAA1BoB,CAALA,EAAyCI,CACzC1R,EAAAsR,CAAItR,CAAAM,UAAAgR,CAAYA,CAAZA,CAAeG,CAAfH,CAAJA,CAA4BI,CAJZJ,CAOpBjJ,CAAAiJ,CAAMzR,CAANyR,CAAAA,CAAYtR,CAADsR,EAAMtR,CAAAW,YAAA2Q,CAAcA,GAAdA,CAANA,GAA6BtR,CAAAL,OAA7B2R,CAAwCA,CAAxCA,CAETtR,CAAAuI,MAAA+I,CAAQA,CAARA,CAAYA,EAAZA,CAFSA,CAGTtR,CAHSsR,EAGJA,EAjBWA,CAoBtBA,MAAOjJ,EAAAqD,KAAA4F,CAAWA,GAAXA,CAvB2BA;AAoFpCK,QAAAA,GAAsBA,CAAC3P,CAAD2P,CAAQjK,CAARiK,CAAiBA,CACrCA,IAAIzB,EAAQyB,EAAZA,CAEIC,EAAID,EAEEA,EAAVA,CAAsB3P,CAAtB2P,CAA6BA,QAAAA,CAAC5M,CAAD4M,CAAUA,CAGhC5M,CAAAuL,EAALqB,EACEtB,CAAAsB,CAAkB5M,CAAlB4M,CAKFA,KAAIE,EAAkB9M,CAAAsG,EAAlBwG,EAA8C9M,CAAA4M,eAC9CjK,EAAJiK,EAAe5M,CAAAuL,EAAAO,EAAfc,EAA+CE,CAA/CF,EACMlC,EAAA9H,KAAAgK,CAAqBjK,CAArBiK,CAA8BE,CAA9BF,CADNA,GAEIb,CAAAa,CAAuB5M,CAAvB4M,CAA6BzB,CAA7ByB,CA6TR,CA3TqBzF,CA2TrB,CA3TqBnH,CAAAmH,MA2TrB,CAFI0F,CAEJ,CAFQE,QAAA,CAASlS,CAAT,CAAa,EAAb,CAAiB,EAAjB,CAER,CA3TiCgS,CA2TjC,CAAKA,CAAL,CAAA,EA3TiCA,CA2TtB,CAAKA,CAAL,CAAX,EAAsB,CAAtB,EADQ,CACR,EADchS,CACd,CADkB,EA9Td+R,CAVqCA,CAAvCA,CAiBGA,IAjBHA,CAiBSA,CAAAA,CAjBTA,CAkBAA,OAAOA,CAACd,EAAYX,CAAbyB,CAAoBI,IAAKH,CAAzBD,CAvB8BA;AAgCvCK,QAAAA,GAAkBA,CAAC7L,CAAD6L,CAAQjN,CAARiN,CAActO,CAAdsO,CAAwBvN,CAAxBuN,CAAkCA,CAC7CjN,CAAAuL,EAAL0B,EACE3B,CAAA2B,CAAkBjN,CAAlBiN,CAEFA,IAAKjN,CAAAuL,EAAAO,EAALmB,CAAAA,CAGIA,IAAAA,EAAgCA,CAAVA,CAAuB7L,CAAvB6L,CAArBhK,EAAAA,CAAAgK,CAAAA,GAAIjK,EAAAA,CAAAiK,CAAAA,EACLjH,EAAAA,CAAY/C,CAAAgK,CACdhH,EAAAgH,CAAgChK,CAAhCgK,CAAoCjK,CAApCiK,CADcA,CAEdA,MACFA,KAAIC,EAAiBlN,CAAAiN,eAArBA,CACIE,EAA6BF,WAA7BE,GAAUD,CAAVC,EAA+DF,MAA/DE,GAA4CD,CADhDD,CAEIG,EAA6CH,CAA7CG,GAASF,CAAApR,QAAAmR,CAAuBA,OAAvBA,CAATG,EAAkDH,CAACE,CAItCF,QAAjBA,GAAItO,CAAJsO,GAEEE,CAEAF,CAFSC,CAETD,GAF6BjH,CAE7BiH,CAFyCA,OAEzCA,CAFmDjH,CAEnDiH,EAFqGA,EAErGA,GAFiEC,CAAApR,QAAAmR,CAAuBA,MAAvBA,CAEjEA,CAAAG,CAAAH,CAASA,CAACE,CAAVF,EAA0DA,CAA1DA,GAAoBC,CAAApR,QAAAmR,CAAuBjH,CAAvBiH,CAJtBA,CAMAA,IAAKE,CAALF,EAAgBG,CAAhBH,CAGIH,CAeJG,CAfsBjH,CAetBiH,CAdIG,CAcJH,GAZOjN,CAAAsG,EAUL2G,GAREjN,CAAAsG,EAQF2G,CAPE1G,EAAA0G,CAAA7I,CAAA6I,CACEjN,CADFiN,CAEE7I,CAAAoC,EAFFyG,CAGqChK,CH1IzCiD,CAwRqBC,GAxRrBD,CG0IyCjD,CH1IzCiD,CAGSA,EGoIL+G,CAIEjH,CAJFiH,CAOFA,EAAAH,CAAAG,CAAkBjN,CAAAsG,EAAlB2G,EAA8CjH,CAEhDiH,EAAAvN,CAAAuN,CAASA,CACP5J,EAAUyJ,CADHG,CAEPG,EAAQA,CAFDH,CAGPE,EAAQA,CAHDF,CAATA,CArCAA,CAJkDA,CAqDpDI,QAAAA,GAA6BA,CAACjM,CAADiM,CAAQpQ,CAARoQ,CAAe1O,CAAf0O,CAAyBA,CAAAA,IAChDC,EAAYD,EADoCA,CAChCE,EAAYF,EAEtBA,EAAVA,CAAsBpQ,CAAtBoQ,CAA6BA,QAAAA,CAACrN,CAADqN,CAAUA,CAErCJ,EAAAI,CAAwBjM,CAAxBiM,CAA+BrN,CAA/BqN,CAAqC1O,CAArC0O,CAA+CA,QAAAA,CAACnF,CAADmF,CAAUA,CAEnD3C,EAAA9H,KAAAyK,CADUjM,CAAAoM,SACVH,EAD4BjM,CAC5BiM,CAA8BnF,CAAA7E,EAA9BgK,CAAJA,GACMnF,CAAAkF,EAAJC,CACEtB,CAAAsB,CAAuBrN,CAAvBqN,CAA6BC,CAA7BD,CADFA,CAGEtB,CAAAsB,CAAuBrN,CAAvBqN,CAA6BE,CAA7BF,CAJJA,CAFuDA,CAAzDA,CAFqCA,CAAvCA,CAYGA,IAZHA,CAYSA,CAAAA,CAZTA,CAaAA,OAAOA,CAACE,EAAWA,CAAZF,CAAuBC,EAAWA,CAAlCD,CAhB6CA;AAwBtDI,QAAAA,GAAeA,CAAfA,CAAeA,CAAC9K,CAAD8K,CAAU3B,CAAV2B,CAAsBtD,CAAtBsD,CAAqCA,CAE9CA,IAAAA,EAAgCA,CAAVA,CAAuB9K,CAAvB8K,CAAtBA,CACAC,EAAezH,EAAAwH,CADdA,CAAAA,GACcA,CADVA,CAAAA,EACUA,CADfA,CAMAE,EAASF,IAAIG,MAAJH,CNlXUA,eMkXVA,EAHQ9K,CAAAQ,QAAAsK,CACnBA,IADmBA,CACZC,CAAAlK,MAAAiK,CAAmBA,CAAnBA,CAAuBA,EAAvBA,CADYA,CACgBA,KADhBA,CAEnBC,CACWD,ENjXUA,iBMiXVA,CANTA,CAQAA,EAAgCI,CAAAJ,CAAc9K,CAAd8K,CAAnBxQ,EAAAA,CAAZwQ,CAAAA,EAAmB9O,EAAAA,CAAA8O,CAAAA,SACxBA,KAAIK,EACFC,EAAAN,CAAyCxQ,CAAzCwQ,CAAgDtD,CAAhDsD,CACFA,OAAO7H,EAAA6H,CAA+B9K,CAA/B8K,CAAwCxQ,CAAxCwQ,CAA+CA,QAAQA,CAACzN,CAADyN,CAAOA,CAnLrEO,IAAI/E,EAAS+E,EAoLUhO,EAlLlBuL,EAALyC,EACE1C,CAAA0C,CAiLqBhO,CAjLrBgO,CAiLqBhO,EA/KnBuL,EAAAvO,QAAJgR,GACE/E,CADF+E,CACWzB,EAAAyB,CAiKAP,CAjKAO,CA8KYhO,CA9KYuL,EAAAvO,QAAxBgR,CA8KkBlC,CA9KlBkC,CADXA,CA+KuBhO,EA5KvBgO,QAAAA,CAAkB/E,CA6KhBwE,IAAIA,CAACvP,CAALuP,EACIA,CAAWA,EAAVA,CAA8BzN,CAA9ByN,CADLA,EAEIzN,CAAAyN,QAFJA,CAEqBA,CAvKvBQ,IAAIhF,EADA5B,CACA4B,CA0K6BjJ,CA3KrBiO,QAEcA,KAA1BA,EAyKiCjO,CAzK7BkO,EAAJD,GAyKiCjO,CAvK/BkO,EAFFD,CAE0BA,EAAHnG,KAAAmG,CAAwB5G,CAAxB4G,CAFvBA,CAKAA,IAoKiCjO,CApK7BkO,EAAJD,CAIEA,GAAqCA,IAArCA,EAgK+BjO,CAhK3BmO,EAAJF,CAA2CA,CAgKZjO,CA/J7BmO,EAAAF,CAAgCA,EAChCA,KAAKA,IAAIG,CAATH,GA8JmCH,EA9JnCG,CACEI,CAIAJ,CAyJiCH,CA7JrBG,CAAmBG,CAAnBH,CAIZA,CAHAhF,CAGAgF,CAHSI,CAAAJ,CAAU5G,CAAV4G,CAGTA,CAAI5G,CAAJ4G,GAAchF,CAAdgF,GACE5G,CACA4G,CADQhF,CACRgF,CAuJyBjO,CAvJzBmO,EAAAhT,KAAA8S,CAAmCG,CAAnCH,CAFFA,CAPuCA,CAA3CA,IAYOA,CAGLA,IAASnT,CAATmT,CAAaA,CAAbA,CAAgBnT,CAAhBmT,CAiJ6BjO,CAjJTmO,EAAAvT,OAApBqT,CAA0DA,EAAEnT,CAA5DmT,CACEI,CACAJ,CA+IiCH,CAhJrBG,CAgJejO,CAhJImO,EAAAF,CAA8BnT,CAA9BmT,CAAnBA,CACZA,CAAA5G,CAAA4G,CAAQI,CAAAJ,CAAU5G,CAAV4G,CAEVhF,EAAAgF,CAAS5G,CAPJ4G,CAoJwBjO,CA1IjCiO,QAAAA,CAAkBhF,CA2IMjJ,EA4ExBsG,EAAAgI,CA5EwBtO,CA4EGsG,EAA3BgI,EA5EwBtO,CA4E+BsO,SAEnDlN;CAAAA,CAAQkN,GAARlN,CA9EgD+I,CA+EhD7G,EAAAA,CAAkBgL,EAAVA,CA/EYtO,CA6ETsG,EAEHgI,CACHxT,EAAAA,CAAEwT,CAAXA,KALkDA,IAKpCvT,GAAEuI,CAAA1I,OALkC0T,CAKpBrT,EAAAA,IAAAA,EAA9BqT,CAAkCxT,CAAlCwT,CAAoCvT,EAApCuT,GAA2CrT,CAA3CqT,CAA6ChL,CAAAgL,CAAMxT,CAANwT,CAA7CA,EAAwDxT,CAAAwT,EAAxDA,CACEhL,CAAAgL,CAAMxT,CAANwT,CAAAA,CAAWrT,CAAAiB,MAAAoS,CAjFiBX,CAiFjBW,CAAAA,CACTrT,CAAAV,QAAA+T,CAlFkCZ,CAkFlCY,CAAwBlN,CAAxBkN,CADSA,CAETlN,CAFSkN,CAEDA,GAFCA,CAEKrT,CAnFM+E,EAqFxBsO,SAAAA,CAAmBhL,CAAAqD,KAAA2H,CAAWA,GAAXA,CAzFIb,CAJ8CA,CAA9DA,CAUJ9O,CAVI8O,CAb2CA,CAgCpDM,QAAAA,GAA0BA,CAAU9Q,CAAV8Q,CAAiB5D,CAAjB4D,CAAgCA,CACpDQ,CAAAA,CAAiBtR,CAAA2O,EACrBmC,KAAID,EAAqBC,EACzBA,IAAIA,CAAC7P,CAAL6P,EAAqBQ,CAArBR,CAIEA,IAJmCA,IAI1BjT,EAAIiT,CAJsBA,CAInB/P,EAAgBuQ,CAAAR,CAAejT,CAAfiT,CAAhCA,CACKjT,CADLiT,CACSQ,CAAA3T,OADTmT,CAEK/P,CAFL+P,CAEqBQ,CAAAR,CAAeA,EAAEjT,CAAjBiT,CAFrBA,CAE0CA,CACnB/P,IAAAA,EAAAA,CAAAA,CAAemM,EAAAA,CAiCxCnK,EAAAwO,EAAAC,CAAuBA,IAAIb,MAAJa,CAAWA,KAAXA,CAAiBzO,CAAAyO,cAAjBA,CAAsCA,WAAtCA,CAAmDA,GAAnDA,CACvBzO,EAAA0O,EAAAD,CAAgCzO,CAAAyO,cAAhCA,CAAwDA,GAAxDA,CAA8DE,CAC9D3O,EAAAsG,EAAAmI,CAA2BzO,CAAAsG,EAA3BmI,EAAuDzO,CAAAyO,SACvDzO,EAAAyO,SAAAA,CAAmBzO,CAAAsG,EAAA/L,QAAAkU,CACfzO,CAAAyO,cADeA,CACQzO,CAAA0O,EADRD,CAnCfX,EAAAC,CAAmB/P,CAAA+P,cAAnBA,CAAAA,CACIa,EAAAb,CAA+B/P,CAA/B+P,CAHoCA,CAM5CA,MAAOD,EAfiDC,CAwB1Da,QAAAA,GAAyBA,CAAC5Q,CAAD4Q,CAAgBA,CACvCA,MAAOA,SAAQA,CAAC5R,CAAD4R,CAAUA,CACvBA,MAAO5R,EAAAzC,QAAAqU,CACH5Q,CAAAwQ,EADGI,CAEH5Q,CAAA0Q,EAFGE,CADgBA,CADcA;AA4IzCC,QAAAA,GAAgBA,CAAChP,CAADgP,CAAQ/C,CAAR+C,CAAoBA,CAApCA,IAAAA,EFzJM5D,CEyJN4D,CACM5R,EAAkB4R,CAAVA,CAAwDhP,CAAxDgP,CAEZhP,EAAAC,YAAA+O,CAA8BA,CAAVA,CAAoB5R,CAApB4R,CAA2BA,QAAQA,CAAiB7O,CAAjB6O,CAAuBA,CAC5EA,IAAI/I,EAAM9F,CAAA6O,QAAN/I,CAAwB9F,CAAA6O,cACxB7O,EAAAuL,EAAJsD,EAAyB7O,CAAAuL,EAAAvO,QAAzB6R,GASE/I,CAEA+I,CAFuD/I,CT9WtDvL,QAAA,CACI2C,EADJ,CACmB,EADnB,CAAA3C,QAAAsU,CAEI1R,EAFJ0R,CAEkB,EAFlBA,CSgXDA,CAAA7O,CAAA6O,QAAAA,CAAkBtC,EAAAsC,CAdXA,CAcWA,CAAwB/I,CAAxB+I,CAA6B/C,CAA7B+C,CAXpBA,CAF4EA,CAA1DA,CAHcA,CA3hBtClF,EAAA,OAAA,iBAAA,CAAA,EAAA,UAAA,CAAA,CAAA,EACM,CAAA,aAAA,CAAA,CAAA,CAAA,WAAA,CAAA,CAAA,CAAA,IAAcmF,QAAA,EAAA,CAChB,MAJgBA,SAGA,CAAd,CADN,CAAA,CA2jBA,KAAAlF,EAAe,IAAIqB,E,CE/kBnB,IAAM8D,EAAiB,EAAvB,CAsBMC,EAAK7Q,MAAA,eACX,IAAI6Q,CAAJ,EAAU,CAAC9Q,CAAX,CAAyB,CAIvB,IAAM+Q,GAAaD,CAAA,OAUnBA,EAAA,OAAA,CAJsBE,QAAA,CAACxD,CAAD,CAAOyD,CAAP,CAAcC,CAAd,CAA0B,CAnB3CL,CAAA,CAoBoBrD,CApBpB,CAAL,GACEqD,CAAA,CAmBuBrD,CAnBvB,CADF,CACgCzK,EAAA,CAmBPyK,CAnBO,CADhC,CAqBEuD,GAAArM,KAAA,CAAsDoM,CAAtD,CAA2DtD,CAA3D,CAAiEyD,CAAjE,CAAwEC,CAAxE,CAF8C,CAVzB,C,CC3BvBjV,QADmBkV,GACR,EAAgB,CAEzB,IAAAC,MAAA,CAAa,EAFY,CAiB3BC,EAAAA,UAAAA,MAAAA,CAAAA,QAAKA,CAACC,CAADD,CAAUzD,CAAVyD,CAAsBE,CAAtBF,CAAoCpF,CAApCoF,CAAmDA,CACtDA,IAAIG,EAAOH,IAAAD,MAAAC,CAAWC,CAAXD,CAAPG,EAA8BH,EAClCG,EAAAvU,KAAAoU,CAAUA,CAACzD,EAAAA,CAADyD,CAAaE,aAAAA,CAAbF,CAA2BpF,EAAAA,CAA3BoF,CAAVA,CAnBoBI,IAoBpBJ,CAAIG,CAAA9U,OAAJ2U,EACEG,CAAAE,MAAAL,EAEFA,KAAAD,MAAAC,CAAWC,CAAXD,CAAAA,CAAsBG,CANgCH,C,CJbvCM,QAAA,GAAQ,EAAG,EAgB9B,IAAMC,GAAc,IAAIlC,MAAJ,CAAcxJ,CAAAe,EAAd,CAAyC,eAAzC,CAMb4K,SAASA,GAAe,CAACpN,CAAD,CAAU,CAEvC,MAAA,CADMzG,CACN,CADcA,CAAWyG,CAhBrBsC,UAAJ,EAgByBtC,CAhBAsC,UAAAzC,MAAzB,CAgByBG,CAfhBsC,UAAAzC,MADT,CAgByBG,CAXhBO,aAAA,CAAqB,OAArB,CALT,EAK0C,EAW5BhH,OAAA,CAA0B4T,EAA1B,CACd,EACS5T,CAAA,CAAM,CAAN,CADT,CAGS,EAL8B,CAYlC8T,QAASA,GAAa,CAAC3U,CAAD,CAAO,CAClC,IAAM4U,EAAYpN,CAAA,CAAKxH,CAAL,CAAA6U,YAAA,EAClB,OAAID,EAAJ,GAAkB5U,CAAlB,EAA0B4U,CAA1B,GAAwC5U,CAAA8U,cAAxC,CACS,EADT,CAIA,CADM9G,CACN,CADwC4G,CAAD5G,KACvC,EAIOvG,CAAA,CAAauG,CAAb,CAAApG,GAJP,CAES,EARyB;AAyEpCmN,QAASA,GAAO,CAACC,CAAD,CAAO,CACrB,IAAK,IAAIC,EAAE,CAAX,CAAcA,CAAd,CAAkBD,CAAAzV,OAAlB,CAA+B0V,CAAA,EAA/B,CAAoC,CAClC,IAAIC,EAAMF,CAAA,CAAKC,CAAL,CACV,IAAIC,CAAA7P,OAAJ,GAAmBE,QAAA4P,gBAAnB,EACED,CAAA7P,OADF,GACiBE,QAAAS,KADjB,CAIA,IAAK,IAAIvG,EAAE,CAAX,CAAcA,CAAd,CAAkByV,CAAAE,WAAA7V,OAAlB,CAAyCE,CAAA,EAAzC,CAA8C,CAC5C,IAAID,EAAI0V,CAAAE,WAAA,CAAe3V,CAAf,CACR,IAAID,CAAA6J,SAAJ,GAAmB9C,IAAA+C,aAAnB,CAAA,CAIA,IAAIhK,EAAOE,CAAAqV,YAAA,EAAX,CACIQ,EAAeX,EAAA,CAAgBlV,CAAhB,CAInB,IAAI6V,CAAJ,EAAoB/V,CAApB,GAA6BE,CAAAsV,cAA7B,GA3BiB,OA2BjB,GAAuEtV,CA3BvEkI,UA2BA,EA3B6C,UA2B7C,GAAuElI,CA3B3CkI,UA2B5B,EHgO4B,EGhO5B,GHgOGU,CAAA,CGhOoE5I,CHgOpE,CGhOH,EACE8K,EAAA,CAAgC9K,CAAhC,CAAmC6V,CAAnC,CADF,KAEO,IAAI/V,CAAJ,WAAoBgW,WAApB,CAnDX,IAoDYjL,CApDHkL,CAoDcZ,EAAA,CAAcnV,CAAd,CApDd+V,CAsDClL,CAtDDkL,GAsDcF,CAtDdE,EAuDDpL,EAAA,CAAiC3K,CAAjC,CAAoC6V,CAApC,CAAkDhL,CAAlD,CAvDCkL,CAHHC,CAGGD,CAHazS,MAAA,SAAA,cAAA,iBAAAyE,KAAA,CA6DY/H,CA7DZ,CACX,QADW,CACFuJ,CAAAe,EADE,CACyB,GADzB,CAGbyL,CAAAA,CAAAA,CAAI,CAAb,CAAgBA,CAAhB,CAAoBC,CAAAjW,OAApB,CAA0CgW,CAAA,EAA1C,CAA+C,CASvCE,CAAAA,CAAeD,CAAA,CAAcD,CAAd,CACrB;IAAMG,EAAiCf,EAAA,CAAcc,CAAd,CACnCC,EAAJ,EACEpO,CAAA,CAAyBmO,CAAzB,CAAuCC,CAAvC,CAZ2C,CAwC3C,CAF4C,CANZ,CADf;AAkCvB,GAAI,EAAC7S,CAAD,EAAmBC,MAAA,SAAnB,EAAyCA,MAAA,SAAA,sBAAzC,CAAJ,CAA2F,CACzF,IAAI6S,GAAW,IAAIC,gBAAJ,CAAqBb,EAArB,CAAf,CACIrO,GAAQA,QAAA,CAAC1G,CAAD,CAAU,CACpB2V,EAAAE,QAAA,CAAiB7V,CAAjB,CAAuB,CAAC8V,UAAW,CAAA,CAAZ,CAAkBC,QAAS,CAAA,CAA3B,CAAvB,CADoB,CAStB,IAN4BjT,MAAA,eAM5B,EALE,CAACA,MAAA,eAAA,0BAKH,CACE4D,EAAA,CAAMnB,QAAN,CADF,KAEO,CACL,IAAIyQ,GAAeA,QAAA,EAAM,CACvBtP,EAAA,CAAMnB,QAAA0Q,KAAN,CADuB,CAIrBnT,OAAA,YAAJ,CACEA,MAAA,YAAA,UAAA,CAAmCkT,EAAnC,CADF,CAKEE,qBAAA,CAAsB,QAAQ,EAAG,CAC/B,GAA4B,SAA5B,GAAI3Q,QAAA4Q,WAAJ,CAAuC,CACrC,IAAIC,EAAWA,QAAQ,EAAG,CACxBJ,EAAA,EACAzQ,SAAA8Q,oBAAA,CAA6B,kBAA7B,CAAiDD,CAAjD,CAFwB,CAI1B7Q,SAAA+Q,iBAAA,CAA0B,kBAA1B;AAA8CF,CAA9C,CALqC,CAAvC,IAOEJ,GAAA,EAR6B,CAAjC,CAVG,CAwBPxB,EAAA,CAAQA,QAAQ,EAAG,CACjBO,EAAA,CAAQY,EAAAY,YAAA,EAAR,CADiB,CArCsE,CA7IhF/B,IAAAgC,GAAAhC,E,CKDX,IAAMiC,EAAc,E,CCkBpB,IAAMC,GAAUC,OAAAC,QAAA,EAKTC,SAASA,GAAU,CAACC,CAAD,CAAa,CAErC,GADIC,CACJ,CDxBaN,CCuBE,CAAYK,CAAZ,CACf,CACqBC,CAerB,yBAIA,CAnBqBA,CAeO,yBAI5B,EAJyD,CAIzD,CAnBqBA,CAiBrB,4BAEA,CAnBqBA,CAiBU,4BAE/B,EAF+D,CAE/D,CAnBqBA,CAmBrB,sBAAA,EAnBqBA,CAmBK,sBAA1B,EAAoD,CAApD,EAAyD,CAtBpB,CAyChCC,QAASA,GAAe,CAACD,CAAD,CAAW,CACxC,MAAOA,EAAA,yBAAP,GAAqCA,CAAA,sBADG,CA4CnCE,QAASA,GAAuB,CAACF,CAAD,CAAW,CAEhDA,CAAA,4BAAA,CAA+BA,CAAA,sBAE1BA,EAAAG,YAAL,GACEH,CAAAG,YACA,CADuB,CAAA,CACvB,CAAAR,EAAAS,KAAA,CAAa,QAAQ,EAAG,CAEtBJ,CAAA,yBAAA,CAA4BA,CAAA,sBAC5BA,EAAAG,YAAA,CAAuB,CAAA,CAHD,CAAxB,CAFF,CAJgD,C,CP9FlD,IAAME,GAAa,IAAIpD,EAGrBlV,SADmBuY,EACR,EAAG,CACZ,IAAAC,EAAA,CAAqB,EACrB,KAAAC,EAAA,CAAkDhS,QAAA4P,gBAClD,KAAI1G,EAAM,IAAI1P,CACd0P,EAAA,MAAA,CAAe,EACf,KAAA+I,EAAA,CAA+BC,EAAA,CAAc,IAAAF,EAAd,CAAmC,IAAI/I,CAAJ,CAAcC,CAAd,CAAnC,CAC/B,KAAAiJ,EAAA,CAA4B,CAAA,CAI5B,KAAAC,EAAA,CAFA,IAAAC,EAEA,CAFkB,IARN,CAYdpD,CAAAA,CAAAA,CAAAA,UAAAqD,EAAArD,MAAAA,CAAAA,QAAKA,EAAGA,CACNgC,EAAAhC,EADMA,CAORsD,EAAAC,EAAAA,CAAAA,QAAWA,CAACvT,CAADuT,CAAQA,CACjBA,MAAiBA,EAAVA,CAAwBvT,CAAxBuT,CADUA,CAGnBC,EAAAC,EAAAA,CAAAA,QAAgBA,CAACxJ,CAADwJ,CAAMA,CACpBA,MAAiBA,EAAVA,CAAoBxJ,CAApBwJ,CADaA,CAatBC,EAAAC,gBAAAA,CAAAA,QAAeA,CAACpB,CAADoB,CAAWrB,CAAXqB,CAAwBxQ,CAAxBwQ,CAAuCA,CACpDA,IAAAC,mBAAAD,CAAwBpB,CAAxBoB,CAAkCrB,CAAlCqB,CACAA,KAAAE,sBAAAF,CAA2BpB,CAA3BoB,CAAqCrB,CAArCqB,CAAkDxQ,CAAlDwQ,CAFoDA,CAUtDG;CAAAD,sBAAAA,CAAAA,QAAqBA,CAACtB,CAADsB,CAAWvB,CAAXuB,CAAwB1Q,CAAxB0Q,CAAuCA,CAC1DA,GAAIE,CAAAxB,CAAAwB,UAAJF,CAAAA,CAIKxV,CAALwV,EIpDG3E,CAAA,CJqDsBoD,CIrDtB,CJoDHuB,GInDA3E,CAAA,CJoDyBoD,CIpDzB,CJmDAuB,CInD8BzS,EAAA,CJoDLkR,CIpDK,CJmD9BuB,CAGAtB,EAAAwB,UAAAF,CAAqBA,CAAAA,CACrBtB,EAAA1G,KAAAgI,CAAgBvB,CAChBC,EAAAjP,QAAAuQ,CAAmB1Q,CMvER8O,ENwEX4B,CAAYvB,CAAZuB,CAAAA,CAA2BtB,CAC3BsB,KAAI/U,EAAqB+U,CAAVA,CAAsBtB,CAAtBsB,CAAfA,CACMG,EAAyBH,EAAVA,CAA4B/U,CAA5B+U,CACjBxL,EAAAA,CAAOwL,CACTzQ,GAAIkP,CADKuB,CAETvQ,QAASH,CAFA0Q,CFqLPI,KAAAA,EAAiB,EAEvB,KADA,IAAMC,EElL6B3B,CArCAtO,QFuNwBkQ,iBAAA,CAAyB,OAAzB,CAA3D,CACSlZ,EAAI,CAAb,CAAgBA,CAAhB,CAAoBiZ,CAAAnZ,OAApB,CAAmCE,CAAA,EAAnC,CAAwC,CACtC,IAAM+E,EAAQkU,CAAA,CAAOjZ,CAAP,CACd,IAAoB+E,CD9OfoU,aAAA,CAvBuBC,gBAuBvB,CC8OL,CACE,IAAI,CAAChW,CAAL,CAAmB,CD7PvB,IAAM5D,EC8PqBuF,CD9PdC,YACRP,GAAA4U,IAAA,CAAiB7Z,CAAjB,CAAL,GACEiF,EAAA6F,IAAA,CAAiB9K,CAAjB,CAEA,CADM8Z,CACN,CC0PyBvU,CD3PRwU,UAAA,CAAgB,CAAA,CAAhB,CACjB,CAAAzT,QAAAS,KAAAiT,YAAA,CAA0BF,CAA1B,CAHF,CC8PMvU,EAAAoE,WAAAC,YAAA,CAA6BrE,CAA7B,CAFiB,CAAnB,CADF,IAMEiU,EAAA3Y,KAAA,CAAoB0E,CAAAC,YAApB,CACA,CAAAD,CAAAoE,WAAAC,YAAA,CAA6BrE,CAA7B,CAToC,CAYxC,CAAA,CAAOiU,CAAAnN,KAAA,CAAoB,EAApB,CAAAnL,KAAA,EE7LL+Y,EAAAb,CAAAA,IAAAA,CACAA,IAAIA,CAACG,CAALH,CAAmBA,CACDA,GAAAA,CAAAA;AAAAA,CAAAA,CAAAA,CQ9CdS,CAGN,CAHYjV,CAAA4I,KAAA,CR8CqB4L,CQ9CrB,CAGZ,EAHyCzU,CAAA6I,KAAA,CR8CR4L,CQ9CQ,CAGzC,CADAxU,CAAAuN,UACA,CADwB,CACxB,CAAAxN,CAAAwN,UAAA,CAAuB,CR4Cf3C,EAAAA,CAAMzP,CAAAqZ,CAAM1W,CAAN0W,CAENc,EAAJd,EAAiB3U,CAAjB2U,EAAuCA,IAAAT,EAAvCS,EACEA,IAAAT,EAAAS,eAAAA,CAAkC5J,CAAlC4J,CAAuCvB,CAAvCuB,CAEFtB,EAAAsB,UAAAA,CAAwB5J,CAPP4J,CASfe,CAAAA,CAAmBf,EAClB3U,EAAL2U,GACEe,CADFf,CACqBxI,EAAAwI,CAA+BtB,CAAAsB,UAA/BA,CADrBA,CAGAA,IAAIA,CAACe,CAAA7Z,OAAL8Y,EAAgC3U,CAAhC2U,CACaA,CAGXA,CAHWxV,CAAAwV,CAAetB,CAAAtO,QAAf4P,CAAkCA,IAG7CA,CI5FGA,CJ4FHA,CI5FG3E,CAAA2E,CJ0FmCvB,CI1FnCuB,CJ4FHA,EI5FkCA,IJ4FlCA,CA0BF1W,CA1BE0W,CA0BQ9N,CAAA8O,CA3B8BxM,CA2B9BwM,CA3BoCtC,CAAAsB,UA2BpCgB,CAA4CA,IAA5CA,CA3B8E/V,CA2B9E+V,CA3BwFb,CAAAH,CAAe1W,CAAf0W,CAAyBA,EA2BjHgB,CA1BRhB,CA2BFgB,CA3BEhB,CA2BE1W,CAAApC,OAAJ8Z,CACmBA,CAAVA,CAAmB1X,CAAnB0X,CA7B+BxM,CA6BHjF,GAA5ByR,CAAqCC,CAArCD,CAAiD3K,CAAjD2K,CADTA,CAGOA,IA9BLhB,CAAAtB,CAAAwC,OAAAlB,CAAkB7T,CAEpBuS,EAAAyC,EAAAnB,CAA6Be,CAvC7Bf,CAD0DA,CA+C5DoB,EAAArB,mBAAAA,CAAAA,QAAkBA,CAACrB,CAADqB,CAAWtB,CAAXsB,CAAwBA,CACxCA,IAAM9U,EAAqB8U,CAAVA,CAAsBrB,CAAtBqB,CACZvV,EAALuV,EAAkCA,OAAlCA,GAAqB9U,CAArB8U,EAA8CrB,CAAA2C,aAA9CtB,GACErB,CAAA2C,aACAtB,CADwBA,CAAAA,CACxBA,CAAApP,EAAAoP,CAA6BrB,CAAAtO,QAA7B2P,CAA+CtB,CAA/CsB,CAFFA,CAFwCA,CAuB1CuB;QAAAA,GAAYA,CAAC3L,CAAD2L,CAAOA,CACXA,IAAAA,EAAgCA,CAAVA,CAAuB3L,CAAvB2L,CAAtBA,CAAC/R,EAAA+R,CAAAA,GAAIhS,EAAAA,CAAAgS,CAAAA,EACXA,KAAMjL,EI9HDgF,CAAA,CJ8HmC9L,CI9HnC,CJ8HC8G,EI9H8B,IJ8HpCiL,CACM5C,EMtIKN,CNsIMkD,CAAY/R,CAAZ+R,CACjBA,IAAK5C,CAAL4C,CAAAA,CAGMlL,CAAAA,CAAMsI,CAAA4C,UACZA,KAAMhL,EAAwBoI,CAAAyC,EACxBlW,EAAAA,CAAqBqW,CAAVA,CAAsB5C,CAAtB4C,CACXzK,EAAAA,CAAYyK,IAAInL,CAAJmL,CAChBlL,CADgBkL,CAEhBjL,CAFgBiL,CAGhBhL,CAHgBgL,CAKhBhS,CALgBgS,CAMhBrW,CANgBqW,CAQlBlC,GAAAkC,CAAc3L,CAAd2L,CAAoBzK,CAApByK,CACAA,OAAOzK,EAfPyK,CAJiBA,CA6BnBC,QAAAA,GAA2BA,CAA3BA,CAA2BA,CAAGA,CACxBjC,CAAAiC,CAAAjC,EAAJiC,EAEW9W,MAAAS,SAFXqW,EAE8B9W,MAAAS,SAAAsW,qBAF9BD,GAGEA,CAAAjC,EAGAiC,CAH2E9W,MAAAS,SAAAsW,qBAG3ED,CADAA,CAAAjC,EAAAiC,kBACAA,CADkDA,QAAAA,CAACpV,CAADoV,CAAWA,CANnCA,CAMoCE,EAAAF,CAAqCpV,CAArCoV,CAADA,CAC7DA,CAAAA,CAAAjC,EAAAiC,iBAAAA,CAAiDA,QAAAA,EAAMA,CACrD1D,qBAAA0D,CAAsBA,QAAAA,EAAMA,CAC1BA,CATsBA,CASlBjC,EAAAiC,SAAJA,EATsBA,CASwBlC,EAA9CkC,GATsBA,CAUpBG,kBAAAH,EAFwBA,CAA5BA,CADqDA,CANzDA,CAD4BA;AAgB9BV,QAAAA,EAAOA,CAAPA,CAAOA,CAAGA,CAvBJtB,CAwBJsB,CAxBItB,EAAJoC,EAEWlX,MAAAS,SAFXyW,EAE8BlX,MAAAS,SAAA0W,UAF9BD,GAwBAd,CArBEtB,EACAoC,CAD0ClX,MAAAS,SAAA0W,UAC1CD,CAoBFd,CApBEtB,EAAAoC,gBAAAA,CAAoDA,EAJtDA,CAyBAJ,GAAAV,CAAAA,CAAAA,CAFQA;AAOVgB,CAAAH,kBAAAA,CAAAA,QAAiBA,EAAGA,CAClBb,CAAAa,CAAAA,IAAAA,CACAA,IAAKA,IAAApC,EAALoC,CAAAA,CAGAA,IAAII,EAAeJ,IAAApC,EAAAoC,cAAAA,EAEnBA,IAAKA,IAAApC,EAAAoC,SAALA,EAIIA,CAAUA,EAAVA,CAA4BA,IAAAvC,EAAAlU,SAA5ByW,CAJJA,CAIAA,CAGAA,GAAKrW,CAALqW,CAOOA,IAAKzW,CAAAyW,IAAAvC,EAAAlU,SAALyW,CA6LPK,IAAKA,IAAI3a,EAAI2a,CAAbA,CAAgB3a,CAAhB2a,CA5LuCD,CA4LnB5a,OAApB6a,CAAyC3a,CAAA2a,EAAzCA,CAA8CA,CAE5CA,IAAI5Z,EA9LJuZ,IA8LQpC,EAAAyC,uBAAAA,CA9L6BD,CA6L7BC,CAAa3a,CAAb2a,CACAA,CACRA,IAAI5Z,CAAJ4Z,EAyCE1W,CAzCF0W,EA/LAL,IAwOwBnC,EAzCxBwC,CAyCyCC,CACzCA,IAAI5L,EAAgB4L,CAAVA,CAAwB7V,CAAxB6V,CACVnB,EAAAmB,CA1OAN,IA0OAM,CA1OAN,KA2OAnC,EAAAyC,eAAAA,CAAkC5L,CAAlC4L,CACA7V,EAAAC,YAAA4V,CAA8BA,CAAVA,CAAoB5L,CAApB4L,CAJqBA,CA5CGD,CA7LvCL,CAPPA,IAAyBA,CACvBO,EAAAP,CAAAA,IAAAA,CAAuBA,IAAAxC,EAAvBwC,CAA4CA,IAAAvC,EAA5CuC,CA4MFQ,KAAS9a,CAAT8a,CAAaA,CAAbA,CAAgB9a,CAAhB8a,CA3M0BJ,CA2MN5a,OAApBgb,CAAyC9a,CAAA8a,EAAzCA,CAGEA,CADI/Z,CACJ+Z,CA9MAR,IA6MQpC,EAAA4C,uBAAAA,CA7MgBJ,CA4MhBI,CAAa9a,CAAb8a,CACAA,CACRA,GACE/G,EAAA+G,CAAiC/Z,CAAjC+Z,CA/MFR,IA+MsCvC,EAAAzI,EAApCwL,CA9MER,KAAArC,EAAJqC,EAEEA,IAAAS,cAAAT,EALqBA,CAUzBA,IAAApC,EAAAoC,SAAAA,CAAyCA,CAAAA,CAbzCA,CATAA,CAFkBA,CAgCpBU;CAAArG,aAAAA,CAAAA,QAAYA,CAACpG,CAADoG,CAAOsG,CAAPtG,CAAsBA,CAChCA,IAAMlF,EAAYsD,CAAA4B,CAAcpG,CAAdoG,CAAZlF,EAAmCyK,EAAAvF,CAAkBpG,CAAlBoG,CAEzCA,IAAKlF,CAALkF,CAYAA,GARuBpG,CAQlBtK,GARA0Q,IA6EYmD,EArEZ7T,GAPH0Q,IAAAsD,EAOGhU,CAPyB0Q,CAAAA,CAOzB1Q,EALDgX,CAKChX,GAJHwL,CAAAN,EAEAwF,CADElF,CAAAN,EACFwF,EADuCA,EACvCA,CAAAvD,MAAAC,OAAAsD,CAAclF,CAAAN,EAAdwF,CAAiDsG,CAAjDtG,CAEG1Q,EAAAA,CAAL0Q,CAAAA,CAsBQxM,CAAAA,CAAiB+S,CAAVA,CAnBoB3M,CAmBpB2M,CAAPA,GACRA,IApByCzL,CAoBrCN,EAAJ+L,CAAAA,CAC+B/L,IAAAA,EArBUM,CAqBVN,EAAAA,CQ1PxBhP,CAAT,KAASA,CAAT,GAAc6Q,EAAd,CAEY,IAAV,GAAI7Q,CAAJ,CRmOmCoO,CQlOjCxJ,MAAAoW,eAAA,CAA6Bhb,CAA7B,CADF,CRmOmCoO,CQhOjCxJ,MAAAqW,YAAA,CAA0Bjb,CAA1B,CAA6B6Q,CAAA,CAAW7Q,CAAX,CAA7B,CRoPF+a,CAKAA,GAAIA,EAFE5D,EAAAA,CAAAA,CMhQKN,CNgQMkE,CAAY/S,CAAZ+S,CAAX5D,CAEF4D,EAzB+B3M,CAyB/B2M,GAzBFvG,IAkEemD,EAzCboD,EAIA5D,CAJA4D,EF2F0B,EE3F1BA,GF2FCvS,CAAA,CEvFwC2O,CFuFxC,CE3FD4D,CAAJA,EAOI5D,CAPJ4D,EAOgB5D,CAAAwC,OAPhBoB,EAOmCA,CAAgBA,EAAfA,CAA+B5D,CAA/B4D,CAPpCA,CAO8EA,CAE5EA,GOrLI3D,EAAA,CPqLqCD,COrLrC,CPqLJ4D,EAAyC5D,COrLR,4BPqLjC4D,GAAyC5D,COrLyB,sBPqLlE4D,CACEzB,CAAAyB,CAnCFvG,IAmCEuG,CAGAA,CAtCFvG,IAoCEwD,EAEA+C,EAtCFvG,IAoCqBwD,EAAA+C,eAAAA,CAAkC5D,CAAA4D,UAAlCA,CAAyD/S,CAAzD+S,CAEnBA,CADA5D,CAAAwC,OAAA9U,YACAkW,CAD8BpQ,CAAAoQ,CArCC3M,CAqCD2M,CArCOzL,CAqC8B1E,EAArCmQ,CAC9BA,CAAeA,EAAfA,CAAuC5D,CAAvC4D,CAGE9X,EAAJ8X,GACMrb,CADNqb,CAzCiC3M,CA0CpB8M,WADbH,IAGQnW,CAHRmW,CAGgBrb,CAAAyb,cAAAJ,CAAmBA,OAAnBA,CAHhBA,IAKMnW,CAAAC,YALNkW;AAK0BpQ,CAAAoQ,CA9CO3M,CA8CP2M,CA9CazL,CA8CwB1E,EAArCmQ,CAL1BA,CAzCuCzL,EAkDvC1E,EAAAmQ,CAAuB5D,CAAA4D,UAlBqDA,CAnC9EvG,CAAAA,IAaA4G,IAZE5G,IAUFI,MAAAwG,EAEIA,CADJV,EAAAU,CAXE5G,IAWF4G,CAXiChN,CAWjCgN,CAXuC9L,CAWvC8L,CACIA,CAZmC9L,CAYnCP,EAAAqM,EAZmC9L,CAYAP,EAAApP,OAAvCyb,CAAAA,CA2DIpT,CAAAA,CAAeqT,CAAVA,CAvEwBjN,CAuExBiN,CAAArT,GKxRkCsT,EAAAA,CAAAA,CAE3CA,GADI7G,CACJ6G,CLuRiB9D,EKxRNnD,MAAAiH,CLwRuBtT,CKxRvBsT,CACXA,CAIAA,IAAS5O,CAAT4O,CAAe7G,CAAA9U,OAAf2b,CAA6BA,CAA7BA,CAAuCA,CAAvCA,EAAgC5O,CAAhC4O,CAA0C5O,CAAA4O,EAA1CA,CAAiDA,CAC/CA,IAAIC,EAAQ9G,CAAA6G,CAAK5O,CAAL4O,CA1BoCE,EAAAA,CAAAA,CL4SezM,IAAAA,EAxE1BO,CAwE0BP,EK3SjEyM,KAAKA,IAAI9O,EAAM8O,CAAfA,CAAkB9O,CAAlB8O,CAAwBhC,CAAA7Z,OAAxB6b,CAAiD9O,CAAA8O,EAAjDA,CAAwDA,CACtDA,IAAIC,EAAKjC,CAAAgC,CAAiB9O,CAAjB8O,CACTA,IAwBmBD,CAxBf1K,EAAA2K,CAAsBC,CAAtBD,CAAJA,GLiOqClM,CAwEDH,EKzSFqM,CAAWC,CAAXD,CAAlCA,CAAkDA,CAChDA,CAAAA,CAAOA,CAAAA,CAAPA,OAAAA,CADgDA,CAFIA,CAMxDA,CAAAA,CAAOA,CAAAA,CAP2CA,CA2BhDF,GAAIA,CAAJA,CAAyDA,CACvDA,CAAAA,CAAOC,CAAPD,OAAAA,CADuDA,CAFVA,CANNA,CAAAA,CAAAA,IAAAA,EAAAA,CL2RvCI,CAAAA,CAAcC,CAAAN,CAAaM,CAAAnH,aAAb6G,CAAuCA,IACrDO,EAAAA,CA3EmCtM,CA2EhBJ,EAEGmM,EAJAA,CAIAA,CAJAA,CAIAA,EAJAA,CAAAA,EAIAA,IApRtBQ,CACJC,CAsMEtH,IAvMOkD,EAAAoE,CAoRwCT,CApRxCS,CACTA,EAsMEtH,IAvMmCkD,EAAAoE,CAoRYT,CApRZS,CACrCA,EADiEA,CACjEA,EADsEA,CACtEA,CAAAA,CAAAA,CAmRiDT,CAnRjDS,CAAcA,GAAdA,CAAkBD,CAmRQR,CA7Ea/L,EA6EvCJ,EAAAmM,CAA0BA,CACqDnM,EAAAA,CA9ExCI,CA8EwCJ,EE4LjF6M,EAAAA,CF5Lc/L,CE8LRjO,EAAAA,CAAU6C,CAAAmX,CAAQnX,CAAAC,YAARkX,EAA6BA,EAA7BA,CACZvJ,EAAAuJ,CAAAA,CAAAA,CF7Q+B3N,CE6Q/B2N,CF7QqCzM,CA8EaH,EE+LlD4M,CAA0C3T,CAA1C2T,CAEEzM,EAAAA,CAAYsD,CAAAmJ,CF/QiB3N,CE+QjB2N,CAChBA,KAAInb,EAAI0O,CAAAL,EACJrO,EAAJmb,EAASA,CAAC9Y,CAAV8Y,EAA2Bnb,CAA3Bmb,GAAiCnX,CAAjCmX,GACEnb,CAAAmb,UAAAA,EACAA,CAAsBA,CAAtBA,EAAInb,CAAAmb,UAAJA,EAA2Bnb,CAAAoI,WAA3B+S,EACEnb,CAAAoI,WAAAC,YAAA8S,CAAyBnb,CAAzBmb,CAHJA,CAQI9Y;CAAJ8Y,CAEMzM,CAAAL,EAAJ8M,EACEzM,CAAAL,EAAApK,YACAkX,CADoCha,CACpCga,CAAAnX,CAAAmX,CAAQzM,CAAAL,EAFV8M,EAIWha,CAJXga,GAOEnX,CAPFmX,CAOoBA,CAAVA,CAAmBha,CAAnBga,CAA4B3T,CAA5B2T,CFlSqB3N,CEkSiB8M,WAAtCa,CACNzM,CAAAR,EADMiN,CAPVA,CAFFA,CAcOnX,CAALmX,CAQYnX,CAAAoE,WARZ+S,GASMhM,EAKJgM,EAL0CA,EAK1CA,CALaha,CAAAlB,QAAAkb,CAAgBA,QAAhBA,CAKbA,GAFEnX,CAAAC,YAEFkX,CAFsBha,CAEtBga,EAAUA,EAAVA,CAAqBnX,CAArBmX,CAA4BA,IAA5BA,CAAkCzM,CAAAR,EAAlCiN,CAdFA,EAGMha,CAHNga,GAIInX,CAJJmX,CAIsBA,CAAVA,CAAmBha,CAAnBga,CAA4B3T,CAA5B2T,CAAsCA,IAAtCA,CACNzM,CAAAR,EADMiN,CAJZA,CAkBEnX,EAAJmX,GACEnX,CAAAmX,UAKAA,CALqBnX,CAAAmX,UAKrBA,EAL2CA,CAK3CA,CAHIzM,CAAAL,EAGJ8M,EAH6BnX,CAG7BmX,EAFEnX,CAAAmX,UAAAA,EAEFA,CAAAzM,CAAAL,EAAA8M,CAAwBnX,CAN1BmX,CAQAA,EAAAA,CAAOnX,CFlPF3B,EAALoY,GACkDnM,CE8KlD8M,CF9PuC1M,CAgFWJ,EE8KlD8M,CANIC,CAMJD,CAPI5R,CAOJ4R,CF9PiC5N,CEuPzBnG,aAAA+T,CAAqBA,OAArBA,CAORA,EAPyCA,EAOzCA,CF9K2EJ,CE8K3EI,GAJEC,CAIFD,CAJM5R,CAAA9K,QAAA0c,CACFA,IAAIrJ,MAAJqJ,CAAWA,iBAAXA,CF3KuEJ,CE2KvEI,CAAiDA,MAAjDA,CAAyDA,GAAzDA,CADEA,CAC6DA,GAD7DA,CAINA,EADAC,CACAD,GADMC,CAAAD,CAAIA,GAAJA,CAAUA,EAChBA,EADoCA,UACpCA,CAD0C5T,CAC1C4T,CAAI5R,CAAJ4R,GAAUC,CAAVD,EACYA,CAAVA,CF/P+B5N,CE+P/B4N,CAAsCC,CAAtCD,CFhLFX,CAGKM,EAALN,EACE7D,EAAAlD,MAAA+G,CAAiBrT,CAAjBqT,CAnFqC/L,CAmFhBH,EAArBkM,CAAgDzW,CAAhDyW,CAnFqC/L,CAmFkBJ,EAAvDmM,CAvEFD,CA5BgC5G,CAuElC0H,SAAAA,GAAkBA,CAAlBA,CAAkBA,CAAC9b,CAAD8b,CAAOA,CAGvBA,MAAAA,CADI9N,CACJ8N,CAFqBA,CAAVA,CAAe9b,CAAf8b,CAAAjH,YAAAiH,EACA9N,KACX8N,EACMtJ,CAAAsJ,CAAc9N,CAAd8N,CAAJA,EAA2BnC,EAAAmC,CAAkB9N,CAAlB8N,CAA3BA,CACS9N,CADT8N,CAGSA,EAAAA,CAAAA,CAAAA,CAAwB9N,CAAxB8N,CAJXA,CAOOA,CAAAvE,EAVgBuE;AAgCzBxB,QAAAA,GAAiBA,CAAjBA,CAAiBA,CAACtM,CAADsM,CAAOpL,CAAPoL,CAAkBA,CACjCA,IAAIyB,EAAQD,EAAAxB,CAAAA,CAAAA,CAAwBtM,CAAxBsM,CAAZA,CACI0B,EAAiBxJ,CAAA8H,CAAcyB,CAAdzB,CADrBA,CAEI2B,EAAkBD,CAAAjN,EAIlBgN,EAAJzB,GAAcA,CAAA/C,EAAd+C,EAAsC2B,CAAtC3B,GACEA,EAAAA,CAAAA,CAAAA,CAAuByB,CAAvBzB,CAA8B0B,CAA9B1B,CACAA,CAAA2B,CAAA3B,CAAkB0B,CAAAjN,EAFpBuL,CAIIxK,EAAAA,CAAQe,MAAAqL,OAAA5B,CAAc2B,CAAd3B,EAAiCA,IAAjCA,CACR6B,EAAAA,CAAmBnK,EAAAsI,CAA8CtM,CAA9CsM,CAAoDpL,CAAA1E,EAApD8P,CAA0EpL,CAAA5L,SAA1EgX,CAEnB8B,EAAAA,CADe7K,EAAA+I,CAAuC0B,CAAAxR,EAAvC8P,CAAkEtM,CAAlEsM,CACU7J,EAC7BI,OAAAC,OAAAwJ,CACExK,CADFwK,CAEE6B,CAAAlK,EAFFqI,CAGE8B,CAHF9B,CAIE6B,CAAAjK,EAJFoI,CAMiC1L,EAAAA,CAAAM,CAAAN,EAKjCyN,KAAKA,IAAIzc,CAATyc,GAAcC,EAAdD,CAIEA,IAHIR,CAGJQ,CAHQC,CAAAD,CAAUzc,CAAVyc,CAGRA,GAAeA,CAAfA,GAASR,CAATQ,CATwBvM,CAUtBuM,CAAMzc,CAANyc,CAAAA,CAAWR,CEtOjBU,EAAAA,CF6NE3M,CE1NIY,EAAAA,CAAQK,MAAA2L,oBAAAD,CF0NUzM,CE1NVyM,CACZA,KAAS9c,CAAT8c,CAAWA,CAAXA,CAAiB9c,CAAjB8c,CAAqB/L,CAAAjR,OAArBgd,CAAmC9c,CAAA8c,EAAnCA,CACE/c,CACA+c,CADI/L,CAAA+L,CAAM9c,CAAN8c,CACJA,CFuNoBzM,CEvNpByM,CAAM/c,CAAN+c,CAAAA,CAAWvL,CAAAuL,CAAAA,CAAAA,CFuNSzM,CEvNayM,CAAM/c,CAAN+c,CAAtBA,CFuNSzM,CEvNTyM,CFwNbrN,EAAAH,EAAAuL,CAA4BxK,CAvBKwK,CAwCnCmC,CAAAjC,cAAAA,CAAAA,QAAaA,CAAC/J,CAAD+J,CAAaA,CACxBA,IAAAkC,aAAAlC,CAAkBA,IAAAjD,EAAlBiD,CAAuC/J,CAAvC+J,CADwBA,CAS1BmC;CAAAD,aAAAA,CAAAA,QAAYA,CAAC1O,CAAD0O,CAAOjM,CAAPiM,CAAmBA,CAC7BA,IAAIpd,EAAO0O,CAAA8M,WACX4B,EAAIpd,CAAJod,EAA8B1O,CAA9B0O,GAAYA,IAtEKnF,EAsEjBmF,GACEA,IAAAtI,aAAAsI,CAAkB1O,CAAlB0O,CAAwBjM,CAAxBiM,CAKFA,IAFIE,CAEJF,CADIpd,CACJod,GADyCpd,CAADoK,SACxCgT,EAD2Dpd,CAAAkK,WAC3DkT,EACEA,IAASjd,CAATid,CAAaA,CAAbA,CAAgBjd,CAAhBid,CAAoBE,CAAArd,OAApBmd,CAA2Cjd,CAAAid,EAA3CA,CAEEA,IAAAA,aAAAA,CADoCE,CAAAF,CAAejd,CAAfid,CACpCA,CAHJA,KAQEA,IADIhT,CACJgT,CADe1O,CAAAtE,SACfgT,EADgC1O,CAAAxE,WAChCkT,CACEA,IAASjd,CAATid,CAAaA,CAAbA,CAAgBjd,CAAhBid,CAAoBhT,CAAAnK,OAApBmd,CAAqCjd,CAAAid,EAArCA,CAEEA,IAAAA,aAAAA,CADoChT,CAAAgT,CAASjd,CAATid,CACpCA,CAnBuBA,CA2C/BG;CAAA/C,EAAAA,CAAAA,QAA+BA,CAACtV,CAADsV,CAAQA,CAAAA,IAAAA,EAAAA,IAAAA,CAC/BxW,EAAqBwW,CAAVA,CAAsBtV,CAAtBsV,CACbxW,EAAJwW,GAAiBA,IAAAtC,EAAAlU,SAAjBwW,GACEA,IAAAtC,EAAAlU,SADFwW,CAC0CxW,CAD1CwW,CAGAA,IAAIA,CAAUA,EAAVA,CAA4BxW,CAA5BwW,CAAJA,CAAAA,CAGAA,IAAIrL,EAAgBqL,CAAVA,CAAwBtV,CAAxBsV,CACAA,EAAVA,CAAsBrL,CAAtBqL,CAA2BA,QAAAA,CAACnV,CAADmV,CAAUA,CACnCA,GAAIjX,CAAJiX,CACE5L,EAAA4L,CAAuCnV,CAAvCmV,CADFA,KAAAA,CDJJgD,IAAAA,ECOM/T,CAA8BpE,EDLlCmY,SAAAA,CCKkCnY,CDLfmY,eACnB5O,GAAA4O,CCIkCnY,CDJlCmY,CCIkCnY,EDrNlCqG,SAAAA,CCqNkCrG,CDrNfsG,EAAnBD,CACEE,EAAAF,CAiNF8R,CAjNE9R,CCoNgCrG,CDpNhCqG,CAiNwB8R,CAAA1O,EAjNxBpD,CAiNF8R,IAAAA,EAjNE9R,CAiNF8R,IAAAA,EAjNE9R,CCiNA8O,CAKIpW,CAAJoW,EAAuCA,EAAvCA,GAA0BxW,CAA1BwW,GACEZ,CAAAY,CAAAA,CAAAA,CACAA,CAAAA,CAAAlC,EAAAkC,EAAmBA,CAAAlC,EAAAkC,cAAAA,CAAiCnV,CAAjCmV,CAFrBA,CANmCA,CAArCA,CAWIpW,EAAJoW,CACEtV,CAAAC,YADFqV,CACgCA,CAAVA,CAAoBrL,CAApBqL,CADtBA,CAGEA,IAAAtC,EAAAhN,EAAAsP,MAAAha,KAAAga,CAAsDrL,CAAtDqL,CAlBFA,CALqCA,CAkCvCiD,EAAAC,sBAAAA,CAAAA,QAAqBA,CAAC1V,CAAD0V,CAAU/L,CAAV+L,CAAoBA,CACvCA,IAAI7V,CACCzD,EAALsZ,GAGE7V,CAHF6V,CAGUjO,CADQyD,CAAAwK,CAAc1V,CAAd0V,CACRjO,EADkCyD,CAAAwK,CAAclB,EAAAkB,CAAAA,IAAAA,CAAwB1V,CAAxB0V,CAAdA,CAClCjO,GAAAiO,CAA0B/L,CAA1B+L,CAHVA,CASAA,OAAOA,CAHP7V,CAGO6V,CAHC7V,CAGD6V,EAHUla,MAAAma,iBAAAD,CAAwB1V,CAAxB0V,CAAAE,iBAAAF,CAAkD/L,CAAlD+L,CAGVA,EAAQ7V,CAAAhH,KAAA6c,EAARA,CAAuBA,EAXSA,CAgBzCG;CAAAC,EAAAA,CAAAA,QAAeA,CAAC9V,CAAD8V,CAAUC,CAAVD,CAAuBA,CACpCA,IAAI9d,EAAiB8d,CAAVA,CAAe9V,CAAf8V,CAAAvI,YAAAuI,EACPE,EAAAA,CAAUD,CAAAD,CAAcC,CAAArc,MAAAoc,CAAkBA,IAAlBA,CAAdA,CAAwCA,EAClDG,EAAAA,CAAYje,CAAA0O,KAAZuP,EAAyBje,CAAA0O,KAAAtG,UAI7B0V,IAAIA,CAACG,CAALH,CAAgBA,CACdA,IAAII,EAAYlW,CAAAO,aAAAuV,CAAqBA,OAArBA,CAChBA,IAAII,CAAJJ,CAAeA,CACTK,CAAAA,CAAKD,CAAAxc,MAAAoc,CAAgBA,IAAhBA,CACTA,KAAKA,IAAI3d,EAAE2d,CAAXA,CAAc3d,CAAd2d,CAAkBK,CAAAle,OAAlB6d,CAA6B3d,CAAA2d,EAA7BA,CACEA,GAAIK,CAAAL,CAAG3d,CAAH2d,CAAJA,GAAcrU,CAAAe,EAAdsT,CAA2CA,CACzCG,CAAAH,CAAYK,CAAAL,CAAG3d,CAAH2d,CAAKA,CAALA,CACZA,MAFyCA,CAHhCA,CAFDA,CAYZG,CAAJH,EACEE,CAAAxd,KAAAsd,CAAarU,CAAAe,EAAbsT,CAA0CG,CAA1CH,CAEG1Z,EAAL0Z,GACMlO,CADNkO,CACkB5K,CAAA4K,CAAc9V,CAAd8V,CADlBA,GAEmBlO,CAAAJ,EAFnBsO,EAGIE,CAAAxd,KAAAsd,CAAaxN,CAAA6D,EAAb2J,CAA0ClO,CAAAJ,EAA1CsO,CAGMA,EAAVA,CAA6B9V,CAA7B8V,CAAsCE,CAAAhS,KAAA8R,CAAaA,GAAbA,CAAtCA,CA5BoCA,CA8BtCM,EAAAC,EAAAA,CAAAA,QAAiBA,CAAC3d,CAAD2d,CAAOA,CACtBA,MAAOnL,EAAAmL,CAAc3d,CAAd2d,CADeA,CAOxBC,EAAAC,EAAAA,CAAAA,QAASA,CAAC7d,CAAD6d,CAAO9X,CAAP8X,CAAcA,CACrBvW,CAAAuW,CAAyB7d,CAAzB6d,CAA+B9X,CAA/B8X,CADqBA,CAOvBC,EAAAC,EAAAA,CAAAA,QAAWA,CAAC/d,CAAD+d,CAAOhY,CAAPgY,CAAcA,CACvBzW,CAAAyW,CAAyB/d,CAAzB+d,CAA+BhY,CAA/BgY,CAAsCA,CAAAA,CAAtCA,CADuBA,CAOzBC,EAAAC,EAAAA,CAAAA,QAAYA,CAACje,CAADie,CAAOA,CACjBA,MAAOtJ,GAAAsJ,CAAcje,CAAdie,CADUA,CAOnBC,EAAAC,EAAAA,CAAAA,QAAmBA,CAACne,CAADme,CAAOA,CACxBA,MAAOzJ,GAAAyJ,CAAgBne,CAAhBme,CADiBA,CAO5B9G,EAAAjI,UAAA,MAAA,CAAiCiI,CAAAjI,UAAAoF,MACjC6C,EAAAjI,UAAA,gBAAA,CAA2CiI,CAAAjI,UAAA+I,gBAC3Cd;CAAAjI,UAAA,aAAA,CAAwCiI,CAAAjI,UAAAgF,aACxCiD,EAAAjI,UAAA,cAAA,CAAyCiI,CAAAjI,UAAAoL,cACzCnD,EAAAjI,UAAA,aAAA,CAAwCiI,CAAAjI,UAAAsN,aACxCrF,EAAAjI,UAAA,sBAAA,CAAiDiI,CAAAjI,UAAA4N,sBACjD3F,EAAAjI,UAAA,gBAAA,CAA2CiI,CAAAjI,UAAAgO,EAC3C/F,EAAAjI,UAAA,kBAAA,CAA6CiI,CAAAjI,UAAAuO,EAC7CtG,EAAAjI,UAAA,gCAAA,CAA2DiI,CAAAjI,UAAA0K,EAC3DzC,EAAAjI,UAAA,YAAA,CAAuCiI,CAAAjI,UAAA2I,EACvCV,EAAAjI,UAAA,iBAAA,CAA4CiI,CAAAjI,UAAA6I,EAC5CZ,EAAAjI,UAAA,kBAAA,CAA6CiI,CAAAjI,UAAA2K,kBAC7C1C;CAAAjI,UAAA,UAAA,CAAqCiI,CAAAjI,UAAAyO,EACrCxG,EAAAjI,UAAA,YAAA,CAAuCiI,CAAAjI,UAAA2O,EACvC1G,EAAAjI,UAAA,aAAA,CAAwCiI,CAAAjI,UAAA6O,EACxC5G,EAAAjI,UAAA,oBAAA,CAA+CiI,CAAAjI,UAAA+O,EAE/CtN,OAAAuN,iBAAA,CAAwB/G,CAAAjI,UAAxB,CAA+C,CAC7C,aAAgB,CACd,IAAAJ,QAAG,EAAG,CACJ,MAAOnM,EADH,CADQ,CAD6B,CAM7C,UAAa,CACX,IAAAmM,QAAG,EAAG,CACJ,MAAOtL,EADH,CADK,CANgC,CAA/C,C,CS9hBA,IAAM2a,EAAc,IAAIhH,CAAxB,CAEI4C,EAFJ,CAEeJ,EAEX/W,OAAA,SAAJ,GACEmX,EACA,CADYnX,MAAA,SAAA,UACZ,CAAA+W,EAAA,CAAuB/W,MAAA,SAAA,qBAFzB,CAKAA;MAAAS,SAAA,CAAkB,CAChB8T,YAAagH,CADG,CAOhB,gBAAAlG,QAAe,CAACpB,CAAD,CAAWD,CAAX,CAAwBwH,CAAxB,CAAwC,CACrDD,CAAAtE,kBAAA,EACAsE,EAAAlG,gBAAA,CAA4BpB,CAA5B,CAAsCD,CAAtC,CAAmDwH,CAAnD,CAFqD,CAPvC,CAgBhB,mBAAAlG,QAAkB,CAACrB,CAAD,CAAWD,CAAX,CAAwB,CACxCuH,CAAAjG,mBAAA,CAA+BrB,CAA/B,CAAyCD,CAAzC,CADwC,CAhB1B,CAyBhB,sBAAAuB,QAAqB,CAACtB,CAAD,CAAWD,CAAX,CAAwBwH,CAAxB,CAAwC,CAC3DD,CAAAtE,kBAAA,EACAsE,EAAAhG,sBAAA,CAAkCtB,CAAlC,CAA4CD,CAA5C,CAAyDwH,CAAzD,CAF2D,CAzB7C,CAiChB,aAAA5B,QAAY,CAACpV,CAAD,CAAUmJ,CAAV,CAAsB,CAChC4N,CAAAtE,kBAAA,EACAsE,EAAA3B,aAAA,CAAyBpV,CAAzB,CAAkCmJ,CAAlC,CAFgC,CAjClB,CAyChB,aAAA2D,QAAY,CAAC9M,CAAD,CAAU,CACpB+W,CAAAtE,kBAAA,EACAsE,EAAAjK,aAAA,CAAyB9M,CAAzB,CAFoB,CAzCN,CAiDhB,cAAAkT,QAAa,CAAC/J,CAAD,CAAa,CACxB4N,CAAAtE,kBAAA,EACAsE,EAAA7D,cAAA,CAA0B/J,CAA1B,CAFwB,CAjDV,CAsDhB,kBAAAsJ,QAAiB,EAAG,CAClBsE,CAAAtE,kBAAA,EADkB,CAtDJ;AA+DhB,sBAAAiD,QAAqB,CAAC1V,CAAD,CAAU2J,CAAV,CAAoB,CACvC,MAAOoN,EAAArB,sBAAA,CAAkC1V,CAAlC,CAA2C2J,CAA3C,CADgC,CA/DzB,CAmEhBxN,UAAWC,CAnEK,CAqEhBb,aAAcA,CArEE,CAuEhBS,SAAUK,CAvEM,CA0EdsW,GAAJ,GACEnX,MAAAS,SAAA0W,UADF,CAC8BA,EAD9B,CAIIJ,GAAJ,GACE/W,MAAAS,SAAAsW,qBADF,CACyCA,EADzC","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'] ? node['previous']['end'] : node['parent']['start'];\n    t = text.substring(ss, node['start'] - 1);\n    t = _expandUnicodeEscapes(t);\n    t = t.replace(RX.multipleSpaces, ' ');\n    // TODO(sorvell): ad hoc; make selector include only after last ;\n    // helps with mixin syntax\n    t = t.substring(t.lastIndexOf(';') + 1);\n    let s = node['parsedSelector'] = node['selector'] = t.trim();\n    node['atRule'] = (s.indexOf(AT_START) === 0);\n    // note, support a subset of rule types...\n    if (node['atRule']) {\n      if (s.indexOf(MEDIA_START) === 0) {\n        node['type'] = types.MEDIA_RULE;\n      } else if (s.match(RX.keyframesRule)) {\n        node['type'] = types.KEYFRAMES_RULE;\n        node['keyframesName'] =\n          node['selector'].split(RX.multipleSpaces).pop();\n      }\n    } else {\n      if (s.indexOf(VAR_START) === 0) {\n        node['type'] = types.MIXIN_RULE;\n      } else {\n        node['type'] = types.STYLE_RULE;\n      }\n    }\n  }\n  let r$ = node['rules'];\n  if (r$) {\n    for (let i = 0, l = r$.length, r;\n      (i < l) && (r = r$[i]); i++) {\n      parseCss(r, text);\n    }\n  }\n  return node;\n}\n\n/**\n * conversion of sort unicode escapes with spaces like `\\33 ` (and longer) into\n * expanded form that doesn't require trailing space `\\000033`\n * @param {string} s\n * @return {string}\n */\nfunction _expandUnicodeEscapes(s) {\n  return s.replace(/\\\\([0-9a-f]{1,6})\\s/gi, function() {\n    let code = arguments[1],\n      repeat = 6 - code.length;\n    while (repeat--) {\n      code = '0' + code;\n    }\n    return '\\\\' + code;\n  });\n}\n\n/**\n * stringify parsed css.\n * @param {StyleNode} node\n * @param {boolean=} preserveProperties\n * @param {string=} text\n * @return {string}\n */\nexport function stringify(node, preserveProperties, text = '') {\n  // calc rule cssText\n  let cssText = '';\n  if (node['cssText'] || node['rules']) {\n    let r$ = node['rules'];\n    if (r$ && !_hasMixinRules(r$)) {\n      for (let i = 0, l = r$.length, r;\n        (i < l) && (r = r$[i]); i++) {\n        cssText = stringify(r, preserveProperties, cssText);\n      }\n    } else {\n      cssText = preserveProperties ? node['cssText'] :\n        removeCustomProps(node['cssText']);\n      cssText = cssText.trim();\n      if (cssText) {\n        cssText = '  ' + cssText + '\\n';\n      }\n    }\n  }\n  // emit rule if there is cssText\n  if (cssText) {\n    if (node['selector']) {\n      text += node['selector'] + ' ' + OPEN_BRACE + '\\n';\n    }\n    text += cssText;\n    if (node['selector']) {\n      text += CLOSE_BRACE + '\\n\\n';\n    }\n  }\n  return text;\n}\n\n/**\n * @param {Array<StyleNode>} rules\n * @return {boolean}\n */\nfunction _hasMixinRules(rules) {\n  let r = rules[0];\n  return Boolean(r) && Boolean(r['selector']) && r['selector'].indexOf(VAR_START) === 0;\n}\n\n/**\n * @param {string} cssText\n * @return {string}\n */\nfunction removeCustomProps(cssText) {\n  cssText = removeCustomPropAssignment(cssText);\n  return removeCustomPropApply(cssText);\n}\n\n/**\n * @param {string} cssText\n * @return {string}\n */\nexport function removeCustomPropAssignment(cssText) {\n  return cssText\n    .replace(RX.customProp, '')\n    .replace(RX.mixinProp, '');\n}\n\n/**\n * @param {string} cssText\n * @return {string}\n */\nfunction removeCustomPropApply(cssText) {\n  return cssText\n    .replace(RX.mixinApply, '')\n    .replace(RX.varApply, '');\n}\n\n/** @enum {number} */\nexport const types = {\n  STYLE_RULE: 1,\n  KEYFRAMES_RULE: 7,\n  MEDIA_RULE: 4,\n  MIXIN_RULE: 1000\n}\n\nconst OPEN_BRACE = '{';\nconst CLOSE_BRACE = '}';\n\n// helper regexp's\nconst RX = {\n  comments: /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//gim,\n  port: /@import[^;]*;/gim,\n  customProp: /(?:^[^;\\-\\s}]+)?--[^;{}]*?:[^{};]*?(?:[;\\n]|$)/gim,\n  mixinProp: /(?:^[^;\\-\\s}]+)?--[^;{}]*?:[^{};]*?{[^}]*?}(?:[;\\n]|$)?/gim,\n  mixinApply: /@apply\\s*\\(?[^);]*\\)?\\s*(?:[;\\n]|$)?/gim,\n  varApply: /[^;:]*?:[^;]*?var\\([^;]*\\)(?:[;\\n]|$)?/gim,\n  keyframesRule: /^@[^\\s]*keyframes/,\n  multipleSpaces: /\\s+/g\n}\n\nconst VAR_START = '--';\nconst MEDIA_START = '@media';\nconst AT_START = '@';\n",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 = !(window['ShadyDOM'] && window['ShadyDOM']['inUse']);\nlet nativeCssVariables_;\n\n/**\n * @param {(ShadyCSSOptions | ShadyCSSInterface)=} settings\n */\nfunction calcCssVariables(settings) {\n  if (settings && settings['shimcssproperties']) {\n    nativeCssVariables_ = false;\n  } else {\n    // chrome 49 has semi-working css vars, check if box-shadow works\n    // safari 9.1 has a recalc bug: https://bugs.webkit.org/show_bug.cgi?id=155782\n    // However, shim css custom properties are only supported with ShadyDOM enabled,\n    // so fall back on native if we do not detect ShadyDOM\n    // Edge 15: custom properties used in ::before and ::after will also be used in the parent element\n    // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12414257/\n    nativeCssVariables_ = nativeShadow || Boolean(!navigator.userAgent.match(/AppleWebKit\\/601|Edge\\/15/) &&\n      window.CSS && CSS.supports && CSS.supports('box-shadow', '0 0 0 var(--foo)'));\n  }\n}\n\n/** @type {string | undefined} */\nexport let cssBuild;\nif (window.ShadyCSS && window.ShadyCSS.cssBuild !== undefined) {\n  cssBuild = window.ShadyCSS.cssBuild;\n}\n\nif (window.ShadyCSS && window.ShadyCSS.nativeCss !== undefined) {\n  nativeCssVariables_ = window.ShadyCSS.nativeCss;\n} else if (window.ShadyCSS) {\n  calcCssVariables(window.ShadyCSS);\n  // reset window variable to let ShadyCSS API take its place\n  window.ShadyCSS = undefined;\n} else {\n  calcCssVariables(window['WebComponents'] && window['WebComponents']['flags']);\n}\n\n// Hack for type error under new type inference which doesn't like that\n// nativeCssVariables is updated in a function and assigns the type\n// `function(): ?` instead of `boolean`.\nexport const nativeCssVariables = /** @type {boolean} */(nativeCssVariables_);","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\nexport const VAR_ASSIGN = /(?:^|[;\\s{]\\s*)(--[\\w-]*?)\\s*:\\s*(?:((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^)]*?\\)|[^};{])+)|\\{([^}]*)\\}(?:(?=[;\\s}])|$))/gi;\nexport const MIXIN_MATCH = /(?:^|\\W+)@apply\\s*\\(?([^);\\n]*)\\)?/gi;\nexport const VAR_CONSUMED = /(--[\\w-]+)\\s*([:,;)]|$)/gi;\nexport const ANIMATION_MATCH = /(animation\\s*:)|(animation-name\\s*:)/;\nexport const MEDIA_MATCH = /@media\\s(.*)/;\nexport const IS_VAR = /^--/;\nexport const BRACKETED = /\\{[^}]*\\}/g;\nexport const HOST_PREFIX = '(?:^|[^.#[:])';\nexport const HOST_SUFFIX = '($|[.:[\\\\s>+~])';\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\n/** @type {!Set<string>} */\nconst styleTextSet = new Set();\n\nexport const scopingAttribute = 'shady-unscoped';\n\n/**\n * Add a specifically-marked style to the document directly, and only one copy of that style.\n *\n * @param {!HTMLStyleElement} style\n * @return {undefined}\n */\nexport function processUnscopedStyle(style) {\n  const text = style.textContent;\n  if (!styleTextSet.has(text)) {\n    styleTextSet.add(text);\n    const newStyle = style.cloneNode(true);\n    document.head.appendChild(newStyle);\n  }\n}\n\n/**\n * Check if a style is supposed to be unscoped\n * @param {!HTMLStyleElement} style\n * @return {boolean} true if the style has the unscoping attribute\n */\nexport function isUnscopedStyle(style) {\n  return style.hasAttribute(scopingAttribute);\n}","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {nativeShadow, nativeCssVariables, cssBuild} from './style-settings.js';\nimport {parse, stringify, types, StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\nimport {MEDIA_MATCH} from './common-regex.js';\nimport {processUnscopedStyle, isUnscopedStyle} from './unscoped-style-handler.js';\n\n/**\n * @param {string|StyleNode} rules\n * @param {function(StyleNode)=} callback\n * @return {string}\n */\nexport function toCssText (rules, callback) {\n  if (!rules) {\n    return '';\n  }\n  if (typeof rules === 'string') {\n    rules = parse(rules);\n  }\n  if (callback) {\n    forEachRule(rules, callback);\n  }\n  return stringify(rules, nativeCssVariables);\n}\n\n/**\n * @param {HTMLStyleElement} style\n * @return {StyleNode}\n */\nexport function rulesForStyle(style) {\n  if (!style['__cssRules'] && style.textContent) {\n    style['__cssRules'] = parse(style.textContent);\n  }\n  return style['__cssRules'] || null;\n}\n\n// Tests if a rule is a keyframes selector, which looks almost exactly\n// like a normal selector but is not (it has nothing to do with scoping\n// for example).\n/**\n * @param {StyleNode} rule\n * @return {boolean}\n */\nexport function isKeyframesSelector(rule) {\n  return Boolean(rule['parent']) &&\n  rule['parent']['type'] === types.KEYFRAMES_RULE;\n}\n\n/**\n * @param {StyleNode} node\n * @param {Function=} styleRuleCallback\n * @param {Function=} keyframesRuleCallback\n * @param {boolean=} onlyActiveRules\n */\nexport function forEachRule(node, styleRuleCallback, keyframesRuleCallback, onlyActiveRules) {\n  if (!node) {\n    return;\n  }\n  let skipRules = false;\n  let type = node['type'];\n  if (onlyActiveRules) {\n    if (type === types.MEDIA_RULE) {\n      let matchMedia = node['selector'].match(MEDIA_MATCH);\n      if (matchMedia) {\n        // if rule is a non matching @media rule, skip subrules\n        if (!window.matchMedia(matchMedia[1]).matches) {\n          skipRules = true;\n        }\n      }\n    }\n  }\n  if (type === types.STYLE_RULE) {\n    styleRuleCallback(node);\n  } else if (keyframesRuleCallback &&\n    type === types.KEYFRAMES_RULE) {\n    keyframesRuleCallback(node);\n  } else if (type === types.MIXIN_RULE) {\n    skipRules = true;\n  }\n  let r$ = node['rules'];\n  if (r$ && !skipRules) {\n    for (let i=0, l=r$.length, r; (i<l) && (r=r$[i]); i++) {\n      forEachRule(r, styleRuleCallback, keyframesRuleCallback, onlyActiveRules);\n    }\n  }\n}\n\n// add a string of cssText to the document.\n/**\n * @param {string} cssText\n * @param {string} moniker\n * @param {Node} target\n * @param {Node} contextNode\n * @return {HTMLStyleElement}\n */\nexport function applyCss(cssText, moniker, target, contextNode) {\n  let style = createScopeStyle(cssText, moniker);\n  applyStyle(style, target, contextNode);\n  return style;\n}\n\n/**\n * @param {string} cssText\n * @param {string} moniker\n * @return {HTMLStyleElement}\n */\nexport function createScopeStyle(cssText, moniker) {\n  let style = /** @type {HTMLStyleElement} */(document.createElement('style'));\n  if (moniker) {\n    style.setAttribute('scope', moniker);\n  }\n  style.textContent = cssText;\n  return style;\n}\n\n/**\n * Track the position of the last added style for placing placeholders\n * @type {Node}\n */\nlet lastHeadApplyNode = null;\n\n// insert a comment node as a styling position placeholder.\n/**\n * @param {string} moniker\n * @return {!Comment}\n */\nexport function applyStylePlaceHolder(moniker) {\n  let placeHolder = document.createComment(' Shady DOM styles for ' +\n    moniker + ' ');\n  let after = lastHeadApplyNode ?\n    lastHeadApplyNode['nextSibling'] : null;\n  let scope = document.head;\n  scope.insertBefore(placeHolder, after || scope.firstChild);\n  lastHeadApplyNode = placeHolder;\n  return placeHolder;\n}\n\n/**\n * @param {HTMLStyleElement} style\n * @param {?Node} target\n * @param {?Node} contextNode\n */\nexport function applyStyle(style, target, contextNode) {\n  target = target || document.head;\n  let after = (contextNode && contextNode.nextSibling) ||\n    target.firstChild;\n  target.insertBefore(style, after);\n  if (!lastHeadApplyNode) {\n    lastHeadApplyNode = style;\n  } else {\n    // only update lastHeadApplyNode if the new style is inserted after the old lastHeadApplyNode\n    let position = style.compareDocumentPosition(lastHeadApplyNode);\n    if (position === Node.DOCUMENT_POSITION_PRECEDING) {\n      lastHeadApplyNode = style;\n    }\n  }\n}\n\n/**\n * @param {string} buildType\n * @return {boolean}\n */\nexport function isTargetedBuild(buildType) {\n  return nativeShadow ? buildType === 'shadow' : buildType === 'shady';\n}\n\n/**\n * Walk from text[start] matching parens and\n * returns position of the outer end paren\n * @param {string} text\n * @param {number} start\n * @return {number}\n */\nexport function findMatchingParen(text, start) {\n  let level = 0;\n  for (let i=start, l=text.length; i < l; i++) {\n    if (text[i] === '(') {\n      level++;\n    } else if (text[i] === ')') {\n      if (--level === 0) {\n        return i;\n      }\n    }\n  }\n  return -1;\n}\n\n/**\n * @param {string} str\n * @param {function(string, string, string, string)} callback\n */\nexport function processVariableAndFallback(str, callback) {\n  // find 'var('\n  let start = str.indexOf('var(');\n  if (start === -1) {\n    // no var?, everything is prefix\n    return callback(str, '', '', '');\n  }\n  //${prefix}var(${inner})${suffix}\n  let end = findMatchingParen(str, start + 3);\n  let inner = str.substring(start + 4, end);\n  let prefix = str.substring(0, start);\n  // suffix may have other variables\n  let suffix = processVariableAndFallback(str.substring(end + 1), callback);\n  let comma = inner.indexOf(',');\n  // value and fallback args should be trimmed to match in property lookup\n  if (comma === -1) {\n    // variable, no fallback\n    return callback(prefix, inner.trim(), '', suffix);\n  }\n  // var(${value},${fallback})\n  let value = inner.substring(0, comma).trim();\n  let fallback = inner.substring(comma + 1).trim();\n  return callback(prefix, value, fallback, suffix);\n}\n\n/**\n * @param {Element} element\n * @param {string} value\n */\nexport function setElementClassRaw(element, value) {\n  // use native setAttribute provided by ShadyDOM when setAttribute is patched\n  if (nativeShadow) {\n    element.setAttribute('class', value);\n  } else {\n    window['ShadyDOM']['nativeMethods']['setAttribute'].call(element, 'class', value);\n  }\n}\n\nexport const wrap = window['ShadyDOM'] && window['ShadyDOM']['wrap'] || ((node) => node);\n\n/**\n * @param {Element | {is: string, extends: string}} element\n * @return {{is: string, typeExtension: string}}\n */\nexport function getIsExtends(element) {\n  let localName = element['localName'];\n  let is = '', typeExtension = '';\n  /*\n  NOTE: technically, this can be wrong for certain svg elements\n  with `-` in the name like `<font-face>`\n  */\n  if (localName) {\n    if (localName.indexOf('-') > -1) {\n      is = localName;\n    } else {\n      typeExtension = localName;\n      is = (element.getAttribute && element.getAttribute('is')) || '';\n    }\n  } else {\n    is = /** @type {?} */(element).is;\n    typeExtension = /** @type {?} */(element).extends;\n  }\n  return {is, typeExtension};\n}\n\n/**\n * @param {Element|DocumentFragment} element\n * @return {string}\n */\nexport function gatherStyleText(element) {\n  /** @type {!Array<string>} */\n  const styleTextParts = [];\n  const styles = /** @type {!NodeList<!HTMLStyleElement>} */(element.querySelectorAll('style'));\n  for (let i = 0; i < styles.length; i++) {\n    const style = styles[i];\n    if (isUnscopedStyle(style)) {\n      if (!nativeShadow) {\n        processUnscopedStyle(style);\n        style.parentNode.removeChild(style);\n      }\n    } else {\n      styleTextParts.push(style.textContent);\n      style.parentNode.removeChild(style);\n    }\n  }\n  return styleTextParts.join('').trim();\n}\n\n/**\n * Split a selector separated by commas into an array in a smart way\n * @param {string} selector\n * @return {!Array<string>}\n */\nexport function splitSelectorList(selector) {\n  const parts = [];\n  let part = '';\n  for (let i = 0; i >= 0 && i < selector.length; i++) {\n    // A selector with parentheses will be one complete part\n    if (selector[i] === '(') {\n      // find the matching paren\n      const end = findMatchingParen(selector, i);\n      // push the paren block into the part\n      part += selector.slice(i, end + 1);\n      // move the index to after the paren block\n      i = end;\n    } else if (selector[i] === ',') {\n      parts.push(part);\n      part = '';\n    } else {\n      part += selector[i];\n    }\n  }\n  // catch any pieces after the last comma\n  if (part) {\n    parts.push(part);\n  }\n  return parts;\n}\n\nconst CSS_BUILD_ATTR = 'css-build';\n\n/**\n * Return the polymer-css-build \"build type\" applied to this element\n *\n * @param {!HTMLElement} element\n * @return {string} Can be \"\", \"shady\", or \"shadow\"\n */\nexport function getCssBuild(element) {\n  if (cssBuild !== undefined) {\n    return /** @type {string} */(cssBuild);\n  }\n  if (element.__cssBuild === undefined) {\n    // try attribute first, as it is the common case\n    const attrValue = element.getAttribute(CSS_BUILD_ATTR);\n    if (attrValue) {\n      element.__cssBuild = attrValue;\n    } else {\n      const buildComment = getBuildComment(element);\n      if (buildComment !== '') {\n        // remove build comment so it is not needlessly copied into every element instance\n        removeBuildComment(element);\n      }\n      element.__cssBuild = buildComment;\n    }\n  }\n  return element.__cssBuild || '';\n}\n\n/**\n * Check if the given element, either a <template> or <style>, has been processed\n * by polymer-css-build.\n *\n * If so, then we can make a number of optimizations:\n * - polymer-css-build will decompose mixins into individual CSS Custom Properties,\n * so the ApplyShim can be skipped entirely.\n * - Under native ShadowDOM, the style text can just be copied into each instance\n * without modification\n * - If the build is \"shady\" and ShadyDOM is in use, the styling does not need\n * scoping beyond the shimming of CSS Custom Properties\n *\n * @param {!HTMLElement} element\n * @return {boolean}\n */\nexport function elementHasBuiltCss(element) {\n  return getCssBuild(element) !== '';\n}\n\n/**\n * For templates made with tagged template literals, polymer-css-build will\n * insert a comment of the form `<!--css-build:shadow-->`\n *\n * @param {!HTMLElement} element\n * @return {string}\n */\nexport function getBuildComment(element) {\n  const buildComment = element.localName === 'template' ?\n      /** @type {!HTMLTemplateElement} */ (element).content.firstChild :\n      element.firstChild;\n  if (buildComment instanceof Comment) {\n    const commentParts = buildComment.textContent.trim().split(':');\n    if (commentParts[0] === CSS_BUILD_ATTR) {\n      return commentParts[1];\n    }\n  }\n  return '';\n}\n\n/**\n * Check if the css build status is optimal, and do no unneeded work.\n *\n * @param {string=} cssBuild CSS build status\n * @return {boolean} css build is optimal or not\n */\nexport function isOptimalCssBuild(cssBuild = '') {\n  // CSS custom property shim always requires work\n  if (cssBuild === '' || !nativeCssVariables) {\n    return false;\n  }\n  return nativeShadow ? cssBuild === 'shadow' : cssBuild === 'shady';\n}\n\n/**\n * @param {!HTMLElement} element\n */\nfunction removeBuildComment(element) {\n  const buildComment = element.localName === 'template' ?\n      /** @type {!HTMLTemplateElement} */ (element).content.firstChild :\n      element.firstChild;\n  buildComment.parentNode.removeChild(buildComment);\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\nimport * as StyleUtil from './style-util.js';\nimport {nativeShadow} from './style-settings.js';\n\n/* Transforms ShadowDOM styling into ShadyDOM styling\n\n* scoping:\n\n  * elements in scope get scoping selector class=\"x-foo-scope\"\n  * selectors re-written as follows:\n\n    div button -> div.x-foo-scope button.x-foo-scope\n\n* :host -> scopeName\n\n* :host(...) -> scopeName...\n\n* ::slotted(...) -> scopeName > ...\n\n* ...:dir(ltr|rtl) -> [dir=\"ltr|rtl\"] ..., ...[dir=\"ltr|rtl\"]\n\n* :host(:dir[rtl]) -> scopeName:dir(rtl) -> [dir=\"rtl\"] scopeName, scopeName[dir=\"rtl\"]\n\n*/\nconst SCOPE_NAME = 'style-scope';\n\nclass StyleTransformer {\n  get SCOPE_NAME() {\n    return SCOPE_NAME;\n  }\n  /**\n   * Given a node and scope name, add a scoping class to each node\n   * in the tree. This facilitates transforming css into scoped rules.\n   * @param {!Node} node\n   * @param {string} scope\n   * @param {boolean=} shouldRemoveScope\n   * @deprecated\n   */\n  dom(node, scope, shouldRemoveScope) {\n    const fn = (node) => {\n      this.element(node, scope || '', shouldRemoveScope);\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * Given a node and scope name, add a scoping class to each node in the tree.\n   * @param {!Node} node\n   * @param {string} scope\n   */\n  domAddScope(node, scope) {\n    const fn = (node) => {\n      this.element(node, scope || '');\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * @param {!Node} startNode\n   * @param {!function(!Node)} transformer\n   */\n  _transformDom(startNode, transformer) {\n    if (startNode.nodeType === Node.ELEMENT_NODE) {\n      transformer(startNode)\n    }\n    let c$;\n    if (startNode.localName === 'template') {\n      const template = /** @type {!HTMLTemplateElement} */ (startNode);\n      // In case the template is in svg context, fall back to the node\n      // since it won't be an HTMLTemplateElement with a .content property\n      c$ = (template.content || template._content || template).childNodes;\n    } else {\n      c$ = /** @type {!ParentNode} */ (startNode).children ||\n          startNode.childNodes;\n    }\n    if (c$) {\n      for (let i = 0; i < c$.length; i++) {\n        this._transformDom(c$[i], transformer);\n      }\n    }\n  }\n\n  /**\n   * @param {?} element\n   * @param {?} scope\n   * @param {?=} shouldRemoveScope\n   */\n  element(element, scope, shouldRemoveScope) {\n    // note: if using classes, we add both the general 'style-scope' class\n    // as well as the specific scope. This enables easy filtering of all\n    // `style-scope` elements\n    if (scope) {\n      // note: svg on IE does not have classList so fallback to class\n      if (element.classList) {\n        if (shouldRemoveScope) {\n          element.classList.remove(SCOPE_NAME);\n          element.classList.remove(scope);\n        } else {\n          element.classList.add(SCOPE_NAME);\n          element.classList.add(scope);\n        }\n      } else if (element.getAttribute) {\n        let c = element.getAttribute(CLASS);\n        if (shouldRemoveScope) {\n          if (c) {\n            let newValue = c.replace(SCOPE_NAME, '').replace(scope, '');\n            StyleUtil.setElementClassRaw(element, newValue);\n          }\n        } else {\n          let newValue = (c ? c + ' ' : '') + SCOPE_NAME + ' ' + scope;\n          StyleUtil.setElementClassRaw(element, newValue);\n        }\n      }\n    }\n  }\n\n  /**\n   * Given a node, replace the scoping class to each subnode in the tree.\n   * @param {!Node} node\n   * @param {string} oldScope\n   * @param {string} newScope\n   */\n  domReplaceScope(node, oldScope, newScope) {\n    const fn = (node) => {\n      this.element(node, oldScope, true);\n      this.element(node, newScope);\n    };\n    this._transformDom(node, fn);\n  }\n  /**\n   * Given a node, remove the scoping class to each subnode in the tree.\n   * @param {!Node} node\n   * @param {string} oldScope\n   */\n  domRemoveScope(node, oldScope) {\n    const fn = (node) => {\n      this.element(node, oldScope || '', true);\n    };\n    this._transformDom(node, fn);\n  }\n\n  /**\n   * @param {?} element\n   * @param {?} styleRules\n   * @param {?=} callback\n   * @param {string=} cssBuild\n   * @param {string=} cssText\n   * @return {string}\n   */\n  elementStyles(element, styleRules, callback, cssBuild = '', cssText = '') {\n    // no need to shim selectors if settings.useNativeShadow, also\n    // a shady css build will already have transformed selectors\n    // NOTE: This method may be called as part of static or property shimming.\n    // When there is a targeted build it will not be called for static shimming,\n    // but when the property shim is used it is called and should opt out of\n    // static shimming work when a proper build exists.\n    if (cssText === '') {\n      if (nativeShadow || cssBuild === 'shady') {\n        cssText = StyleUtil.toCssText(styleRules, callback);\n      } else {\n        let {is, typeExtension} = StyleUtil.getIsExtends(element);\n        cssText = this.css(styleRules, is, typeExtension, callback) + '\\n\\n';\n      }\n    }\n    return cssText.trim();\n  }\n\n  // Given a string of cssText and a scoping string (scope), returns\n  // a string of scoped css where each selector is transformed to include\n  // a class created from the scope. ShadowDOM selectors are also transformed\n  // (e.g. :host) to use the scoping selector.\n  css(rules, scope, ext, callback) {\n    let hostScope = this._calcHostScope(scope, ext);\n    scope = this._calcElementScope(scope);\n    let self = this;\n    return StyleUtil.toCssText(rules, function(/** StyleNode */rule) {\n      if (!rule.isScoped) {\n        self.rule(rule, scope, hostScope);\n        rule.isScoped = true;\n      }\n      if (callback) {\n        callback(rule, scope, hostScope);\n      }\n    });\n  }\n\n  _calcElementScope(scope) {\n    if (scope) {\n      return CSS_CLASS_PREFIX + scope;\n    } else {\n      return '';\n    }\n  }\n\n  _calcHostScope(scope, ext) {\n    return ext ? `[is=${scope}]` : scope;\n  }\n\n  rule(rule, scope, hostScope) {\n    this._transformRule(rule, this._transformComplexSelector,\n      scope, hostScope);\n  }\n\n  /**\n   * transforms a css rule to a scoped rule.\n   *\n   * @param {StyleNode} rule\n   * @param {Function} transformer\n   * @param {string=} scope\n   * @param {string=} hostScope\n   */\n  _transformRule(rule, transformer, scope, hostScope) {\n    // NOTE: save transformedSelector for subsequent matching of elements\n    // against selectors (e.g. when calculating style properties)\n    rule['selector'] = rule.transformedSelector =\n      this._transformRuleCss(rule, transformer, scope, hostScope);\n  }\n\n  /**\n   * @param {StyleNode} rule\n   * @param {Function} transformer\n   * @param {string=} scope\n   * @param {string=} hostScope\n   */\n  _transformRuleCss(rule, transformer, scope, hostScope) {\n    let p$ = StyleUtil.splitSelectorList(rule['selector']);\n    // we want to skip transformation of rules that appear in keyframes,\n    // because they are keyframe selectors, not element selectors.\n    if (!StyleUtil.isKeyframesSelector(rule)) {\n      for (let i=0, l=p$.length, p; (i<l) && (p=p$[i]); i++) {\n        p$[i] = transformer.call(this, p, scope, hostScope);\n      }\n    }\n    return p$.filter((part) => Boolean(part)).join(COMPLEX_SELECTOR_SEP);\n  }\n\n  /**\n   * @param {string} selector\n   * @return {string}\n   */\n  _twiddleNthPlus(selector) {\n    return selector.replace(NTH, (m, type, inside) => {\n      if (inside.indexOf('+') > -1) {\n        inside = inside.replace(/\\+/g, '___');\n      } else if (inside.indexOf('___') > -1) {\n        inside = inside.replace(/___/g, '+');\n      }\n      return `:${type}(${inside})`;\n    });\n  }\n\n  /**\n   * Preserve `:matches()` selectors by replacing them with MATCHES_REPLACMENT\n   * and returning an array of `:matches()` selectors.\n   * Use `_replacesMatchesPseudo` to replace the `:matches()` parts\n   *\n   * @param {string} selector\n   * @return {{selector: string, matches: !Array<string>}}\n   */\n  _preserveMatchesPseudo(selector) {\n    /** @type {!Array<string>} */\n    const matches = [];\n    let match;\n    while ((match = selector.match(MATCHES))) {\n      const start = match.index;\n      const end = StyleUtil.findMatchingParen(selector, start);\n      if (end === -1) {\n        throw new Error(`${match.input} selector missing ')'`)\n      }\n      const part = selector.slice(start, end + 1);\n      selector = selector.replace(part, MATCHES_REPLACEMENT);\n      matches.push(part);\n    }\n    return {selector, matches};\n  }\n\n  /**\n   * Replace MATCHES_REPLACMENT character with the given set of `:matches()`\n   * selectors.\n   *\n   * @param {string} selector\n   * @param {!Array<string>} matches\n   * @return {string}\n   */\n  _replaceMatchesPseudo(selector, matches) {\n    const parts = selector.split(MATCHES_REPLACEMENT);\n    return matches.reduce((acc, cur, idx) => acc + cur + parts[idx + 1], parts[0]);\n  }\n\n/**\n * @param {string} selector\n * @param {string} scope\n * @param {string=} hostScope\n */\n  _transformComplexSelector(selector, scope, hostScope) {\n    let stop = false;\n    selector = selector.trim();\n    // Remove spaces inside of selectors like `:nth-of-type` because it confuses SIMPLE_SELECTOR_SEP\n    let isNth = NTH.test(selector);\n    if (isNth) {\n      selector = selector.replace(NTH, (m, type, inner) => `:${type}(${inner.replace(/\\s/g, '')})`)\n      selector = this._twiddleNthPlus(selector);\n    }\n    // Preserve selectors like `:-webkit-any` so that SIMPLE_SELECTOR_SEP does\n    // not get confused by spaces inside the pseudo selector\n    const isMatches = MATCHES.test(selector);\n    /** @type {!Array<string>} */\n    let matches;\n    if (isMatches) {\n      ({selector, matches} = this._preserveMatchesPseudo(selector));\n    }\n    selector = selector.replace(SLOTTED_START, `${HOST} $1`);\n    selector = selector.replace(SIMPLE_SELECTOR_SEP, (m, c, s) => {\n      if (!stop) {\n        let info = this._transformCompoundSelector(s, c, scope, hostScope);\n        stop = stop || info.stop;\n        c = info.combinator;\n        s = info.value;\n      }\n      return c + s;\n    });\n    // replace `:matches()` selectors\n    if (isMatches) {\n      selector = this._replaceMatchesPseudo(selector, matches);\n    }\n    if (isNth) {\n      selector = this._twiddleNthPlus(selector);\n    }\n    return selector;\n  }\n\n  _transformCompoundSelector(selector, combinator, scope, hostScope) {\n    // replace :host with host scoping class\n    let slottedIndex = selector.indexOf(SLOTTED);\n    if (selector.indexOf(HOST) >= 0) {\n      selector = this._transformHostSelector(selector, hostScope);\n    // replace other selectors with scoping class\n    } else if (slottedIndex !== 0) {\n      selector = scope ? this._transformSimpleSelector(selector, scope) :\n        selector;\n    }\n    // mark ::slotted() scope jump to replace with descendant selector + arg\n    // also ignore left-side combinator\n    let slotted = false;\n    if (slottedIndex >= 0) {\n      combinator = '';\n      slotted = true;\n    }\n    // process scope jumping selectors up to the scope jump and then stop\n    let stop;\n    if (slotted) {\n      stop = true;\n      if (slotted) {\n        // .zonk ::slotted(.foo) -> .zonk.scope > .foo\n        selector = selector.replace(SLOTTED_PAREN, (m, paren) => ` > ${paren}`);\n      }\n    }\n    selector = selector.replace(DIR_PAREN, (m, before, dir) =>\n      `[dir=\"${dir}\"] ${before}, ${before}[dir=\"${dir}\"]`);\n    return {value: selector, combinator, stop};\n  }\n\n  _transformSimpleSelector(selector, scope) {\n    const attributes = selector.split(/(\\[.+?\\])/);\n\n    const output = [];\n    for (let i = 0; i < attributes.length; i++) {\n      // Do not attempt to transform any attribute selector content\n      if ((i % 2) === 1) {\n        output.push(attributes[i]);\n      } else {\n        const part = attributes[i];\n\n        if (!(part === '' && i === attributes.length - 1)) {\n          let p$ = part.split(PSEUDO_PREFIX);\n          p$[0] += scope;\n          output.push(p$.join(PSEUDO_PREFIX));\n        }\n      }\n    }\n\n    return output.join('');\n  }\n\n  // :host(...) -> scopeName...\n  _transformHostSelector(selector, hostScope) {\n    let m = selector.match(HOST_PAREN);\n    let paren = m && m[2].trim() || '';\n    if (paren) {\n      if (!paren[0].match(SIMPLE_SELECTOR_PREFIX)) {\n        // paren starts with a type selector\n        let typeSelector = paren.split(SIMPLE_SELECTOR_PREFIX)[0];\n        // if the type selector is our hostScope then avoid pre-pending it\n        if (typeSelector === hostScope) {\n          return paren;\n        // otherwise, this selector should not match in this scope so\n        // output a bogus selector.\n        } else {\n          return SELECTOR_NO_MATCH;\n        }\n      } else {\n        // make sure to do a replace here to catch selectors like:\n        // `:host(.foo)::before`\n        return selector.replace(HOST_PAREN, function(m, host, paren) {\n          return hostScope + paren;\n        });\n      }\n    // if no paren, do a straight :host replacement.\n    // TODO(sorvell): this should not strictly be necessary but\n    // it's needed to maintain support for `:host[foo]` type selectors\n    // which have been improperly used under Shady DOM. This should be\n    // deprecated.\n    } else {\n      return selector.replace(HOST, hostScope);\n    }\n  }\n\n  /**\n   * @param {StyleNode} rule\n   */\n  documentRule(rule) {\n    // reset selector in case this is redone.\n    rule['selector'] = rule['parsedSelector'];\n    this.normalizeRootSelector(rule);\n    this._transformRule(rule, this._transformDocumentSelector);\n  }\n\n  /**\n   * @param {StyleNode} rule\n   */\n  normalizeRootSelector(rule) {\n    if (rule['selector'] === ROOT) {\n      rule['selector'] = 'html';\n    }\n  }\n\n/**\n * @param {string} selector\n */\n  _transformDocumentSelector(selector) {\n    if (selector.match(HOST)) {\n      // remove ':host' type selectors in document rules\n      return '';\n    } else if (selector.match(SLOTTED)) {\n      return this._transformComplexSelector(selector, SCOPE_DOC_SELECTOR)\n    } else {\n      return this._transformSimpleSelector(selector.trim(), SCOPE_DOC_SELECTOR);\n    }\n  }\n}\n\nconst NTH = /:(nth[-\\w]+)\\(([^)]+)\\)/;\nconst SCOPE_DOC_SELECTOR = `:not(.${SCOPE_NAME})`;\nconst COMPLEX_SELECTOR_SEP = ',';\nconst SIMPLE_SELECTOR_SEP = /(^|[\\s>+~]+)((?:\\[.+?\\]|[^\\s>+~=[])+)/g;\nconst SIMPLE_SELECTOR_PREFIX = /[[.:#*]/;\nconst HOST = ':host';\nconst ROOT = ':root';\nconst SLOTTED = '::slotted';\nconst SLOTTED_START = new RegExp(`^(${SLOTTED})`);\n// NOTE: this supports 1 nested () pair for things like\n// :host(:not([selected]), more general support requires\n// parsing which seems like overkill\nconst HOST_PAREN = /(:host)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))/;\n// similar to HOST_PAREN\nconst SLOTTED_PAREN = /(?:::slotted)(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))/;\nconst DIR_PAREN = /(.*):dir\\((?:(ltr|rtl))\\)/;\nconst CSS_CLASS_PREFIX = '.';\nconst PSEUDO_PREFIX = ':';\nconst CLASS = 'class';\nconst SELECTOR_NO_MATCH = 'should_not_match';\nconst MATCHES = /:(?:matches|any|-(?:webkit|moz)-any)/;\nconst MATCHES_REPLACEMENT = '\\u{e000}';\n\nexport default new StyleTransformer()\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {parse, StyleNode} from './css-parse.js';\nimport {nativeShadow, nativeCssVariables} from './style-settings.js';\nimport StyleTransformer from './style-transformer.js';\nimport * as StyleUtil from './style-util.js';\nimport StyleProperties from './style-properties.js';\nimport {ensureStylePlaceholder, getStylePlaceholder} from './style-placeholder.js';\nimport StyleInfo from './style-info.js';\nimport StyleCache from './style-cache.js';\nimport {flush as watcherFlush, getOwnerScope, getCurrentScope} from './document-watcher.js';\nimport templateMap from './template-map.js';\nimport * as ApplyShimUtils from './apply-shim-utils.js';\nimport {updateNativeProperties, detectMixin} from './common-utils.js';\nimport {CustomStyleInterfaceInterface} from './custom-style-interface.js'; // eslint-disable-line no-unused-vars\n\n/**\n * @const {StyleCache}\n */\nconst styleCache = new StyleCache();\n\nexport default class ScopingShim {\n  constructor() {\n    this._scopeCounter = {};\n    this._documentOwner = /** @type {!HTMLElement} */(document.documentElement);\n    let ast = new StyleNode();\n    ast['rules'] = [];\n    this._documentOwnerStyleInfo = StyleInfo.set(this._documentOwner, new StyleInfo(ast));\n    this._elementsHaveApplied = false;\n    /** @type {?Object} */\n    this._applyShim = null;\n    /** @type {?CustomStyleInterfaceInterface} */\n    this._customStyleInterface = null;\n  }\n  flush() {\n    watcherFlush();\n  }\n  _generateScopeSelector(name) {\n    let id = this._scopeCounter[name] = (this._scopeCounter[name] || 0) + 1;\n    return `${name}-${id}`;\n  }\n  getStyleAst(style) {\n    return StyleUtil.rulesForStyle(style);\n  }\n  styleAstToString(ast) {\n    return StyleUtil.toCssText(ast);\n  }\n  _gatherStyles(template) {\n    return StyleUtil.gatherStyleText(template.content);\n  }\n  /**\n   * Prepare the styling and template for the given element type\n   *\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} typeExtension\n   */\n  prepareTemplate(template, elementName, typeExtension) {\n    this.prepareTemplateDom(template, elementName);\n    this.prepareTemplateStyles(template, elementName, typeExtension);\n  }\n  /**\n   * Prepare styling for the given element type\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   * @param {string=} typeExtension\n   */\n  prepareTemplateStyles(template, elementName, typeExtension) {\n    if (template._prepared) {\n      return;\n    }\n    // style placeholders are only used when ShadyDOM is active\n    if (!nativeShadow) {\n      ensureStylePlaceholder(elementName);\n    }\n    template._prepared = true;\n    template.name = elementName;\n    template.extends = typeExtension;\n    templateMap[elementName] = template;\n    let cssBuild = StyleUtil.getCssBuild(template);\n    const optimalBuild = StyleUtil.isOptimalCssBuild(cssBuild);\n    let info = {\n      is: elementName,\n      extends: typeExtension,\n    };\n    let cssText = this._gatherStyles(template);\n    // check if the styling has mixin definitions or uses\n    this._ensure();\n    if (!optimalBuild) {\n      let hasMixins = !cssBuild && detectMixin(cssText);\n      let ast = parse(cssText);\n      // only run the applyshim transforms if there is a mixin involved\n      if (hasMixins && nativeCssVariables && this._applyShim) {\n        this._applyShim['transformRules'](ast, elementName);\n      }\n      template['_styleAst'] = ast;\n    }\n    let ownPropertyNames = [];\n    if (!nativeCssVariables) {\n      ownPropertyNames = StyleProperties.decorateStyles(template['_styleAst']);\n    }\n    if (!ownPropertyNames.length || nativeCssVariables) {\n      let root = nativeShadow ? template.content : null;\n      let placeholder = getStylePlaceholder(elementName);\n      let style = this._generateStaticStyle(info, template['_styleAst'], root, placeholder, cssBuild, optimalBuild ? cssText : '');\n      template._style = style;\n    }\n    template._ownPropertyNames = ownPropertyNames;\n  }\n  /**\n   * Prepare template for the given element type\n   * @param {!HTMLTemplateElement} template\n   * @param {string} elementName\n   */\n  prepareTemplateDom(template, elementName) {\n    const cssBuild = StyleUtil.getCssBuild(template);\n    if (!nativeShadow && cssBuild !== 'shady' && !template._domPrepared) {\n      template._domPrepared = true;\n      StyleTransformer.domAddScope(template.content, elementName);\n    }\n  }\n  /**\n   * @param {!{is: string, extends: (string|undefined)}} info\n   * @param {!StyleNode} rules\n   * @param {DocumentFragment} shadowroot\n   * @param {Node} placeholder\n   * @param {string} cssBuild\n   * @param {string=} cssText\n   * @return {?HTMLStyleElement}\n   */\n  _generateStaticStyle(info, rules, shadowroot, placeholder, cssBuild, cssText) {\n    cssText = StyleTransformer.elementStyles(info, rules, null, cssBuild, cssText);\n    if (cssText.length) {\n      return StyleUtil.applyCss(cssText, info.is, shadowroot, placeholder);\n    }\n    return null;\n  }\n  _prepareHost(host) {\n    const {is, typeExtension} = StyleUtil.getIsExtends(host);\n    const placeholder = getStylePlaceholder(is);\n    const template = templateMap[is];\n    if (!template) {\n      return;\n    }\n    const ast = template['_styleAst'];\n    const ownStylePropertyNames = template._ownPropertyNames;\n    const cssBuild = StyleUtil.getCssBuild(template);\n    const styleInfo = new StyleInfo(\n      ast,\n      placeholder,\n      ownStylePropertyNames,\n      is,\n      typeExtension,\n      cssBuild\n    );\n    StyleInfo.set(host, styleInfo);\n    return styleInfo;\n  }\n  _ensureApplyShim() {\n    if (this._applyShim) {\n      return;\n    } else if (window.ShadyCSS && window.ShadyCSS.ApplyShim) {\n      this._applyShim = /** @type {!Object} */ (window.ShadyCSS.ApplyShim);\n      this._applyShim['invalidCallback'] = ApplyShimUtils.invalidate;\n    }\n  }\n  _ensureCustomStyleInterface() {\n    if (this._customStyleInterface) {\n      return;\n    } else if (window.ShadyCSS && window.ShadyCSS.CustomStyleInterface) {\n      this._customStyleInterface = /** @type {!CustomStyleInterfaceInterface} */(window.ShadyCSS.CustomStyleInterface);\n      /** @type {function(!HTMLStyleElement)} */\n      this._customStyleInterface['transformCallback'] = (style) => {this.transformCustomStyleForDocument(style)};\n      this._customStyleInterface['validateCallback'] = () => {\n        requestAnimationFrame(() => {\n          if (this._customStyleInterface['enqueued'] || this._elementsHaveApplied) {\n            this.flushCustomStyles();\n          }\n        })\n      };\n    }\n  }\n  _ensure() {\n    this._ensureApplyShim();\n    this._ensureCustomStyleInterface();\n  }\n  /**\n   * Flush and apply custom styles to document\n   */\n  flushCustomStyles() {\n    this._ensure();\n    if (!this._customStyleInterface) {\n      return;\n    }\n    let customStyles = this._customStyleInterface['processStyles']();\n    // early return if custom-styles don't need validation\n    if (!this._customStyleInterface['enqueued']) {\n      return;\n    }\n    // bail if custom styles are built optimally\n    if (StyleUtil.isOptimalCssBuild(this._documentOwnerStyleInfo.cssBuild)) {\n      return;\n    }\n    if (!nativeCssVariables) {\n      this._updateProperties(this._documentOwner, this._documentOwnerStyleInfo);\n      this._applyCustomStyles(customStyles);\n      if (this._elementsHaveApplied) {\n        // if custom elements have upgraded and there are no native css variables, we must recalculate the whole tree\n        this.styleDocument();\n      }\n    } else if (!this._documentOwnerStyleInfo.cssBuild) {\n      this._revalidateCustomStyleApplyShim(customStyles);\n    }\n    this._customStyleInterface['enqueued'] = false;\n  }\n  /**\n   * Apply styles for the given element\n   *\n   * @param {!HTMLElement} host\n   * @param {Object=} overrideProps\n   */\n  styleElement(host, overrideProps) {\n    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      styleInfo.overrideStyleProperties =\n        styleInfo.overrideStyleProperties || {};\n      Object.assign(styleInfo.overrideStyleProperties, overrideProps);\n    }\n    if (!nativeCssVariables) {\n      this.styleElementShimVariables(host, styleInfo);\n    } else {\n      this.styleElementNativeVariables(host, styleInfo);\n    }\n  }\n  /**\n   * @param {!HTMLElement} host\n   * @param {!StyleInfo} styleInfo\n   */\n  styleElementShimVariables(host, styleInfo) {\n    this.flush();\n    this._updateProperties(host, styleInfo);\n    if (styleInfo.ownStylePropertyNames && styleInfo.ownStylePropertyNames.length) {\n      this._applyStyleProperties(host, styleInfo);\n    }\n  }\n  /**\n   * @param {!HTMLElement} host\n   * @param {!StyleInfo} styleInfo\n   */\n  styleElementNativeVariables(host, styleInfo) {\n    const { is } = StyleUtil.getIsExtends(host);\n    if (styleInfo.overrideStyleProperties) {\n      updateNativeProperties(host, styleInfo.overrideStyleProperties);\n    }\n    const template = templateMap[is];\n    // bail early if there is no shadowroot for this element\n    if (!template && !this._isRootOwner(host)) {\n      return;\n    }\n    // bail early if the template was built with polymer-css-build\n    if (template && StyleUtil.elementHasBuiltCss(template)) {\n      return;\n    }\n    if (template && template._style && !ApplyShimUtils.templateIsValid(template)) {\n      // update template\n      if (!ApplyShimUtils.templateIsValidating(template)) {\n        this._ensure();\n        this._applyShim && this._applyShim['transformRules'](template['_styleAst'], is);\n        template._style.textContent = StyleTransformer.elementStyles(host, styleInfo.styleRules);\n        ApplyShimUtils.startValidatingTemplate(template);\n      }\n      // update instance if native shadowdom\n      if (nativeShadow) {\n        let root = host.shadowRoot;\n        if (root) {\n          let style = root.querySelector('style');\n          if (style) {\n            style.textContent = StyleTransformer.elementStyles(host, styleInfo.styleRules);\n          }\n        }\n      }\n      styleInfo.styleRules = template['_styleAst'];\n    }\n  }\n  _styleOwnerForNode(node) {\n    let root = StyleUtil.wrap(node).getRootNode();\n    let host = root.host;\n    if (host) {\n      if (StyleInfo.get(host) || this._prepareHost(host)) {\n        return host;\n      } else {\n        return this._styleOwnerForNode(host);\n      }\n    }\n    return this._documentOwner;\n  }\n  _isRootOwner(node) {\n    return (node === this._documentOwner);\n  }\n  _applyStyleProperties(host, styleInfo) {\n    let is = StyleUtil.getIsExtends(host).is;\n    let cacheEntry = styleCache.fetch(is, styleInfo.styleProperties, styleInfo.ownStylePropertyNames);\n    let cachedScopeSelector = cacheEntry && cacheEntry.scopeSelector;\n    let cachedStyle = cacheEntry ? cacheEntry.styleElement : null;\n    let oldScopeSelector = styleInfo.scopeSelector;\n    // only generate new scope if cached style is not found\n    styleInfo.scopeSelector = cachedScopeSelector || this._generateScopeSelector(is);\n    let style = StyleProperties.applyElementStyle(host, styleInfo.styleProperties, styleInfo.scopeSelector, cachedStyle);\n    if (!nativeShadow) {\n      StyleProperties.applyElementScopeSelector(host, styleInfo.scopeSelector, oldScopeSelector);\n    }\n    if (!cacheEntry) {\n      styleCache.store(is, styleInfo.styleProperties, style, styleInfo.scopeSelector);\n    }\n    return style;\n  }\n  _updateProperties(host, styleInfo) {\n    let owner = this._styleOwnerForNode(host);\n    let ownerStyleInfo = StyleInfo.get(owner);\n    let ownerProperties = ownerStyleInfo.styleProperties;\n    // style owner has not updated properties yet\n    // go up the chain and force property update,\n    // except if the owner is the document\n    if (owner !== this._documentOwner && !ownerProperties) {\n      this._updateProperties(owner, ownerStyleInfo);\n      ownerProperties = ownerStyleInfo.styleProperties;\n    }\n    let props = Object.create(ownerProperties || null);\n    let hostAndRootProps = StyleProperties.hostAndRootPropertiesForScope(host, styleInfo.styleRules, styleInfo.cssBuild);\n    let propertyData = StyleProperties.propertyDataFromStyles(ownerStyleInfo.styleRules, host);\n    let propertiesMatchingHost = propertyData.properties\n    Object.assign(\n      props,\n      hostAndRootProps.hostProps,\n      propertiesMatchingHost,\n      hostAndRootProps.rootProps\n    );\n    this._mixinOverrideStyles(props, styleInfo.overrideStyleProperties);\n    StyleProperties.reify(props);\n    styleInfo.styleProperties = props;\n  }\n  _mixinOverrideStyles(props, overrides) {\n    for (let p in overrides) {\n      let v = overrides[p];\n      // skip override props if they are not truthy or 0\n      // in order to fall back to inherited values\n      if (v || v === 0) {\n        props[p] = v;\n      }\n    }\n  }\n  /**\n   * Update styles of the whole document\n   *\n   * @param {Object=} properties\n   */\n  styleDocument(properties) {\n    this.styleSubtree(this._documentOwner, properties);\n  }\n  /**\n   * Update styles of a subtree\n   *\n   * @param {!HTMLElement} host\n   * @param {Object=} properties\n   */\n  styleSubtree(host, properties) {\n    let root = host.shadowRoot;\n    if (root || this._isRootOwner(host)) {\n      this.styleElement(host, properties);\n    }\n    // process the shadowdom children of `host`\n    let shadowChildren =\n        root && (/** @type {!ParentNode} */ (root).children || root.childNodes);\n    if (shadowChildren) {\n      for (let i = 0; i < shadowChildren.length; i++) {\n        let c = /** @type {!HTMLElement} */(shadowChildren[i]);\n        this.styleSubtree(c);\n      }\n    } else {\n      // process the lightdom children of `host`\n      let children = host.children || host.childNodes;\n      if (children) {\n        for (let i = 0; i < children.length; i++) {\n          let c = /** @type {!HTMLElement} */(children[i]);\n          this.styleSubtree(c);\n        }\n      }\n    }\n  }\n  /* Custom Style operations */\n  _revalidateCustomStyleApplyShim(customStyles) {\n    for (let i = 0; i < customStyles.length; i++) {\n      let c = customStyles[i];\n      let s = this._customStyleInterface['getStyleForCustomStyle'](c);\n      if (s) {\n        this._revalidateApplyShim(s);\n      }\n    }\n  }\n  _applyCustomStyles(customStyles) {\n    for (let i = 0; i < customStyles.length; i++) {\n      let c = customStyles[i];\n      let s = this._customStyleInterface['getStyleForCustomStyle'](c);\n      if (s) {\n        StyleProperties.applyCustomStyle(s, this._documentOwnerStyleInfo.styleProperties);\n      }\n    }\n  }\n  transformCustomStyleForDocument(style) {\n    const cssBuild = StyleUtil.getCssBuild(style);\n    if (cssBuild !== this._documentOwnerStyleInfo.cssBuild) {\n      this._documentOwnerStyleInfo.cssBuild = cssBuild;\n    }\n    if (StyleUtil.isOptimalCssBuild(cssBuild)) {\n      return;\n    }\n    let ast = StyleUtil.rulesForStyle(style);\n    StyleUtil.forEachRule(ast, (rule) => {\n      if (nativeShadow) {\n        StyleTransformer.normalizeRootSelector(rule);\n      } else {\n        StyleTransformer.documentRule(rule);\n      }\n      if (nativeCssVariables && cssBuild === '') {\n        this._ensure();\n        this._applyShim && this._applyShim['transformRule'](rule);\n      }\n    });\n    if (nativeCssVariables) {\n      style.textContent = StyleUtil.toCssText(ast);\n    } else {\n      this._documentOwnerStyleInfo.styleRules['rules'].push(ast);\n    }\n  }\n  _revalidateApplyShim(style) {\n    if (nativeCssVariables && this._applyShim) {\n      let ast = StyleUtil.rulesForStyle(style);\n      this._ensure();\n      this._applyShim['transformRules'](ast);\n      style.textContent = StyleUtil.toCssText(ast);\n    }\n  }\n  getComputedStyleValue(element, property) {\n    let value;\n    if (!nativeCssVariables) {\n      // element is either a style host, or an ancestor of a style host\n      let styleInfo = StyleInfo.get(element) || StyleInfo.get(this._styleOwnerForNode(element));\n      value = styleInfo.styleProperties[property];\n    }\n    // fall back to the property value from the computed styling\n    value = value || window.getComputedStyle(element).getPropertyValue(property);\n    // trim whitespace that can come after the `:` in css\n    // example: padding: 2px -> \" 2px\"\n    return value ? value.trim() : '';\n  }\n  // given an element and a classString, replaces\n  // the element's class with the provided classString and adds\n  // any necessary ShadyCSS static and property based scoping selectors\n  setElementClass(element, classString) {\n    let root = StyleUtil.wrap(element).getRootNode();\n    let classes = classString ? classString.split(/\\s/) : [];\n    let scopeName = root.host && root.host.localName;\n    // If no scope, try to discover scope name from existing class.\n    // This can occur if, for example, a template stamped element that\n    // has been scoped is manipulated when not in a root.\n    if (!scopeName) {\n      var classAttr = element.getAttribute('class');\n      if (classAttr) {\n        let k$ = classAttr.split(/\\s/);\n        for (let i=0; i < k$.length; i++) {\n          if (k$[i] === StyleTransformer.SCOPE_NAME) {\n            scopeName = k$[i+1];\n            break;\n          }\n        }\n      }\n    }\n    if (scopeName) {\n      classes.push(StyleTransformer.SCOPE_NAME, scopeName);\n    }\n    if (!nativeCssVariables) {\n      let styleInfo = StyleInfo.get(element);\n      if (styleInfo && styleInfo.scopeSelector) {\n        classes.push(StyleProperties.XSCOPE_NAME, styleInfo.scopeSelector);\n      }\n    }\n    StyleUtil.setElementClassRaw(element, classes.join(' '));\n  }\n  _styleInfoForNode(node) {\n    return StyleInfo.get(node);\n  }\n  /**\n   * @param {!Element} node\n   * @param {string} scope\n   */\n  scopeNode(node, scope) {\n    StyleTransformer.element(node, scope);\n  }\n  /**\n   * @param {!Element} node\n   * @param {string} scope\n   */\n  unscopeNode(node, scope) {\n    StyleTransformer.element(node, scope, true);\n  }\n  /**\n   * @param {!Node} node\n   * @return {string}\n   */\n  scopeForNode(node) {\n    return getOwnerScope(node);\n  }\n  /**\n   * @param {!Element} node\n   * @return {string}\n   */\n  currentScopeForNode(node) {\n    return getCurrentScope(node);\n  }\n}\n\n/* exports */\n/* eslint-disable no-self-assign */\nScopingShim.prototype['flush'] = ScopingShim.prototype.flush;\nScopingShim.prototype['prepareTemplate'] = ScopingShim.prototype.prepareTemplate;\nScopingShim.prototype['styleElement'] = ScopingShim.prototype.styleElement;\nScopingShim.prototype['styleDocument'] = ScopingShim.prototype.styleDocument;\nScopingShim.prototype['styleSubtree'] = ScopingShim.prototype.styleSubtree;\nScopingShim.prototype['getComputedStyleValue'] = ScopingShim.prototype.getComputedStyleValue;\nScopingShim.prototype['setElementClass'] = ScopingShim.prototype.setElementClass;\nScopingShim.prototype['_styleInfoForNode'] = ScopingShim.prototype._styleInfoForNode;\nScopingShim.prototype['transformCustomStyleForDocument'] = ScopingShim.prototype.transformCustomStyleForDocument;\nScopingShim.prototype['getStyleAst'] = ScopingShim.prototype.getStyleAst;\nScopingShim.prototype['styleAstToString'] = ScopingShim.prototype.styleAstToString;\nScopingShim.prototype['flushCustomStyles'] = ScopingShim.prototype.flushCustomStyles;\nScopingShim.prototype['scopeNode'] = ScopingShim.prototype.scopeNode;\nScopingShim.prototype['unscopeNode'] = ScopingShim.prototype.unscopeNode;\nScopingShim.prototype['scopeForNode'] = ScopingShim.prototype.scopeForNode;\nScopingShim.prototype['currentScopeForNode'] = ScopingShim.prototype.currentScopeForNode;\n/* eslint-enable no-self-assign */\nObject.defineProperties(ScopingShim.prototype, {\n  'nativeShadow': {\n    get() {\n      return nativeShadow;\n    }\n  },\n  'nativeCss': {\n    get() {\n      return nativeCssVariables;\n    }\n  }\n});\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {nativeShadow} from './style-settings.js';\nimport StyleTransformer from './style-transformer.js';\nimport {getIsExtends, elementHasBuiltCss, wrap} from './style-util.js';\n\nexport let flush = function() {};\n\n/**\n * @param {!Element} element\n * @return {string}\n */\nfunction getClasses(element) {\n  if (element.classList && element.classList.value) {\n    return element.classList.value;\n  } else {\n    // NOTE: className is patched to remove scoping classes in ShadyDOM\n    // use getAttribute('class') instead, which is unpatched\n    return element.getAttribute('class') || '';\n  }\n}\n\nconst scopeRegExp = new RegExp(`${StyleTransformer.SCOPE_NAME}\\\\s*([^\\\\s]*)`);\n\n/**\n * @param {!Element} element\n * @return {string}\n */\nexport function getCurrentScope(element) {\n  const match = getClasses(element).match(scopeRegExp);\n  if (match) {\n    return match[1];\n  } else {\n    return '';\n  }\n}\n\n/**\n * @param {!Node} node\n */\nexport function getOwnerScope(node) {\n  const ownerRoot = wrap(node).getRootNode();\n  if (ownerRoot === node || ownerRoot === node.ownerDocument) {\n    return '';\n  }\n  const host = /** @type {!ShadowRoot} */(ownerRoot).host;\n  if (!host) {\n    // this may actually be a document fragment\n    return '';\n  }\n  return getIsExtends(host).is;\n}\n\n/**\n * @param {!Element} element\n */\nexport function ensureCorrectScope(element) {\n  const currentScope = getCurrentScope(element);\n  const ownerRoot = wrap(element).getRootNode();\n  if (ownerRoot === element) {\n    return;\n  }\n  if (currentScope && ownerRoot === element.ownerDocument) {\n    // node was scoped, but now is in document\n    StyleTransformer.domRemoveScope(element, currentScope);\n  } else if (ownerRoot instanceof ShadowRoot) {\n    const ownerScope = getOwnerScope(element);\n    if (ownerScope !== currentScope) {\n      // node was scoped, but not by its current owner\n      StyleTransformer.domReplaceScope(element, currentScope, ownerScope);\n    }\n  }\n}\n\n/**\n * @param {!HTMLElement|!HTMLDocument} element\n */\nexport function ensureCorrectSubtreeScoping(element) {\n  // find unscoped subtree nodes\n  const unscopedNodes = window['ShadyDOM']['nativeMethods']['querySelectorAll'].call(\n    element, `:not(.${StyleTransformer.SCOPE_NAME})`);\n\n  for (let j = 0; j < unscopedNodes.length; j++) {\n    // it's possible, during large batch inserts, that nodes that aren't\n    // scoped within the current scope were added.\n    // To make sure that any unscoped nodes that were inserted in the current batch are correctly styled,\n    // query all unscoped nodes and force their style-scope to be applied.\n    // This could happen if a sub-element appended an unscoped node in its shadowroot and this function\n    // runs on a parent element of the host of that unscoped node:\n    // parent-element -> element -> unscoped node\n    // Here unscoped node should have the style-scope element, not parent-element.\n    const unscopedNode = unscopedNodes[j];\n    const scopeForPreviouslyUnscopedNode = getOwnerScope(unscopedNode);\n    if (scopeForPreviouslyUnscopedNode) {\n      StyleTransformer.element(unscopedNode, scopeForPreviouslyUnscopedNode);\n    }\n  }\n}\n\n/**\n * @param {HTMLElement} el\n * @return {boolean}\n */\nfunction isElementWithBuiltCss(el) {\n  if (el.localName === 'style' || el.localName === 'template') {\n    return elementHasBuiltCss(el);\n  }\n  return false;\n}\n\n/**\n * @param {Array<MutationRecord|null>|null} mxns\n */\nfunction handler(mxns) {\n  for (let x=0; x < mxns.length; x++) {\n    let mxn = mxns[x];\n    if (mxn.target === document.documentElement ||\n      mxn.target === document.head) {\n      continue;\n    }\n    for (let i=0; i < mxn.addedNodes.length; i++) {\n      let n = mxn.addedNodes[i];\n      if (n.nodeType !== Node.ELEMENT_NODE) {\n        continue;\n      }\n      n = /** @type {HTMLElement} */(n); // eslint-disable-line no-self-assign\n      let root = n.getRootNode();\n      let currentScope = getCurrentScope(n);\n      // node was scoped, but now is in document\n      // If this element has built css, we must not remove scoping as this node\n      // will be used as a template or style without re - applying scoping as an optimization\n      if (currentScope && root === n.ownerDocument && !isElementWithBuiltCss(n)) {\n        StyleTransformer.domRemoveScope(n, currentScope);\n      } else if (root instanceof ShadowRoot) {\n        const newScope = getOwnerScope(n);\n        // rescope current node and subtree if necessary\n        if (newScope !== currentScope) {\n          StyleTransformer.domReplaceScope(n, currentScope, newScope);\n        }\n        // make sure all the subtree elements are scoped correctly\n        ensureCorrectSubtreeScoping(n);\n      }\n    }\n  }\n}\n\n// if native Shadow DOM is being used, or ShadyDOM handles dynamic scoiping, do not activate the MutationObserver\nif (!nativeShadow && !(window['ShadyDOM'] && window['ShadyDOM']['handlesDynamicScoping'])) {\n  let observer = new MutationObserver(handler);\n  let start = (node) => {\n    observer.observe(node, {childList: true, subtree: true});\n  }\n  let nativeCustomElements = (window['customElements'] &&\n    !window['customElements']['polyfillWrapFlushCallback']);\n  // need to start immediately with native custom elements\n  // TODO(dfreedm): with polyfilled HTMLImports and native custom elements\n  // excessive mutations may be observed; this can be optimized via cooperation\n  // with the HTMLImports polyfill.\n  if (nativeCustomElements) {\n    start(document);\n  } else {\n    let delayedStart = () => {\n      start(document.body);\n    }\n    // use polyfill timing if it's available\n    if (window['HTMLImports']) {\n      window['HTMLImports']['whenReady'](delayedStart);\n    // otherwise push beyond native imports being ready\n    // which requires RAF + readystate interactive.\n    } else {\n      requestAnimationFrame(function() {\n        if (document.readyState === 'loading') {\n          let listener = function() {\n            delayedStart();\n            document.removeEventListener('readystatechange', listener);\n          }\n          document.addEventListener('readystatechange', listener);\n        } else {\n          delayedStart();\n        }\n      });\n    }\n  }\n\n  flush = function() {\n    handler(observer.takeRecords());\n  }\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {removeCustomPropAssignment, StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\nimport {nativeShadow} from './style-settings.js';\nimport StyleTransformer from './style-transformer.js';\nimport * as StyleUtil from './style-util.js';\nimport * as RX from './common-regex.js';\nimport StyleInfo from './style-info.js';\n\n// TODO: dedupe with shady\n/**\n * @param {string} selector\n * @return {boolean}\n * @this {Element}\n */\nconst matchesSelector = function(selector) {\n  const method = this.matches || this.matchesSelector ||\n    this.mozMatchesSelector || this.msMatchesSelector ||\n    this.oMatchesSelector || this.webkitMatchesSelector;\n  return method && method.call(this, selector);\n};\n\nconst IS_IE = navigator.userAgent.match('Trident');\n\nconst XSCOPE_NAME = 'x-scope';\n\nclass StyleProperties {\n  get XSCOPE_NAME() {\n    return XSCOPE_NAME;\n  }\n/**\n * decorates styles with rule info and returns an array of used style property names\n *\n * @param {StyleNode} rules\n * @return {Array<string>}\n */\n  decorateStyles(rules) {\n    let self = this, props = {}, keyframes = [], ruleIndex = 0;\n    StyleUtil.forEachRule(rules, function(rule) {\n      self.decorateRule(rule);\n      // mark in-order position of ast rule in styles block, used for cache key\n      rule.index = ruleIndex++;\n      self.collectPropertiesInCssText(rule.propertyInfo.cssText, props);\n    }, function onKeyframesRule(rule) {\n      keyframes.push(rule);\n    });\n    // Cache all found keyframes rules for later reference:\n    rules._keyframes = keyframes;\n    // return this list of property names *consumes* in these styles.\n    let names = [];\n    for (let i in props) {\n      names.push(i);\n    }\n    return names;\n  }\n\n  // decorate a single rule with property info\n  decorateRule(rule) {\n    if (rule.propertyInfo) {\n      return rule.propertyInfo;\n    }\n    let info = {}, properties = {};\n    let hasProperties = this.collectProperties(rule, properties);\n    if (hasProperties) {\n      info.properties = properties;\n      // TODO(sorvell): workaround parser seeing mixins as additional rules\n      rule['rules'] = null;\n    }\n    info.cssText = this.collectCssText(rule);\n    rule.propertyInfo = info;\n    return info;\n  }\n\n  // collects the custom properties from a rule's cssText\n  collectProperties(rule, properties) {\n    let info = rule.propertyInfo;\n    if (info) {\n      if (info.properties) {\n        Object.assign(properties, info.properties);\n        return true;\n      }\n    } else {\n      let m, rx = RX.VAR_ASSIGN;\n      let cssText = rule['parsedCssText'];\n      let value;\n      let any;\n      while ((m = rx.exec(cssText))) {\n        // note: group 2 is var, 3 is mixin\n        value = (m[2] || m[3]).trim();\n        // value of 'inherit' or 'unset' is equivalent to not setting the property here\n        if (value !== 'inherit' || value !== 'unset') {\n          properties[m[1].trim()] = value;\n        }\n        any = true;\n      }\n      return any;\n    }\n\n  }\n\n  // returns cssText of properties that consume variables/mixins\n  collectCssText(rule) {\n    return this.collectConsumingCssText(rule['parsedCssText']);\n  }\n\n  // NOTE: we support consumption inside mixin assignment\n  // but not production, so strip out {...}\n  collectConsumingCssText(cssText) {\n    return cssText.replace(RX.BRACKETED, '')\n      .replace(RX.VAR_ASSIGN, '');\n  }\n\n  collectPropertiesInCssText(cssText, props) {\n    let m;\n    while ((m = RX.VAR_CONSUMED.exec(cssText))) {\n      let name = m[1];\n      // This regex catches all variable names, and following non-whitespace char\n      // If next char is not ':', then variable is a consumer\n      if (m[2] !== ':') {\n        props[name] = true;\n      }\n    }\n  }\n\n  // turns custom properties into realized values.\n  reify(props) {\n    // big perf optimization here: reify only *own* properties\n    // since this object has __proto__ of the element's scope properties\n    let names = Object.getOwnPropertyNames(props);\n    for (let i=0, n; i < names.length; i++) {\n      n = names[i];\n      props[n] = this.valueForProperty(props[n], props);\n    }\n  }\n\n  // given a property value, returns the reified value\n  // a property value may be:\n  // (1) a literal value like: red or 5px;\n  // (2) a variable value like: var(--a), var(--a, red), or var(--a, --b) or\n  // var(--a, var(--b));\n  // (3) a literal mixin value like { properties }. Each of these properties\n  // can have values that are: (a) literal, (b) variables, (c) @apply mixins.\n  valueForProperty(property, props) {\n    // case (1) default\n    // case (3) defines a mixin and we have to reify the internals\n    if (property) {\n      if (property.indexOf(';') >=0) {\n        property = this.valueForProperties(property, props);\n      } else {\n        // case (2) variable\n        let self = this;\n        let fn = function(prefix, value, fallback, suffix) {\n          if (!value) {\n            return prefix + suffix;\n          }\n          let propertyValue = self.valueForProperty(props[value], props);\n          // if value is \"initial\", then the variable should be treated as unset\n          if (!propertyValue || propertyValue === 'initial') {\n            // fallback may be --a or var(--a) or literal\n            propertyValue = self.valueForProperty(props[fallback] || fallback, props) ||\n            fallback;\n          } else if (propertyValue === 'apply-shim-inherit') {\n            // CSS build will replace `inherit` with `apply-shim-inherit`\n            // for use with native css variables.\n            // Since we have full control, we can use `inherit` directly.\n            propertyValue = 'inherit';\n          }\n          return prefix + (propertyValue || '') + suffix;\n        };\n        property = StyleUtil.processVariableAndFallback(property, fn);\n      }\n    }\n    return property && property.trim() || '';\n  }\n\n  // note: we do not yet support mixin within mixin\n  valueForProperties(property, props) {\n    let parts = property.split(';');\n    for (let i=0, p, m; i<parts.length; i++) {\n      if ((p = parts[i])) {\n        RX.MIXIN_MATCH.lastIndex = 0;\n        m = RX.MIXIN_MATCH.exec(p);\n        if (m) {\n          p = this.valueForProperty(props[m[1]], props);\n        } else {\n          let colon = p.indexOf(':');\n          if (colon !== -1) {\n            let pp = p.substring(colon);\n            pp = pp.trim();\n            pp = this.valueForProperty(pp, props) || pp;\n            p = p.substring(0, colon) + pp;\n          }\n        }\n        parts[i] = (p && p.lastIndexOf(';') === p.length - 1) ?\n          // strip trailing ;\n          p.slice(0, -1) :\n          p || '';\n      }\n    }\n    return parts.join(';');\n  }\n\n  applyProperties(rule, props) {\n    let output = '';\n    // dynamically added sheets may not be decorated so ensure they are.\n    if (!rule.propertyInfo) {\n      this.decorateRule(rule);\n    }\n    if (rule.propertyInfo.cssText) {\n      output = this.valueForProperties(rule.propertyInfo.cssText, props);\n    }\n    rule['cssText'] = output;\n  }\n\n  // Apply keyframe transformations to the cssText of a given rule. The\n  // keyframeTransforms object is a map of keyframe names to transformer\n  // functions which take in cssText and spit out transformed cssText.\n  applyKeyframeTransforms(rule, keyframeTransforms) {\n    let input = rule['cssText'];\n    let output = rule['cssText'];\n    if (rule.hasAnimations == null) {\n      // Cache whether or not the rule has any animations to begin with:\n      rule.hasAnimations = RX.ANIMATION_MATCH.test(input);\n    }\n    // If there are no animations referenced, we can skip transforms:\n    if (rule.hasAnimations) {\n      let transform;\n      // If we haven't transformed this rule before, we iterate over all\n      // transforms:\n      if (rule.keyframeNamesToTransform == null) {\n        rule.keyframeNamesToTransform = [];\n        for (let keyframe in keyframeTransforms) {\n          transform = keyframeTransforms[keyframe];\n          output = transform(input);\n          // If the transform actually changed the CSS text, we cache the\n          // transform name for future use:\n          if (input !== output) {\n            input = output;\n            rule.keyframeNamesToTransform.push(keyframe);\n          }\n        }\n      } else {\n        // If we already have a list of keyframe names that apply to this\n        // rule, we apply only those keyframe name transforms:\n        for (let i = 0; i < rule.keyframeNamesToTransform.length; ++i) {\n          transform = keyframeTransforms[rule.keyframeNamesToTransform[i]];\n          input = transform(input);\n        }\n        output = input;\n      }\n    }\n    rule['cssText'] = output;\n  }\n\n  // Test if the rules in these styles matches the given `element` and if so,\n  // collect any custom properties into `props`.\n  /**\n   * @param {StyleNode} rules\n   * @param {Element} element\n   */\n  propertyDataFromStyles(rules, element) {\n    let props = {};\n    // generates a unique key for these matches\n    let o = [];\n    // note: active rules excludes non-matching @media rules\n    StyleUtil.forEachRule(rules, (rule) => {\n      // TODO(sorvell): we could trim the set of rules at declaration\n      // time to only include ones that have properties\n      if (!rule.propertyInfo) {\n        this.decorateRule(rule);\n      }\n      // match element against transformedSelector: selector may contain\n      // unwanted uniquification and parsedSelector does not directly match\n      // for :host selectors.\n      let selectorToMatch = rule.transformedSelector || rule['parsedSelector'];\n      if (element && rule.propertyInfo.properties && selectorToMatch) {\n        if (matchesSelector.call(element, selectorToMatch)) {\n          this.collectProperties(rule, props);\n          // produce numeric key for these matches for lookup\n          addToBitMask(rule.index, o);\n        }\n      }\n    }, null, true);\n    return {properties: props, key: o};\n  }\n\n  /**\n   * @param {Element} scope\n   * @param {StyleNode} rule\n   * @param {string} cssBuild\n   * @param {function(Object)} callback\n   */\n  whenHostOrRootRule(scope, rule, cssBuild, callback) {\n    if (!rule.propertyInfo) {\n      this.decorateRule(rule);\n    }\n    if (!rule.propertyInfo.properties) {\n      return;\n    }\n    let {is, typeExtension} = StyleUtil.getIsExtends(scope);\n    let hostScope = is ?\n      StyleTransformer._calcHostScope(is, typeExtension) :\n      'html';\n    let parsedSelector = rule['parsedSelector'];\n    let isRoot = (parsedSelector === ':host > *' || parsedSelector === 'html');\n    let isHost = parsedSelector.indexOf(':host') === 0 && !isRoot;\n    // build info is either in scope (when scope is an element) or in the style\n    // when scope is the default scope; note: this allows default scope to have\n    // mixed mode built and unbuilt styles.\n    if (cssBuild === 'shady') {\n      // :root -> x-foo > *.x-foo for elements and html for custom-style\n      isRoot = parsedSelector === (hostScope + ' > *.' + hostScope) || parsedSelector.indexOf('html') !== -1;\n      // :host -> x-foo for elements, but sub-rules have .x-foo in them\n      isHost = !isRoot && parsedSelector.indexOf(hostScope) === 0;\n    }\n    if (!isRoot && !isHost) {\n      return;\n    }\n    let selectorToMatch = hostScope;\n    if (isHost) {\n      // need to transform :host because `:host` does not work with `matches`\n      if (!rule.transformedSelector) {\n        // transform :host into a matchable selector\n        rule.transformedSelector =\n        StyleTransformer._transformRuleCss(\n          rule,\n          StyleTransformer._transformComplexSelector,\n          StyleTransformer._calcElementScope(is),\n          hostScope\n        );\n      }\n      selectorToMatch = rule.transformedSelector || hostScope;\n    }\n    callback({\n      selector: selectorToMatch,\n      isHost: isHost,\n      isRoot: isRoot\n    });\n  }\n/**\n * @param {Element} scope\n * @param {StyleNode} rules\n * @param {string} cssBuild\n * @return {Object}\n */\n  hostAndRootPropertiesForScope(scope, rules, cssBuild) {\n    let hostProps = {}, rootProps = {};\n    // note: active rules excludes non-matching @media rules\n    StyleUtil.forEachRule(rules, (rule) => {\n      // if scope is StyleDefaults, use _element for matchesSelector\n      this.whenHostOrRootRule(scope, rule, cssBuild, (info) => {\n        let element = scope._element || scope;\n        if (matchesSelector.call(element, info.selector)) {\n          if (info.isHost) {\n            this.collectProperties(rule, hostProps);\n          } else {\n            this.collectProperties(rule, rootProps);\n          }\n        }\n      });\n    }, null, true);\n    return {rootProps: rootProps, hostProps: hostProps};\n  }\n\n  /**\n   * @param {Element} element\n   * @param {Object} properties\n   * @param {string} scopeSelector\n   */\n  transformStyles(element, properties, scopeSelector) {\n    let self = this;\n    let {is, typeExtension} = StyleUtil.getIsExtends(element);\n    let hostSelector = StyleTransformer\n      ._calcHostScope(is, typeExtension);\n    let rxHostSelector = element.extends ?\n      '\\\\' + hostSelector.slice(0, -1) + '\\\\]' :\n      hostSelector;\n    let hostRx = new RegExp(RX.HOST_PREFIX + rxHostSelector +\n      RX.HOST_SUFFIX);\n    let {styleRules: rules, cssBuild} = StyleInfo.get(element);\n    let keyframeTransforms =\n      this._elementKeyframeTransforms(element, rules, scopeSelector);\n    return StyleTransformer.elementStyles(element, rules, function(rule) {\n      self.applyProperties(rule, properties);\n      if (!nativeShadow &&\n          !StyleUtil.isKeyframesSelector(rule) &&\n          rule['cssText']) {\n        // NOTE: keyframe transforms only scope munge animation names, so it\n        // is not necessary to apply them in ShadowDOM.\n        self.applyKeyframeTransforms(rule, keyframeTransforms);\n        self._scopeSelector(rule, hostRx, hostSelector, scopeSelector);\n      }\n    }, cssBuild);\n  }\n\n  /**\n   * @param {Element} element\n   * @param {StyleNode} rules\n   * @param {string} scopeSelector\n   * @return {Object}\n   */\n  _elementKeyframeTransforms(element, rules, scopeSelector) {\n    let keyframesRules = rules._keyframes;\n    let keyframeTransforms = {};\n    if (!nativeShadow && keyframesRules) {\n      // For non-ShadowDOM, we transform all known keyframes rules in\n      // advance for the current scope. This allows us to catch keyframes\n      // rules that appear anywhere in the stylesheet:\n      for (let i = 0, keyframesRule = keyframesRules[i];\n           i < keyframesRules.length;\n           keyframesRule = keyframesRules[++i]) {\n        this._scopeKeyframes(keyframesRule, scopeSelector);\n        keyframeTransforms[keyframesRule['keyframesName']] =\n            this._keyframesRuleTransformer(keyframesRule);\n      }\n    }\n    return keyframeTransforms;\n  }\n\n  // Generate a factory for transforming a chunk of CSS text to handle a\n  // particular scoped keyframes rule.\n  /**\n   * @param {StyleNode} keyframesRule\n   * @return {function(string):string}\n   */\n  _keyframesRuleTransformer(keyframesRule) {\n    return function(cssText) {\n      return cssText.replace(\n          keyframesRule.keyframesNameRx,\n          keyframesRule.transformedKeyframesName);\n    };\n  }\n\n/**\n * Transforms `@keyframes` names to be unique for the current host.\n * Example: @keyframes foo-anim -> @keyframes foo-anim-x-foo-0\n *\n * @param {StyleNode} rule\n * @param {string} scopeId\n */\n  _scopeKeyframes(rule, scopeId) {\n    // Animation names are of the form [\\w-], so ensure that the name regex does not partially apply\n    // to similarly named keyframe names by checking for a word boundary at the beginning and\n    // a non-word boundary or `-` at the end.\n    rule.keyframesNameRx = new RegExp(`\\\\b${rule['keyframesName']}(?!\\\\B|-)`, 'g');\n    rule.transformedKeyframesName = rule['keyframesName'] + '-' + scopeId;\n    rule.transformedSelector = rule.transformedSelector || rule['selector'];\n    rule['selector'] = rule.transformedSelector.replace(\n        rule['keyframesName'], rule.transformedKeyframesName);\n  }\n\n  // Strategy: x scope shim a selector e.g. to scope `.x-foo-42` (via classes):\n  // non-host selector: .a.x-foo -> .x-foo-42 .a.x-foo\n  // host selector: x-foo.wide -> .x-foo-42.wide\n  // note: we use only the scope class (.x-foo-42) and not the hostSelector\n  // (x-foo) to scope :host rules; this helps make property host rules\n  // have low specificity. They are overrideable by class selectors but,\n  // unfortunately, not by type selectors (e.g. overriding via\n  // `.special` is ok, but not by `x-foo`).\n  /**\n   * @param {StyleNode} rule\n   * @param {RegExp} hostRx\n   * @param {string} hostSelector\n   * @param {string} scopeId\n   */\n  _scopeSelector(rule, hostRx, hostSelector, scopeId) {\n    rule.transformedSelector = rule.transformedSelector || rule['selector'];\n    let selector = rule.transformedSelector;\n    let scope = '.' + scopeId;\n    let parts = StyleUtil.splitSelectorList(selector);\n    for (let i=0, l=parts.length, p; (i<l) && (p=parts[i]); i++) {\n      parts[i] = p.match(hostRx) ?\n        p.replace(hostSelector, scope) :\n        scope + ' ' + p;\n    }\n    rule['selector'] = parts.join(',');\n  }\n\n  /**\n   * @param {Element} element\n   * @param {string} selector\n   * @param {string} old\n   */\n  applyElementScopeSelector(element, selector, old) {\n    let c = element.getAttribute('class') || '';\n    let v = c;\n    if (old) {\n      v = c.replace(\n        new RegExp('\\\\s*' + XSCOPE_NAME + '\\\\s*' + old + '\\\\s*', 'g'), ' ');\n    }\n    v += (v ? ' ' : '') + XSCOPE_NAME + ' ' + selector;\n    if (c !== v) {\n      StyleUtil.setElementClassRaw(element, v);\n    }\n  }\n\n  /**\n   * @param {HTMLElement} element\n   * @param {Object} properties\n   * @param {string} selector\n   * @param {HTMLStyleElement} style\n   * @return {HTMLStyleElement}\n   */\n  applyElementStyle(element, properties, selector, style) {\n    // calculate cssText to apply\n    let cssText = style ? style.textContent || '' :\n      this.transformStyles(element, properties, selector);\n    // if shady and we have a cached style that is not style, decrement\n    let styleInfo = StyleInfo.get(element);\n    let s = styleInfo.customStyle;\n    if (s && !nativeShadow && (s !== style)) {\n      s['_useCount']--;\n      if (s['_useCount'] <= 0 && s.parentNode) {\n        s.parentNode.removeChild(s);\n      }\n    }\n    // apply styling always under native or if we generated style\n    // or the cached style is not in document(!)\n    if (nativeShadow) {\n      // update existing style only under native\n      if (styleInfo.customStyle) {\n        styleInfo.customStyle.textContent = cssText;\n        style = styleInfo.customStyle;\n      // otherwise, if we have css to apply, do so\n      } else if (cssText) {\n        // apply css after the scope style of the element to help with\n        // style precedence rules.\n        style = StyleUtil.applyCss(cssText, selector, element.shadowRoot,\n          styleInfo.placeholder);\n      }\n    } else {\n      // shady and no cache hit\n      if (!style) {\n        // apply css after the scope style of the element to help with\n        // style precedence rules.\n        if (cssText) {\n          style = StyleUtil.applyCss(cssText, selector, null,\n            styleInfo.placeholder);\n        }\n      // shady and cache hit but not in document\n      } else if (!style.parentNode) {\n        if (IS_IE && cssText.indexOf('@media') > -1) {\n            // @media rules may be stale in IE 10 and 11\n            // refresh the text content of the style to revalidate them.\n          style.textContent = cssText;\n        }\n        StyleUtil.applyStyle(style, null, styleInfo.placeholder);\n      }\n    }\n    // ensure this style is our custom style and increment its use count.\n    if (style) {\n      style['_useCount'] = style['_useCount'] || 0;\n      // increment use count if we changed styles\n      if (styleInfo.customStyle != style) {\n        style['_useCount']++;\n      }\n      styleInfo.customStyle = style;\n    }\n    return style;\n  }\n\n  /**\n   * @param {Element} style\n   * @param {Object} properties\n   */\n  applyCustomStyle(style, properties) {\n    let rules = StyleUtil.rulesForStyle(/** @type {HTMLStyleElement} */(style));\n    let self = this;\n    style.textContent = StyleUtil.toCssText(rules, function(/** StyleNode */rule) {\n      let css = rule['cssText'] = rule['parsedCssText'];\n      if (rule.propertyInfo && rule.propertyInfo.cssText) {\n        // remove property assignments\n        // so next function isn't confused\n        // NOTE: we have 3 categories of css:\n        // (1) normal properties,\n        // (2) custom property assignments (--foo: red;),\n        // (3) custom property usage: border: var(--foo); @apply(--foo);\n        // In elements, 1 and 3 are separated for efficiency; here they\n        // are not and this makes this case unique.\n        css = removeCustomPropAssignment(/** @type {string} */(css));\n        // replace with reified properties, scenario is same as mixin\n        rule['cssText'] = self.valueForProperties(css, properties);\n      }\n    });\n  }\n}\n\n/**\n * @param {number} n\n * @param {Array<number>} bits\n */\nfunction addToBitMask(n, bits) {\n  let o = parseInt(n / 32, 10);\n  let v = 1 << (n % 32);\n  bits[o] = (bits[o] || 0) | v;\n}\n\nexport default new StyleProperties();","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport {StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\n\n/** @const {string} */\nconst infoKey = '__styleInfo';\n\nexport default class StyleInfo {\n  /**\n   * @param {Element} node\n   * @return {StyleInfo}\n   */\n  static get(node) {\n    if (node) {\n      return node[infoKey];\n    } else {\n      return null;\n    }\n  }\n  /**\n   * @param {!Element} node\n   * @param {StyleInfo} styleInfo\n   * @return {StyleInfo}\n   */\n  static set(node, styleInfo) {\n    node[infoKey] = styleInfo;\n    return styleInfo;\n  }\n  /**\n   * @param {StyleNode} ast\n   * @param {Node=} placeholder\n   * @param {Array<string>=} ownStylePropertyNames\n   * @param {string=} elementName\n   * @param {string=} typeExtension\n   * @param {string=} cssBuild\n   */\n  constructor(ast, placeholder, ownStylePropertyNames, elementName, typeExtension, cssBuild) {\n    /** @type {StyleNode} */\n    this.styleRules = ast || null;\n    /** @type {Node} */\n    this.placeholder = placeholder || null;\n    /** @type {!Array<string>} */\n    this.ownStylePropertyNames = ownStylePropertyNames || [];\n    /** @type {Array<Object>} */\n    this.overrideStyleProperties = null;\n    /** @type {string} */\n    this.elementName = elementName || '';\n    /** @type {string} */\n    this.cssBuild = cssBuild || '';\n    /** @type {string} */\n    this.typeExtension = typeExtension || '';\n    /** @type {Object<string, string>} */\n    this.styleProperties = null;\n    /** @type {?string} */\n    this.scopeSelector = null;\n    /** @type {HTMLStyleElement} */\n    this.customStyle = null;\n  }\n  _getStyleRules() {\n    return this.styleRules;\n  }\n}\n\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} 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) {\n  /**\n   * @const {function(this:CustomElementRegistry, string,function(new:HTMLElement),{extends: string}=)}\n   */\n  const origDefine = ce['define'];\n  /**\n   * @param {string} name\n   * @param {function(new:HTMLElement)} clazz\n   * @param {{extends: string}=} options\n   */\n  const wrappedDefine = (name, clazz, options) => {\n    ensureStylePlaceholder(name);\n    origDefine.call(/** @type {!CustomElementRegistry} */(ce), name, clazz, options);\n  };\n  ce['define'] = wrappedDefine;\n}","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n'use strict';\n\nexport default class StyleCache {\n  constructor(typeMax = 100) {\n    // map element name -> [{properties, styleElement, scopeSelector}]\n    this.cache = {};\n    /** @type {number} */\n    this.typeMax = typeMax;\n  }\n\n  _validate(cacheEntry, properties, ownPropertyNames) {\n    for (let idx = 0; idx < ownPropertyNames.length; idx++) {\n      let pn = ownPropertyNames[idx];\n      if (cacheEntry.properties[pn] !== properties[pn]) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  store(tagname, properties, styleElement, scopeSelector) {\n    let list = this.cache[tagname] || [];\n    list.push({properties, styleElement, scopeSelector});\n    if (list.length > this.typeMax) {\n      list.shift();\n    }\n    this.cache[tagname] = list;\n  }\n\n  fetch(tagname, properties, ownPropertyNames) {\n    let list = this.cache[tagname];\n    if (!list) {\n      return;\n    }\n    // reverse list for most-recent lookups\n    for (let idx = list.length - 1; idx >= 0; idx--) {\n      let entry = list[idx];\n      if (this._validate(entry, properties, ownPropertyNames)) {\n        return entry;\n      }\n    }\n  }\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\n/**\n * @const {!Object<string, !HTMLTemplateElement>}\n */\nconst templateMap = {};\nexport default templateMap;\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\nimport templateMap from './template-map.js';\nimport {StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars\n\n/*\n * Utilities for handling invalidating apply-shim mixins for a given template.\n *\n * The invalidation strategy involves keeping track of the \"current\" version of a template's mixins, and updating that count when a mixin is invalidated.\n * The template\n */\n\n/** @const {string} */\nconst CURRENT_VERSION = '_applyShimCurrentVersion';\n\n/** @const {string} */\nconst NEXT_VERSION = '_applyShimNextVersion';\n\n/** @const {string} */\nconst VALIDATING_VERSION = '_applyShimValidatingVersion';\n\n/**\n * @const {Promise<void>}\n */\nconst promise = Promise.resolve();\n\n/**\n * @param {string} elementName\n */\nexport function invalidate(elementName){\n  let template = templateMap[elementName];\n  if (template) {\n    invalidateTemplate(template);\n  }\n}\n\n/**\n * This function can be called multiple times to mark a template invalid\n * and signal that the style inside must be regenerated.\n *\n * Use `startValidatingTemplate` to begin an asynchronous validation cycle.\n * During that cycle, call `templateIsValidating` to see if the template must\n * be revalidated\n * @param {HTMLTemplateElement} template\n */\nexport function invalidateTemplate(template) {\n  // default the current version to 0\n  template[CURRENT_VERSION] = template[CURRENT_VERSION] || 0;\n  // ensure the \"validating for\" flag exists\n  template[VALIDATING_VERSION] = template[VALIDATING_VERSION] || 0;\n  // increment the next version\n  template[NEXT_VERSION] = (template[NEXT_VERSION] || 0) + 1;\n}\n\n/**\n * @param {string} elementName\n * @return {boolean}\n */\nexport function isValid(elementName) {\n  let template = templateMap[elementName];\n  if (template) {\n    return templateIsValid(template);\n  }\n  return true;\n}\n\n/**\n * @param {HTMLTemplateElement} template\n * @return {boolean}\n */\nexport function templateIsValid(template) {\n  return template[CURRENT_VERSION] === template[NEXT_VERSION];\n}\n\n/**\n * @param {string} elementName\n * @return {boolean}\n */\nexport function isValidating(elementName) {\n  let template = templateMap[elementName];\n  if (template) {\n    return templateIsValidating(template);\n  }\n  return false;\n}\n\n/**\n * Returns true if the template is currently invalid and `startValidating` has been called since the last invalidation.\n * If false, the template must be validated.\n * @param {HTMLTemplateElement} template\n * @return {boolean}\n */\nexport function templateIsValidating(template) {\n  return !templateIsValid(template) && template[VALIDATING_VERSION] === template[NEXT_VERSION];\n}\n\n/**\n * the template is marked as `validating` for one microtask so that all instances\n * found in the tree crawl of `applyStyle` will update themselves,\n * but the template will only be updated once.\n * @param {string} elementName\n*/\nexport function startValidating(elementName) {\n  let template = templateMap[elementName];\n  startValidatingTemplate(template);\n}\n\n/**\n * Begin an asynchronous invalidation cycle.\n * This should be called after every validation of a template\n *\n * After one microtask, the template will be marked as valid until the next call to `invalidateTemplate`\n * @param {HTMLTemplateElement} template\n */\nexport function startValidatingTemplate(template) {\n  // remember that the current \"next version\" is the reason for this validation cycle\n  template[VALIDATING_VERSION] = template[NEXT_VERSION];\n  // however, there only needs to be one async task to clear the counters\n  if (!template._validating) {\n    template._validating = true;\n    promise.then(function() {\n      // sync the current version to let future invalidations cause a refresh cycle\n      template[CURRENT_VERSION] = template[NEXT_VERSION];\n      template._validating = false;\n    });\n  }\n}\n\n/**\n * @return {boolean}\n */\nexport function elementsAreInvalid() {\n  for (let elementName in templateMap) {\n    let template = templateMap[elementName];\n    if (!templateIsValid(template)) {\n      return true;\n    }\n  }\n  return false;\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport { MIXIN_MATCH, VAR_ASSIGN } from './common-regex.js';\n\n/**\n * @param {Element} element\n * @param {Object=} properties\n */\nexport function updateNativeProperties(element, properties) {\n  // remove previous properties\n  for (let p in properties) {\n    // NOTE: for bc with shim, don't apply null values.\n    if (p === null) {\n      element.style.removeProperty(p);\n    } else {\n      element.style.setProperty(p, properties[p]);\n    }\n  }\n}\n\n/**\n * @param {Element} element\n * @param {string} property\n * @return {string}\n */\nexport function getComputedStyleValue(element, property) {\n  /**\n   * @const {string}\n   */\n  const value = window.getComputedStyle(element).getPropertyValue(property);\n  if (!value) {\n    return '';\n  } else {\n    return value.trim();\n  }\n}\n\n/**\n * return true if `cssText` contains a mixin definition or consumption\n * @param {string} cssText\n * @return {boolean}\n */\nexport function detectMixin(cssText) {\n  const has = MIXIN_MATCH.test(cssText) || VAR_ASSIGN.test(cssText);\n  // reset state of the regexes\n  MIXIN_MATCH.lastIndex = 0;\n  VAR_ASSIGN.lastIndex = 0;\n  return has;\n}\n","/**\n@license\nCopyright (c) 2017 The Polymer Project Authors. All rights reserved.\nThis code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\nThe complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\nThe complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\nCode distributed by Google as part of the polymer project is also\nsubject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n*/\n\n'use strict';\n\nimport ScopingShim from '../src/scoping-shim.js';\nimport {nativeCssVariables, nativeShadow, cssBuild} 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\nif (ApplyShim) {\n  window.ShadyCSS.ApplyShim = ApplyShim;\n}\n\nif (CustomStyleInterface) {\n  window.ShadyCSS.CustomStyleInterface = CustomStyleInterface;\n}"]}