{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./src/scripts/polyfills.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","document","addEventListener","svg4everybody","window","IntersectionObserverEntry","this","intersectionRatio","startDoc","doc","frame","getFrameElement","ownerDocument","registry","crossOriginUpdater","crossOriginRect","IntersectionObserver","THROTTLE_TIMEOUT","POLL_INTERVAL","USE_MUTATION_OBSERVER","_setupCrossOriginUpdater","boundingClientRect","intersectionRect","convertFromParentRect","top","bottom","left","right","width","height","forEach","observer","_checkForIntersections","_resetCrossOriginUpdater","observe","target","_observationTargets","some","item","element","nodeType","Error","_registerInstance","push","entry","_monitorIntersections","unobserve","filter","_unmonitorIntersections","length","_unregisterInstance","disconnect","_unmonitorAllIntersections","takeRecords","records","_queuedEntries","slice","_initThresholds","opt_threshold","threshold","Array","isArray","sort","a","isNaN","_parseRootMargin","opt_rootMargin","margins","split","map","margin","parts","exec","parseFloat","unit","win","defaultView","_monitoringDocuments","indexOf","callback","monitoringInterval","domObserver","setInterval","addEvent","MutationObserver","attributes","childList","characterData","subtree","_monitoringUnsubscribes","clearInterval","removeEvent","rootDoc","root","index","itemDoc","unsubscribe","splice","unsubscribes","rootIsInDom","_rootIsInDom","rootRect","_getRootRect","targetRect","getBoundingClientRect","rootContainsTarget","_rootContainsTarget","oldEntry","_computeTargetAndRootIntersection","rootBounds","newEntry","time","performance","now","_hasCrossedThreshold","isIntersecting","_callback","getComputedStyle","display","rect1","rect2","parent","getParentNode","atRoot","parentRect","parentComputedStyle","frameRect","frameIntersect","body","documentElement","overflow","Math","max","min","isDoc","html","clientWidth","clientHeight","_expandRectByRootMargin","rect","_rootMarginValues","newRect","oldRatio","newRatio","thresholds","containsDeep","frameElement","e","ensureDOMRect","targetArea","intersectionArea","Number","toFixed","opt_options","fn","timeout","timer","options","setTimeout","rootMargin","join","node","event","opt_useCapture","attachEvent","removeEventListener","detatchEvent","el","err","y","x","parentBoundingRect","parentIntersectionRect","child","parentNode","assignedSlot","host"],"mappings":"aACE,IAAIA,EAAmB,GAGvB,SAASC,EAAoBC,GAG5B,GAAGF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUC,QAGnC,IAAIC,EAASJ,EAAiBE,GAAY,CACzCG,EAAGH,EACHI,GAAG,EACHH,QAAS,IAUV,OANAI,EAAQL,GAAUM,KAAKJ,EAAOD,QAASC,EAAQA,EAAOD,QAASF,GAG/DG,EAAOE,GAAI,EAGJF,EAAOD,QAKfF,EAAoBQ,EAAIF,EAGxBN,EAAoBS,EAAIV,EAGxBC,EAAoBU,EAAI,SAASR,EAASS,EAAMC,GAC3CZ,EAAoBa,EAAEX,EAASS,IAClCG,OAAOC,eAAeb,EAASS,EAAM,CAAEK,YAAY,EAAMC,IAAKL,KAKhEZ,EAAoBkB,EAAI,SAAShB,GACX,oBAAXiB,QAA0BA,OAAOC,aAC1CN,OAAOC,eAAeb,EAASiB,OAAOC,YAAa,CAAEC,MAAO,WAE7DP,OAAOC,eAAeb,EAAS,aAAc,CAAEmB,OAAO,KAQvDrB,EAAoBsB,EAAI,SAASD,EAAOE,GAEvC,GADU,EAAPA,IAAUF,EAAQrB,EAAoBqB,IAC/B,EAAPE,EAAU,OAAOF,EACpB,GAAW,EAAPE,GAA8B,iBAAVF,GAAsBA,GAASA,EAAMG,WAAY,OAAOH,EAChF,IAAII,EAAKX,OAAOY,OAAO,MAGvB,GAFA1B,EAAoBkB,EAAEO,GACtBX,OAAOC,eAAeU,EAAI,UAAW,CAAET,YAAY,EAAMK,MAAOA,IACtD,EAAPE,GAA4B,iBAATF,EAAmB,IAAI,IAAIM,KAAON,EAAOrB,EAAoBU,EAAEe,EAAIE,EAAK,SAASA,GAAO,OAAON,EAAMM,IAAQC,KAAK,KAAMD,IAC9I,OAAOF,GAIRzB,EAAoB6B,EAAI,SAAS1B,GAChC,IAAIS,EAAST,GAAUA,EAAOqB,WAC7B,WAAwB,OAAOrB,EAAgB,SAC/C,WAA8B,OAAOA,GAEtC,OADAH,EAAoBU,EAAEE,EAAQ,IAAKA,GAC5BA,GAIRZ,EAAoBa,EAAI,SAASiB,EAAQC,GAAY,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,IAGzG/B,EAAoBkC,EAAI,GAIjBlC,EAAoBA,EAAoBmC,EAAI,G,uPCjFjDC,SAASC,iBAAiB,oBAAoB,WACtCC,eACAA,mBAcX,WACG,aAGA,GAAsB,YAAlB,oBAAOC,OAAP,cAAOA,SAMX,GAAI,yBAA0BA,QAC1B,8BAA+BA,QAC/B,sBAAuBA,OAAOC,0BAA0BR,UAIlD,mBAAoBO,OAAOC,0BAA0BR,WACvDlB,OAAOC,eAAewB,OAAOC,0BAA0BR,UACvD,iBAAkB,CACdf,IAAK,WACD,OAAOwB,KAAKC,kBAAoB,SAVhD,CAkCA,IAAIN,EAAY,SAASO,GAGrB,IAFA,IAAIC,EAOLL,OAAOH,SANFS,EAAQC,EAAgBF,GACrBC,GAEHA,EAAQC,EADRF,EAAMC,EAAME,eAGhB,OAAOH,EAPK,GAgBZI,EAAW,GAOXC,EAAqB,KAMrBC,EAAkB,KAuFtBC,EAAqBnB,UAAUoB,iBAAmB,IAOlDD,EAAqBnB,UAAUqB,cAAgB,KAM/CF,EAAqBnB,UAAUsB,uBAAwB,EAWvDH,EAAqBI,yBAA2B,WAiB5C,OAhBKN,IAKDA,EAAqB,SAASO,EAAoBC,GAI1CP,EAHCM,GAAuBC,EAGNC,EAAsBF,EAAoBC,GAsqBjE,CACHE,IAAK,EACLC,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPC,MAAO,EACPC,OAAQ,GA1qBJhB,EAASiB,SAAQ,SAASC,GACtBA,EAASC,8BAIdlB,GAMXE,EAAqBiB,yBAA2B,WAC5CnB,EAAqB,KACrBC,EAAkB,MAQtBC,EAAqBnB,UAAUqC,QAAU,SAASC,GAK9C,IAJ8B7B,KAAK8B,oBAAoBC,MAAK,SAASC,GACjE,OAAOA,EAAKC,SAAWJ,KAG3B,CAIA,IAAMA,GAA6B,GAAnBA,EAAOK,SACnB,MAAM,IAAIC,MAAM,6BAGpBnC,KAAKoC,oBACLpC,KAAK8B,oBAAoBO,KAAK,CAACJ,QAASJ,EAAQS,MAAO,OACvDtC,KAAKuC,sBAAsBV,EAAOvB,eAClCN,KAAK0B,2BAQThB,EAAqBnB,UAAUiD,UAAY,SAASX,GAChD7B,KAAK8B,oBACD9B,KAAK8B,oBAAoBW,QAAO,SAAST,GACrC,OAAOA,EAAKC,SAAWJ,KAE/B7B,KAAK0C,wBAAwBb,EAAOvB,eACG,GAAnCN,KAAK8B,oBAAoBa,QACzB3C,KAAK4C,uBAQblC,EAAqBnB,UAAUsD,WAAa,WACxC7C,KAAK8B,oBAAsB,GAC3B9B,KAAK8C,6BACL9C,KAAK4C,uBAUTlC,EAAqBnB,UAAUwD,YAAc,WACzC,IAAIC,EAAUhD,KAAKiD,eAAeC,QAElC,OADAlD,KAAKiD,eAAiB,GACfD,GAaXtC,EAAqBnB,UAAU4D,gBAAkB,SAASC,GACtD,IAAIC,EAAYD,GAAiB,CAAC,GAGlC,OAFKE,MAAMC,QAAQF,KAAYA,EAAY,CAACA,IAErCA,EAAUG,OAAOf,QAAO,SAAS5D,EAAGlB,EAAG8F,GAC1C,GAAgB,iBAAL5E,GAAiB6E,MAAM7E,IAAMA,EAAI,GAAKA,EAAI,EACjD,MAAM,IAAIsD,MAAM,0DAEpB,OAAOtD,IAAM4E,EAAE9F,EAAI,OAe3B+C,EAAqBnB,UAAUoE,iBAAmB,SAASC,GACvD,IACIC,GADeD,GAAkB,OACVE,MAAM,OAAOC,KAAI,SAASC,GACjD,IAAIC,EAAQ,wBAAwBC,KAAKF,GACzC,IAAKC,EACD,MAAM,IAAI9B,MAAM,qDAEpB,MAAO,CAACvD,MAAOuF,WAAWF,EAAM,IAAKG,KAAMH,EAAM,OAQrD,OAJAJ,EAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GACnCA,EAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GACnCA,EAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GAE5BA,GASXnD,EAAqBnB,UAAUgD,sBAAwB,SAASpC,GAC5D,IAAIkE,EAAMlE,EAAImE,YACd,GAAKD,IAI0C,GAA3CrE,KAAKuE,qBAAqBC,QAAQrE,GAAtC,CAMA,IAAIsE,EAAWzE,KAAK0B,uBAChBgD,EAAqB,KACrBC,EAAc,KAId3E,KAAKY,cACL8D,EAAqBL,EAAIO,YAAYH,EAAUzE,KAAKY,gBAEpDiE,EAASR,EAAK,SAAUI,GAAU,GAClCI,EAAS1E,EAAK,SAAUsE,GAAU,GAC9BzE,KAAKa,uBAAyB,qBAAsBwD,IACpDM,EAAc,IAAIN,EAAIS,iBAAiBL,IAC3B7C,QAAQzB,EAAK,CACrB4E,YAAY,EACZC,WAAW,EACXC,eAAe,EACfC,SAAS,KAKrBlF,KAAKuE,qBAAqBlC,KAAKlC,GAC/BH,KAAKmF,wBAAwB9C,MAAK,WAG9B,IAAIgC,EAAMlE,EAAImE,YAEVD,IACIK,GACAL,EAAIe,cAAcV,GAEtBW,EAAYhB,EAAK,SAAUI,GAAU,IAGzCY,EAAYlF,EAAK,SAAUsE,GAAU,GACjCE,GACAA,EAAY9B,gBAKpB,IAAIyC,EAAWtF,KAAKuF,OAASvF,KAAKuF,KAAKjF,eAAiBN,KAAKuF,OAAU5F,EACvE,GAAIQ,GAAOmF,EAAS,CAChB,IAAIlF,EAAQC,EAAgBF,GACxBC,GACAJ,KAAKuC,sBAAsBnC,EAAME,kBAW7CI,EAAqBnB,UAAUmD,wBAA0B,SAASvC,GAC9D,IAAIqF,EAAQxF,KAAKuE,qBAAqBC,QAAQrE,GAC9C,IAAc,GAAVqF,EAAJ,CAIA,IAAIF,EAAWtF,KAAKuF,OAASvF,KAAKuF,KAAKjF,eAAiBN,KAAKuF,OAAU5F,EAoBvE,IAhBIK,KAAK8B,oBAAoBC,MAAK,SAASC,GACnC,IAAIyD,EAAUzD,EAAKC,QAAQ3B,cAE3B,GAAImF,GAAWtF,EACX,OAAO,EAGX,KAAOsF,GAAWA,GAAWH,GAAS,CAClC,IAAIlF,EAAQC,EAAgBoF,GAE5B,IADAA,EAAUrF,GAASA,EAAME,gBACVH,EACX,OAAO,EAGf,OAAO,KAEf,CAKA,IAAIuF,EAAc1F,KAAKmF,wBAAwBK,GAM/C,GALAxF,KAAKuE,qBAAqBoB,OAAOH,EAAO,GACxCxF,KAAKmF,wBAAwBQ,OAAOH,EAAO,GAC3CE,IAGIvF,GAAOmF,EAAS,CAChB,IAAIlF,EAAQC,EAAgBF,GACxBC,GACAJ,KAAK0C,wBAAwBtC,EAAME,mBAW/CI,EAAqBnB,UAAUuD,2BAA6B,WACxD,IAAI8C,EAAe5F,KAAKmF,wBAAwBjC,MAAM,GACtDlD,KAAKuE,qBAAqB5B,OAAS,EACnC3C,KAAKmF,wBAAwBxC,OAAS,EACtC,IAAK,IAAIhF,EAAI,EAAGA,EAAIiI,EAAajD,OAAQhF,IACrCiI,EAAajI,MAWrB+C,EAAqBnB,UAAUmC,uBAAyB,WACpD,GAAK1B,KAAKuF,OAAQ/E,GAAuBC,EAAzC,CAKA,IAAIoF,EAAc7F,KAAK8F,eACnBC,EAAWF,EAAc7F,KAAKgG,eA6Y3B,CACH9E,IAAK,EACLC,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPC,MAAO,EACPC,OAAQ,GAjZZvB,KAAK8B,oBAAoBN,SAAQ,SAASQ,GACtC,IAAIH,EAASG,EAAKC,QACdgE,EAAaC,EAAsBrE,GACnCsE,EAAqBnG,KAAKoG,oBAAoBvE,GAC9CwE,EAAWrE,EAAKM,MAChBtB,EAAmB6E,GAAeM,GAClCnG,KAAKsG,kCAAkCzE,EAAQoE,EAAYF,GAE3DQ,EAAa,KACZvG,KAAKoG,oBAAoBvE,GAElBrB,IAAsBR,KAAKuF,OACnCgB,EAAaR,GAFbQ,EAiYD,CACHrF,IAAK,EACLC,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPC,MAAO,EACPC,OAAQ,GAlYR,IAAIiF,EAAWxE,EAAKM,MAAQ,IAAIvC,EAA0B,CACtD0G,KA8PD3G,OAAO4G,aAAeA,YAAYC,KAAOD,YAAYC,MA7PpD9E,OAAQA,EACRd,mBAAoBkF,EACpBM,WAAYA,EACZvF,iBAAkBA,IAGjBqF,EAEMR,GAAeM,EAGtBnG,KAAK4G,qBAAqBP,EAAUG,IACpCxG,KAAKiD,eAAeZ,KAAKmE,GAMrBH,GAAYA,EAASQ,gBACrB7G,KAAKiD,eAAeZ,KAAKmE,GAZ7BxG,KAAKiD,eAAeZ,KAAKmE,KAe9BxG,MAECA,KAAKiD,eAAeN,QACpB3C,KAAK8G,UAAU9G,KAAK+C,cAAe/C,QAkB3CU,EAAqBnB,UAAU+G,kCAAoC,SAASzE,EAAQoE,EAAYF,GAE5F,GAA+C,QAA3CjG,OAAOiH,iBAAiBlF,GAAQmF,QAApC,CAMA,IAJA,IAkR6BC,EAAOC,EAChChG,EACAC,EACAC,EACAC,EACAC,EACAC,EAxRAP,EAAmBiF,EACnBkB,EAASC,EAAcvF,GACvBwF,GAAS,GAELA,GAAUF,GAAQ,CACtB,IAAIG,EAAa,KACbC,EAAyC,GAAnBJ,EAAOjF,SAC7BpC,OAAOiH,iBAAiBI,GAAU,GAGtC,GAAmC,QAA/BI,EAAoBP,QAAmB,OAAO,KAElD,GAAIG,GAAUnH,KAAKuF,MAA0C,GAAlC4B,EAAOjF,SAE9B,GADAmF,GAAS,EACLF,GAAUnH,KAAKuF,MAAQ4B,GAAUxH,EAC7Ba,IAAuBR,KAAKuF,MACvB9E,GACwB,GAAzBA,EAAgBa,OAAwC,GAA1Bb,EAAgBc,QAE9C4F,EAAS,KACTG,EAAa,KACbtG,EAAmB,MAEnBsG,EAAa7G,EAGjB6G,EAAavB,MAEd,CAEH,IAAI3F,EAAQgH,EAAcD,GACtBK,EAAYpH,GAAS8F,EAAsB9F,GAC3CqH,EACArH,GACAJ,KAAKsG,kCAAkClG,EAAOoH,EAAWzB,GACzDyB,GAAaC,GACjBN,EAAS/G,EACTkH,EAAarG,EAAsBuG,EAAWC,KAE9CN,EAAS,KACTnG,EAAmB,UAGpB,CAKH,IAAIb,EAAMgH,EAAO7G,cACb6G,GAAUhH,EAAIuH,MACdP,GAAUhH,EAAIwH,iBACkB,WAAhCJ,EAAoBK,WACpBN,EAAapB,EAAsBiB,IAS3C,GAHIG,IAwNqBL,EAvNsBK,EAuNfJ,EAvN2BlG,EAwN3DE,SACAC,SACAC,SACAC,SACAC,SACAC,SALAL,EAAM2G,KAAKC,IAAIb,EAAM/F,IAAKgG,EAAMhG,KAChCC,EAAS0G,KAAKE,IAAId,EAAM9F,OAAQ+F,EAAM/F,QACtCC,EAAOyG,KAAKC,IAAIb,EAAM7F,KAAM8F,EAAM9F,MAClCC,EAAQwG,KAAKE,IAAId,EAAM5F,MAAO6F,EAAM7F,OAEpCE,EAASJ,EAASD,EA7NdF,GA4NJM,EAAQD,EAAQD,IAGH,GAAKG,GAAU,GAAM,CAClCL,IAAKA,EACLC,OAAQA,EACRC,KAAMA,EACNC,MAAOA,EACPC,MAAOA,EACPC,OAAQA,IACP,OApOIP,EAAkB,MACvBmG,EAASA,GAAUC,EAAcD,GAErC,OAAOnG,IASXN,EAAqBnB,UAAUyG,aAAe,WAC1C,IAAID,EACJ,GAAI/F,KAAKuF,OAASyC,EAAMhI,KAAKuF,MACzBQ,EAAWG,EAAsBlG,KAAKuF,UACnC,CAEH,IAAIpF,EAAM6H,EAAMhI,KAAKuF,MAAQvF,KAAKuF,KAAO5F,EACrCsI,EAAO9H,EAAIwH,gBACXD,EAAOvH,EAAIuH,KACf3B,EAAW,CACP7E,IAAK,EACLE,KAAM,EACNC,MAAO4G,EAAKC,aAAeR,EAAKQ,YAChC5G,MAAO2G,EAAKC,aAAeR,EAAKQ,YAChC/G,OAAQ8G,EAAKE,cAAgBT,EAAKS,aAClC5G,OAAQ0G,EAAKE,cAAgBT,EAAKS,cAG1C,OAAOnI,KAAKoI,wBAAwBrC,IAUxCrF,EAAqBnB,UAAU6I,wBAA0B,SAASC,GAC9D,IAAIxE,EAAU7D,KAAKsI,kBAAkBvE,KAAI,SAASC,EAAQrG,GACtD,MAAsB,MAAfqG,EAAOI,KAAeJ,EAAOpF,MAChCoF,EAAOpF,OAASjB,EAAI,EAAI0K,EAAK/G,MAAQ+G,EAAK9G,QAAU,OAExDgH,EAAU,CACVrH,IAAKmH,EAAKnH,IAAM2C,EAAQ,GACxBxC,MAAOgH,EAAKhH,MAAQwC,EAAQ,GAC5B1C,OAAQkH,EAAKlH,OAAS0C,EAAQ,GAC9BzC,KAAMiH,EAAKjH,KAAOyC,EAAQ,IAK9B,OAHA0E,EAAQjH,MAAQiH,EAAQlH,MAAQkH,EAAQnH,KACxCmH,EAAQhH,OAASgH,EAAQpH,OAASoH,EAAQrH,IAEnCqH,GAcX7H,EAAqBnB,UAAUqH,qBAC3B,SAASP,EAAUG,GAInB,IAAIgC,EAAWnC,GAAYA,EAASQ,eAAiBR,EAASpG,mBAAqB,GAAK,EACpFwI,EAAWjC,EAASK,eAAiBL,EAASvG,mBAAqB,GAAK,EAG5E,GAAIuI,IAAaC,EAEjB,IAAK,IAAI9K,EAAI,EAAGA,EAAIqC,KAAK0I,WAAW/F,OAAQhF,IAAK,CAC7C,IAAI0F,EAAYrD,KAAK0I,WAAW/K,GAIhC,GAAI0F,GAAamF,GAAYnF,GAAaoF,GAAYpF,EAAYmF,GAAanF,EAAYoF,EACvF,OAAO,IAWnB/H,EAAqBnB,UAAUuG,aAAe,WAC1C,OAAQ9F,KAAKuF,MAAQoD,EAAahJ,EAAUK,KAAKuF,OAUrD7E,EAAqBnB,UAAU6G,oBAAsB,SAASvE,GAC1D,IAAIyD,EACCtF,KAAKuF,OAASvF,KAAKuF,KAAKjF,eAAiBN,KAAKuF,OAAU5F,EAC7D,OACIgJ,EAAarD,EAASzD,MACpB7B,KAAKuF,MAAQD,GAAWzD,EAAOvB,gBAUzCI,EAAqBnB,UAAU6C,kBAAoB,WAC3C7B,EAASiE,QAAQxE,MAAQ,GACzBO,EAAS8B,KAAKrC,OAStBU,EAAqBnB,UAAUqD,oBAAsB,WACjD,IAAI4C,EAAQjF,EAASiE,QAAQxE,OACf,GAAVwF,GAAajF,EAASoF,OAAOH,EAAO,IA4P5C1F,OAAOY,qBAAuBA,EAC9BZ,OAAOC,0BAA4BA,EA97BnC,SAASM,EAAgBF,GACrB,IACI,OAAOA,EAAImE,aAAenE,EAAImE,YAAYsE,cAAgB,KAC5D,MAAOC,GAEL,OAAO,MA6Cf,SAAS9I,EAA0BuC,GAC/BtC,KAAKyG,KAAOnE,EAAMmE,KAClBzG,KAAK6B,OAASS,EAAMT,OACpB7B,KAAKuG,WAAauC,EAAcxG,EAAMiE,YACtCvG,KAAKe,mBAAqB+H,EAAcxG,EAAMvB,oBAC9Cf,KAAKgB,iBAAmB8H,EAAcxG,EAAMtB,kBAixBrC,CACHE,IAAK,EACLC,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPC,MAAO,EACPC,OAAQ,IAtxBZvB,KAAK6G,iBAAmBvE,EAAMtB,iBAG9B,IAAIiF,EAAajG,KAAKe,mBAClBgI,EAAa9C,EAAW3E,MAAQ2E,EAAW1E,OAC3CP,EAAmBhB,KAAKgB,iBACxBgI,EAAmBhI,EAAiBM,MAAQN,EAAiBO,OAM7DvB,KAAKC,kBAHL8I,EAGyBE,QAAQD,EAAmBD,GAAYG,QAAQ,IAG/ClJ,KAAK6G,eAAiB,EAAI,EAc3D,SAASnG,EAAqB+D,EAAU0E,GAEpC,IAgoBcC,EAAIC,EACdC,EAjoBAC,EAAUJ,GAAe,GAE7B,GAAuB,mBAAZ1E,EACP,MAAM,IAAItC,MAAM,+BAGpB,GACIoH,EAAQhE,MACiB,GAAzBgE,EAAQhE,KAAKrD,UACY,GAAzBqH,EAAQhE,KAAKrD,SAEb,MAAM,IAAIC,MAAM,sCAIpBnC,KAAK0B,wBAinBS0H,EAhnBVpJ,KAAK0B,uBAAuBvC,KAAKa,MAgnBnBqJ,EAhnB0BrJ,KAAKW,iBAinB7C2I,EAAQ,KACL,WACEA,IACDA,EAAQE,YAAW,WACfJ,IACAE,EAAQ,OACTD,MApnBXrJ,KAAK8G,UAAYrC,EACjBzE,KAAK8B,oBAAsB,GAC3B9B,KAAKiD,eAAiB,GACtBjD,KAAKsI,kBAAoBtI,KAAK2D,iBAAiB4F,EAAQE,YAGvDzJ,KAAK0I,WAAa1I,KAAKmD,gBAAgBoG,EAAQlG,WAC/CrD,KAAKuF,KAAOgE,EAAQhE,MAAQ,KAC5BvF,KAAKyJ,WAAazJ,KAAKsI,kBAAkBvE,KAAI,SAASC,GAClD,OAAOA,EAAOpF,MAAQoF,EAAOI,QAC9BsF,KAAK,KAGR1J,KAAKuE,qBAAuB,GAE5BvE,KAAKmF,wBAA0B,GAmnBnC,SAASN,EAAS8E,EAAMC,EAAOR,EAAIS,GACK,mBAAzBF,EAAK/J,iBACZ+J,EAAK/J,iBAAiBgK,EAAOR,EAAIS,IAAkB,GAEnB,mBAApBF,EAAKG,aACjBH,EAAKG,YAAY,KAAOF,EAAOR,GAavC,SAAS/D,EAAYsE,EAAMC,EAAOR,EAAIS,GACK,mBAA5BF,EAAKI,oBACZJ,EAAKI,oBAAoBH,EAAOR,EAAIS,IAAkB,GAErB,mBAArBF,EAAKK,cACjBL,EAAKK,aAAa,KAAOJ,EAAOR,GAoCxC,SAASlD,EAAsB+D,GAC3B,IAAI5B,EAEJ,IACIA,EAAO4B,EAAG/D,wBACZ,MAAOgE,IAKT,OAAK7B,GAGCA,EAAK/G,OAAS+G,EAAK9G,SACrB8G,EAAO,CACHnH,IAAKmH,EAAKnH,IACVG,MAAOgH,EAAKhH,MACZF,OAAQkH,EAAKlH,OACbC,KAAMiH,EAAKjH,KACXE,MAAO+G,EAAKhH,MAAQgH,EAAKjH,KACzBG,OAAQ8G,EAAKlH,OAASkH,EAAKnH,MAG5BmH,GAUA,CACHnH,IAAK,EACLC,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPC,MAAO,EACPC,OAAQ,GAYhB,SAASuH,EAAcT,GAEnB,OAAKA,GAAQ,MAAOA,EACTA,EAMJ,CACHnH,IAAKmH,EAAKnH,IACViJ,EAAG9B,EAAKnH,IACRC,OAAQkH,EAAKlH,OACbC,KAAMiH,EAAKjH,KACXgJ,EAAG/B,EAAKjH,KACRC,MAAOgH,EAAKhH,MACZC,MAAO+G,EAAK/G,MACZC,OAAQ8G,EAAK9G,QAYrB,SAASN,EAAsBoJ,EAAoBC,GAC/C,IAAIpJ,EAAMoJ,EAAuBpJ,IAAMmJ,EAAmBnJ,IACtDE,EAAOkJ,EAAuBlJ,KAAOiJ,EAAmBjJ,KAC5D,MAAO,CACHF,IAAKA,EACLE,KAAMA,EACNG,OAAQ+I,EAAuB/I,OAC/BD,MAAOgJ,EAAuBhJ,MAC9BH,OAAQD,EAAMoJ,EAAuB/I,OACrCF,MAAOD,EAAOkJ,EAAuBhJ,OAY7C,SAASqH,EAAaxB,EAAQoD,GAE1B,IADA,IAAIZ,EAAOY,EACJZ,GAAM,CACT,GAAIA,GAAQxC,EAAQ,OAAO,EAE3BwC,EAAOvC,EAAcuC,GAEzB,OAAO,EAUX,SAASvC,EAAcuC,GACnB,IAAIxC,EAASwC,EAAKa,WAElB,OAAoC,GAAhCb,EAAKzH,UAAgCyH,GAAQhK,EAEtCU,EAAgBsJ,IAIvBxC,GAAUA,EAAOsD,eACjBtD,EAASA,EAAOsD,aAAaD,YAG7BrD,GAA6B,IAAnBA,EAAOjF,UAAkBiF,EAAOuD,KAEnCvD,EAAOuD,KAGXvD,GAQX,SAASa,EAAM2B,GACX,OAAOA,GAA0B,IAAlBA,EAAKzH,UAx9B3B","file":"polyfills.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 9);\n","(function () {\r\n    document.addEventListener(\"DOMContentLoaded\", function() {\r\n        if (svg4everybody) {\r\n            svg4everybody();\r\n        }\r\n    });\r\n})();\r\n\r\n\r\n/**\r\n * Copyright 2016 Google Inc. All Rights Reserved.\r\n *\r\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\r\n *\r\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\r\n *\r\n */\r\n(function() {\r\n    'use strict';\r\n    \r\n    // Exit early if we're not running in a browser.\r\n    if (typeof window !== 'object') {\r\n        return;\r\n    }\r\n    \r\n    // Exit early if all IntersectionObserver and IntersectionObserverEntry\r\n    // features are natively supported.\r\n    if ('IntersectionObserver' in window &&\r\n        'IntersectionObserverEntry' in window &&\r\n        'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\r\n    \r\n        // Minimal polyfill for Edge 15's lack of `isIntersecting`\r\n        // See: https://github.com/w3c/IntersectionObserver/issues/211\r\n        if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\r\n            Object.defineProperty(window.IntersectionObserverEntry.prototype,\r\n            'isIntersecting', {\r\n                get: function () {\r\n                    return this.intersectionRatio > 0;\r\n                }\r\n            });\r\n        }\r\n        return;\r\n    }\r\n    \r\n    /**\r\n     * Returns the embedding frame element, if any.\r\n     * @param {!Document} doc\r\n     * @return {!Element}\r\n     */\r\n    function getFrameElement(doc) {\r\n        try {\r\n            return doc.defaultView && doc.defaultView.frameElement || null;\r\n        } catch (e) {\r\n            // Ignore the error.\r\n            return null;\r\n        }\r\n    }\r\n    \r\n    /**\r\n     * A local reference to the root document.\r\n     */\r\n    var document = (function(startDoc) {\r\n        var doc = startDoc;\r\n        var frame = getFrameElement(doc);\r\n        while (frame) {\r\n            doc = frame.ownerDocument;\r\n            frame = getFrameElement(doc);\r\n        }\r\n        return doc;\r\n    })(window.document);\r\n    \r\n    /**\r\n     * An IntersectionObserver registry. This registry exists to hold a strong\r\n     * reference to IntersectionObserver instances currently observing a target\r\n     * element. Without this registry, instances without another reference may be\r\n     * garbage collected.\r\n     */\r\n    var registry = [];\r\n    \r\n    /**\r\n     * The signal updater for cross-origin intersection. When not null, it means\r\n     * that the polyfill is configured to work in a cross-origin mode.\r\n     * @type {function(DOMRect|ClientRect, DOMRect|ClientRect)}\r\n     */\r\n    var crossOriginUpdater = null;\r\n    \r\n    /**\r\n     * The current cross-origin intersection. Only used in the cross-origin mode.\r\n     * @type {DOMRect|ClientRect}\r\n     */\r\n    var crossOriginRect = null;\r\n    \r\n    \r\n    /**\r\n     * Creates the global IntersectionObserverEntry constructor.\r\n     * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\r\n     * @param {Object} entry A dictionary of instance properties.\r\n     * @constructor\r\n     */\r\n    function IntersectionObserverEntry(entry) {\r\n        this.time = entry.time;\r\n        this.target = entry.target;\r\n        this.rootBounds = ensureDOMRect(entry.rootBounds);\r\n        this.boundingClientRect = ensureDOMRect(entry.boundingClientRect);\r\n        this.intersectionRect = ensureDOMRect(entry.intersectionRect || getEmptyRect());\r\n        this.isIntersecting = !!entry.intersectionRect;\r\n        \r\n        // Calculates the intersection ratio.\r\n        var targetRect = this.boundingClientRect;\r\n        var targetArea = targetRect.width * targetRect.height;\r\n        var intersectionRect = this.intersectionRect;\r\n        var intersectionArea = intersectionRect.width * intersectionRect.height;\r\n        \r\n        // Sets intersection ratio.\r\n        if (targetArea) {\r\n            // Round the intersection ratio to avoid floating point math issues:\r\n            // https://github.com/w3c/IntersectionObserver/issues/324\r\n            this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));\r\n        } else {\r\n            // If area is zero and is intersecting, sets to 1, otherwise to 0\r\n            this.intersectionRatio = this.isIntersecting ? 1 : 0;\r\n        }\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Creates the global IntersectionObserver constructor.\r\n     * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\r\n     * @param {Function} callback The function to be invoked after intersection\r\n     *     changes have queued. The function is not invoked if the queue has\r\n     *     been emptied by calling the `takeRecords` method.\r\n     * @param {Object=} opt_options Optional configuration options.\r\n     * @constructor\r\n     */\r\n    function IntersectionObserver(callback, opt_options) {\r\n        \r\n        var options = opt_options || {};\r\n        \r\n        if (typeof callback != 'function') {\r\n            throw new Error('callback must be a function');\r\n        }\r\n        \r\n        if (\r\n            options.root &&\r\n            options.root.nodeType != 1 &&\r\n            options.root.nodeType != 9\r\n        ) {\r\n            throw new Error('root must be a Document or Element');\r\n        }\r\n        \r\n        // Binds and throttles `this._checkForIntersections`.\r\n        this._checkForIntersections = throttle(\r\n            this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\r\n        \r\n        // Private properties.\r\n        this._callback = callback;\r\n        this._observationTargets = [];\r\n        this._queuedEntries = [];\r\n        this._rootMarginValues = this._parseRootMargin(options.rootMargin);\r\n        \r\n        // Public properties.\r\n        this.thresholds = this._initThresholds(options.threshold);\r\n        this.root = options.root || null;\r\n        this.rootMargin = this._rootMarginValues.map(function(margin) {\r\n            return margin.value + margin.unit;\r\n        }).join(' ');\r\n        \r\n        /** @private @const {!Array<!Document>} */\r\n        this._monitoringDocuments = [];\r\n        /** @private @const {!Array<function()>} */\r\n        this._monitoringUnsubscribes = [];\r\n    }\r\n\r\n    /**\r\n     * The minimum interval within which the document will be checked for\r\n     * intersection changes.\r\n     */\r\n    IntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\r\n    \r\n    /**\r\n     * The frequency in which the polyfill polls for intersection changes.\r\n     * this can be updated on a per instance basis and must be set prior to\r\n     * calling `observe` on the first target.\r\n     */\r\n    IntersectionObserver.prototype.POLL_INTERVAL = null;\r\n    \r\n    /**\r\n     * Use a mutation observer on the root element\r\n     * to detect intersection changes.\r\n     */\r\n    IntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\r\n    \r\n    /**\r\n     * Sets up the polyfill in the cross-origin mode. The result is the\r\n     * updater function that accepts two arguments: `boundingClientRect` and\r\n     * `intersectionRect` - just as these fields would be available to the\r\n     * parent via `IntersectionObserverEntry`. This function should be called\r\n     * each time the iframe receives intersection information from the parent\r\n     * window, e.g. via messaging.\r\n     * @return {function(DOMRect|ClientRect, DOMRect|ClientRect)}\r\n     */\r\n    IntersectionObserver._setupCrossOriginUpdater = function() {\r\n        if (!crossOriginUpdater) {\r\n            /**\r\n             * @param {DOMRect|ClientRect} boundingClientRect\r\n             * @param {DOMRect|ClientRect} intersectionRect\r\n             */\r\n            crossOriginUpdater = function(boundingClientRect, intersectionRect) {\r\n                if (!boundingClientRect || !intersectionRect) {\r\n                    crossOriginRect = getEmptyRect();\r\n                } else {\r\n                    crossOriginRect = convertFromParentRect(boundingClientRect, intersectionRect);\r\n                }\r\n                registry.forEach(function(observer) {\r\n                    observer._checkForIntersections();\r\n                });\r\n            };\r\n        }\r\n        return crossOriginUpdater;\r\n    };\r\n    \r\n    /**\r\n     * Resets the cross-origin mode.\r\n     */\r\n    IntersectionObserver._resetCrossOriginUpdater = function() {\r\n        crossOriginUpdater = null;\r\n        crossOriginRect = null;\r\n    };\r\n    \r\n    /**\r\n     * Starts observing a target element for intersection changes based on\r\n     * the thresholds values.\r\n     * @param {Element} target The DOM element to observe.\r\n     */\r\n    IntersectionObserver.prototype.observe = function(target) {\r\n        var isTargetAlreadyObserved = this._observationTargets.some(function(item) {\r\n            return item.element == target;\r\n        });\r\n        \r\n        if (isTargetAlreadyObserved) {\r\n            return;\r\n        }\r\n        \r\n        if (!(target && target.nodeType == 1)) {\r\n            throw new Error('target must be an Element');\r\n        }\r\n        \r\n        this._registerInstance();\r\n        this._observationTargets.push({element: target, entry: null});\r\n        this._monitorIntersections(target.ownerDocument);\r\n        this._checkForIntersections();\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Stops observing a target element for intersection changes.\r\n     * @param {Element} target The DOM element to observe.\r\n     */\r\n    IntersectionObserver.prototype.unobserve = function(target) {\r\n        this._observationTargets =\r\n            this._observationTargets.filter(function(item) {\r\n                return item.element != target;\r\n            });\r\n        this._unmonitorIntersections(target.ownerDocument);\r\n        if (this._observationTargets.length == 0) {\r\n            this._unregisterInstance();\r\n        }\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Stops observing all target elements for intersection changes.\r\n     */\r\n    IntersectionObserver.prototype.disconnect = function() {\r\n        this._observationTargets = [];\r\n        this._unmonitorAllIntersections();\r\n        this._unregisterInstance();\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Returns any queue entries that have not yet been reported to the\r\n     * callback and clears the queue. This can be used in conjunction with the\r\n     * callback to obtain the absolute most up-to-date intersection information.\r\n     * @return {Array} The currently queued entries.\r\n     */\r\n    IntersectionObserver.prototype.takeRecords = function() {\r\n        var records = this._queuedEntries.slice();\r\n        this._queuedEntries = [];\r\n        return records;\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Accepts the threshold value from the user configuration object and\r\n     * returns a sorted array of unique threshold values. If a value is not\r\n     * between 0 and 1 and error is thrown.\r\n     * @private\r\n     * @param {Array|number=} opt_threshold An optional threshold value or\r\n     *     a list of threshold values, defaulting to [0].\r\n     * @return {Array} A sorted list of unique and valid threshold values.\r\n     */\r\n    IntersectionObserver.prototype._initThresholds = function(opt_threshold) {\r\n        var threshold = opt_threshold || [0];\r\n        if (!Array.isArray(threshold)) threshold = [threshold];\r\n        \r\n        return threshold.sort().filter(function(t, i, a) {\r\n            if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\r\n                throw new Error('threshold must be a number between 0 and 1 inclusively');\r\n            }\r\n            return t !== a[i - 1];\r\n        });\r\n    };\r\n    \r\n    /**\r\n     * Accepts the rootMargin value from the user configuration object\r\n     * and returns an array of the four margin values as an object containing\r\n     * the value and unit properties. If any of the values are not properly\r\n     * formatted or use a unit other than px or %, and error is thrown.\r\n     * @private\r\n     * @param {string=} opt_rootMargin An optional rootMargin value,\r\n     *     defaulting to '0px'.\r\n     * @return {Array<Object>} An array of margin objects with the keys\r\n     *     value and unit.\r\n     */\r\n    IntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\r\n        var marginString = opt_rootMargin || '0px';\r\n        var margins = marginString.split(/\\s+/).map(function(margin) {\r\n            var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\r\n            if (!parts) {\r\n                throw new Error('rootMargin must be specified in pixels or percent');\r\n            }\r\n            return {value: parseFloat(parts[1]), unit: parts[2]};\r\n        });\r\n        \r\n        // Handles shorthand.\r\n        margins[1] = margins[1] || margins[0];\r\n        margins[2] = margins[2] || margins[0];\r\n        margins[3] = margins[3] || margins[1];\r\n        \r\n        return margins;\r\n    };\r\n    \r\n    /**\r\n     * Starts polling for intersection changes if the polling is not already\r\n     * happening, and if the page's visibility state is visible.\r\n     * @param {!Document} doc\r\n     * @private\r\n     */\r\n    IntersectionObserver.prototype._monitorIntersections = function(doc) {\r\n        var win = doc.defaultView;\r\n        if (!win) {\r\n            // Already destroyed.\r\n            return;\r\n        }\r\n        if (this._monitoringDocuments.indexOf(doc) != -1) {\r\n            // Already monitoring.\r\n            return;\r\n        }\r\n    \r\n      // Private state for monitoring.\r\n        var callback = this._checkForIntersections;\r\n        var monitoringInterval = null;\r\n        var domObserver = null;\r\n        \r\n        // If a poll interval is set, use polling instead of listening to\r\n        // resize and scroll events or DOM mutations.\r\n        if (this.POLL_INTERVAL) {\r\n            monitoringInterval = win.setInterval(callback, this.POLL_INTERVAL);\r\n        } else {\r\n            addEvent(win, 'resize', callback, true);\r\n            addEvent(doc, 'scroll', callback, true);\r\n            if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in win) {\r\n                domObserver = new win.MutationObserver(callback);\r\n                domObserver.observe(doc, {\r\n                    attributes: true,\r\n                    childList: true,\r\n                    characterData: true,\r\n                    subtree: true\r\n                });\r\n            }\r\n        }\r\n    \r\n        this._monitoringDocuments.push(doc);\r\n        this._monitoringUnsubscribes.push(function() {\r\n            // Get the window object again. When a friendly iframe is destroyed, it\r\n            // will be null.\r\n            var win = doc.defaultView;\r\n        \r\n            if (win) {\r\n                if (monitoringInterval) {\r\n                    win.clearInterval(monitoringInterval);\r\n                }\r\n                removeEvent(win, 'resize', callback, true);\r\n            }\r\n        \r\n            removeEvent(doc, 'scroll', callback, true);\r\n            if (domObserver) {\r\n                domObserver.disconnect();\r\n            }\r\n        });\r\n    \r\n        // Also monitor the parent.\r\n        var rootDoc = (this.root && (this.root.ownerDocument || this.root)) || document;\r\n        if (doc != rootDoc) {\r\n            var frame = getFrameElement(doc);\r\n            if (frame) {\r\n                this._monitorIntersections(frame.ownerDocument);\r\n            }\r\n        }\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Stops polling for intersection changes.\r\n     * @param {!Document} doc\r\n     * @private\r\n     */\r\n    IntersectionObserver.prototype._unmonitorIntersections = function(doc) {\r\n        var index = this._monitoringDocuments.indexOf(doc);\r\n        if (index == -1) {\r\n            return;\r\n        }\r\n        \r\n        var rootDoc = (this.root && (this.root.ownerDocument || this.root)) || document;\r\n        \r\n        // Check if any dependent targets are still remaining.\r\n        var hasDependentTargets =\r\n            this._observationTargets.some(function(item) {\r\n                var itemDoc = item.element.ownerDocument;\r\n                // Target is in this context.\r\n                if (itemDoc == doc) {\r\n                    return true;\r\n                }\r\n                // Target is nested in this context.\r\n                while (itemDoc && itemDoc != rootDoc) {\r\n                    var frame = getFrameElement(itemDoc);\r\n                    itemDoc = frame && frame.ownerDocument;\r\n                    if (itemDoc == doc) {\r\n                        return true;\r\n                    }\r\n                }\r\n                return false;\r\n            });\r\n        if (hasDependentTargets) {\r\n            return;\r\n        }\r\n        \r\n        // Unsubscribe.\r\n        var unsubscribe = this._monitoringUnsubscribes[index];\r\n        this._monitoringDocuments.splice(index, 1);\r\n        this._monitoringUnsubscribes.splice(index, 1);\r\n        unsubscribe();\r\n        \r\n        // Also unmonitor the parent.\r\n        if (doc != rootDoc) {\r\n            var frame = getFrameElement(doc);\r\n            if (frame) {\r\n                this._unmonitorIntersections(frame.ownerDocument);\r\n            }\r\n        }\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Stops polling for intersection changes.\r\n     * @param {!Document} doc\r\n     * @private\r\n     */\r\n    IntersectionObserver.prototype._unmonitorAllIntersections = function() {\r\n        var unsubscribes = this._monitoringUnsubscribes.slice(0);\r\n        this._monitoringDocuments.length = 0;\r\n        this._monitoringUnsubscribes.length = 0;\r\n        for (var i = 0; i < unsubscribes.length; i++) {\r\n            unsubscribes[i]();\r\n        }\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Scans each observation target for intersection changes and adds them\r\n     * to the internal entries queue. If new entries are found, it\r\n     * schedules the callback to be invoked.\r\n     * @private\r\n     */\r\n    IntersectionObserver.prototype._checkForIntersections = function() {\r\n        if (!this.root && crossOriginUpdater && !crossOriginRect) {\r\n            // Cross origin monitoring, but no initial data available yet.\r\n            return;\r\n        }\r\n        \r\n        var rootIsInDom = this._rootIsInDom();\r\n        var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\r\n        \r\n        this._observationTargets.forEach(function(item) {\r\n            var target = item.element;\r\n            var targetRect = getBoundingClientRect(target);\r\n            var rootContainsTarget = this._rootContainsTarget(target);\r\n            var oldEntry = item.entry;\r\n            var intersectionRect = rootIsInDom && rootContainsTarget && \r\n                this._computeTargetAndRootIntersection(target, targetRect, rootRect);\r\n        \r\n            var rootBounds = null;\r\n            if (!this._rootContainsTarget(target)) {\r\n                rootBounds = getEmptyRect();\r\n            } else if (!crossOriginUpdater || this.root) {\r\n                rootBounds = rootRect;\r\n            }\r\n        \r\n            var newEntry = item.entry = new IntersectionObserverEntry({\r\n                time: now(),\r\n                target: target,\r\n                boundingClientRect: targetRect,\r\n                rootBounds: rootBounds,\r\n                intersectionRect: intersectionRect\r\n            });\r\n        \r\n            if (!oldEntry) {\r\n                this._queuedEntries.push(newEntry);\r\n            } else if (rootIsInDom && rootContainsTarget) {\r\n            // If the new entry intersection ratio has crossed any of the\r\n            // thresholds, add a new entry.\r\n            if (this._hasCrossedThreshold(oldEntry, newEntry)) {\r\n                this._queuedEntries.push(newEntry);\r\n            }\r\n            } else {\r\n                // If the root is not in the DOM or target is not contained within\r\n                // root but the previous entry for this target had an intersection,\r\n                // add a new record indicating removal.\r\n                if (oldEntry && oldEntry.isIntersecting) {\r\n                    this._queuedEntries.push(newEntry);\r\n                }\r\n            }\r\n        }, this);\r\n        \r\n        if (this._queuedEntries.length) {\r\n            this._callback(this.takeRecords(), this);\r\n        }\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Accepts a target and root rect computes the intersection between then\r\n     * following the algorithm in the spec.\r\n     * TODO(philipwalton): at this time clip-path is not considered.\r\n     * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\r\n     * @param {Element} target The target DOM element\r\n     * @param {Object} targetRect The bounding rect of the target.\r\n     * @param {Object} rootRect The bounding rect of the root after being\r\n     *     expanded by the rootMargin value.\r\n     * @return {?Object} The final intersection rect object or undefined if no\r\n     *     intersection is found.\r\n     * @private\r\n     */\r\n    IntersectionObserver.prototype._computeTargetAndRootIntersection = function(target, targetRect, rootRect) {\r\n        // If the element isn't displayed, an intersection can't happen.\r\n        if (window.getComputedStyle(target).display == 'none') return;\r\n        \r\n        var intersectionRect = targetRect;\r\n        var parent = getParentNode(target);\r\n        var atRoot = false;\r\n        \r\n        while (!atRoot && parent) {\r\n            var parentRect = null;\r\n            var parentComputedStyle = parent.nodeType == 1 ?\r\n                window.getComputedStyle(parent) : {};\r\n        \r\n            // If the parent isn't displayed, an intersection can't happen.\r\n            if (parentComputedStyle.display == 'none') return null;\r\n        \r\n            if (parent == this.root || parent.nodeType == /* DOCUMENT */ 9) {\r\n                atRoot = true;\r\n                if (parent == this.root || parent == document) {\r\n                    if (crossOriginUpdater && !this.root) {\r\n                        if (!crossOriginRect ||\r\n                            crossOriginRect.width == 0 && crossOriginRect.height == 0) {\r\n                            // A 0-size cross-origin intersection means no-intersection.\r\n                            parent = null;\r\n                            parentRect = null;\r\n                            intersectionRect = null;\r\n                        } else {\r\n                            parentRect = crossOriginRect;\r\n                        }\r\n                    } else {\r\n                        parentRect = rootRect;\r\n                    }\r\n                } else {\r\n                    // Check if there's a frame that can be navigated to.\r\n                    var frame = getParentNode(parent);\r\n                    var frameRect = frame && getBoundingClientRect(frame);\r\n                    var frameIntersect =\r\n                        frame &&\r\n                        this._computeTargetAndRootIntersection(frame, frameRect, rootRect);\r\n                    if (frameRect && frameIntersect) {\r\n                    parent = frame;\r\n                    parentRect = convertFromParentRect(frameRect, frameIntersect);\r\n                    } else {\r\n                    parent = null;\r\n                    intersectionRect = null;\r\n                    }\r\n                }\r\n            } else {\r\n                // If the element has a non-visible overflow, and it's not the <body>\r\n                // or <html> element, update the intersection rect.\r\n                // Note: <body> and <html> cannot be clipped to a rect that's not also\r\n                // the document rect, so no need to compute a new intersection.\r\n                var doc = parent.ownerDocument;\r\n                if (parent != doc.body &&\r\n                    parent != doc.documentElement &&\r\n                    parentComputedStyle.overflow != 'visible') {\r\n                    parentRect = getBoundingClientRect(parent);\r\n                }\r\n            }\r\n        \r\n            // If either of the above conditionals set a new parentRect,\r\n            // calculate new intersection data.\r\n            if (parentRect) {\r\n                intersectionRect = computeRectIntersection(parentRect, intersectionRect);\r\n            }\r\n            if (!intersectionRect) break;\r\n            parent = parent && getParentNode(parent);\r\n        }\r\n        return intersectionRect;\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Returns the root rect after being expanded by the rootMargin value.\r\n     * @return {ClientRect} The expanded root rect.\r\n     * @private\r\n     */\r\n    IntersectionObserver.prototype._getRootRect = function() {\r\n        var rootRect;\r\n        if (this.root && !isDoc(this.root)) {\r\n            rootRect = getBoundingClientRect(this.root);\r\n        } else {\r\n            // Use <html>/<body> instead of window since scroll bars affect size.\r\n            var doc = isDoc(this.root) ? this.root : document;\r\n            var html = doc.documentElement;\r\n            var body = doc.body;\r\n            rootRect = {\r\n                top: 0,\r\n                left: 0,\r\n                right: html.clientWidth || body.clientWidth,\r\n                width: html.clientWidth || body.clientWidth,\r\n                bottom: html.clientHeight || body.clientHeight,\r\n                height: html.clientHeight || body.clientHeight\r\n            };\r\n        }\r\n        return this._expandRectByRootMargin(rootRect);\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Accepts a rect and expands it by the rootMargin value.\r\n     * @param {DOMRect|ClientRect} rect The rect object to expand.\r\n     * @return {ClientRect} The expanded rect.\r\n     * @private\r\n     */\r\n    IntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\r\n        var margins = this._rootMarginValues.map(function(margin, i) {\r\n            return margin.unit == 'px' ? margin.value :\r\n                margin.value * (i % 2 ? rect.width : rect.height) / 100;\r\n        });\r\n        var newRect = {\r\n            top: rect.top - margins[0],\r\n            right: rect.right + margins[1],\r\n            bottom: rect.bottom + margins[2],\r\n            left: rect.left - margins[3]\r\n        };\r\n        newRect.width = newRect.right - newRect.left;\r\n        newRect.height = newRect.bottom - newRect.top;\r\n        \r\n        return newRect;\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Accepts an old and new entry and returns true if at least one of the\r\n     * threshold values has been crossed.\r\n     * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\r\n     *    particular target element or null if no previous entry exists.\r\n     * @param {IntersectionObserverEntry} newEntry The current entry for a\r\n     *    particular target element.\r\n     * @return {boolean} Returns true if a any threshold has been crossed.\r\n     * @private\r\n     */\r\n    IntersectionObserver.prototype._hasCrossedThreshold =\r\n        function(oldEntry, newEntry) {\r\n    \r\n        // To make comparing easier, an entry that has a ratio of 0\r\n        // but does not actually intersect is given a value of -1\r\n        var oldRatio = oldEntry && oldEntry.isIntersecting ? oldEntry.intersectionRatio || 0 : -1;\r\n        var newRatio = newEntry.isIntersecting ? newEntry.intersectionRatio || 0 : -1;\r\n        \r\n        // Ignore unchanged ratios\r\n        if (oldRatio === newRatio) return;\r\n        \r\n        for (var i = 0; i < this.thresholds.length; i++) {\r\n            var threshold = this.thresholds[i];\r\n        \r\n            // Return true if an entry matches a threshold or if the new ratio\r\n            // and the old ratio are on the opposite sides of a threshold.\r\n            if (threshold == oldRatio || threshold == newRatio || threshold < oldRatio !== threshold < newRatio) {\r\n                return true;\r\n            }\r\n        }\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Returns whether or not the root element is an element and is in the DOM.\r\n     * @return {boolean} True if the root element is an element and is in the DOM.\r\n     * @private\r\n     */\r\n    IntersectionObserver.prototype._rootIsInDom = function() {\r\n        return !this.root || containsDeep(document, this.root);\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Returns whether or not the target element is a child of root.\r\n     * @param {Element} target The target element to check.\r\n     * @return {boolean} True if the target element is a child of root.\r\n     * @private\r\n     */\r\n    IntersectionObserver.prototype._rootContainsTarget = function(target) {\r\n        var rootDoc =\r\n            (this.root && (this.root.ownerDocument || this.root)) || document;\r\n        return (\r\n            containsDeep(rootDoc, target) &&\r\n            (!this.root || rootDoc == target.ownerDocument)\r\n        );\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Adds the instance to the global IntersectionObserver registry if it isn't\r\n     * already present.\r\n     * @private\r\n     */\r\n    IntersectionObserver.prototype._registerInstance = function() {\r\n        if (registry.indexOf(this) < 0) {\r\n            registry.push(this);\r\n        }\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Removes the instance from the global IntersectionObserver registry.\r\n     * @private\r\n     */\r\n    IntersectionObserver.prototype._unregisterInstance = function() {\r\n        var index = registry.indexOf(this);\r\n        if (index != -1) registry.splice(index, 1);\r\n    };\r\n    \r\n    \r\n    /**\r\n     * Returns the result of the performance.now() method or null in browsers\r\n     * that don't support the API.\r\n     * @return {number} The elapsed time since the page was requested.\r\n     */\r\n    function now() {\r\n        return window.performance && performance.now && performance.now();\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Throttles a function and delays its execution, so it's only called at most\r\n     * once within a given time period.\r\n     * @param {Function} fn The function to throttle.\r\n     * @param {number} timeout The amount of time that must pass before the\r\n     *     function can be called again.\r\n     * @return {Function} The throttled function.\r\n     */\r\n    function throttle(fn, timeout) {\r\n        var timer = null;\r\n        return function () {\r\n            if (!timer) {\r\n                timer = setTimeout(function() {\r\n                    fn();\r\n                    timer = null;\r\n                }, timeout);\r\n            }\r\n        };\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Adds an event handler to a DOM node ensuring cross-browser compatibility.\r\n     * @param {Node} node The DOM node to add the event handler to.\r\n     * @param {string} event The event name.\r\n     * @param {Function} fn The event handler to add.\r\n     * @param {boolean} opt_useCapture Optionally adds the even to the capture\r\n     *     phase. Note: this only works in modern browsers.\r\n     */\r\n    function addEvent(node, event, fn, opt_useCapture) {\r\n        if (typeof node.addEventListener == 'function') {\r\n            node.addEventListener(event, fn, opt_useCapture || false);\r\n        }\r\n        else if (typeof node.attachEvent == 'function') {\r\n            node.attachEvent('on' + event, fn);\r\n        }\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Removes a previously added event handler from a DOM node.\r\n     * @param {Node} node The DOM node to remove the event handler from.\r\n     * @param {string} event The event name.\r\n     * @param {Function} fn The event handler to remove.\r\n     * @param {boolean} opt_useCapture If the event handler was added with this\r\n     *     flag set to true, it should be set to true here in order to remove it.\r\n     */\r\n    function removeEvent(node, event, fn, opt_useCapture) {\r\n        if (typeof node.removeEventListener == 'function') {\r\n            node.removeEventListener(event, fn, opt_useCapture || false);\r\n        }\r\n        else if (typeof node.detatchEvent == 'function') {\r\n            node.detatchEvent('on' + event, fn);\r\n        }\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Returns the intersection between two rect objects.\r\n     * @param {Object} rect1 The first rect.\r\n     * @param {Object} rect2 The second rect.\r\n     * @return {?Object|?ClientRect} The intersection rect or undefined if no\r\n     *     intersection is found.\r\n     */\r\n    function computeRectIntersection(rect1, rect2) {\r\n        var top = Math.max(rect1.top, rect2.top);\r\n        var bottom = Math.min(rect1.bottom, rect2.bottom);\r\n        var left = Math.max(rect1.left, rect2.left);\r\n        var right = Math.min(rect1.right, rect2.right);\r\n        var width = right - left;\r\n        var height = bottom - top;\r\n        \r\n        return (width >= 0 && height >= 0) && {\r\n            top: top,\r\n            bottom: bottom,\r\n            left: left,\r\n            right: right,\r\n            width: width,\r\n            height: height\r\n        } || null;\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Shims the native getBoundingClientRect for compatibility with older IE.\r\n     * @param {Element} el The element whose bounding rect to get.\r\n     * @return {DOMRect|ClientRect} The (possibly shimmed) rect of the element.\r\n     */\r\n    function getBoundingClientRect(el) {\r\n        var rect;\r\n        \r\n        try {\r\n            rect = el.getBoundingClientRect();\r\n        } catch (err) {\r\n            // Ignore Windows 7 IE11 \"Unspecified error\"\r\n            // https://github.com/w3c/IntersectionObserver/pull/205\r\n        }\r\n        \r\n        if (!rect) return getEmptyRect();\r\n        \r\n        // Older IE\r\n        if (!(rect.width && rect.height)) {\r\n            rect = {\r\n                top: rect.top,\r\n                right: rect.right,\r\n                bottom: rect.bottom,\r\n                left: rect.left,\r\n                width: rect.right - rect.left,\r\n                height: rect.bottom - rect.top\r\n            };\r\n        }\r\n        return rect;\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Returns an empty rect object. An empty rect is returned when an element\r\n     * is not in the DOM.\r\n     * @return {ClientRect} The empty rect.\r\n     */\r\n    function getEmptyRect() {\r\n        return {\r\n            top: 0,\r\n            bottom: 0,\r\n            left: 0,\r\n            right: 0,\r\n            width: 0,\r\n            height: 0\r\n        };\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Ensure that the result has all of the necessary fields of the DOMRect.\r\n     * Specifically this ensures that `x` and `y` fields are set.\r\n     *\r\n     * @param {?DOMRect|?ClientRect} rect\r\n     * @return {?DOMRect}\r\n     */\r\n    function ensureDOMRect(rect) {\r\n        // A `DOMRect` object has `x` and `y` fields.\r\n        if (!rect || 'x' in rect) {\r\n            return rect;\r\n        }\r\n        // A IE's `ClientRect` type does not have `x` and `y`. The same is the case\r\n        // for internally calculated Rect objects. For the purposes of\r\n        // `IntersectionObserver`, it's sufficient to simply mirror `left` and `top`\r\n        // for these fields.\r\n        return {\r\n            top: rect.top,\r\n            y: rect.top,\r\n            bottom: rect.bottom,\r\n            left: rect.left,\r\n            x: rect.left,\r\n            right: rect.right,\r\n            width: rect.width,\r\n            height: rect.height\r\n        };\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Inverts the intersection and bounding rect from the parent (frame) BCR to\r\n     * the local BCR space.\r\n     * @param {DOMRect|ClientRect} parentBoundingRect The parent's bound client rect.\r\n     * @param {DOMRect|ClientRect} parentIntersectionRect The parent's own intersection rect.\r\n     * @return {ClientRect} The local root bounding rect for the parent's children.\r\n     */\r\n    function convertFromParentRect(parentBoundingRect, parentIntersectionRect) {\r\n        var top = parentIntersectionRect.top - parentBoundingRect.top;\r\n        var left = parentIntersectionRect.left - parentBoundingRect.left;\r\n        return {\r\n            top: top,\r\n            left: left,\r\n            height: parentIntersectionRect.height,\r\n            width: parentIntersectionRect.width,\r\n            bottom: top + parentIntersectionRect.height,\r\n            right: left + parentIntersectionRect.width\r\n        };\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Checks to see if a parent element contains a child element (including inside\r\n     * shadow DOM).\r\n     * @param {Node} parent The parent element.\r\n     * @param {Node} child The child element.\r\n     * @return {boolean} True if the parent node contains the child node.\r\n     */\r\n    function containsDeep(parent, child) {\r\n        var node = child;\r\n        while (node) {\r\n            if (node == parent) return true;\r\n        \r\n            node = getParentNode(node);\r\n        }\r\n        return false;\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Gets the parent node of an element or its host element if the parent node\r\n     * is a shadow root.\r\n     * @param {Node} node The node whose parent to get.\r\n     * @return {Node|null} The parent node or null if no parent exists.\r\n     */\r\n    function getParentNode(node) {\r\n        var parent = node.parentNode;\r\n        \r\n        if (node.nodeType == /* DOCUMENT */ 9 && node != document) {\r\n            // If this node is a document node, look for the embedding frame.\r\n            return getFrameElement(node);\r\n        }\r\n        \r\n        // If the parent has element that is assigned through shadow root slot\r\n        if (parent && parent.assignedSlot) {\r\n            parent = parent.assignedSlot.parentNode\r\n        }\r\n        \r\n        if (parent && parent.nodeType == 11 && parent.host) {\r\n            // If the parent is a shadow root, return the host element.\r\n            return parent.host;\r\n        }\r\n        \r\n        return parent;\r\n    }\r\n    \r\n    /**\r\n     * Returns true if `node` is a Document.\r\n     * @param {!Node} node\r\n     * @returns {boolean}\r\n     */\r\n    function isDoc(node) {\r\n        return node && node.nodeType === 9;\r\n    }\r\n    \r\n    \r\n    // Exposes the constructors globally.\r\n    window.IntersectionObserver = IntersectionObserver;\r\n    window.IntersectionObserverEntry = IntersectionObserverEntry;\r\n    \r\n    }());"],"sourceRoot":""}