{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/lodash/debounce.js","webpack:///./node_modules/lodash/isObject.js","webpack:///./node_modules/@threespot/expand-toggle/dist/expand-toggle.m.js","webpack:///./node_modules/lodash/_root.js","webpack:///./node_modules/lodash/_Symbol.js","webpack:///./node_modules/@threespot/freeze-scroll/dist/freeze-scroll.m.js","webpack:///./node_modules/ev-emitter/ev-emitter.js","webpack:///./node_modules/lodash/now.js","webpack:///./node_modules/lodash/_freeGlobal.js","webpack:///./node_modules/lodash/toNumber.js","webpack:///./node_modules/lodash/_baseTrim.js","webpack:///./node_modules/lodash/_trimmedEndIndex.js","webpack:///./node_modules/lodash/isSymbol.js","webpack:///./node_modules/lodash/_baseGetTag.js","webpack:///./node_modules/lodash/_getRawTag.js","webpack:///./node_modules/lodash/_objectToString.js","webpack:///./node_modules/lodash/isObjectLike.js","webpack:///./node_modules/lodash/throttle.js","webpack:///./app/javascript/modules/explainer-desktop-nav.js","webpack:///./node_modules/intersection-observer/intersection-observer.js","webpack:///./app/javascript/modules/explainer-mobile-nav.js","webpack:///./app/javascript/lib/modals.js","webpack:///./app/javascript/modules/explainer-modal.js","webpack:///./app/javascript/modules/explainer-nested-modals.js","webpack:///./app/javascript/modules/explainer-scroll.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","g","this","Function","e","window","isObject","now","toNumber","nativeMax","Math","max","nativeMin","min","func","wait","options","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","time","args","thisArg","undefined","apply","leadingEdge","setTimeout","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","arguments","clearTimeout","cancel","flush","type","__webpack_exports__","eval","freeGlobal","freeSelf","self","root","configurable","EvEmitter","proto","on","eventName","listener","events","_events","listeners","indexOf","push","once","onceEvents","_onceEvents","off","length","index","splice","emitEvent","slice","onceListeners","allOff","Date","global","baseTrim","isSymbol","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","other","valueOf","isBinary","test","trimmedEndIndex","reTrimStart","string","replace","reWhitespace","charAt","baseGetTag","isObjectLike","getRawTag","objectToString","symToStringTag","objectProto","nativeObjectToString","toString","isOwn","tag","unmasked","debounce","ExplainerDesktopNav","el","modalContent","document","querySelector","explainerSlides","querySelectorAll","mediaQueryList","matchMedia","addListener","evt","matches","init","addEventListener","preventDefault","updateSlides","currentTarget","hash","activeHash","activeId","foundActive","forEach","slide","classList","remove","add","id","scrollTop","offsetTop","IntersectionObserverEntry","intersectionRatio","registry","IntersectionObserver","THROTTLE_TIMEOUT","POLL_INTERVAL","USE_MUTATION_OBSERVER","observe","target","_observationTargets","some","item","element","nodeType","Error","_registerInstance","entry","_monitorIntersections","_checkForIntersections","unobserve","filter","_unmonitorIntersections","_unregisterInstance","disconnect","takeRecords","records","_queuedEntries","_initThresholds","opt_threshold","threshold","Array","isArray","sort","a","isNaN","_parseRootMargin","opt_rootMargin","margins","split","map","margin","parts","exec","parseFloat","unit","_monitoringIntersections","_monitoringInterval","setInterval","addEvent","_domObserver","MutationObserver","attributes","childList","characterData","subtree","clearInterval","removeEvent","rootIsInDom","_rootIsInDom","rootRect","_getRootRect","top","bottom","left","right","width","height","targetRect","getBoundingClientRect","rootContainsTarget","_rootContainsTarget","oldEntry","intersectionRect","_computeTargetAndRootIntersection","newEntry","performance","boundingClientRect","rootBounds","_hasCrossedThreshold","isIntersecting","_callback","getComputedStyle","display","rect1","rect2","parent","getParentNode","atRoot","parentRect","parentComputedStyle","body","documentElement","overflow","html","clientWidth","clientHeight","_expandRectByRootMargin","rect","_rootMarginValues","newRect","oldRatio","newRatio","thresholds","containsDeep","targetArea","intersectionArea","Number","toFixed","callback","opt_options","fn","timeout","timer","rootMargin","join","node","event","opt_useCapture","attachEvent","removeEventListener","detatchEvent","err","child","parentNode","host","assignedSlot","ExplainerMobileNav","contentEl","getElementById","getAttribute","eventType","windowClick","windowClickHandler","destroy","closest","toggleExpand","collapse","ExpandToggle","Modal","opts","assign","transitionSpeed","activeClasses","modalContentClass","onReady","isOpen","hasToggles","customContentEl","closeEls","toggleEls","random","substr","prevFocusedEl","focusableEls","getFocusableEls","firstFocusableEl","lastFocusableEl","console","warn","setAttribute","toggleEl","closeEl","bindEvents","removeAttribute","unbindEvents","isSameNode","hasFocus","activeElement","focus","isToggle","targetInsideWrapper","contains","targetIsWrapper","close","which","focusedEl","getFocusedEl","shiftKey","toggleClick","toggle","closeClick","keydown","keydownHandler","scroll","freeze","focusDelay","unfreeze","open","EventEmitter","ExplainerModal","activeClass","closeLinks","slides","modal","reset","targetEl","scrollTarget","scrollIntoView","Explainer","desktopNavLinks","watchEls","scrollContent","stickyClass","yOffsets","observer","entries","observerHandler","throttle","disableHover","scrollTimer","len","innerText","substring","scrollDirection","slideEl","updateDesktopNav","idArray"],"mappings":";aACE,IAAIA,EAAmB,CAAC,EAGxB,SAASC,EAAoBC,GAG5B,GAAGF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUC,QAGnC,IAAIC,EAASJ,EAAiBE,GAAY,CACzCG,EAAGH,EACHI,GAAG,EACHH,QAAS,CAAC,GAUX,OANAI,EAAQL,GAAUM,KAAKJ,EAAOD,QAASC,EAAQA,EAAOD,QAASF,GAG/DG,EAAOE,GAAI,EAGJF,EAAOD,OACf,CAIAF,EAAoBQ,EAAIF,EAGxBN,EAAoBS,EAAIV,EAGxBC,EAAoBU,EAAI,SAASR,EAASS,EAAMC,GAC3CZ,EAAoBa,EAAEX,EAASS,IAClCG,OAAOC,eAAeb,EAASS,EAAM,CAAEK,YAAY,EAAMC,IAAKL,GAEhE,EAGAZ,EAAoBkB,EAAI,SAAShB,GACX,qBAAXiB,QAA0BA,OAAOC,aAC1CN,OAAOC,eAAeb,EAASiB,OAAOC,YAAa,CAAEC,MAAO,WAE7DP,OAAOC,eAAeb,EAAS,aAAc,CAAEmB,OAAO,GACvD,EAOArB,EAAoBsB,EAAI,SAASD,EAAOE,GAEvC,GADU,EAAPA,IAAUF,EAAQrB,EAAoBqB,IAC/B,EAAPE,EAAU,OAAOF,EACpB,GAAW,EAAPE,GAA8B,kBAAVF,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,EAAM,EAAEC,KAAK,KAAMD,IAC9I,OAAOF,CACR,EAGAzB,EAAoB6B,EAAI,SAAS1B,GAChC,IAAIS,EAAST,GAAUA,EAAOqB,WAC7B,WAAwB,OAAOrB,EAAgB,OAAG,EAClD,WAA8B,OAAOA,CAAQ,EAE9C,OADAH,EAAoBU,EAAEE,EAAQ,IAAKA,GAC5BA,CACR,EAGAZ,EAAoBa,EAAI,SAASiB,EAAQC,GAAY,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,EAAW,EAGpH/B,EAAoBkC,EAAI,UAIjBlC,EAAoBA,EAAoBmC,EAAI,G,iBClFrD,IAAIC,EAGJA,EAAI,WACF,OAAOC,IACT,CAFI,GAGJ,IAEED,EAAIA,GAAK,IAAIE,SAAS,cAAb,EAIX,CAHE,MAAOC,GAEe,kBAAXC,SAAqBJ,EAAII,OACtC,CAMArC,EAAOD,QAAUkC,C,kBClBjB,IAAIK,EAAW,EAAQ,GACrBC,EAAM,EAAQ,IACdC,EAAW,EAAQ,IAMjBC,EAAYC,KAAKC,IACnBC,EAAYF,KAAKG,IAmKnB7C,EAAOD,QA3GP,SAAkB+C,EAAMC,EAAMC,GAC5B,IAAIC,EACFC,EACAC,EACAC,EACAC,EACAC,EACAC,EAAiB,EACjBC,GAAU,EACVC,GAAS,EACTC,GAAW,EACb,GAAmB,mBAARZ,EACT,MAAM,IAAIa,UAxEQ,uBAiFpB,SAASC,EAAWC,GAClB,IAAIC,EAAOb,EACTc,EAAUb,EAIZ,OAHAD,EAAWC,OAAWc,EACtBT,EAAiBM,EACjBT,EAASN,EAAKmB,MAAMF,EAASD,EAE/B,CACA,SAASI,EAAYL,GAMnB,OAJAN,EAAiBM,EAEjBR,EAAUc,WAAWC,EAAcrB,GAE5BS,EAAUI,EAAWC,GAAQT,CACtC,CAOA,SAASiB,EAAaR,GACpB,IAAIS,EAAoBT,EAAOP,EAM/B,YAAwBU,IAAjBV,GAA8BgB,GAAqBvB,GAAQuB,EAAoB,GAAKb,GALnEI,EAAON,GAK6FJ,CAC9H,CACA,SAASiB,IACP,IAAIP,EAAOtB,IACX,GAAI8B,EAAaR,GACf,OAAOU,EAAaV,GAGtBR,EAAUc,WAAWC,EArBvB,SAAuBP,GACrB,IAEEW,EAAczB,GAFQc,EAAOP,GAG/B,OAAOG,EAASb,EAAU4B,EAAarB,GAFfU,EAAON,IAEyCiB,CAC1E,CAgBqCC,CAAcZ,GACnD,CACA,SAASU,EAAaV,GAKpB,OAJAR,OAAUW,EAINN,GAAYT,EACPW,EAAWC,IAEpBZ,EAAWC,OAAWc,EACfZ,EACT,CAWA,SAASsB,IACP,IAAIb,EAAOtB,IACToC,EAAaN,EAAaR,GAI5B,GAHAZ,EAAW2B,UACX1B,EAAWhB,KACXoB,EAAeO,EACXc,EAAY,CACd,QAAgBX,IAAZX,EACF,OAAOa,EAAYZ,GAErB,GAAIG,EAIF,OAFAoB,aAAaxB,GACbA,EAAUc,WAAWC,EAAcrB,GAC5Ba,EAAWN,EAEtB,CAIA,YAHgBU,IAAZX,IACFA,EAAUc,WAAWC,EAAcrB,IAE9BK,CACT,CAGA,OA3FAL,EAAOP,EAASO,IAAS,EACrBT,EAASU,KACXQ,IAAYR,EAAQQ,QAEpBL,GADAM,EAAS,YAAaT,GACHP,EAAUD,EAASQ,EAAQG,UAAY,EAAGJ,GAAQI,EACrEO,EAAW,aAAcV,IAAYA,EAAQU,SAAWA,GAoF1DgB,EAAUI,OAhCV,gBACkBd,IAAZX,GACFwB,aAAaxB,GAEfE,EAAiB,EACjBN,EAAWK,EAAeJ,EAAWG,OAAUW,CACjD,EA2BAU,EAAUK,MA1BV,WACE,YAAmBf,IAAZX,EAAwBD,EAASmB,EAAahC,IACvD,EAyBOmC,CACT,C,gBC9IA1E,EAAOD,QAJP,SAAkBmB,GAChB,IAAI8D,SAAc9D,EAClB,OAAgB,MAATA,IAA0B,UAAR8D,GAA4B,YAARA,EAC/C,C,4BC5BAhF,OAAOD,QAAkB,SAAUI,GAIjC,IAAIP,EAAmB,CAAC,EAIxB,SAASC,EAAoBC,GAGnB,GAAIF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUC,QAK5C,IAAIC,EAASJ,EAAiBE,GAAY,CAChCG,EAAGH,EACHI,GAAG,EACHH,QAAS,CAAC,GAcpB,OARAI,EAAQL,GAAUM,KAAKJ,EAAOD,QAASC,EAAQA,EAAOD,QAASF,GAI/DG,EAAOE,GAAI,EAIJF,EAAOD,OAEhB,CAkGA,OA7FAF,EAAoBQ,EAAIF,EAIxBN,EAAoBS,EAAIV,EAIxBC,EAAoBU,EAAI,SAAUR,EAASS,EAAMC,GAClCZ,EAAoBa,EAAEX,EAASS,IAClCG,OAAOC,eAAeb,EAASS,EAAM,CAC3CK,YAAY,EACZC,IAAKL,GAKX,EAIAZ,EAAoBkB,EAAI,SAAUhB,GACF,qBAAXiB,QAA0BA,OAAOC,aAC1CN,OAAOC,eAAeb,EAASiB,OAAOC,YAAa,CACzDC,MAAO,WAKXP,OAAOC,eAAeb,EAAS,aAAc,CAC3CmB,OAAO,GAGX,EAQArB,EAAoBsB,EAAI,SAAUD,EAAOE,GAGvC,GAFmB,EAAPA,IAAUF,EAAQrB,EAAoBqB,IAEvC,EAAPE,EAAU,OAAOF,EAErB,GAAW,EAAPE,GAA6B,kBAAVF,GAAsBA,GAASA,EAAMG,WAAY,OAAOH,EAE/E,IAAII,EAAKX,OAAOY,OAAO,MASvB,GAPA1B,EAAoBkB,EAAEO,GAEtBX,OAAOC,eAAeU,EAAI,UAAW,CACnCT,YAAY,EACZK,MAAOA,IAGE,EAAPE,GAA4B,iBAATF,EAAmB,IAAK,IAAIM,KAAON,EAAOrB,EAAoBU,EAAEe,EAAIE,EAAK,SAAUA,GACxG,OAAON,EAAMM,EACf,EAAEC,KAAK,KAAMD,IAEb,OAAOF,CAET,EAIAzB,EAAoB6B,EAAI,SAAU1B,GACxB,IAAIS,EAAST,GAAUA,EAAOqB,WAAqB,WACzD,OAAOrB,EAAgB,OACzB,EAAY,WACV,OAAOA,CACT,EAIA,OAFAH,EAAoBU,EAAEE,EAAQ,IAAKA,GAE5BA,CAET,EAIAZ,EAAoBa,EAAI,SAAUiB,EAAQC,GACxC,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,EACtD,EAIA/B,EAAoBkC,EAAI,GAKjBlC,EAAoBA,EAAoBmC,EAAI,aAErD,CAxIyB,CA0IhB,CACF,aAML,SAAUhC,OAAQiF,oBAAqBpF,qBACrC,aAEAqF,KAAK,qleAGP,EAEK,0CAML,SAAUlF,OAAQD,QAASF,qBACzBqF,KAAK,giGAGP,EAEK,mCAML,SAAUlF,OAAQD,QAASF,qBACzBqF,KAAK,6PAGP,EAEK,uCAML,SAAUlF,OAAQD,QAASF,qBACzBqF,KAAK,kjCAGP,EAEK,uCAML,SAAUlF,OAAQD,QAASF,qBACzBqF,KAAK,qcAGP,EAEK,sCAML,SAAUlF,OAAQD,QAASF,qBACzBqF,KAAK,uyCAGP,EAEK,2CAML,SAAUlF,OAAQD,SAChBmF,KAAK,kqBAGP,EAEK,iCAML,SAAUlF,OAAQD,QAASF,qBACzBqF,KAAK,4bAGP,EAEK,oCAML,SAAUlF,OAAQD,QAASF,qBACzBqF,KAAK,m4MAGP,EAEK,oCAML,SAAUlF,OAAQD,SAChBmF,KAAK,40BAGP,EAEK,wCAML,SAAUlF,OAAQD,SAChBmF,KAAK,ytBAGP,EAEK,oCAML,SAAUlF,OAAQD,QAASF,qBACzBqF,KAAK,44BAGP,EAEK,+BAML,SAAUlF,OAAQD,QAASF,qBACzBqF,KAAK,4pBAGP,EAEK,oCAML,SAAUlF,OAAQD,QAASF,qBACzBqF,KAAK,syDAGP,EAEK,2CAML,SAAUlF,OAAQD,SAChBmF,KAAK,4jBAGP,G,kBC/TF,IAAIC,EAAa,EAAQ,IAGrBC,EAA0B,iBAARC,MAAoBA,MAAQA,KAAK1E,SAAWA,QAAU0E,KAGxEC,EAAOH,GAAcC,GAAYjD,SAAS,cAATA,GACrCnC,EAAOD,QAAUuF,C,kBCPjB,IAGItE,EAHO,EAAQ,GAGDA,OAClBhB,EAAOD,QAAUiB,C,8BCJjBhB,OAAOD,QAAkB,SAAUI,GAIjC,IAAIP,EAAmB,CAAC,EAIxB,SAASC,EAAoBC,GAGnB,GAAIF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUC,QAK5C,IAAIC,EAASJ,EAAiBE,GAAY,CAChCG,EAAGH,EACHI,GAAG,EACHH,QAAS,CAAC,GAcpB,OARAI,EAAQL,GAAUM,KAAKJ,EAAOD,QAASC,EAAQA,EAAOD,QAASF,GAI/DG,EAAOE,GAAI,EAIJF,EAAOD,OAEhB,CA+DA,OA1DAF,EAAoBQ,EAAIF,EAIxBN,EAAoBS,EAAIV,EAIxBC,EAAoBU,EAAI,SAAUR,EAASS,EAAMC,GAClCZ,EAAoBa,EAAEX,EAASS,IAClCG,OAAOC,eAAeb,EAASS,EAAM,CACnC+E,cAAc,EACd1E,YAAY,EACZC,IAAKL,GAMnB,EAIAZ,EAAoBkB,EAAI,SAAUhB,GACxBY,OAAOC,eAAeb,EAAS,aAAc,CACnDmB,OAAO,GAGX,EAIArB,EAAoB6B,EAAI,SAAU1B,GACxB,IAAIS,EAAST,GAAUA,EAAOqB,WAAqB,WACzD,OAAOrB,EAAgB,OACzB,EAAY,WACV,OAAOA,CACT,EAIA,OAFAH,EAAoBU,EAAEE,EAAQ,IAAKA,GAE5BA,CAET,EAIAZ,EAAoBa,EAAI,SAAUiB,EAAQC,GACxC,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,EACtD,EAIA/B,EAAoBkC,EAAI,GAKjBlC,EAAoBA,EAAoBmC,EAAI,aAErD,CArGyB,CAuGhB,CACF,aAML,SAAUhC,OAAQD,QAASF,qBACzB,aAEAqF,KAAK,y0HAGP,G,kBCpHF,QAqBoB,oBAAV7C,QAAwBA,YARhB,2BAAd,EAQ6C,WAC/C,aAEA,SAASmD,IAAa,CACtB,IAAIC,EAAQD,EAAU3D,UAsEtB,OArEA4D,EAAMC,GAAK,SAAUC,EAAWC,GAC9B,GAAKD,GAAcC,EAAnB,CAIA,IAAIC,EAAS3D,KAAK4D,QAAU5D,KAAK4D,SAAW,CAAC,EAEzCC,EAAYF,EAAOF,GAAaE,EAAOF,IAAc,GAKzD,OAHoC,GAAhCI,EAAUC,QAAQJ,IACpBG,EAAUE,KAAKL,GAEV1D,IATP,CAUF,EACAuD,EAAMS,KAAO,SAAUP,EAAWC,GAChC,GAAKD,GAAcC,EAAnB,CAIA1D,KAAKwD,GAAGC,EAAWC,GAGnB,IAAIO,EAAajE,KAAKkE,YAAclE,KAAKkE,aAAe,CAAC,EAKzD,OAHoBD,EAAWR,GAAaQ,EAAWR,IAAc,CAAC,GAExDC,IAAY,EACnB1D,IAVP,CAWF,EACAuD,EAAMY,IAAM,SAAUV,EAAWC,GAC/B,IAAIG,EAAY7D,KAAK4D,SAAW5D,KAAK4D,QAAQH,GAC7C,GAAKI,GAAcA,EAAUO,OAA7B,CAGA,IAAIC,EAAQR,EAAUC,QAAQJ,GAI9B,OAHc,GAAVW,GACFR,EAAUS,OAAOD,EAAO,GAEnBrE,IALP,CAMF,EACAuD,EAAMgB,UAAY,SAAUd,EAAW7B,GACrC,IAAIiC,EAAY7D,KAAK4D,SAAW5D,KAAK4D,QAAQH,GAC7C,GAAKI,GAAcA,EAAUO,OAA7B,CAIAP,EAAYA,EAAUW,MAAM,GAC5B5C,EAAOA,GAAQ,GAGf,IADA,IAAI6C,EAAgBzE,KAAKkE,aAAelE,KAAKkE,YAAYT,GAChD1F,EAAI,EAAGA,EAAI8F,EAAUO,OAAQrG,IAAK,CACzC,IAAI2F,EAAWG,EAAU9F,GACZ0G,GAAiBA,EAAcf,KAI1C1D,KAAKmE,IAAIV,EAAWC,UAEbe,EAAcf,IAGvBA,EAAS3B,MAAM/B,KAAM4B,EACvB,CACA,OAAO5B,IAnBP,CAoBF,EACAuD,EAAMmB,OAAS,kBACN1E,KAAK4D,eACL5D,KAAKkE,WACd,EACOZ,CACT,GAnFkB,iC,oBCblB,IAAIF,EAAO,EAAQ,GAqBnBtF,EAAOD,QAHG,WACR,OAAOuF,EAAKuB,KAAKtE,KACnB,C,mBCpBA,YACA,IAAI4C,EAA8B,iBAAV2B,GAAsBA,GAAUA,EAAOnG,SAAWA,QAAUmG,EACpF9G,EAAOD,QAAUoF,C,oCCFjB,IAAI4B,EAAW,EAAQ,IACrBzE,EAAW,EAAQ,GACnB0E,EAAW,EAAQ,IAMjBC,EAAa,qBAGbC,EAAa,aAGbC,EAAY,cAGZC,EAAeC,SA2CnBrH,EAAOD,QAlBP,SAAkBmB,GAChB,GAAoB,iBAATA,EACT,OAAOA,EAET,GAAI8F,EAAS9F,GACX,OA1CM,IA4CR,GAAIoB,EAASpB,GAAQ,CACnB,IAAIoG,EAAgC,mBAAjBpG,EAAMqG,QAAwBrG,EAAMqG,UAAYrG,EACnEA,EAAQoB,EAASgF,GAASA,EAAQ,GAAKA,CACzC,CACA,GAAoB,iBAATpG,EACT,OAAiB,IAAVA,EAAcA,GAASA,EAEhCA,EAAQ6F,EAAS7F,GACjB,IAAIsG,EAAWN,EAAWO,KAAKvG,GAC/B,OAAOsG,GAAYL,EAAUM,KAAKvG,GAASkG,EAAalG,EAAMwF,MAAM,GAAIc,EAAW,EAAI,GAAKP,EAAWQ,KAAKvG,GArDpG,KAqDoHA,CAC9H,C,kBC3DA,IAAIwG,EAAkB,EAAQ,IAG1BC,EAAc,OAYlB3H,EAAOD,QAHP,SAAkB6H,GAChB,OAAOA,EAASA,EAAOlB,MAAM,EAAGgB,EAAgBE,GAAU,GAAGC,QAAQF,EAAa,IAAMC,CAC1F,C,gBCbA,IAAIE,EAAe,KAenB9H,EAAOD,QALP,SAAyB6H,GAEvB,IADA,IAAIrB,EAAQqB,EAAOtB,OACZC,KAAWuB,EAAaL,KAAKG,EAAOG,OAAOxB,MAClD,OAAOA,CACT,C,kBCfA,IAAIyB,EAAa,EAAQ,IACvBC,EAAe,EAAQ,IAyBzBjI,EAAOD,QAHP,SAAkBmB,GAChB,MAAuB,iBAATA,GAAqB+G,EAAa/G,IApBlC,mBAoB4C8G,EAAW9G,EACvE,C,kBCzBA,IAAIF,EAAS,EAAQ,GACnBkH,EAAY,EAAQ,IACpBC,EAAiB,EAAQ,IAOvBC,EAAiBpH,EAASA,EAAOC,iBAAc+C,EAenDhE,EAAOD,QANP,SAAoBmB,GAClB,OAAa,MAATA,OACe8C,IAAV9C,EAdM,qBADH,gBAiBLkH,GAAkBA,KAAkBzH,OAAOO,GAASgH,EAAUhH,GAASiH,EAAejH,EAC/F,C,kBCvBA,IAAIF,EAAS,EAAQ,GAGjBqH,EAAc1H,OAAOkB,UAGrBC,EAAiBuG,EAAYvG,eAO7BwG,EAAuBD,EAAYE,SAGnCH,EAAiBpH,EAASA,EAAOC,iBAAc+C,EA0BnDhE,EAAOD,QAjBP,SAAmBmB,GACjB,IAAIsH,EAAQ1G,EAAe1B,KAAKc,EAAOkH,GACrCK,EAAMvH,EAAMkH,GACd,IACElH,EAAMkH,QAAkBpE,EACxB,IAAI0E,GAAW,CACJ,CAAX,MAAOtG,GAAI,CACb,IAAIgB,EAASkF,EAAqBlI,KAAKc,GAQvC,OAPIwH,IACEF,EACFtH,EAAMkH,GAAkBK,SAEjBvH,EAAMkH,IAGVhF,CACT,C,gBCxCA,IAOIkF,EAPc3H,OAAOkB,UAOc0G,SAYvCvI,EAAOD,QAHP,SAAwBmB,GACtB,OAAOoH,EAAqBlI,KAAKc,EACnC,C,gBCQAlB,EAAOD,QAHP,SAAsBmB,GACpB,OAAgB,MAATA,GAAiC,iBAATA,CACjC,C,uBC1BA,IAAIyH,EAAW,EAAQ,GACrBrG,EAAW,EAAQ,GAiErBtC,EAAOD,QAhBP,SAAkB+C,EAAMC,EAAMC,GAC5B,IAAIQ,GAAU,EACZE,GAAW,EACb,GAAmB,mBAARZ,EACT,MAAM,IAAIa,UAlDQ,uBAwDpB,OAJIrB,EAASU,KACXQ,EAAU,YAAaR,IAAYA,EAAQQ,QAAUA,EACrDE,EAAW,aAAcV,IAAYA,EAAQU,SAAWA,GAEnDiF,EAAS7F,EAAMC,EAAM,CAC1B,QAAWS,EACX,QAAWT,EACX,SAAYW,GAEhB,C,6gBChEA,IAEMkF,EAAmB,WACvB,WAAYC,GAAK,IAAD,Q,4FAAA,SACd3G,KAAK2G,GAAKA,EACV3G,KAAK4G,aAAeC,SAASC,cAAc,sBAC3C9G,KAAK+G,gBAAkBF,SAASG,iBAAiB,oBAGjDhH,KAAKiH,eAAiB9G,OAAO+G,WAAW,sBAGxClH,KAAKiH,eAAeE,aAAY,SAAAC,GAC1BA,EAAIC,SACN,EAAKC,MAET,IAGItH,KAAKiH,eAAeI,SACtBrH,KAAKsH,MAET,C,UA6BC,O,EA7BA,G,EAAA,mBAED,WAAQ,IAAD,OACLtH,KAAK2G,GAAGY,iBAAiB,SAAS,SAAAH,GAChCA,EAAII,iBACJ,EAAKC,aAAaL,EAAIM,cAAcC,KACtC,GACF,GAAC,0BAED,SAAaC,GAAa,IAAD,OACnBC,EAAWD,EAAWjC,QAAQ,IAAK,IAGnCmC,GAAc,EAElB9H,KAAK+G,gBAAgBgB,SAAQ,SAAAC,GACtBF,EAUHE,EAAMC,UAAUC,OAAO,aATvBF,EAAMC,UAAUE,IAAI,YAEhBH,EAAMI,IAAMP,IACdC,GAAc,EAGd,EAAKlB,aAAayB,UAAYL,EAAMM,WAK1C,GACF,M,8EAAC,EAjDsB,GAqDzBzB,SAASG,iBAAiB,6BAA6Be,SAAQ,SAAApB,GAAE,OAAI,IAAID,EAAoBC,EAAG,G,iBChDhG,WACE,aAGA,GAAsB,kBAAXxG,OAMX,GAAI,yBAA0BA,QAAU,8BAA+BA,QAAU,sBAAuBA,OAAOoI,0BAA0B5I,UAGjI,mBAAoBQ,OAAOoI,0BAA0B5I,WACzDlB,OAAOC,eAAeyB,OAAOoI,0BAA0B5I,UAAW,iBAAkB,CAClFf,IAAK,WACH,OAAOoB,KAAKwI,kBAAoB,CAClC,QAPN,CAgBA,IAAI3B,EAAW1G,OAAO0G,SAQlB4B,EAAW,GAwEfC,EAAqB/I,UAAUgJ,iBAAmB,IAOlDD,EAAqB/I,UAAUiJ,cAAgB,KAM/CF,EAAqB/I,UAAUkJ,uBAAwB,EAOvDH,EAAqB/I,UAAUmJ,QAAU,SAAUC,GAIjD,IAH8B/I,KAAKgJ,oBAAoBC,MAAK,SAAUC,GACpE,OAAOA,EAAKC,SAAWJ,CACzB,IACA,CAGA,IAAMA,GAA6B,GAAnBA,EAAOK,SACrB,MAAM,IAAIC,MAAM,6BAElBrJ,KAAKsJ,oBACLtJ,KAAKgJ,oBAAoBjF,KAAK,CAC5BoF,QAASJ,EACTQ,MAAO,OAETvJ,KAAKwJ,wBACLxJ,KAAKyJ,wBAVL,CAWF,EAMAf,EAAqB/I,UAAU+J,UAAY,SAAUX,GACnD/I,KAAKgJ,oBAAsBhJ,KAAKgJ,oBAAoBW,QAAO,SAAUT,GACnE,OAAOA,EAAKC,SAAWJ,CACzB,IACK/I,KAAKgJ,oBAAoB5E,SAC5BpE,KAAK4J,0BACL5J,KAAK6J,sBAET,EAKAnB,EAAqB/I,UAAUmK,WAAa,WAC1C9J,KAAKgJ,oBAAsB,GAC3BhJ,KAAK4J,0BACL5J,KAAK6J,qBACP,EAQAnB,EAAqB/I,UAAUoK,YAAc,WAC3C,IAAIC,EAAUhK,KAAKiK,eAAezF,QAElC,OADAxE,KAAKiK,eAAiB,GACfD,CACT,EAWAtB,EAAqB/I,UAAUuK,gBAAkB,SAAUC,GACzD,IAAIC,EAAYD,GAAiB,CAAC,GAElC,OADKE,MAAMC,QAAQF,KAAYA,EAAY,CAACA,IACrCA,EAAUG,OAAOZ,QAAO,SAAU1K,EAAGlB,EAAGyM,GAC7C,GAAgB,iBAALvL,GAAiBwL,MAAMxL,IAAMA,EAAI,GAAKA,EAAI,EACnD,MAAM,IAAIoK,MAAM,0DAElB,OAAOpK,IAAMuL,EAAEzM,EAAI,EACrB,GACF,EAaA2K,EAAqB/I,UAAU+K,iBAAmB,SAAUC,GAC1D,IACIC,GADeD,GAAkB,OACVE,MAAM,OAAOC,KAAI,SAAUC,GACpD,IAAIC,EAAQ,wBAAwBC,KAAKF,GACzC,IAAKC,EACH,MAAM,IAAI3B,MAAM,qDAElB,MAAO,CACLrK,MAAOkM,WAAWF,EAAM,IACxBG,KAAMH,EAAM,GAEhB,IAMA,OAHAJ,EAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GACnCA,EAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GACnCA,EAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GAC5BA,CACT,EAOAlC,EAAqB/I,UAAU6J,sBAAwB,WAChDxJ,KAAKoL,2BACRpL,KAAKoL,0BAA2B,EAI5BpL,KAAK4I,cACP5I,KAAKqL,oBAAsBC,YAAYtL,KAAKyJ,uBAAwBzJ,KAAK4I,gBAEzE2C,EAASpL,OAAQ,SAAUH,KAAKyJ,wBAAwB,GACxD8B,EAAS1E,EAAU,SAAU7G,KAAKyJ,wBAAwB,GACtDzJ,KAAK6I,uBAAyB,qBAAsB1I,SACtDH,KAAKwL,aAAe,IAAIC,iBAAiBzL,KAAKyJ,wBAC9CzJ,KAAKwL,aAAa1C,QAAQjC,EAAU,CAClC6E,YAAY,EACZC,WAAW,EACXC,eAAe,EACfC,SAAS,MAKnB,EAMAnD,EAAqB/I,UAAUiK,wBAA0B,WACnD5J,KAAKoL,2BACPpL,KAAKoL,0BAA2B,EAChCU,cAAc9L,KAAKqL,qBACnBrL,KAAKqL,oBAAsB,KAC3BU,EAAY5L,OAAQ,SAAUH,KAAKyJ,wBAAwB,GAC3DsC,EAAYlF,EAAU,SAAU7G,KAAKyJ,wBAAwB,GACzDzJ,KAAKwL,eACPxL,KAAKwL,aAAa1B,aAClB9J,KAAKwL,aAAe,MAG1B,EAQA9C,EAAqB/I,UAAU8J,uBAAyB,WACtD,IAAIuC,EAAchM,KAAKiM,eACnBC,EAAWF,EAAchM,KAAKmM,eA+T3B,CACLC,IAAK,EACLC,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPC,MAAO,EACPC,OAAQ,GApUVzM,KAAKgJ,oBAAoBjB,SAAQ,SAAUmB,GACzC,IAAIH,EAASG,EAAKC,QACduD,EAAaC,EAAsB5D,GACnC6D,EAAqB5M,KAAK6M,oBAAoB9D,GAC9C+D,EAAW5D,EAAKK,MAChBwD,EAAmBf,GAAeY,GAAsB5M,KAAKgN,kCAAkCjE,EAAQmD,GACvGe,EAAW/D,EAAKK,MAAQ,IAAIhB,EAA0B,CACxD5G,KAqMGxB,OAAO+M,aAAeA,YAAY7M,KAAO6M,YAAY7M,MApMxD0I,OAAQA,EACRoE,mBAAoBT,EACpBU,WAAYlB,EACZa,iBAAkBA,IAEfD,EAEMd,GAAeY,EAGpB5M,KAAKqN,qBAAqBP,EAAUG,IACtCjN,KAAKiK,eAAelG,KAAKkJ,GAMvBH,GAAYA,EAASQ,gBACvBtN,KAAKiK,eAAelG,KAAKkJ,GAZ3BjN,KAAKiK,eAAelG,KAAKkJ,EAe7B,GAAGjN,MACCA,KAAKiK,eAAe7F,QACtBpE,KAAKuN,UAAUvN,KAAK+J,cAAe/J,KAEvC,EAcA0I,EAAqB/I,UAAUqN,kCAAoC,SAAUjE,EAAQmD,GAEnF,GAA+C,QAA3C/L,OAAOqN,iBAAiBzE,GAAQ0E,QAApC,CAKA,IAJA,IAwN+BC,EAAOC,EAClCvB,EACAC,EACAC,EACAC,EACAC,EACAC,EA7NAM,EADaJ,EAAsB5D,GAEnC6E,EAASC,EAAc9E,GACvB+E,GAAS,GACLA,GAAQ,CACd,IAAIC,EAAa,KACbC,EAAyC,GAAnBJ,EAAOxE,SAAgBjJ,OAAOqN,iBAAiBI,GAAU,CAAC,EAGpF,GAAmC,QAA/BI,EAAoBP,QAAmB,OAgB3C,GAfIG,GAAU5N,KAAKoD,MAAQwK,GAAU/G,GACnCiH,GAAS,EACTC,EAAa7B,GAMT0B,GAAU/G,EAASoH,MAAQL,GAAU/G,EAASqH,iBAAmD,WAAhCF,EAAoBG,WACvFJ,EAAapB,EAAsBiB,IAMnCG,IA+LyBL,EA9LgBK,EA8LTJ,EA9LqBZ,EA+LvDX,SACAC,SACAC,SACAC,SACAC,SACAC,SALAL,EAAM5L,KAAKC,IAAIiN,EAAMtB,IAAKuB,EAAMvB,KAChCC,EAAS7L,KAAKG,IAAI+M,EAAMrB,OAAQsB,EAAMtB,QACtCC,EAAO9L,KAAKC,IAAIiN,EAAMpB,KAAMqB,EAAMrB,MAClCC,EAAQ/L,KAAKG,IAAI+M,EAAMnB,MAAOoB,EAAMpB,OAEpCE,EAASJ,EAASD,IApMlBW,GAmMAP,EAAQD,EAAQD,IAEJ,GAAKG,GAAU,GAAK,CAClCL,IAAKA,EACLC,OAAQA,EACRC,KAAMA,EACNC,MAAOA,EACPC,MAAOA,EACPC,OAAQA,KA1MiB,MAEzBmB,EAASC,EAAcD,EACzB,CACA,OAAOb,CAhCsD,CAiC/D,EAOArE,EAAqB/I,UAAUwM,aAAe,WAC5C,IAAID,EACJ,GAAIlM,KAAKoD,KACP8I,EAAWS,EAAsB3M,KAAKoD,UACjC,CAEL,IAAIgL,EAAOvH,EAASqH,gBAChBD,EAAOpH,EAASoH,KACpB/B,EAAW,CACTE,IAAK,EACLE,KAAM,EACNC,MAAO6B,EAAKC,aAAeJ,EAAKI,YAChC7B,MAAO4B,EAAKC,aAAeJ,EAAKI,YAChChC,OAAQ+B,EAAKE,cAAgBL,EAAKK,aAClC7B,OAAQ2B,EAAKE,cAAgBL,EAAKK,aAEtC,CACA,OAAOtO,KAAKuO,wBAAwBrC,EACtC,EAQAxD,EAAqB/I,UAAU4O,wBAA0B,SAAUC,GACjE,IAAI5D,EAAU5K,KAAKyO,kBAAkB3D,KAAI,SAAUC,EAAQhN,GACzD,MAAsB,MAAfgN,EAAOI,KAAeJ,EAAO/L,MAAQ+L,EAAO/L,OAASjB,EAAI,EAAIyQ,EAAKhC,MAAQgC,EAAK/B,QAAU,GAClG,IACIiC,EAAU,CACZtC,IAAKoC,EAAKpC,IAAMxB,EAAQ,GACxB2B,MAAOiC,EAAKjC,MAAQ3B,EAAQ,GAC5ByB,OAAQmC,EAAKnC,OAASzB,EAAQ,GAC9B0B,KAAMkC,EAAKlC,KAAO1B,EAAQ,IAI5B,OAFA8D,EAAQlC,MAAQkC,EAAQnC,MAAQmC,EAAQpC,KACxCoC,EAAQjC,OAASiC,EAAQrC,OAASqC,EAAQtC,IACnCsC,CACT,EAYAhG,EAAqB/I,UAAU0N,qBAAuB,SAAUP,EAAUG,GAGxE,IAAI0B,EAAW7B,GAAYA,EAASQ,eAAiBR,EAAStE,mBAAqB,GAAK,EACpFoG,EAAW3B,EAASK,eAAiBL,EAASzE,mBAAqB,GAAK,EAG5E,GAAImG,IAAaC,EACjB,IAAK,IAAI7Q,EAAI,EAAGA,EAAIiC,KAAK6O,WAAWzK,OAAQrG,IAAK,CAC/C,IAAIqM,EAAYpK,KAAK6O,WAAW9Q,GAIhC,GAAIqM,GAAauE,GAAYvE,GAAawE,GAAYxE,EAAYuE,IAAavE,EAAYwE,EACzF,OAAO,CAEX,CACF,EAOAlG,EAAqB/I,UAAUsM,aAAe,WAC5C,OAAQjM,KAAKoD,MAAQ0L,EAAajI,EAAU7G,KAAKoD,KACnD,EAQAsF,EAAqB/I,UAAUkN,oBAAsB,SAAU9D,GAC7D,OAAO+F,EAAa9O,KAAKoD,MAAQyD,EAAUkC,EAC7C,EAOAL,EAAqB/I,UAAU2J,kBAAoB,WAC7Cb,EAAS3E,QAAQ9D,MAAQ,GAC3ByI,EAAS1E,KAAK/D,KAElB,EAMA0I,EAAqB/I,UAAUkK,oBAAsB,WACnD,IAAIxF,EAAQoE,EAAS3E,QAAQ9D,OACf,GAAVqE,GAAaoE,EAASnE,OAAOD,EAAO,EAC1C,EAwKAlE,OAAOuI,qBAAuBA,EAC9BvI,OAAOoI,0BAA4BA,CAvnBnC,CAqBA,SAASA,EAA0BgB,GACjCvJ,KAAK2B,KAAO4H,EAAM5H,KAClB3B,KAAK+I,OAASQ,EAAMR,OACpB/I,KAAKoN,WAAa7D,EAAM6D,WACxBpN,KAAKmN,mBAAqB5D,EAAM4D,mBAChCnN,KAAK+M,iBAAmBxD,EAAMwD,kBA8iBvB,CACLX,IAAK,EACLC,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPC,MAAO,EACPC,OAAQ,GAnjBVzM,KAAKsN,iBAAmB/D,EAAMwD,iBAG9B,IAAIL,EAAa1M,KAAKmN,mBAClB4B,EAAarC,EAAWF,MAAQE,EAAWD,OAC3CM,EAAmB/M,KAAK+M,iBACxBiC,EAAmBjC,EAAiBP,MAAQO,EAAiBN,OAM/DzM,KAAKwI,kBAHHuG,EAGuBE,QAAQD,EAAmBD,GAAYG,QAAQ,IAG/ClP,KAAKsN,eAAiB,EAAI,CAEvD,CAWA,SAAS5E,EAAqByG,EAAUC,GACtC,IAyagBC,EAAIC,EAChBC,EA1aAzO,EAAUsO,GAAe,CAAC,EAC9B,GAAuB,mBAAZD,EACT,MAAM,IAAI9F,MAAM,+BAElB,GAAIvI,EAAQsC,MAAiC,GAAzBtC,EAAQsC,KAAKgG,SAC/B,MAAM,IAAIC,MAAM,2BAIlBrJ,KAAKyJ,wBAgaW4F,EAhauBrP,KAAKyJ,uBAAuBlK,KAAKS,MAgapDsP,EAha2DtP,KAAK2I,iBAiahF4G,EAAQ,KACL,WACAA,IACHA,EAAQtN,YAAW,WACjBoN,IACAE,EAAQ,IACV,GAAGD,GAEP,GAtaAtP,KAAKuN,UAAY4B,EACjBnP,KAAKgJ,oBAAsB,GAC3BhJ,KAAKiK,eAAiB,GACtBjK,KAAKyO,kBAAoBzO,KAAK0K,iBAAiB5J,EAAQ0O,YAGvDxP,KAAK6O,WAAa7O,KAAKkK,gBAAgBpJ,EAAQsJ,WAC/CpK,KAAKoD,KAAOtC,EAAQsC,MAAQ,KAC5BpD,KAAKwP,WAAaxP,KAAKyO,kBAAkB3D,KAAI,SAAUC,GACrD,OAAOA,EAAO/L,MAAQ+L,EAAOI,IAC/B,IAAGsE,KAAK,IACV,CAsaA,SAASlE,EAASmE,EAAMC,EAAON,EAAIO,GACG,mBAAzBF,EAAKnI,iBACdmI,EAAKnI,iBAAiBoI,EAAON,EAAIO,IAAkB,GACf,mBAApBF,EAAKG,aACrBH,EAAKG,YAAY,KAAOF,EAAON,EAEnC,CAUA,SAAStD,EAAY2D,EAAMC,EAAON,EAAIO,GACG,mBAA5BF,EAAKI,oBACdJ,EAAKI,oBAAoBH,EAAON,EAAIO,IAAkB,GACjB,mBAArBF,EAAKK,cACrBL,EAAKK,aAAa,KAAOJ,EAAON,EAEpC,CA+BA,SAAS1C,EAAsBhG,GAC7B,IAAI6H,EACJ,IACEA,EAAO7H,EAAGgG,uBAIZ,CAHE,MAAOqD,GAGT,CACA,OAAKxB,GAGCA,EAAKhC,OAASgC,EAAK/B,SACvB+B,EAAO,CACLpC,IAAKoC,EAAKpC,IACVG,MAAOiC,EAAKjC,MACZF,OAAQmC,EAAKnC,OACbC,KAAMkC,EAAKlC,KACXE,MAAOgC,EAAKjC,MAAQiC,EAAKlC,KACzBG,OAAQ+B,EAAKnC,OAASmC,EAAKpC,MAGxBoC,GASA,CACLpC,IAAK,EACLC,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPC,MAAO,EACPC,OAAQ,EAdZ,CAyBA,SAASqC,EAAalB,EAAQqC,GAE5B,IADA,IAAIP,EAAOO,EACJP,GAAM,CACX,GAAIA,GAAQ9B,EAAQ,OAAO,EAC3B8B,EAAO7B,EAAc6B,EACvB,CACA,OAAO,CACT,CAQA,SAAS7B,EAAc6B,GACrB,IAAI9B,EAAS8B,EAAKQ,WAClB,OAAItC,GAA6B,IAAnBA,EAAOxE,UAAkBwE,EAAOuC,KAErCvC,EAAOuC,KAEZvC,GAAUA,EAAOwC,aAEZxC,EAAOwC,aAAaF,WAEtBtC,CACT,CAKD,CA7oBD,E,wFCLa,kfAEuC,IAE9CyC,EAAkB,WACtB,WAAY1J,GAAK,IAAD,QALL,4FAKK,SACd3G,KAAK2G,GAAKA,EAEV3G,KAAKiH,eAAiB9G,OAAO+G,WAAW,sBACxClH,KAAKsQ,UAAYzJ,SAAS0J,eAAevQ,KAAK2G,GAAG6J,aAAa,iBAE9DxQ,KAAKyQ,UAAY,eAAgBtQ,OAAS,WAAa,QAEvDH,KAAK0Q,YAAc1Q,KAAK2Q,mBAAmBpR,KAAKS,MAGhDA,KAAKiH,eAAeE,aAAY,SAAAC,GAC1BA,EAAIC,QACN,EAAKC,OAEL,EAAKsJ,SAET,IAGI5Q,KAAKiH,eAAeI,SACtBrH,KAAKsH,MAET,CA5BW,UA4CV,OA5CU,EA4BV,GA5BU,EA4BV,iCAED,SAAmBF,GACZA,EAAI2B,OAAO8H,QAAQ,+BACtB7Q,KAAK8Q,aAAaC,UAEtB,GAAC,kBAED,WACE/Q,KAAK8Q,aAAe,IAAIE,IAAahR,KAAK2G,IAC1CxG,OAAOoH,iBAAiBvH,KAAKyQ,UAAWzQ,KAAK0Q,YAC/C,GAAC,qBAED,WACE1Q,KAAK8Q,aAAaF,UAClBzQ,OAAO2P,oBAAoB9P,KAAKyQ,UAAWzQ,KAAK0Q,YAClD,MA5CW,8EA4CV,EAxCqB,GA4CxB7J,SAASG,iBAAiB,4CAA4Ce,SAAQ,SAAApB,GAAE,OAAI,IAAI0J,EAAmB1J,EAAG,I,6BClCjG,0sEAIb,IASqBsK,EAAK,aAbb,sRAaa,UAbb,MAaa,OACxB,WAAYtK,EAAIuK,GAAO,IAAD,EA8ER,OA5FH,4FAcW,UAGpB,gBAGKpQ,QAAUrC,OAAO0S,OACpB,CAAC,EACD,CACEC,gBAAiB,IACjBC,cAAe,GACfC,kBAAmB,gBACnBC,QAAS,MAEXL,GAGE,EAAKpQ,QAAQuQ,cAAcjN,SAEzB,EAAKtD,QAAQuQ,cAAcvN,QAAQ,MAAQ,EAG7C,EAAKhD,QAAQuQ,cAAgB,EAAKvQ,QAAQuQ,cACvCxG,MAAM,KACNlB,QAAO,SAAAnK,GAAC,OAAIA,EAAE4E,MAAM,IAIvB,EAAKtD,QAAQuQ,cAAgB,CAAC,EAAKvQ,QAAQuQ,gBAI/C,EAAK1K,GAAKA,EACV,EAAKA,GAAGsB,UAAUE,IAAI,WACtB,EAAKqJ,QAAS,EACd,EAAKC,YAAa,EAClB,EAAKnB,UAAY,EAAK3J,GAAGG,cAAc,kBACvC,EAAK4K,gBAAkB,EAAK/K,GAAGG,cAAc,IAAM,EAAKhG,QAAQwQ,oBAAsB,EAAKhB,UAC3F,EAAKqB,SAAW,EAAKhL,GAAGK,iBAAiB,sBAGrC,EAAKL,GAAGyB,IACV,EAAKwJ,UAAY/K,SAASG,iBAAiB,gBAAD,OACxB,EAAKL,GAAGyB,GAAE,OAE5B,EAAKqJ,aAAe,EAAKG,UAAUxN,QAInC,EAAKuC,GAAGyB,GAAK5H,KAAKqR,SACfxL,SAAS,IACTyL,OAAO,EAAG,GAIf,EAAKC,cAAgB,KAGrB,EAAKC,aAAe,EAAKC,kBAGrB,EAAKD,aAAa5N,SACpB,EAAK8N,iBAAmB,EAAKF,aAAa,GAC1C,EAAKG,gBAAkB,EAAKH,aAAa,EAAKA,aAAa5N,OAAS,IAKnE,EAAKuC,GAAG6J,aAAa,eACrB,EAAK7J,GAAG6J,aAAa,oBAEtB4B,QAAQC,KACN,0GACA,EAAK1L,IAKT,EAAKW,OAAO,CACd,CAmWC,OAhcU,EA6FV,GA7FU,EA6FV,mBAED,WAAQ,IAAD,OAELtH,KAAK2G,GAAG2L,aAAa,cAAe,QACpCtS,KAAK2G,GAAG2L,aAAa,OAAQ,UAGzBtS,KAAKyR,YACPzR,KAAK4R,UAAU7J,SAAQ,SAAAwK,GAGrBA,EAASD,aAAa,gBAAiB,EAAK3L,GAAGyB,IAC/CmK,EAASD,aAAa,gBAAiB,SACvCC,EAASD,aAAa,OAAQ,SAChC,IAIEtS,KAAK2R,SAASvN,QAChBpE,KAAK2R,SAAS5J,SAAQ,SAAAyK,GACpBA,EAAQF,aAAa,OAAQ,SAC/B,IAIFtS,KAAKyS,aAG+B,oBAAzBzS,KAAKc,QAAQyQ,SACtBvR,KAAKc,QAAQyQ,SAWjB,GAAC,qBAED,WAEEvR,KAAK2G,GAAG+L,gBAAgB,eACxB1S,KAAK2G,GAAG+L,gBAAgB,QACxB1S,KAAK2G,GAAG+L,gBAAgB,YAGpB1S,KAAKyR,YACPzR,KAAK4R,UAAU7J,SAAQ,SAAAwK,GACrBA,EAASG,gBAAgB,iBACzBH,EAASG,gBAAgB,iBACzBH,EAASG,gBAAgB,OAC3B,IAIE1S,KAAK2R,SAASvN,QAChBpE,KAAK2R,SAAS5J,SAAQ,SAAAyK,GACpBA,EAAQE,gBAAgB,cACxBF,EAAQE,gBAAgB,OAC1B,IAIF1S,KAAK2S,eAGL3S,KAAKuE,UAAU,UACjB,GAIA,6BACA,WAAmB,IAAD,OACZyN,EAAehS,KAAK2G,GAAGK,iBACzB,wIAaF,OATAgL,EAAY,EAAOA,GAGfhS,KAAK2G,GAAGG,cAAc,YACxBkL,EAAeA,EAAarI,QAC1B,SAAAhD,GAAE,OAAIA,EAAGkK,QAAQ,UAAU+B,WAAW,EAAKjM,GAAG,KAI3CqL,CACT,GAIA,0BACA,WACE,OACEnL,SAASgM,YACThM,SAASiM,gBAAkBjM,SAASoH,MACpCpH,SAASiM,gBAAkBjM,SAASqH,gBAE7BrH,SAASiM,cAGX,IACT,GAAC,wBAED,SAAWnM,GAMTxG,OAAO8B,YAAW,kBAAM0E,EAAGoM,OAAO,GAAE/S,KAAKc,QAAQsQ,gBACnD,GAAC,gCAED,SAAmBhK,GACjB,IAAKpH,KAAKwR,OACR,OAAO,EAIT,IAAIwB,EAAW3I,MAAM1K,UAAUmE,QAAQ5F,KAAK8B,KAAK4R,UAAWxK,EAAI2B,OAAO8H,QAAQ,kBAAoB,EAE/FoC,EAAsBjT,KAAK0R,iBAAmB1R,KAAK0R,gBAAgBwB,SAAS9L,EAAI2B,QAEhFoK,EAAkBnT,KAAK0R,gBAAgBkB,WAAWxL,EAAI2B,QAGvDiK,GACCC,GAAuBE,GAEzBnT,KAAKoT,MAAMhM,EAEf,GAAC,4BAED,SAAeA,GACb,IAAKpH,KAAKwR,OACR,OAAO,EAST,GALkB,KAAdpK,EAAIiM,OACNrT,KAAKoT,MAAMhM,GAIK,IAAdA,EAAIiM,MAAa,CAEnB,IAAKrT,KAAKgS,aAAa5N,OAErB,OADApE,KAAKoT,MAAMhM,IACJ,EAIT,IAAIkM,EAAYtT,KAAKuT,gBAGhBnM,EAAIoM,UAAYF,EAAUV,WAAW5S,KAAKmS,kBAE7C/K,EAAII,iBACJxH,KAAKkS,iBAAiBa,SAGtB3L,EAAIoM,WAEFF,EAAUV,WAAW5S,KAAKkS,mBAC1BoB,EAAUV,WAAW5S,KAAKsQ,cAG5BlJ,EAAII,iBACJxH,KAAKmS,gBAAgBY,QAEzB,CACF,GAAC,wBAED,WAAc,IAAD,OAEP/S,KAAKyR,aAGPzR,KAAKyT,YAAczT,KAAK0T,OAAOnU,KAAKS,MAEpCA,KAAK4R,UAAU7J,SAAQ,SAAAwK,GACrBA,EAAShL,iBAAiB,QAAS,EAAKkM,YAC1C,KAIEzT,KAAK2R,SAASvN,SAGhBpE,KAAK2T,WAAa3T,KAAKoT,MAAM7T,KAAKS,MAElCA,KAAK2R,SAAS5J,SAAQ,SAAAyK,GAEhBA,EAAQ3B,QAAQ,UAAU+B,WAAW,EAAKjM,KAC5C6L,EAAQjL,iBAAiB,QAAS,EAAKoM,WAE3C,KAIF3T,KAAK0Q,YAAc1Q,KAAK2Q,mBAAmBpR,KAAKS,MAChDG,OAAOoH,iBAAiB,QAASvH,KAAK0Q,aAGtC1Q,KAAK4T,QAAU5T,KAAK6T,eAAetU,KAAKS,MACxCG,OAAOoH,iBAAiB,UAAWvH,KAAK4T,QAC1C,GAAC,0BAED,WAAgB,IAAD,OAET5T,KAAKyR,YACPzR,KAAK4R,UAAU7J,SAAQ,SAAAwK,GACrBA,EAASzC,oBAAoB,QAAS,EAAK2D,YAC7C,IAIEzT,KAAK2R,SAASvN,QAChBpE,KAAK2R,SAAS5J,SAAQ,SAAAyK,GACpBA,EAAQ1C,oBAAoB,QAAS,EAAK6D,WAC5C,IAIFxT,OAAO2P,oBAAoB,QAAS9P,KAAK0Q,aACzCvQ,OAAO2P,oBAAoB,UAAW9P,KAAK4T,QAC7C,GAEA,kBACA,SAAKxM,GAAM,IAuB8B,EAvB/B,OACR,GAAIpH,KAAKwR,OACP,OAAO,EAGTpK,EAAII,iBAGJxH,KAAK+R,cAAgB/R,KAAKuT,eAG1BO,IAAOC,SAIH/T,KAAKsQ,YACPtQ,KAAKsQ,UAAUjI,UAAY,GAI7BrI,KAAK2G,GAAG2L,aAAa,cAAe,SAGhCtS,KAAKc,QAAQuQ,cAAcjN,SAC7B,EAAApE,KAAK2G,GAAGsB,WAAUE,IAAG,UAAInI,KAAKc,QAAQuQ,gBAIpCrR,KAAKyR,YACPzR,KAAK4R,UAAU7J,SAAQ,SAAAwK,GAImB,IAAD,EAHvCA,EAASD,aAAa,gBAAiB,QAGnC,EAAKxR,QAAQuQ,cAAcjN,SAC7B,EAAAmO,EAAStK,WAAUE,IAAG,UAAI,EAAKrH,QAAQuQ,eAE3C,IAIErR,KAAKsQ,WACPtQ,KAAKsQ,UAAUgC,aAAa,WAAY,MACxCtS,KAAKgU,WAAWhU,KAAKsQ,aAErBtQ,KAAK2G,GAAG2L,aAAa,WAAY,MACjCtS,KAAKgU,WAAWhU,KAAK2G,KAYvB3G,KAAKwR,QAAS,EAGdxR,KAAKuE,UAAU,OACjB,GAEA,mBACA,SAAM6C,GAAM,IAgB6B,EAhB9B,OACT,IAAKpH,KAAKwR,OACR,OAAO,EAGTpK,EAAII,iBAQJxH,KAAK2G,GAAG2L,aAAa,cAAe,QAGhCtS,KAAKc,QAAQuQ,cAAcjN,SAC7B,EAAApE,KAAK2G,GAAGsB,WAAUC,OAAM,UAAIlI,KAAKc,QAAQuQ,gBAIvCrR,KAAKyR,YACPzR,KAAK4R,UAAU7J,SAAQ,SAAAwK,GAImB,IAAD,EAHvCA,EAASD,aAAa,gBAAiB,SAGnC,EAAKxR,QAAQuQ,cAAcjN,SAC7B,EAAAmO,EAAStK,WAAUC,OAAM,UAAI,EAAKpH,QAAQuQ,eAE9C,IAIFyC,IAAOG,WAGHjU,KAAK+R,cACP/R,KAAKgU,WAAWhU,KAAK+R,eACZ/R,KAAKyR,YAEdzR,KAAKgU,WAAWhU,KAAK4R,UAAU,IAIjC5R,KAAKwR,QAAS,EAGdxR,KAAKuE,UAAU,QACjB,GAEA,oBACA,SAAO6C,GACDpH,KAAKwR,OACPxR,KAAKoT,MAAMhM,GAEXpH,KAAKkU,KAAK9M,EAEd,MAhcW,8EAgcV,EAnbuB,C,OAAS+M,G,kfC3BD,IAE5BC,EAAc,WAClB,WAAYzN,GAAK,IAAD,Q,4FAAA,SAEd3G,KAAKqU,YAAc,WACnBrU,KAAKsU,WAAazN,SAASG,iBAAiB,wBAE5ChH,KAAKuU,OAAS1N,SAASG,iBAAiB,sCACxChH,KAAKwU,MAAQ,IAAIvD,EAAMtK,GAEvB3G,KAAKwU,MAAMhR,GAAG,SAAS,WACrB,EAAKiR,OACP,IAGAzU,KAAKsU,WAAWvM,SAAQ,SAAApB,GACtBA,EAAGY,iBAAiB,SAAS,SAAAH,GAC3BA,EAAII,iBACJ,EAAKgN,MAAMpB,MAAMhM,GAEjB,IAAIsN,EAAWtN,EAAIM,cACfiN,EAAe9N,SAASC,cAAc4N,EAAS/M,MAE/CgN,GAEF1S,YAAW,WACT0S,EAAaC,gBACf,GAAG,IAEP,GACF,GACF,C,UAOC,O,EALD,G,EAAA,oBACA,WAAS,IAAD,OACN5U,KAAKuU,OAAOxM,SAAQ,SAAApB,GAClBA,EAAGsB,UAAUC,OAAO,EAAKmM,YAC3B,GACF,M,8EAAC,EArCiB,GAwCd1N,EAAKE,SAASC,cAAc,cAElC,GAAIH,EACU,IAAIyN,EAAezN,GC3CjCE,SAASG,iBAAiB,0BAA0Be,SAAQ,SAAApB,GAAE,OAAI,IAAIsK,EAAMtK,EAAG,I,6gBCQxC,IAEjCkO,EAAS,WACb,WAAYN,GAAS,IAAD,Q,4FAAA,SAClBvU,KAAKuU,OAASA,EACdvU,KAAK4G,aAAeC,SAASC,cAAc,qBAC3C9G,KAAK8U,gBAAkBjO,SAASG,iBAAiB,6BAGjDhH,KAAK+U,SAAW,GAChB/U,KAAKuU,OAAOxM,SAAQ,SAAApB,GAClB,IAAIqO,EAAgBrO,EAAGG,cAAc,4BACjCkO,GACF,EAAKD,SAAShR,KAAKiR,EAEvB,IAGAhV,KAAKiH,eAAiB9G,OAAO+G,WAAW,sBAGxClH,KAAKiV,YAAc,WAGnBjV,KAAKqU,YAAc,YAInBrU,KAAKoK,UAAY,CAAC,GAAK,IAGvBpK,KAAKkV,SAAW,CAAC,EAGjBlV,KAAKmV,SAAW,IAAIzM,sBAClB,SAAC0M,EAASD,GACRC,EAAQrN,SAAQ,SAAAwB,GACd,EAAK8L,gBAAgB9L,EACvB,GACF,GAAG,CAAEa,UAAWpK,KAAKoK,YAIvBpK,KAAKiH,eAAeE,aAAY,SAAAC,GAC1BA,EAAIC,QACN,EAAKC,OAEL,EAAKsJ,SAET,IAGI5Q,KAAKiH,eAAeI,SACtBrH,KAAKsH,OAIP,IAAInE,EAAOnD,KACXG,OAAOoH,iBACL,QACA+N,KAAS,SAAS3F,GAChBxM,EAAKoS,aAAa5F,EACpB,GAAG,KACH,EAEJ,C,UAqGC,O,EArGA,G,EAAA,2BAED,SAAaA,GAAQ,IAAD,OAClBhN,aAAa3C,KAAKwV,aAClBxV,KAAK4G,aAAaqB,UAAUE,IAAI,iBAEhCnI,KAAKwV,YAAcvT,YAAY,WAC7B,EAAK2E,aAAaqB,UAAUC,OAAO,gBACrC,GAAG,GACL,GAAC,mBAED,WAAS,IAAD,OAENlI,KAAK4G,aAAayB,UAAY,EAG9BrI,KAAKuU,OAAOxM,SAAQ,SAAApB,GAClBA,EAAGsB,UAAUC,OAAO,EAAK+M,YAC3B,IAEA,IAAK,IAAIlX,EAAE,EAAG0X,EAAIzV,KAAK8U,gBAAgB1Q,OAAQrG,EAAE0X,EAAK1X,IAC3CiC,KAAK8U,gBAAgB/W,GAC3BkK,UAAUyL,OAAO1T,KAAKqU,YAAmB,IAANtW,EAE1C,GAAC,kBAED,WAAQ,IAAD,OAGLiC,KAAKyU,QAELzU,KAAK+U,SAAShN,SAAQ,SAAApB,GACpB,EAAKwO,SAASrM,QAAQnC,EACxB,GACF,GAAC,qBAED,WAEE3G,KAAKmV,SAASrL,aACd9J,KAAKyU,OACP,GAAC,6BAED,SAAgBlL,GACIA,EAAMR,OAAO2M,UAAUC,UAAU,EAAG,IAAtD,IACIC,EAAkB,KAyBtB,GArBI5V,KAAKkV,SAAS3L,EAAMR,OAAOX,MAC7BwN,EAAkBrM,EAAM4D,mBAAmBf,IAAMpM,KAAKkV,SAAS3L,EAAMR,OAAOX,IAAM,OAAS,MAI7FpI,KAAKkV,SAAS3L,EAAMR,OAAOX,IAAMmB,EAAM4D,mBAAmBf,IAgBnC,QAAnBwJ,GAA4D,IAA/BrM,EAAMwD,iBAAiBX,IAAW,CAEjE,IAAIyJ,EAAUtM,EAAMR,OAAO8H,QAAQ,oBACnCgF,EAAQ5N,UAAUE,IAAInI,KAAKiV,aAE3BjV,KAAK8V,iBAAiBD,EAAQzN,GAAI,OACpC,MAGK,GAAuB,MAAnBwN,GAA0D,IAA/BrM,EAAMwD,iBAAiBX,IAAW,CACpE,IAAIyJ,EAAUtM,EAAMR,OAAO8H,QAAQ,oBAEnCgF,EAAQ5N,UAAUC,OAAOlI,KAAKiV,aAE9BjV,KAAK8V,iBAAiBD,EAAQzN,GAAI,KACpC,CACF,GAAC,8BAED,SAAiBA,EAAIwN,GAAkB,IAAD,OAChC/N,EAAWO,EAIf,GAAuB,MAAnBwN,EAAyB,CAC3B,IAAIG,EAAUlO,EAASgD,MAAM,KAC7BhD,EAAWkO,EAAQ,GAAK,KAAO5Q,SAAS4Q,EAAQ,GAAI,IAAM,EAC5D,CAEA/V,KAAK8U,gBAAgB/M,SAAQ,SAAApB,GAE3BA,EAAGsB,UAAUyL,OAAO,EAAKW,YAAa1N,EAAGgB,MAAQ,IAAME,EACzD,GACF,M,8EAAC,EApKY,GAyKT0M,EAAS1N,SAASG,iBAAiB,sCAErCuN,EAAOnQ,QACT,IAAIyQ,EAAUN,E","file":"js/explainer-d754ef1614a8b93c203c.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 = \"/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 67);\n","var g;\n\n// This works in non-strict mode\ng = function () {\n  return this;\n}();\ntry {\n  // This works if eval is allowed (see CSP)\n  g = g || new Function(\"return this\")();\n} catch (e) {\n  // This works if the window reference is available\n  if (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;","var isObject = require('./isObject'),\n  now = require('./now'),\n  toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n  nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n    lastThis,\n    maxWait,\n    result,\n    timerId,\n    lastCallTime,\n    lastInvokeTime = 0,\n    leading = false,\n    maxing = false,\n    trailing = true;\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  function invokeFunc(time) {\n    var args = lastArgs,\n      thisArg = lastThis;\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n      timeSinceLastInvoke = time - lastInvokeTime,\n      timeWaiting = wait - timeSinceLastCall;\n    return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;\n  }\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n      timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return lastCallTime === undefined || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;\n  }\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n  function debounced() {\n    var time = now(),\n      isInvoking = shouldInvoke(time);\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\nmodule.exports = debounce;","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\nmodule.exports = isObject;","module.exports = /******/function (modules) {\n  // webpackBootstrap\n  /******/ // The module cache\n  /******/\n  var installedModules = {};\n  /******/\n  /******/ // The require function\n  /******/\n  function __webpack_require__(moduleId) {\n    /******/\n    /******/ // Check if module is in cache\n    /******/if (installedModules[moduleId]) {\n      /******/return installedModules[moduleId].exports;\n      /******/\n    }\n    /******/ // Create a new module (and put it into the cache)\n    /******/\n    var module = installedModules[moduleId] = {\n      /******/i: moduleId,\n      /******/l: false,\n      /******/exports: {}\n      /******/\n    };\n    /******/\n    /******/ // Execute the module function\n    /******/\n    modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n    /******/\n    /******/ // Flag the module as loaded\n    /******/\n    module.l = true;\n    /******/\n    /******/ // Return the exports of the module\n    /******/\n    return module.exports;\n    /******/\n  }\n  /******/\n  /******/\n  /******/ // expose the modules object (__webpack_modules__)\n  /******/\n  __webpack_require__.m = modules;\n  /******/\n  /******/ // expose the module cache\n  /******/\n  __webpack_require__.c = installedModules;\n  /******/\n  /******/ // define getter function for harmony exports\n  /******/\n  __webpack_require__.d = function (exports, name, getter) {\n    /******/if (!__webpack_require__.o(exports, name)) {\n      /******/Object.defineProperty(exports, name, {\n        enumerable: true,\n        get: getter\n      });\n      /******/\n    }\n    /******/\n  };\n  /******/\n  /******/ // define __esModule on exports\n  /******/\n  __webpack_require__.r = function (exports) {\n    /******/if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n      /******/Object.defineProperty(exports, Symbol.toStringTag, {\n        value: 'Module'\n      });\n      /******/\n    }\n    /******/\n    Object.defineProperty(exports, '__esModule', {\n      value: true\n    });\n    /******/\n  };\n  /******/\n  /******/ // create a fake namespace object\n  /******/ // mode & 1: value is a module id, require it\n  /******/ // mode & 2: merge all properties of value into the ns\n  /******/ // mode & 4: return value when already ns object\n  /******/ // mode & 8|1: behave like require\n  /******/\n  __webpack_require__.t = function (value, mode) {\n    /******/if (mode & 1) value = __webpack_require__(value);\n    /******/\n    if (mode & 8) return value;\n    /******/\n    if (mode & 4 && typeof value === 'object' && value && value.__esModule) return value;\n    /******/\n    var ns = Object.create(null);\n    /******/\n    __webpack_require__.r(ns);\n    /******/\n    Object.defineProperty(ns, 'default', {\n      enumerable: true,\n      value: value\n    });\n    /******/\n    if (mode & 2 && typeof value != 'string') for (var key in value) __webpack_require__.d(ns, key, function (key) {\n      return value[key];\n    }.bind(null, key));\n    /******/\n    return ns;\n    /******/\n  };\n  /******/\n  /******/ // getDefaultExport function for compatibility with non-harmony modules\n  /******/\n  __webpack_require__.n = function (module) {\n    /******/var getter = module && module.__esModule ? /******/function getDefault() {\n      return module['default'];\n    } : /******/function getModuleExports() {\n      return module;\n    };\n    /******/\n    __webpack_require__.d(getter, 'a', getter);\n    /******/\n    return getter;\n    /******/\n  };\n  /******/\n  /******/ // Object.prototype.hasOwnProperty.call\n  /******/\n  __webpack_require__.o = function (object, property) {\n    return Object.prototype.hasOwnProperty.call(object, property);\n  };\n  /******/\n  /******/ // __webpack_public_path__\n  /******/\n  __webpack_require__.p = \"\";\n  /******/\n  /******/\n  /******/ // Load entry module and return exports\n  /******/\n  return __webpack_require__(__webpack_require__.s = \"./index.js\");\n  /******/\n}\n/************************************************************************/\n/******/({\n  /***/\"./index.js\":\n  /*!******************!*\\\n    !*** ./index.js ***!\n    \\******************/\n  /*! exports provided: default */\n  /***/\n  function (module, __webpack_exports__, __webpack_require__) {\n    \"use strict\";\n\n    eval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \\\"default\\\", function() { return ExpandToggle; });\\n/* harmony import */ var lodash_debounce__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! lodash/debounce */ \\\"./node_modules/lodash/debounce.js\\\");\\n/* harmony import */ var lodash_debounce__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(lodash_debounce__WEBPACK_IMPORTED_MODULE_0__);\\n/* harmony import */ var ev_emitter__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ev-emitter */ \\\"./node_modules/ev-emitter/ev-emitter.js\\\");\\n/* harmony import */ var ev_emitter__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(ev_emitter__WEBPACK_IMPORTED_MODULE_1__);\\n\\n\\nfunction _typeof(obj) { if (typeof Symbol === \\\"function\\\" && typeof Symbol.iterator === \\\"symbol\\\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \\\"function\\\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \\\"symbol\\\" : typeof obj; }; } return _typeof(obj); }\\n\\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }\\n\\nfunction _nonIterableSpread() { throw new TypeError(\\\"Invalid attempt to spread non-iterable instance\\\"); }\\n\\nfunction _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \\\"[object Arguments]\\\") return Array.from(iter); }\\n\\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }\\n\\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\\\"Cannot call a class as a function\\\"); } }\\n\\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\\\"value\\\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\\n\\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\\n\\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \\\"object\\\" || typeof call === \\\"function\\\")) { return call; } return _assertThisInitialized(self); }\\n\\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\\\"this hasn't been initialised - super() hasn't been called\\\"); } return self; }\\n\\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\\n\\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \\\"function\\\" && superClass !== null) { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\\n\\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\\n\\n\\n\\n/**\\n * Wrap the last X words in an HTML tag to prevent them from wrapping (i.e. orphans)\\n * @param {HTMLElement} el - Toggle button DOM node\\n * @param {Object} opts - Options\\n * @param {string} [opts.expandedClasses=\\\"\\\"] - Class(es) to apply when expanded\\n * @param {boolean} [opts.shouldToggleHeight=false] - Whether or not to animate height\\n * @param {string} [opts.activeToggleText=\\\"\\\"] - Expanded state toggle button text\\n * @param {boolean} [opts.shouldStartExpanded=false] - Whether menu should start expanded\\n * @param {function} [opts.onReady=\\\"\\\"] - Ready callback function\\n */\\n\\nvar ExpandToggle =\\n/*#__PURE__*/\\nfunction (_EventEmitter) {\\n  _inherits(ExpandToggle, _EventEmitter);\\n\\n  function ExpandToggle(el, opts) {\\n    var _this;\\n\\n    _classCallCheck(this, ExpandToggle);\\n\\n    // Have to call super() first before referencing “this” since we’re extending EventEmitter\\n    // https://stackoverflow.com/a/43591507/673457\\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(ExpandToggle).call(this));\\n    _this.el = el;\\n    _this.targetId = _this.el.getAttribute(\\\"data-expands\\\");\\n    _this.targetEl = document.getElementById(_this.targetId); // Ensure target element exist before initializing\\n\\n    if (!_this.targetEl) {\\n      console.warn(\\\"Can\\\\u2019t find expandable target with id \\\\u201C\\\".concat(_this.targetId, \\\"\\\\u201D\\\"));\\n      return _possibleConstructorReturn(_this, false);\\n    } // Use Object.assign() to merge “opts” object with default values in this.options\\n\\n\\n    _this.options = Object.assign({}, {\\n      expandedClasses: \\\"\\\",\\n      // string, accepts multiple space-separated classes\\n      shouldToggleHeight: false,\\n      // should target element’s height be animated using max-height\\n      activeToggleText: \\\"\\\",\\n      // expanded state toggle button text\\n      shouldStartExpanded: false,\\n      // component starts expanded on init\\n      onReady: null // ready callback function\\n\\n    }, opts); // Check for custom expanded class(es)\\n\\n    _this.expandedClasses = _this.el.getAttribute(\\\"data-expands-class\\\") || _this.options.expandedClasses;\\n\\n    if (_this.expandedClasses.length) {\\n      // Check if active class string contains multiple classes\\n      if (_this.expandedClasses.indexOf(\\\" \\\") > -1) {\\n        // Convert to array and remove any empty string values\\n        // caused by having multiple spaces in a row.\\n        _this.expandedClasses = _this.expandedClasses.split(\\\" \\\").filter(function (n) {\\n          return n.length;\\n        });\\n      } else {\\n        // We still need to convert a single active class to an array\\n        // so we can use the spread syntax later in classList.add()\\n        _this.expandedClasses = [_this.expandedClasses];\\n      }\\n    } // Check if height should be animated\\n\\n\\n    _this.shouldToggleHeight = _this.el.hasAttribute(\\\"data-expands-height\\\") || _this.options.shouldToggleHeight; // Check if component should start expanded\\n\\n    _this.shouldStartExpanded = _this.el.hasAttribute(\\\"data-expanded\\\") || _this.options.shouldStartExpanded; // Check for custom toggle button text to use when expanded\\n\\n    _this.hasActiveText = false;\\n    _this.textEl = _this.el.querySelector(\\\"[data-expands-text]\\\");\\n\\n    if (_this.textEl) {\\n      _this.defaultToggleText = _this.textEl.textContent;\\n      _this.activeToggleText = _this.textEl.getAttribute(\\\"data-expands-text\\\") || _this.options.activeToggleText;\\n      _this.hasActiveText = !!_this.activeToggleText.length;\\n    }\\n\\n    _this.init();\\n\\n    return _this;\\n  }\\n\\n  _createClass(ExpandToggle, [{\\n    key: \\\"init\\\",\\n    value: function init() {\\n      // Store state to avoid calling resize handler after component has been destroyed\\n      this.hasInitialized = true; // Accessibility setup\\n\\n      this.el.setAttribute(\\\"aria-haspopup\\\", true);\\n      this.el.setAttribute(\\\"aria-expanded\\\", this.shouldStartExpanded); // Omit “aria-controls” for now\\n      // See https://inclusive-components.design/menus-menu-buttons/#ariacontrols\\n      // this.el.setAttribute(\\\"aria-controls\\\", this.targetId);\\n\\n      this.targetEl.setAttribute(\\\"aria-hidden\\\", !this.shouldStartExpanded);\\n\\n      if (this.el.tagName.toLowerCase() === \\\"a\\\") {\\n        this.el.setAttribute(\\\"role\\\", \\\"button\\\");\\n      }\\n\\n      if (this.shouldToggleHeight) {\\n        this.heightToggleSetup();\\n      } // Click event listener on toggle button\\n      // Note: Callback needs to be assigned to a let so we can remove it since we’re using bind()\\n      // https://stackoverflow.com/a/22870717/673457\\n\\n\\n      this.clickHandler = this.toggle.bind(this);\\n      this.el.addEventListener(\\\"click\\\", this.clickHandler); // Keyboard listeners on toggle button\\n\\n      this.keydownHandler = this.keyboardEvents.bind(this);\\n      this.el.addEventListener(\\\"keydown\\\", this.keydownHandler); // Check for onReady callback\\n\\n      if (typeof this.options.onReady === \\\"function\\\") {\\n        this.options.onReady();\\n      }\\n    }\\n  }, {\\n    key: \\\"destroy\\\",\\n    value: function destroy() {\\n      this.hasInitialized = false; // Remove event listeners\\n\\n      this.el.removeEventListener(\\\"click\\\", this.clickHandler);\\n      this.el.removeEventListener(\\\"keydown\\\", this.keydownHandler);\\n      window.removeEventListener(\\\"resize\\\", this.resizeHandler); // Remove aria attributes\\n\\n      this.el.removeAttribute(\\\"aria-haspopup\\\");\\n      this.el.removeAttribute(\\\"aria-expanded\\\");\\n      this.targetEl.removeAttribute(\\\"aria-hidden\\\");\\n      this.targetEl.style.removeProperty(\\\"max-height\\\");\\n\\n      if (this.el.tagName.toLowerCase() === \\\"a\\\") {\\n        this.el.removeAttribute(\\\"role\\\");\\n      } // Reset toggle text\\n\\n\\n      if (this.hasActiveText) {\\n        this.textEl.textContent = this.defaultToggleText;\\n      } // Remove custom classes\\n\\n\\n      if (this.expandedClasses.length) {\\n        var _this$el$classList, _this$targetEl$classL;\\n\\n        (_this$el$classList = this.el.classList).remove.apply(_this$el$classList, _toConsumableArray(this.expandedClasses));\\n\\n        (_this$targetEl$classL = this.targetEl.classList).remove.apply(_this$targetEl$classL, _toConsumableArray(this.expandedClasses));\\n      }\\n\\n      this.emitEvent(\\\"destroy\\\");\\n    }\\n  }, {\\n    key: \\\"keyboardEvents\\\",\\n    value: function keyboardEvents(event) {\\n      // Expand with down arrow\\n      if (event.keyCode == 40) {\\n        this.expand();\\n      } else if (event.keyCode == 38 || event.keyCode == 27) {\\n        // Close with up arrow or escape key\\n        this.collapse();\\n      }\\n    }\\n  }, {\\n    key: \\\"heightToggleSetup\\\",\\n    value: function heightToggleSetup() {\\n      var _this2 = this;\\n\\n      this.targetParentEl = this.targetEl.parentNode; // Set max-height to the expanded height so we can animate it.\\n\\n      window.requestAnimationFrame(this.updateExpandedHeight.bind(this));\\n      this.resizeHandler = lodash_debounce__WEBPACK_IMPORTED_MODULE_0___default()(function (event) {\\n        // Due to debounce() it’s possible for this to run after destroy() has been called.\\n        // To avoid this edge case, check “this.hasInitialized” first.\\n        if (_this2.hasInitialized) {\\n          window.requestAnimationFrame(_this2.updateExpandedHeight.bind(_this2));\\n        }\\n      }, 100).bind(this); // Update target element’s max-height on resize\\n\\n      window.addEventListener(\\\"resize\\\", this.resizeHandler);\\n    } // Set max-height of target element to its expanded height without triggering relayout.\\n    //\\n    // This technique works by creating an absolutely-positioned invisible clone of the target\\n    // element and calculating its height. This avoids any relayout that would otherwise occur\\n    // if the element was briefly expanded so we could measure it.\\n    //\\n    // Note: We’re using CSS to transition max-height instead jQuery’s slideToggle(),\\n    //       or another 3rd-party lib like Velocity.js, to avoid loading a large lib.\\n\\n  }, {\\n    key: \\\"updateExpandedHeight\\\",\\n    value: function updateExpandedHeight() {\\n      // Get width of original element so we can apply it to the clone\\n      var nodeWidth = Math.round(parseFloat(this.targetEl.offsetWidth)); // Create clone of node\\n\\n      var cloneEl = this.targetEl.cloneNode(true); // 'true' includes child nodes\\n      // Inline styles added to prevent reflow, ensure clone is same size as expanded element\\n\\n      cloneEl.style.cssText = \\\"max-height: none !important; position: absolute !important; right: 100% !important; visibility: hidden !important; width: \\\".concat(nodeWidth, \\\"px !important; -webkit-transition: none !important; -moz-transition: none !important; transition: none !important\\\"); // Update “aria-hidden” attribute\\n\\n      cloneEl.setAttribute(\\\"aria-hidden\\\", false); // Remove id just to be safe\\n\\n      cloneEl.removeAttribute(\\\"id\\\"); // Remove “name” attributes to prevent resetting checkbox or radio elements\\n\\n      var childElsWithId = cloneEl.querySelectorAll(\\\"[name]\\\"); // IE-friendly way of iterating over a NodeList\\n\\n      Array.prototype.forEach.call(childElsWithId, function (el) {\\n        el.removeAttribute(\\\"name\\\");\\n      }); // Append clone to document, save as new let so we can remove it later\\n\\n      var newEl = this.targetParentEl.insertBefore(cloneEl, this.targetEl); // Calculate height\\n\\n      var expandedHeight = Math.round(parseFloat(newEl.offsetHeight)); // Remove cloned node to clean up after ourselves\\n\\n      this.targetParentEl.removeChild(newEl); // Apply inline max-height to collapsed element\\n      // Note: CSS is overriding this when aria-hidden=\\\"true\\\"\\n\\n      this.targetEl.style.maxHeight = expandedHeight + \\\"px\\\";\\n    }\\n  }, {\\n    key: \\\"expand\\\",\\n    value: function expand(event) {\\n      // Update toggle text\\n      if (this.hasActiveText) {\\n        this.textEl.textContent = this.activeToggleText;\\n      } // Add classes\\n\\n\\n      if (this.expandedClasses.length) {\\n        var _this$el$classList2, _this$targetEl$classL2;\\n\\n        (_this$el$classList2 = this.el.classList).add.apply(_this$el$classList2, _toConsumableArray(this.expandedClasses));\\n\\n        (_this$targetEl$classL2 = this.targetEl.classList).add.apply(_this$targetEl$classL2, _toConsumableArray(this.expandedClasses));\\n      } // Update aria attributes\\n\\n\\n      this.el.setAttribute(\\\"aria-expanded\\\", true);\\n      this.targetEl.setAttribute(\\\"aria-hidden\\\", false); // Emit event and include original event as an argument\\n\\n      this.emitEvent(\\\"expand\\\", event);\\n    }\\n  }, {\\n    key: \\\"collapse\\\",\\n    value: function collapse(event) {\\n      // Update toggle text\\n      if (this.hasActiveText) {\\n        this.textEl.textContent = this.defaultToggleText;\\n      } // Remove classes\\n\\n\\n      if (this.expandedClasses.length) {\\n        var _this$el$classList3, _this$targetEl$classL3;\\n\\n        (_this$el$classList3 = this.el.classList).remove.apply(_this$el$classList3, _toConsumableArray(this.expandedClasses));\\n\\n        (_this$targetEl$classL3 = this.targetEl.classList).remove.apply(_this$targetEl$classL3, _toConsumableArray(this.expandedClasses));\\n      } // Update aria attributes\\n\\n\\n      this.el.setAttribute(\\\"aria-expanded\\\", false);\\n      this.targetEl.setAttribute(\\\"aria-hidden\\\", true); // Emit event and include original event as an argument\\n\\n      this.emitEvent(\\\"collapse\\\", event);\\n    }\\n  }, {\\n    key: \\\"toggle\\\",\\n    value: function toggle(event) {\\n      // Prevent default in case toggle element is a link instead of a button\\n      event.preventDefault();\\n\\n      if (this.el.getAttribute(\\\"aria-expanded\\\") === \\\"true\\\") {\\n        this.collapse(event);\\n      } else {\\n        this.expand(event);\\n      }\\n    }\\n  }]);\\n\\n  return ExpandToggle;\\n}(ev_emitter__WEBPACK_IMPORTED_MODULE_1___default.a);\\n\\n\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./index.js?\");\n\n    /***/\n  },\n\n  /***/\"./node_modules/ev-emitter/ev-emitter.js\":\n  /*!***********************************************!*\\\n    !*** ./node_modules/ev-emitter/ev-emitter.js ***!\n    \\***********************************************/\n  /*! no static exports found */\n  /***/\n  function (module, exports, __webpack_require__) {\n    eval(\"var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/**\\n * EvEmitter v1.1.0\\n * Lil' event emitter\\n * MIT License\\n */\\n\\n/* jshint unused: true, undef: true, strict: true */\\n\\n( function( global, factory ) {\\n  // universal module definition\\n  /* jshint strict: false */ /* globals define, module, window */\\n  if ( true ) {\\n    // AMD - RequireJS\\n    !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\\n\\t\\t\\t\\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\\n\\t\\t\\t\\t(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :\\n\\t\\t\\t\\t__WEBPACK_AMD_DEFINE_FACTORY__),\\n\\t\\t\\t\\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\\n  } else {}\\n\\n}( typeof window != 'undefined' ? window : this, function() {\\n\\n\\\"use strict\\\";\\n\\nfunction EvEmitter() {}\\n\\nvar proto = EvEmitter.prototype;\\n\\nproto.on = function( eventName, listener ) {\\n  if ( !eventName || !listener ) {\\n    return;\\n  }\\n  // set events hash\\n  var events = this._events = this._events || {};\\n  // set listeners array\\n  var listeners = events[ eventName ] = events[ eventName ] || [];\\n  // only add once\\n  if ( listeners.indexOf( listener ) == -1 ) {\\n    listeners.push( listener );\\n  }\\n\\n  return this;\\n};\\n\\nproto.once = function( eventName, listener ) {\\n  if ( !eventName || !listener ) {\\n    return;\\n  }\\n  // add event\\n  this.on( eventName, listener );\\n  // set once flag\\n  // set onceEvents hash\\n  var onceEvents = this._onceEvents = this._onceEvents || {};\\n  // set onceListeners object\\n  var onceListeners = onceEvents[ eventName ] = onceEvents[ eventName ] || {};\\n  // set flag\\n  onceListeners[ listener ] = true;\\n\\n  return this;\\n};\\n\\nproto.off = function( eventName, listener ) {\\n  var listeners = this._events && this._events[ eventName ];\\n  if ( !listeners || !listeners.length ) {\\n    return;\\n  }\\n  var index = listeners.indexOf( listener );\\n  if ( index != -1 ) {\\n    listeners.splice( index, 1 );\\n  }\\n\\n  return this;\\n};\\n\\nproto.emitEvent = function( eventName, args ) {\\n  var listeners = this._events && this._events[ eventName ];\\n  if ( !listeners || !listeners.length ) {\\n    return;\\n  }\\n  // copy over to avoid interference if .off() in listener\\n  listeners = listeners.slice(0);\\n  args = args || [];\\n  // once stuff\\n  var onceListeners = this._onceEvents && this._onceEvents[ eventName ];\\n\\n  for ( var i=0; i < listeners.length; i++ ) {\\n    var listener = listeners[i]\\n    var isOnce = onceListeners && onceListeners[ listener ];\\n    if ( isOnce ) {\\n      // remove listener\\n      // remove before trigger to prevent recursion\\n      this.off( eventName, listener );\\n      // unset once flag\\n      delete onceListeners[ listener ];\\n    }\\n    // trigger listener\\n    listener.apply( this, args );\\n  }\\n\\n  return this;\\n};\\n\\nproto.allOff = function() {\\n  delete this._events;\\n  delete this._onceEvents;\\n};\\n\\nreturn EvEmitter;\\n\\n}));\\n\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./node_modules/ev-emitter/ev-emitter.js?\");\n\n    /***/\n  },\n\n  /***/\"./node_modules/lodash/_Symbol.js\":\n  /*!****************************************!*\\\n    !*** ./node_modules/lodash/_Symbol.js ***!\n    \\****************************************/\n  /*! no static exports found */\n  /***/\n  function (module, exports, __webpack_require__) {\n    eval(\"var root = __webpack_require__(/*! ./_root */ \\\"./node_modules/lodash/_root.js\\\");\\n\\n/** Built-in value references. */\\nvar Symbol = root.Symbol;\\n\\nmodule.exports = Symbol;\\n\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./node_modules/lodash/_Symbol.js?\");\n\n    /***/\n  },\n\n  /***/\"./node_modules/lodash/_baseGetTag.js\":\n  /*!********************************************!*\\\n    !*** ./node_modules/lodash/_baseGetTag.js ***!\n    \\********************************************/\n  /*! no static exports found */\n  /***/\n  function (module, exports, __webpack_require__) {\n    eval(\"var Symbol = __webpack_require__(/*! ./_Symbol */ \\\"./node_modules/lodash/_Symbol.js\\\"),\\n    getRawTag = __webpack_require__(/*! ./_getRawTag */ \\\"./node_modules/lodash/_getRawTag.js\\\"),\\n    objectToString = __webpack_require__(/*! ./_objectToString */ \\\"./node_modules/lodash/_objectToString.js\\\");\\n\\n/** `Object#toString` result references. */\\nvar nullTag = '[object Null]',\\n    undefinedTag = '[object Undefined]';\\n\\n/** Built-in value references. */\\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\\n\\n/**\\n * The base implementation of `getTag` without fallbacks for buggy environments.\\n *\\n * @private\\n * @param {*} value The value to query.\\n * @returns {string} Returns the `toStringTag`.\\n */\\nfunction baseGetTag(value) {\\n  if (value == null) {\\n    return value === undefined ? undefinedTag : nullTag;\\n  }\\n  return (symToStringTag && symToStringTag in Object(value))\\n    ? getRawTag(value)\\n    : objectToString(value);\\n}\\n\\nmodule.exports = baseGetTag;\\n\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./node_modules/lodash/_baseGetTag.js?\");\n\n    /***/\n  },\n\n  /***/\"./node_modules/lodash/_freeGlobal.js\":\n  /*!********************************************!*\\\n    !*** ./node_modules/lodash/_freeGlobal.js ***!\n    \\********************************************/\n  /*! no static exports found */\n  /***/\n  function (module, exports, __webpack_require__) {\n    eval(\"/* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */\\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\\n\\nmodule.exports = freeGlobal;\\n\\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ \\\"./node_modules/webpack/buildin/global.js\\\")))\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./node_modules/lodash/_freeGlobal.js?\");\n\n    /***/\n  },\n\n  /***/\"./node_modules/lodash/_getRawTag.js\":\n  /*!*******************************************!*\\\n    !*** ./node_modules/lodash/_getRawTag.js ***!\n    \\*******************************************/\n  /*! no static exports found */\n  /***/\n  function (module, exports, __webpack_require__) {\n    eval(\"var Symbol = __webpack_require__(/*! ./_Symbol */ \\\"./node_modules/lodash/_Symbol.js\\\");\\n\\n/** Used for built-in method references. */\\nvar objectProto = Object.prototype;\\n\\n/** Used to check objects for own properties. */\\nvar hasOwnProperty = objectProto.hasOwnProperty;\\n\\n/**\\n * Used to resolve the\\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\\n * of values.\\n */\\nvar nativeObjectToString = objectProto.toString;\\n\\n/** Built-in value references. */\\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\\n\\n/**\\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\\n *\\n * @private\\n * @param {*} value The value to query.\\n * @returns {string} Returns the raw `toStringTag`.\\n */\\nfunction getRawTag(value) {\\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\\n      tag = value[symToStringTag];\\n\\n  try {\\n    value[symToStringTag] = undefined;\\n    var unmasked = true;\\n  } catch (e) {}\\n\\n  var result = nativeObjectToString.call(value);\\n  if (unmasked) {\\n    if (isOwn) {\\n      value[symToStringTag] = tag;\\n    } else {\\n      delete value[symToStringTag];\\n    }\\n  }\\n  return result;\\n}\\n\\nmodule.exports = getRawTag;\\n\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./node_modules/lodash/_getRawTag.js?\");\n\n    /***/\n  },\n\n  /***/\"./node_modules/lodash/_objectToString.js\":\n  /*!************************************************!*\\\n    !*** ./node_modules/lodash/_objectToString.js ***!\n    \\************************************************/\n  /*! no static exports found */\n  /***/\n  function (module, exports) {\n    eval(\"/** Used for built-in method references. */\\nvar objectProto = Object.prototype;\\n\\n/**\\n * Used to resolve the\\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\\n * of values.\\n */\\nvar nativeObjectToString = objectProto.toString;\\n\\n/**\\n * Converts `value` to a string using `Object.prototype.toString`.\\n *\\n * @private\\n * @param {*} value The value to convert.\\n * @returns {string} Returns the converted string.\\n */\\nfunction objectToString(value) {\\n  return nativeObjectToString.call(value);\\n}\\n\\nmodule.exports = objectToString;\\n\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./node_modules/lodash/_objectToString.js?\");\n\n    /***/\n  },\n\n  /***/\"./node_modules/lodash/_root.js\":\n  /*!**************************************!*\\\n    !*** ./node_modules/lodash/_root.js ***!\n    \\**************************************/\n  /*! no static exports found */\n  /***/\n  function (module, exports, __webpack_require__) {\n    eval(\"var freeGlobal = __webpack_require__(/*! ./_freeGlobal */ \\\"./node_modules/lodash/_freeGlobal.js\\\");\\n\\n/** Detect free variable `self`. */\\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\\n\\n/** Used as a reference to the global object. */\\nvar root = freeGlobal || freeSelf || Function('return this')();\\n\\nmodule.exports = root;\\n\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./node_modules/lodash/_root.js?\");\n\n    /***/\n  },\n\n  /***/\"./node_modules/lodash/debounce.js\":\n  /*!*****************************************!*\\\n    !*** ./node_modules/lodash/debounce.js ***!\n    \\*****************************************/\n  /*! no static exports found */\n  /***/\n  function (module, exports, __webpack_require__) {\n    eval(\"var isObject = __webpack_require__(/*! ./isObject */ \\\"./node_modules/lodash/isObject.js\\\"),\\n    now = __webpack_require__(/*! ./now */ \\\"./node_modules/lodash/now.js\\\"),\\n    toNumber = __webpack_require__(/*! ./toNumber */ \\\"./node_modules/lodash/toNumber.js\\\");\\n\\n/** Error message constants. */\\nvar FUNC_ERROR_TEXT = 'Expected a function';\\n\\n/* Built-in method references for those with the same name as other `lodash` methods. */\\nvar nativeMax = Math.max,\\n    nativeMin = Math.min;\\n\\n/**\\n * Creates a debounced function that delays invoking `func` until after `wait`\\n * milliseconds have elapsed since the last time the debounced function was\\n * invoked. The debounced function comes with a `cancel` method to cancel\\n * delayed `func` invocations and a `flush` method to immediately invoke them.\\n * Provide `options` to indicate whether `func` should be invoked on the\\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\\n * with the last arguments provided to the debounced function. Subsequent\\n * calls to the debounced function return the result of the last `func`\\n * invocation.\\n *\\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\\n * invoked on the trailing edge of the timeout only if the debounced function\\n * is invoked more than once during the `wait` timeout.\\n *\\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\\n *\\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\\n * for details over the differences between `_.debounce` and `_.throttle`.\\n *\\n * @static\\n * @memberOf _\\n * @since 0.1.0\\n * @category Function\\n * @param {Function} func The function to debounce.\\n * @param {number} [wait=0] The number of milliseconds to delay.\\n * @param {Object} [options={}] The options object.\\n * @param {boolean} [options.leading=false]\\n *  Specify invoking on the leading edge of the timeout.\\n * @param {number} [options.maxWait]\\n *  The maximum time `func` is allowed to be delayed before it's invoked.\\n * @param {boolean} [options.trailing=true]\\n *  Specify invoking on the trailing edge of the timeout.\\n * @returns {Function} Returns the new debounced function.\\n * @example\\n *\\n * // Avoid costly calculations while the window size is in flux.\\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\\n *\\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\\n *   'leading': true,\\n *   'trailing': false\\n * }));\\n *\\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\\n * var source = new EventSource('/stream');\\n * jQuery(source).on('message', debounced);\\n *\\n * // Cancel the trailing debounced invocation.\\n * jQuery(window).on('popstate', debounced.cancel);\\n */\\nfunction debounce(func, wait, options) {\\n  var lastArgs,\\n      lastThis,\\n      maxWait,\\n      result,\\n      timerId,\\n      lastCallTime,\\n      lastInvokeTime = 0,\\n      leading = false,\\n      maxing = false,\\n      trailing = true;\\n\\n  if (typeof func != 'function') {\\n    throw new TypeError(FUNC_ERROR_TEXT);\\n  }\\n  wait = toNumber(wait) || 0;\\n  if (isObject(options)) {\\n    leading = !!options.leading;\\n    maxing = 'maxWait' in options;\\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\\n  }\\n\\n  function invokeFunc(time) {\\n    var args = lastArgs,\\n        thisArg = lastThis;\\n\\n    lastArgs = lastThis = undefined;\\n    lastInvokeTime = time;\\n    result = func.apply(thisArg, args);\\n    return result;\\n  }\\n\\n  function leadingEdge(time) {\\n    // Reset any `maxWait` timer.\\n    lastInvokeTime = time;\\n    // Start the timer for the trailing edge.\\n    timerId = setTimeout(timerExpired, wait);\\n    // Invoke the leading edge.\\n    return leading ? invokeFunc(time) : result;\\n  }\\n\\n  function remainingWait(time) {\\n    var timeSinceLastCall = time - lastCallTime,\\n        timeSinceLastInvoke = time - lastInvokeTime,\\n        timeWaiting = wait - timeSinceLastCall;\\n\\n    return maxing\\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\\n      : timeWaiting;\\n  }\\n\\n  function shouldInvoke(time) {\\n    var timeSinceLastCall = time - lastCallTime,\\n        timeSinceLastInvoke = time - lastInvokeTime;\\n\\n    // Either this is the first call, activity has stopped and we're at the\\n    // trailing edge, the system time has gone backwards and we're treating\\n    // it as the trailing edge, or we've hit the `maxWait` limit.\\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\\n  }\\n\\n  function timerExpired() {\\n    var time = now();\\n    if (shouldInvoke(time)) {\\n      return trailingEdge(time);\\n    }\\n    // Restart the timer.\\n    timerId = setTimeout(timerExpired, remainingWait(time));\\n  }\\n\\n  function trailingEdge(time) {\\n    timerId = undefined;\\n\\n    // Only invoke if we have `lastArgs` which means `func` has been\\n    // debounced at least once.\\n    if (trailing && lastArgs) {\\n      return invokeFunc(time);\\n    }\\n    lastArgs = lastThis = undefined;\\n    return result;\\n  }\\n\\n  function cancel() {\\n    if (timerId !== undefined) {\\n      clearTimeout(timerId);\\n    }\\n    lastInvokeTime = 0;\\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\\n  }\\n\\n  function flush() {\\n    return timerId === undefined ? result : trailingEdge(now());\\n  }\\n\\n  function debounced() {\\n    var time = now(),\\n        isInvoking = shouldInvoke(time);\\n\\n    lastArgs = arguments;\\n    lastThis = this;\\n    lastCallTime = time;\\n\\n    if (isInvoking) {\\n      if (timerId === undefined) {\\n        return leadingEdge(lastCallTime);\\n      }\\n      if (maxing) {\\n        // Handle invocations in a tight loop.\\n        clearTimeout(timerId);\\n        timerId = setTimeout(timerExpired, wait);\\n        return invokeFunc(lastCallTime);\\n      }\\n    }\\n    if (timerId === undefined) {\\n      timerId = setTimeout(timerExpired, wait);\\n    }\\n    return result;\\n  }\\n  debounced.cancel = cancel;\\n  debounced.flush = flush;\\n  return debounced;\\n}\\n\\nmodule.exports = debounce;\\n\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./node_modules/lodash/debounce.js?\");\n\n    /***/\n  },\n\n  /***/\"./node_modules/lodash/isObject.js\":\n  /*!*****************************************!*\\\n    !*** ./node_modules/lodash/isObject.js ***!\n    \\*****************************************/\n  /*! no static exports found */\n  /***/\n  function (module, exports) {\n    eval(\"/**\\n * Checks if `value` is the\\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\\n *\\n * @static\\n * @memberOf _\\n * @since 0.1.0\\n * @category Lang\\n * @param {*} value The value to check.\\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\\n * @example\\n *\\n * _.isObject({});\\n * // => true\\n *\\n * _.isObject([1, 2, 3]);\\n * // => true\\n *\\n * _.isObject(_.noop);\\n * // => true\\n *\\n * _.isObject(null);\\n * // => false\\n */\\nfunction isObject(value) {\\n  var type = typeof value;\\n  return value != null && (type == 'object' || type == 'function');\\n}\\n\\nmodule.exports = isObject;\\n\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./node_modules/lodash/isObject.js?\");\n\n    /***/\n  },\n\n  /***/\"./node_modules/lodash/isObjectLike.js\":\n  /*!*********************************************!*\\\n    !*** ./node_modules/lodash/isObjectLike.js ***!\n    \\*********************************************/\n  /*! no static exports found */\n  /***/\n  function (module, exports) {\n    eval(\"/**\\n * Checks if `value` is object-like. A value is object-like if it's not `null`\\n * and has a `typeof` result of \\\"object\\\".\\n *\\n * @static\\n * @memberOf _\\n * @since 4.0.0\\n * @category Lang\\n * @param {*} value The value to check.\\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\\n * @example\\n *\\n * _.isObjectLike({});\\n * // => true\\n *\\n * _.isObjectLike([1, 2, 3]);\\n * // => true\\n *\\n * _.isObjectLike(_.noop);\\n * // => false\\n *\\n * _.isObjectLike(null);\\n * // => false\\n */\\nfunction isObjectLike(value) {\\n  return value != null && typeof value == 'object';\\n}\\n\\nmodule.exports = isObjectLike;\\n\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./node_modules/lodash/isObjectLike.js?\");\n\n    /***/\n  },\n\n  /***/\"./node_modules/lodash/isSymbol.js\":\n  /*!*****************************************!*\\\n    !*** ./node_modules/lodash/isSymbol.js ***!\n    \\*****************************************/\n  /*! no static exports found */\n  /***/\n  function (module, exports, __webpack_require__) {\n    eval(\"var baseGetTag = __webpack_require__(/*! ./_baseGetTag */ \\\"./node_modules/lodash/_baseGetTag.js\\\"),\\n    isObjectLike = __webpack_require__(/*! ./isObjectLike */ \\\"./node_modules/lodash/isObjectLike.js\\\");\\n\\n/** `Object#toString` result references. */\\nvar symbolTag = '[object Symbol]';\\n\\n/**\\n * Checks if `value` is classified as a `Symbol` primitive or object.\\n *\\n * @static\\n * @memberOf _\\n * @since 4.0.0\\n * @category Lang\\n * @param {*} value The value to check.\\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\\n * @example\\n *\\n * _.isSymbol(Symbol.iterator);\\n * // => true\\n *\\n * _.isSymbol('abc');\\n * // => false\\n */\\nfunction isSymbol(value) {\\n  return typeof value == 'symbol' ||\\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\\n}\\n\\nmodule.exports = isSymbol;\\n\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./node_modules/lodash/isSymbol.js?\");\n\n    /***/\n  },\n\n  /***/\"./node_modules/lodash/now.js\":\n  /*!************************************!*\\\n    !*** ./node_modules/lodash/now.js ***!\n    \\************************************/\n  /*! no static exports found */\n  /***/\n  function (module, exports, __webpack_require__) {\n    eval(\"var root = __webpack_require__(/*! ./_root */ \\\"./node_modules/lodash/_root.js\\\");\\n\\n/**\\n * Gets the timestamp of the number of milliseconds that have elapsed since\\n * the Unix epoch (1 January 1970 00:00:00 UTC).\\n *\\n * @static\\n * @memberOf _\\n * @since 2.4.0\\n * @category Date\\n * @returns {number} Returns the timestamp.\\n * @example\\n *\\n * _.defer(function(stamp) {\\n *   console.log(_.now() - stamp);\\n * }, _.now());\\n * // => Logs the number of milliseconds it took for the deferred invocation.\\n */\\nvar now = function() {\\n  return root.Date.now();\\n};\\n\\nmodule.exports = now;\\n\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./node_modules/lodash/now.js?\");\n\n    /***/\n  },\n\n  /***/\"./node_modules/lodash/toNumber.js\":\n  /*!*****************************************!*\\\n    !*** ./node_modules/lodash/toNumber.js ***!\n    \\*****************************************/\n  /*! no static exports found */\n  /***/\n  function (module, exports, __webpack_require__) {\n    eval(\"var isObject = __webpack_require__(/*! ./isObject */ \\\"./node_modules/lodash/isObject.js\\\"),\\n    isSymbol = __webpack_require__(/*! ./isSymbol */ \\\"./node_modules/lodash/isSymbol.js\\\");\\n\\n/** Used as references for various `Number` constants. */\\nvar NAN = 0 / 0;\\n\\n/** Used to match leading and trailing whitespace. */\\nvar reTrim = /^\\\\s+|\\\\s+$/g;\\n\\n/** Used to detect bad signed hexadecimal string values. */\\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\\n\\n/** Used to detect binary string values. */\\nvar reIsBinary = /^0b[01]+$/i;\\n\\n/** Used to detect octal string values. */\\nvar reIsOctal = /^0o[0-7]+$/i;\\n\\n/** Built-in method references without a dependency on `root`. */\\nvar freeParseInt = parseInt;\\n\\n/**\\n * Converts `value` to a number.\\n *\\n * @static\\n * @memberOf _\\n * @since 4.0.0\\n * @category Lang\\n * @param {*} value The value to process.\\n * @returns {number} Returns the number.\\n * @example\\n *\\n * _.toNumber(3.2);\\n * // => 3.2\\n *\\n * _.toNumber(Number.MIN_VALUE);\\n * // => 5e-324\\n *\\n * _.toNumber(Infinity);\\n * // => Infinity\\n *\\n * _.toNumber('3.2');\\n * // => 3.2\\n */\\nfunction toNumber(value) {\\n  if (typeof value == 'number') {\\n    return value;\\n  }\\n  if (isSymbol(value)) {\\n    return NAN;\\n  }\\n  if (isObject(value)) {\\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\\n    value = isObject(other) ? (other + '') : other;\\n  }\\n  if (typeof value != 'string') {\\n    return value === 0 ? value : +value;\\n  }\\n  value = value.replace(reTrim, '');\\n  var isBinary = reIsBinary.test(value);\\n  return (isBinary || reIsOctal.test(value))\\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\\n    : (reIsBadHex.test(value) ? NAN : +value);\\n}\\n\\nmodule.exports = toNumber;\\n\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./node_modules/lodash/toNumber.js?\");\n\n    /***/\n  },\n\n  /***/\"./node_modules/webpack/buildin/global.js\":\n  /*!***********************************!*\\\n    !*** (webpack)/buildin/global.js ***!\n    \\***********************************/\n  /*! no static exports found */\n  /***/\n  function (module, exports) {\n    eval(\"var g;\\n\\n// This works in non-strict mode\\ng = (function() {\\n\\treturn this;\\n})();\\n\\ntry {\\n\\t// This works if eval is allowed (see CSP)\\n\\tg = g || new Function(\\\"return this\\\")();\\n} catch (e) {\\n\\t// This works if the window reference is available\\n\\tif (typeof window === \\\"object\\\") g = window;\\n}\\n\\n// g can still be undefined, but nothing to do about it...\\n// We return undefined, instead of nothing here, so it's\\n// easier to handle this case. if(!global) { ...}\\n\\nmodule.exports = g;\\n\\n\\n//# sourceURL=webpack://%5Bname%5DLink/(webpack)/buildin/global.js?\");\n\n    /***/\n  }\n\n  /******/\n});","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\nmodule.exports = root;","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\nmodule.exports = Symbol;","module.exports = /******/function (modules) {\n  // webpackBootstrap\n  /******/ // The module cache\n  /******/\n  var installedModules = {};\n  /******/\n  /******/ // The require function\n  /******/\n  function __webpack_require__(moduleId) {\n    /******/\n    /******/ // Check if module is in cache\n    /******/if (installedModules[moduleId]) {\n      /******/return installedModules[moduleId].exports;\n      /******/\n    }\n    /******/ // Create a new module (and put it into the cache)\n    /******/\n    var module = installedModules[moduleId] = {\n      /******/i: moduleId,\n      /******/l: false,\n      /******/exports: {}\n      /******/\n    };\n    /******/\n    /******/ // Execute the module function\n    /******/\n    modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n    /******/\n    /******/ // Flag the module as loaded\n    /******/\n    module.l = true;\n    /******/\n    /******/ // Return the exports of the module\n    /******/\n    return module.exports;\n    /******/\n  }\n  /******/\n  /******/\n  /******/ // expose the modules object (__webpack_modules__)\n  /******/\n  __webpack_require__.m = modules;\n  /******/\n  /******/ // expose the module cache\n  /******/\n  __webpack_require__.c = installedModules;\n  /******/\n  /******/ // define getter function for harmony exports\n  /******/\n  __webpack_require__.d = function (exports, name, getter) {\n    /******/if (!__webpack_require__.o(exports, name)) {\n      /******/Object.defineProperty(exports, name, {\n        /******/configurable: false,\n        /******/enumerable: true,\n        /******/get: getter\n        /******/\n      });\n      /******/\n    }\n    /******/\n  };\n  /******/\n  /******/ // define __esModule on exports\n  /******/\n  __webpack_require__.r = function (exports) {\n    /******/Object.defineProperty(exports, '__esModule', {\n      value: true\n    });\n    /******/\n  };\n  /******/\n  /******/ // getDefaultExport function for compatibility with non-harmony modules\n  /******/\n  __webpack_require__.n = function (module) {\n    /******/var getter = module && module.__esModule ? /******/function getDefault() {\n      return module['default'];\n    } : /******/function getModuleExports() {\n      return module;\n    };\n    /******/\n    __webpack_require__.d(getter, 'a', getter);\n    /******/\n    return getter;\n    /******/\n  };\n  /******/\n  /******/ // Object.prototype.hasOwnProperty.call\n  /******/\n  __webpack_require__.o = function (object, property) {\n    return Object.prototype.hasOwnProperty.call(object, property);\n  };\n  /******/\n  /******/ // __webpack_public_path__\n  /******/\n  __webpack_require__.p = \"\";\n  /******/\n  /******/\n  /******/ // Load entry module and return exports\n  /******/\n  return __webpack_require__(__webpack_require__.s = \"./index.js\");\n  /******/\n}\n/************************************************************************/\n/******/({\n  /***/\"./index.js\":\n  /*!******************!*\\\n    !*** ./index.js ***!\n    \\******************/\n  /*! no static exports found */\n  /***/\n  function (module, exports, __webpack_require__) {\n    \"use strict\";\n\n    eval(\"//------------------------------------------------------------------------\\n// Disable scrolling (e.g. when modal window is open)\\n//\\n// Inspired by https://benfrain.com/preventing-body-scroll-for-modals-in-ios/\\n//\\n// Note: Once Safari and iOS Safari support the “touch-action” CSS property,\\n//       we can simply toggle a class that adds the following:\\n//\\n//       html,\\n//       body {\\n//         overflow: hidden !important;\\n//         touch-action: none !important;\\n//       }\\n//\\n//       /* Add class to elements like modal windows that still need to scroll */\\n//       .allow-scroll { touch-action: auto !important; }\\n//\\n// https://caniuse.com/#feat=css-touch-action\\n//------------------------------------------------------------------------\\n\\n\\nmodule.exports = {\\n  // Save current scroll position when scrolling is disabled so we can reset it when enabled\\n  _scrollPos: 0,\\n\\n  // Track whether or not we have injected CSS the already\\n  _hasCSS: false,\\n\\n  // Inject <style> tag with CSS rules (simpler than toggling a lot of inline styles)\\n  _injectCSS: function _injectCSS() {\\n\\n    // Don’t add styles more than once\\n    if (!this._hasCSS) {\\n      var css = '\\\\n        html.js-no-scroll { height: 100% !important; }\\\\n        .js-no-scroll body {\\\\n          height: 100%;\\\\n          overflow: hidden !important;\\\\n          position: fixed !important;\\\\n          width: 100% !important;\\\\n        }';\\n\\n      // Note: Setting “position: fixed” on the body prevents iOS from scrolling.\\n      //       However, this will cause the browser to scroll to the top, so we must\\n      //       add inline “height” and “top” styles to the body to address this.\\n\\n      // Create <style> tag and add to <head>\\n      // https://stackoverflow.com/a/524721/673457\\n      var styleEl = document.createElement('style');\\n      styleEl.type = 'text/css';\\n      styleEl.appendChild(document.createTextNode(css));\\n      document.head.appendChild(styleEl);\\n\\n      // Update var so we can avoid loading the CSS multiple times\\n      this._hasCSS = true;\\n    }\\n  },\\n\\n  _saveScrollPos: function _saveScrollPos() {\\n    this._scrollPos = window.pageYOffset || document.documentElement.scrollTop;\\n  },\\n\\n  /**\\n   * Disable scrolling\\n   */\\n  freeze: function freeze() {\\n    // Add required inline CSS (only runs first time)\\n    this._injectCSS();\\n\\n    this._saveScrollPos();\\n\\n    // Add class to prevent page scrolling (sets fixed position on body)\\n    document.documentElement.classList.add(\\\"js-no-scroll\\\");\\n\\n    // Add inline styles if not already at top of page\\n    if (this._scrollPos > 0) {\\n      document.body.style.height = \\\"calc(100% + \\\" + this._scrollPos + \\\"px)\\\";\\n      document.body.style.top = -this._scrollPos + \\\"px\\\";\\n    }\\n  },\\n\\n  /**\\n   * Enable scrolling\\n   */\\n  unfreeze: function unfreeze() {\\n    // Remove js-no-scroll class\\n    document.documentElement.classList.remove(\\\"js-no-scroll\\\");\\n\\n    if (this._scrollPos > 0) {\\n      // Remove inline styles on body, which causes the page to jump to the top.\\n      document.body.style.height = \\\"\\\";\\n      document.body.style.top = \\\"\\\";\\n\\n      // Disable native smooth scrolling before resetting the scroll position.\\n      // Otherwise, there would be an annoying jump after scrolling is enabled.\\n      if (document.documentElement.style.hasOwnProperty('scrollBehavior')) {\\n        document.documentElement.style.scrollBehavior = \\\"auto\\\";\\n      }\\n\\n      // Reset scroll position to what it was before scrolling was disabled.\\n      window.scrollTo(0, this._scrollPos);\\n\\n      // Re-enable native smooth scrolling\\n      if (document.documentElement.style.hasOwnProperty('scrollBehavior')) {\\n        document.documentElement.style.scrollBehavior = \\\"\\\";\\n      }\\n    }\\n  }\\n};\\n\\n//# sourceURL=webpack://%5Bname%5DLink/./index.js?\");\n\n    /***/\n  }\n\n  /******/\n});","/**\n * EvEmitter v1.1.0\n * Lil' event emitter\n * MIT License\n */\n\n/* jshint unused: true, undef: true, strict: true */\n\n(function (global, factory) {\n  // universal module definition\n  /* jshint strict: false */ /* globals define, module, window */\n  if (typeof define == 'function' && define.amd) {\n    // AMD - RequireJS\n    define(factory);\n  } else if (typeof module == 'object' && module.exports) {\n    // CommonJS - Browserify, Webpack\n    module.exports = factory();\n  } else {\n    // Browser globals\n    global.EvEmitter = factory();\n  }\n})(typeof window != 'undefined' ? window : this, function () {\n  \"use strict\";\n\n  function EvEmitter() {}\n  var proto = EvEmitter.prototype;\n  proto.on = function (eventName, listener) {\n    if (!eventName || !listener) {\n      return;\n    }\n    // set events hash\n    var events = this._events = this._events || {};\n    // set listeners array\n    var listeners = events[eventName] = events[eventName] || [];\n    // only add once\n    if (listeners.indexOf(listener) == -1) {\n      listeners.push(listener);\n    }\n    return this;\n  };\n  proto.once = function (eventName, listener) {\n    if (!eventName || !listener) {\n      return;\n    }\n    // add event\n    this.on(eventName, listener);\n    // set once flag\n    // set onceEvents hash\n    var onceEvents = this._onceEvents = this._onceEvents || {};\n    // set onceListeners object\n    var onceListeners = onceEvents[eventName] = onceEvents[eventName] || {};\n    // set flag\n    onceListeners[listener] = true;\n    return this;\n  };\n  proto.off = function (eventName, listener) {\n    var listeners = this._events && this._events[eventName];\n    if (!listeners || !listeners.length) {\n      return;\n    }\n    var index = listeners.indexOf(listener);\n    if (index != -1) {\n      listeners.splice(index, 1);\n    }\n    return this;\n  };\n  proto.emitEvent = function (eventName, args) {\n    var listeners = this._events && this._events[eventName];\n    if (!listeners || !listeners.length) {\n      return;\n    }\n    // copy over to avoid interference if .off() in listener\n    listeners = listeners.slice(0);\n    args = args || [];\n    // once stuff\n    var onceListeners = this._onceEvents && this._onceEvents[eventName];\n    for (var i = 0; i < listeners.length; i++) {\n      var listener = listeners[i];\n      var isOnce = onceListeners && onceListeners[listener];\n      if (isOnce) {\n        // remove listener\n        // remove before trigger to prevent recursion\n        this.off(eventName, listener);\n        // unset once flag\n        delete onceListeners[listener];\n      }\n      // trigger listener\n      listener.apply(this, args);\n    }\n    return this;\n  };\n  proto.allOff = function () {\n    delete this._events;\n    delete this._onceEvents;\n  };\n  return EvEmitter;\n});","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function () {\n  return root.Date.now();\n};\nmodule.exports = now;","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\nmodule.exports = freeGlobal;","var baseTrim = require('./_baseTrim'),\n  isObject = require('./isObject'),\n  isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? other + '' : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = baseTrim(value);\n  var isBinary = reIsBinary.test(value);\n  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;\n}\nmodule.exports = toNumber;","var trimmedEndIndex = require('./_trimmedEndIndex');\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n  return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '') : string;\n}\nmodule.exports = baseTrim;","/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n  var index = string.length;\n  while (index-- && reWhitespace.test(string.charAt(index))) {}\n  return index;\n}\nmodule.exports = trimmedEndIndex;","var baseGetTag = require('./_baseGetTag'),\n  isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' || isObjectLike(value) && baseGetTag(value) == symbolTag;\n}\nmodule.exports = isSymbol;","var Symbol = require('./_Symbol'),\n  getRawTag = require('./_getRawTag'),\n  objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n  undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);\n}\nmodule.exports = baseGetTag;","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n    tag = value[symToStringTag];\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\nmodule.exports = getRawTag;","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\nmodule.exports = objectToString;","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\nmodule.exports = isObjectLike;","var debounce = require('./debounce'),\n  isObject = require('./isObject');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n    trailing = true;\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\nmodule.exports = throttle;","// We only need this JS to prevent the nav jump links from adding a hash to the URL.\n// Note: We’re avoiding preventDefault() in order to take advantage of native smooth scrolling.\n\nclass ExplainerDesktopNav {\n  constructor(el) {\n    this.el = el;\n    this.modalContent = document.querySelector(\".Explainer-content\");\n    this.explainerSlides = document.querySelectorAll(\".Explainer-slide\");\n\n    // Breakpoint at which to init JS (must match $layout-explainer-wide-bp in _layout-vars.scss)\n    this.mediaQueryList = window.matchMedia(\"(min-width: 900px)\");\n\n    // Listen for breakpoint change\n    this.mediaQueryList.addListener(evt => {\n      if (evt.matches) {\n        this.init();\n      }\n    });\n\n    // Init on load\n    if (this.mediaQueryList.matches) {\n      this.init();\n    }\n  }\n\n  init() {\n    this.el.addEventListener(\"click\", evt => {\n      evt.preventDefault();// stops hash from begin added to URL, but also prevents scroll\n      this.updateSlides(evt.currentTarget.hash);\n    });\n  }\n\n  updateSlides(activeHash) {\n    let activeId = activeHash.replace(\"#\", \"\");\n    // We need to know once the active slide was found during\n    // the loop so we can stop applying the “is-stuck” class.\n    let foundActive = false;\n\n    this.explainerSlides.forEach(slide => {\n      if (!foundActive) {\n        slide.classList.add(\"is-stuck\");\n\n        if (slide.id == activeId) {\n          foundActive = true;\n\n          // Scroll to active slide\n          this.modalContent.scrollTop = slide.offsetTop;\n        }\n      } else {\n        slide.classList.remove(\"is-stuck\");\n      }\n    });\n  }\n}\n\n// Init\ndocument.querySelectorAll('.ExplainerNavDesktop-link').forEach(el => new ExplainerDesktopNav(el));\n","/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n *\n */\n(function () {\n  'use strict';\n\n  // Exit early if we're not running in a browser.\n  if (typeof window !== 'object') {\n    return;\n  }\n\n  // Exit early if all IntersectionObserver and IntersectionObserverEntry\n  // features are natively supported.\n  if ('IntersectionObserver' in window && 'IntersectionObserverEntry' in window && 'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n    // Minimal polyfill for Edge 15's lack of `isIntersecting`\n    // See: https://github.com/w3c/IntersectionObserver/issues/211\n    if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n      Object.defineProperty(window.IntersectionObserverEntry.prototype, 'isIntersecting', {\n        get: function () {\n          return this.intersectionRatio > 0;\n        }\n      });\n    }\n    return;\n  }\n\n  /**\n   * A local reference to the document.\n   */\n  var document = window.document;\n\n  /**\n   * An IntersectionObserver registry. This registry exists to hold a strong\n   * reference to IntersectionObserver instances currently observing a target\n   * element. Without this registry, instances without another reference may be\n   * garbage collected.\n   */\n  var registry = [];\n\n  /**\n   * Creates the global IntersectionObserverEntry constructor.\n   * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n   * @param {Object} entry A dictionary of instance properties.\n   * @constructor\n   */\n  function IntersectionObserverEntry(entry) {\n    this.time = entry.time;\n    this.target = entry.target;\n    this.rootBounds = entry.rootBounds;\n    this.boundingClientRect = entry.boundingClientRect;\n    this.intersectionRect = entry.intersectionRect || getEmptyRect();\n    this.isIntersecting = !!entry.intersectionRect;\n\n    // Calculates the intersection ratio.\n    var targetRect = this.boundingClientRect;\n    var targetArea = targetRect.width * targetRect.height;\n    var intersectionRect = this.intersectionRect;\n    var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n    // Sets intersection ratio.\n    if (targetArea) {\n      // Round the intersection ratio to avoid floating point math issues:\n      // https://github.com/w3c/IntersectionObserver/issues/324\n      this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));\n    } else {\n      // If area is zero and is intersecting, sets to 1, otherwise to 0\n      this.intersectionRatio = this.isIntersecting ? 1 : 0;\n    }\n  }\n\n  /**\n   * Creates the global IntersectionObserver constructor.\n   * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n   * @param {Function} callback The function to be invoked after intersection\n   *     changes have queued. The function is not invoked if the queue has\n   *     been emptied by calling the `takeRecords` method.\n   * @param {Object=} opt_options Optional configuration options.\n   * @constructor\n   */\n  function IntersectionObserver(callback, opt_options) {\n    var options = opt_options || {};\n    if (typeof callback != 'function') {\n      throw new Error('callback must be a function');\n    }\n    if (options.root && options.root.nodeType != 1) {\n      throw new Error('root must be an Element');\n    }\n\n    // Binds and throttles `this._checkForIntersections`.\n    this._checkForIntersections = throttle(this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n    // Private properties.\n    this._callback = callback;\n    this._observationTargets = [];\n    this._queuedEntries = [];\n    this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n    // Public properties.\n    this.thresholds = this._initThresholds(options.threshold);\n    this.root = options.root || null;\n    this.rootMargin = this._rootMarginValues.map(function (margin) {\n      return margin.value + margin.unit;\n    }).join(' ');\n  }\n\n  /**\n   * The minimum interval within which the document will be checked for\n   * intersection changes.\n   */\n  IntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n  /**\n   * The frequency in which the polyfill polls for intersection changes.\n   * this can be updated on a per instance basis and must be set prior to\n   * calling `observe` on the first target.\n   */\n  IntersectionObserver.prototype.POLL_INTERVAL = null;\n\n  /**\n   * Use a mutation observer on the root element\n   * to detect intersection changes.\n   */\n  IntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n  /**\n   * Starts observing a target element for intersection changes based on\n   * the thresholds values.\n   * @param {Element} target The DOM element to observe.\n   */\n  IntersectionObserver.prototype.observe = function (target) {\n    var isTargetAlreadyObserved = this._observationTargets.some(function (item) {\n      return item.element == target;\n    });\n    if (isTargetAlreadyObserved) {\n      return;\n    }\n    if (!(target && target.nodeType == 1)) {\n      throw new Error('target must be an Element');\n    }\n    this._registerInstance();\n    this._observationTargets.push({\n      element: target,\n      entry: null\n    });\n    this._monitorIntersections();\n    this._checkForIntersections();\n  };\n\n  /**\n   * Stops observing a target element for intersection changes.\n   * @param {Element} target The DOM element to observe.\n   */\n  IntersectionObserver.prototype.unobserve = function (target) {\n    this._observationTargets = this._observationTargets.filter(function (item) {\n      return item.element != target;\n    });\n    if (!this._observationTargets.length) {\n      this._unmonitorIntersections();\n      this._unregisterInstance();\n    }\n  };\n\n  /**\n   * Stops observing all target elements for intersection changes.\n   */\n  IntersectionObserver.prototype.disconnect = function () {\n    this._observationTargets = [];\n    this._unmonitorIntersections();\n    this._unregisterInstance();\n  };\n\n  /**\n   * Returns any queue entries that have not yet been reported to the\n   * callback and clears the queue. This can be used in conjunction with the\n   * callback to obtain the absolute most up-to-date intersection information.\n   * @return {Array} The currently queued entries.\n   */\n  IntersectionObserver.prototype.takeRecords = function () {\n    var records = this._queuedEntries.slice();\n    this._queuedEntries = [];\n    return records;\n  };\n\n  /**\n   * Accepts the threshold value from the user configuration object and\n   * returns a sorted array of unique threshold values. If a value is not\n   * between 0 and 1 and error is thrown.\n   * @private\n   * @param {Array|number=} opt_threshold An optional threshold value or\n   *     a list of threshold values, defaulting to [0].\n   * @return {Array} A sorted list of unique and valid threshold values.\n   */\n  IntersectionObserver.prototype._initThresholds = function (opt_threshold) {\n    var threshold = opt_threshold || [0];\n    if (!Array.isArray(threshold)) threshold = [threshold];\n    return threshold.sort().filter(function (t, i, a) {\n      if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n        throw new Error('threshold must be a number between 0 and 1 inclusively');\n      }\n      return t !== a[i - 1];\n    });\n  };\n\n  /**\n   * Accepts the rootMargin value from the user configuration object\n   * and returns an array of the four margin values as an object containing\n   * the value and unit properties. If any of the values are not properly\n   * formatted or use a unit other than px or %, and error is thrown.\n   * @private\n   * @param {string=} opt_rootMargin An optional rootMargin value,\n   *     defaulting to '0px'.\n   * @return {Array<Object>} An array of margin objects with the keys\n   *     value and unit.\n   */\n  IntersectionObserver.prototype._parseRootMargin = function (opt_rootMargin) {\n    var marginString = opt_rootMargin || '0px';\n    var margins = marginString.split(/\\s+/).map(function (margin) {\n      var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n      if (!parts) {\n        throw new Error('rootMargin must be specified in pixels or percent');\n      }\n      return {\n        value: parseFloat(parts[1]),\n        unit: parts[2]\n      };\n    });\n\n    // Handles shorthand.\n    margins[1] = margins[1] || margins[0];\n    margins[2] = margins[2] || margins[0];\n    margins[3] = margins[3] || margins[1];\n    return margins;\n  };\n\n  /**\n   * Starts polling for intersection changes if the polling is not already\n   * happening, and if the page's visibility state is visible.\n   * @private\n   */\n  IntersectionObserver.prototype._monitorIntersections = function () {\n    if (!this._monitoringIntersections) {\n      this._monitoringIntersections = true;\n\n      // If a poll interval is set, use polling instead of listening to\n      // resize and scroll events or DOM mutations.\n      if (this.POLL_INTERVAL) {\n        this._monitoringInterval = setInterval(this._checkForIntersections, this.POLL_INTERVAL);\n      } else {\n        addEvent(window, 'resize', this._checkForIntersections, true);\n        addEvent(document, 'scroll', this._checkForIntersections, true);\n        if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in window) {\n          this._domObserver = new MutationObserver(this._checkForIntersections);\n          this._domObserver.observe(document, {\n            attributes: true,\n            childList: true,\n            characterData: true,\n            subtree: true\n          });\n        }\n      }\n    }\n  };\n\n  /**\n   * Stops polling for intersection changes.\n   * @private\n   */\n  IntersectionObserver.prototype._unmonitorIntersections = function () {\n    if (this._monitoringIntersections) {\n      this._monitoringIntersections = false;\n      clearInterval(this._monitoringInterval);\n      this._monitoringInterval = null;\n      removeEvent(window, 'resize', this._checkForIntersections, true);\n      removeEvent(document, 'scroll', this._checkForIntersections, true);\n      if (this._domObserver) {\n        this._domObserver.disconnect();\n        this._domObserver = null;\n      }\n    }\n  };\n\n  /**\n   * Scans each observation target for intersection changes and adds them\n   * to the internal entries queue. If new entries are found, it\n   * schedules the callback to be invoked.\n   * @private\n   */\n  IntersectionObserver.prototype._checkForIntersections = function () {\n    var rootIsInDom = this._rootIsInDom();\n    var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n    this._observationTargets.forEach(function (item) {\n      var target = item.element;\n      var targetRect = getBoundingClientRect(target);\n      var rootContainsTarget = this._rootContainsTarget(target);\n      var oldEntry = item.entry;\n      var intersectionRect = rootIsInDom && rootContainsTarget && this._computeTargetAndRootIntersection(target, rootRect);\n      var newEntry = item.entry = new IntersectionObserverEntry({\n        time: now(),\n        target: target,\n        boundingClientRect: targetRect,\n        rootBounds: rootRect,\n        intersectionRect: intersectionRect\n      });\n      if (!oldEntry) {\n        this._queuedEntries.push(newEntry);\n      } else if (rootIsInDom && rootContainsTarget) {\n        // If the new entry intersection ratio has crossed any of the\n        // thresholds, add a new entry.\n        if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n          this._queuedEntries.push(newEntry);\n        }\n      } else {\n        // If the root is not in the DOM or target is not contained within\n        // root but the previous entry for this target had an intersection,\n        // add a new record indicating removal.\n        if (oldEntry && oldEntry.isIntersecting) {\n          this._queuedEntries.push(newEntry);\n        }\n      }\n    }, this);\n    if (this._queuedEntries.length) {\n      this._callback(this.takeRecords(), this);\n    }\n  };\n\n  /**\n   * Accepts a target and root rect computes the intersection between then\n   * following the algorithm in the spec.\n   * TODO(philipwalton): at this time clip-path is not considered.\n   * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n   * @param {Element} target The target DOM element\n   * @param {Object} rootRect The bounding rect of the root after being\n   *     expanded by the rootMargin value.\n   * @return {?Object} The final intersection rect object or undefined if no\n   *     intersection is found.\n   * @private\n   */\n  IntersectionObserver.prototype._computeTargetAndRootIntersection = function (target, rootRect) {\n    // If the element isn't displayed, an intersection can't happen.\n    if (window.getComputedStyle(target).display == 'none') return;\n    var targetRect = getBoundingClientRect(target);\n    var intersectionRect = targetRect;\n    var parent = getParentNode(target);\n    var atRoot = false;\n    while (!atRoot) {\n      var parentRect = null;\n      var parentComputedStyle = parent.nodeType == 1 ? window.getComputedStyle(parent) : {};\n\n      // If the parent isn't displayed, an intersection can't happen.\n      if (parentComputedStyle.display == 'none') return;\n      if (parent == this.root || parent == document) {\n        atRoot = true;\n        parentRect = rootRect;\n      } else {\n        // If the element has a non-visible overflow, and it's not the <body>\n        // or <html> element, update the intersection rect.\n        // Note: <body> and <html> cannot be clipped to a rect that's not also\n        // the document rect, so no need to compute a new intersection.\n        if (parent != document.body && parent != document.documentElement && parentComputedStyle.overflow != 'visible') {\n          parentRect = getBoundingClientRect(parent);\n        }\n      }\n\n      // If either of the above conditionals set a new parentRect,\n      // calculate new intersection data.\n      if (parentRect) {\n        intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n        if (!intersectionRect) break;\n      }\n      parent = getParentNode(parent);\n    }\n    return intersectionRect;\n  };\n\n  /**\n   * Returns the root rect after being expanded by the rootMargin value.\n   * @return {Object} The expanded root rect.\n   * @private\n   */\n  IntersectionObserver.prototype._getRootRect = function () {\n    var rootRect;\n    if (this.root) {\n      rootRect = getBoundingClientRect(this.root);\n    } else {\n      // Use <html>/<body> instead of window since scroll bars affect size.\n      var html = document.documentElement;\n      var body = document.body;\n      rootRect = {\n        top: 0,\n        left: 0,\n        right: html.clientWidth || body.clientWidth,\n        width: html.clientWidth || body.clientWidth,\n        bottom: html.clientHeight || body.clientHeight,\n        height: html.clientHeight || body.clientHeight\n      };\n    }\n    return this._expandRectByRootMargin(rootRect);\n  };\n\n  /**\n   * Accepts a rect and expands it by the rootMargin value.\n   * @param {Object} rect The rect object to expand.\n   * @return {Object} The expanded rect.\n   * @private\n   */\n  IntersectionObserver.prototype._expandRectByRootMargin = function (rect) {\n    var margins = this._rootMarginValues.map(function (margin, i) {\n      return margin.unit == 'px' ? margin.value : margin.value * (i % 2 ? rect.width : rect.height) / 100;\n    });\n    var newRect = {\n      top: rect.top - margins[0],\n      right: rect.right + margins[1],\n      bottom: rect.bottom + margins[2],\n      left: rect.left - margins[3]\n    };\n    newRect.width = newRect.right - newRect.left;\n    newRect.height = newRect.bottom - newRect.top;\n    return newRect;\n  };\n\n  /**\n   * Accepts an old and new entry and returns true if at least one of the\n   * threshold values has been crossed.\n   * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n   *    particular target element or null if no previous entry exists.\n   * @param {IntersectionObserverEntry} newEntry The current entry for a\n   *    particular target element.\n   * @return {boolean} Returns true if a any threshold has been crossed.\n   * @private\n   */\n  IntersectionObserver.prototype._hasCrossedThreshold = function (oldEntry, newEntry) {\n    // To make comparing easier, an entry that has a ratio of 0\n    // but does not actually intersect is given a value of -1\n    var oldRatio = oldEntry && oldEntry.isIntersecting ? oldEntry.intersectionRatio || 0 : -1;\n    var newRatio = newEntry.isIntersecting ? newEntry.intersectionRatio || 0 : -1;\n\n    // Ignore unchanged ratios\n    if (oldRatio === newRatio) return;\n    for (var i = 0; i < this.thresholds.length; i++) {\n      var threshold = this.thresholds[i];\n\n      // Return true if an entry matches a threshold or if the new ratio\n      // and the old ratio are on the opposite sides of a threshold.\n      if (threshold == oldRatio || threshold == newRatio || threshold < oldRatio !== threshold < newRatio) {\n        return true;\n      }\n    }\n  };\n\n  /**\n   * Returns whether or not the root element is an element and is in the DOM.\n   * @return {boolean} True if the root element is an element and is in the DOM.\n   * @private\n   */\n  IntersectionObserver.prototype._rootIsInDom = function () {\n    return !this.root || containsDeep(document, this.root);\n  };\n\n  /**\n   * Returns whether or not the target element is a child of root.\n   * @param {Element} target The target element to check.\n   * @return {boolean} True if the target element is a child of root.\n   * @private\n   */\n  IntersectionObserver.prototype._rootContainsTarget = function (target) {\n    return containsDeep(this.root || document, target);\n  };\n\n  /**\n   * Adds the instance to the global IntersectionObserver registry if it isn't\n   * already present.\n   * @private\n   */\n  IntersectionObserver.prototype._registerInstance = function () {\n    if (registry.indexOf(this) < 0) {\n      registry.push(this);\n    }\n  };\n\n  /**\n   * Removes the instance from the global IntersectionObserver registry.\n   * @private\n   */\n  IntersectionObserver.prototype._unregisterInstance = function () {\n    var index = registry.indexOf(this);\n    if (index != -1) registry.splice(index, 1);\n  };\n\n  /**\n   * Returns the result of the performance.now() method or null in browsers\n   * that don't support the API.\n   * @return {number} The elapsed time since the page was requested.\n   */\n  function now() {\n    return window.performance && performance.now && performance.now();\n  }\n\n  /**\n   * Throttles a function and delays its execution, so it's only called at most\n   * once within a given time period.\n   * @param {Function} fn The function to throttle.\n   * @param {number} timeout The amount of time that must pass before the\n   *     function can be called again.\n   * @return {Function} The throttled function.\n   */\n  function throttle(fn, timeout) {\n    var timer = null;\n    return function () {\n      if (!timer) {\n        timer = setTimeout(function () {\n          fn();\n          timer = null;\n        }, timeout);\n      }\n    };\n  }\n\n  /**\n   * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n   * @param {Node} node The DOM node to add the event handler to.\n   * @param {string} event The event name.\n   * @param {Function} fn The event handler to add.\n   * @param {boolean} opt_useCapture Optionally adds the even to the capture\n   *     phase. Note: this only works in modern browsers.\n   */\n  function addEvent(node, event, fn, opt_useCapture) {\n    if (typeof node.addEventListener == 'function') {\n      node.addEventListener(event, fn, opt_useCapture || false);\n    } else if (typeof node.attachEvent == 'function') {\n      node.attachEvent('on' + event, fn);\n    }\n  }\n\n  /**\n   * Removes a previously added event handler from a DOM node.\n   * @param {Node} node The DOM node to remove the event handler from.\n   * @param {string} event The event name.\n   * @param {Function} fn The event handler to remove.\n   * @param {boolean} opt_useCapture If the event handler was added with this\n   *     flag set to true, it should be set to true here in order to remove it.\n   */\n  function removeEvent(node, event, fn, opt_useCapture) {\n    if (typeof node.removeEventListener == 'function') {\n      node.removeEventListener(event, fn, opt_useCapture || false);\n    } else if (typeof node.detatchEvent == 'function') {\n      node.detatchEvent('on' + event, fn);\n    }\n  }\n\n  /**\n   * Returns the intersection between two rect objects.\n   * @param {Object} rect1 The first rect.\n   * @param {Object} rect2 The second rect.\n   * @return {?Object} The intersection rect or undefined if no intersection\n   *     is found.\n   */\n  function computeRectIntersection(rect1, rect2) {\n    var top = Math.max(rect1.top, rect2.top);\n    var bottom = Math.min(rect1.bottom, rect2.bottom);\n    var left = Math.max(rect1.left, rect2.left);\n    var right = Math.min(rect1.right, rect2.right);\n    var width = right - left;\n    var height = bottom - top;\n    return width >= 0 && height >= 0 && {\n      top: top,\n      bottom: bottom,\n      left: left,\n      right: right,\n      width: width,\n      height: height\n    };\n  }\n\n  /**\n   * Shims the native getBoundingClientRect for compatibility with older IE.\n   * @param {Element} el The element whose bounding rect to get.\n   * @return {Object} The (possibly shimmed) rect of the element.\n   */\n  function getBoundingClientRect(el) {\n    var rect;\n    try {\n      rect = el.getBoundingClientRect();\n    } catch (err) {\n      // Ignore Windows 7 IE11 \"Unspecified error\"\n      // https://github.com/w3c/IntersectionObserver/pull/205\n    }\n    if (!rect) return getEmptyRect();\n\n    // Older IE\n    if (!(rect.width && rect.height)) {\n      rect = {\n        top: rect.top,\n        right: rect.right,\n        bottom: rect.bottom,\n        left: rect.left,\n        width: rect.right - rect.left,\n        height: rect.bottom - rect.top\n      };\n    }\n    return rect;\n  }\n\n  /**\n   * Returns an empty rect object. An empty rect is returned when an element\n   * is not in the DOM.\n   * @return {Object} The empty rect.\n   */\n  function getEmptyRect() {\n    return {\n      top: 0,\n      bottom: 0,\n      left: 0,\n      right: 0,\n      width: 0,\n      height: 0\n    };\n  }\n\n  /**\n   * Checks to see if a parent element contains a child element (including inside\n   * shadow DOM).\n   * @param {Node} parent The parent element.\n   * @param {Node} child The child element.\n   * @return {boolean} True if the parent node contains the child node.\n   */\n  function containsDeep(parent, child) {\n    var node = child;\n    while (node) {\n      if (node == parent) return true;\n      node = getParentNode(node);\n    }\n    return false;\n  }\n\n  /**\n   * Gets the parent node of an element or its host element if the parent node\n   * is a shadow root.\n   * @param {Node} node The node whose parent to get.\n   * @return {Node|null} The parent node or null if no parent exists.\n   */\n  function getParentNode(node) {\n    var parent = node.parentNode;\n    if (parent && parent.nodeType == 11 && parent.host) {\n      // If the parent is a shadow root, return the host element.\n      return parent.host;\n    }\n    if (parent && parent.assignedSlot) {\n      // If the parent is distributed in a <slot>, return the parent of a slot.\n      return parent.assignedSlot.parentNode;\n    }\n    return parent;\n  }\n\n  // Exposes the constructors globally.\n  window.IntersectionObserver = IntersectionObserver;\n  window.IntersectionObserverEntry = IntersectionObserverEntry;\n})();","//------------------------------------------------------------------------\n// Jump link navigation (used on disease pages and news landing)\n//------------------------------------------------------------------------\n\"use strict\";\n\nimport ExpandToggle from \"@threespot/expand-toggle\";\n\nclass ExplainerMobileNav {\n  constructor(el) {\n    this.el = el;\n    // Breakpoint at which to init JS (must match $layout-explainer-wide-bp in _layout-vars.scss)\n    this.mediaQueryList = window.matchMedia(\"(max-width: 899px)\");\n    this.contentEl = document.getElementById(this.el.getAttribute(\"data-expands\"));\n    // Determine if touch events are supported\n    this.eventType = \"ontouchend\" in window ? \"touchend\" : \"click\";\n    // Use separate var for click handler so we can remove it\n    this.windowClick = this.windowClickHandler.bind(this);\n\n    // Listen for breakpoint change\n    this.mediaQueryList.addListener(evt => {\n      if (evt.matches) {\n        this.init();\n      } else {\n        this.destroy();\n      }\n    });\n\n    // Init on load\n    if (this.mediaQueryList.matches) {\n      this.init();\n    }\n  }\n\n  windowClickHandler(evt) {\n    if (!evt.target.closest(\".ExplainerNavMobile-toggle\")) {\n      this.toggleExpand.collapse();\n    }\n  }\n\n  init() {\n    this.toggleExpand = new ExpandToggle(this.el);\n    window.addEventListener(this.eventType, this.windowClick);\n  }\n\n  destroy() {\n    this.toggleExpand.destroy();\n    window.removeEventListener(this.eventType, this.windowClick);\n  }\n}\n\n// Init\ndocument.querySelectorAll('.ExplainerNavMobile-toggle[data-expands]').forEach(el => new ExplainerMobileNav(el));\n","//------------------------------------------------------------------------\n// Modal windows\n//\n// - Progressively enhanced, works with pure CSS thanks to the `:target` pseudo selector\n// - Supports multiple toggles and multiple close buttons\n//\n// References:\n// - https://www.w3.org/TR/2017/NOTE-wai-aria-practices-1.1-20171214/examples/dialog-modal/dialog.html\n// - https://www.smashingmagazine.com/2014/09/making-modal-windows-better-for-everyone/\n// - https://www.smashingmagazine.com/2016/09/building-social-a-case-study-on-progressive-enhancement/\n// - https://bitsofco.de/accessible-modal-dialog/\n// - https://haltersweb.github.io/Accessibility/dialog.html\n// - https://yoast.com/dev-blog/the-a11y-monthly-making-modals-accessible/\n//\n// Note: Avoid aria-modal=\"true\" until support is beter\n//       https://labs.levelaccess.com/index.php/ARIA_Dialog_Role_with_modal_true\n//------------------------------------------------------------------------\n\"use strict\";\nimport scroll from \"@threespot/freeze-scroll\";\nimport EventEmitter from \"ev-emitter\";\n\n/**\n * Accessible modal window\n * @param {HTMLElement} el - Toggle button DOM node\n * @param {Object} opts - Options\n * @param {number} [opts.transitionSpeed=\"100\"] - CSS transition speed, required to delay focus\n * @param {string} [opts.activeClasses=\"\"] - Class(es) to apply when modal is open\n * @param {string} [opts.modalContentClass=\"Modal-content\"] - Class of modal content wrapper\n * @param {function} [opts.onReady=\"\"] - Ready callback function\n */\nexport default class Modal extends EventEmitter {\n  constructor(el, opts) {\n    // Have to call super() first before referencing “this” since we’re extending EventEmitter\n    // https://stackoverflow.com/a/43591507/673457\n    super();\n\n    // Use Object.assign() to merge “opts” object with default values in this.options\n    this.options = Object.assign(\n      {},\n      {\n        transitionSpeed: 100, // CSS transition speed, required to delay focus\n        activeClasses: \"\", // string, accepts multiple space-separated classes\n        modalContentClass: \"Modal-content\", // string, optional\n        onReady: null // ready callback function\n      },\n      opts\n    );\n\n    if (this.options.activeClasses.length) {\n      // Check if active class string contains multiple classes\n      if (this.options.activeClasses.indexOf(\" \") > -1) {\n        // Convert to array and remove any empty string values\n        // caused by having multiple spaces in a row.\n        this.options.activeClasses = this.options.activeClasses\n          .split(\" \")\n          .filter(n => n.length);\n      } else {\n        // We still need to convert a single active class to an array\n        // so we can use the spread syntax later in classList.add()\n        this.options.activeClasses = [this.options.activeClasses];\n      }\n    }\n\n    this.el = el;\n    this.el.classList.add(\"js-init\");\n    this.isOpen = false;\n    this.hasToggles = false;\n    this.contentEl = this.el.querySelector(\".Modal-content\");\n    this.customContentEl = this.el.querySelector(\".\" + this.options.modalContentClass) || this.contentEl;\n    this.closeEls = this.el.querySelectorAll(\"[data-modal-close]\");\n\n    // If modal has an ID, check for matching toggle elements with “data-modal” attribute\n    if (this.el.id) {\n      this.toggleEls = document.querySelectorAll(\n        `[data-modal=\"${this.el.id}\"]`\n      );\n      this.hasToggles = !!this.toggleEls.length;\n    } else {\n      // If modal doesn’t have an id, add a random one for “aria-controls”\n      // https://gist.github.com/gordonbrander/2230317\n      this.el.id = Math.random()\n        .toString(36)\n        .substr(2, 4);\n    }\n\n    // Store currently focused element when modal opens so we can restore focus when it closes\n    this.prevFocusedEl = null;\n\n    // Find focusable elements inside of modal window (used to prevent tabbing outside of modal)\n    this.focusableEls = this.getFocusableEls();\n\n    // Save first and last focusable elements\n    if (this.focusableEls.length) {\n      this.firstFocusableEl = this.focusableEls[0];\n      this.lastFocusableEl = this.focusableEls[this.focusableEls.length - 1];\n    }\n\n    // Check for aria-label/aria-labelledby on modal (a11y best practice)\n    if (\n      !this.el.getAttribute(\"aria-label\") &&\n      !this.el.getAttribute(\"aria-labelledby\")\n    ) {\n      console.warn(\n        \"A11y Issue: Modal window should have an “aria-label” or “aria-labelledby” attribute\",\n        this.el\n      );\n    }\n\n    // Init modal window\n    this.init();\n  }\n\n  init() {\n    // Add aria attributes to modal window\n    this.el.setAttribute(\"aria-hidden\", \"true\");\n    this.el.setAttribute(\"role\", \"dialog\");\n\n    // Add aria attributes to toggle buttons\n    if (this.hasToggles) {\n      this.toggleEls.forEach(toggleEl => {\n        // Add “aria-controls” but be aware only JAWS supports it\n        // https://inclusive-components.design/menus-menu-buttons/#ariacontrols\n        toggleEl.setAttribute(\"aria-controls\", this.el.id);\n        toggleEl.setAttribute(\"aria-expanded\", \"false\");\n        toggleEl.setAttribute(\"role\", \"button\");\n      });\n    }\n\n    // Add aria attributes to close buttons\n    if (this.closeEls.length) {\n      this.closeEls.forEach(closeEl => {\n        closeEl.setAttribute(\"role\", \"button\");\n      });\n    }\n\n    // Add event listeners\n    this.bindEvents();\n\n    // Check for ready callback\n    if (typeof this.options.onReady === \"function\") {\n      this.options.onReady();\n    }\n\n    // Check URL hash to determine if modal should start open\n    // if (\n    //   this.el.id &&\n    //   window.location.hash &&\n    //   window.location.hash.substring(1) == this.el.id\n    // ) {\n    //   this.open();\n    // }\n  }\n\n  destroy() {\n    // Remove aria attributes on modal window\n    this.el.removeAttribute(\"aria-hidden\");\n    this.el.removeAttribute(\"role\");\n    this.el.removeAttribute(\"tabindex\");\n\n    // Remove aria attributes on toggle buttons\n    if (this.hasToggles) {\n      this.toggleEls.forEach(toggleEl => {\n        toggleEl.removeAttribute(\"aria-controls\");\n        toggleEl.removeAttribute(\"aria-expanded\");\n        toggleEl.removeAttribute(\"role\");\n      });\n    }\n\n    // Remove aria attributes on close buttons\n    if (this.closeEls.length) {\n      this.closeEls.forEach(closeEl => {\n        closeEl.removeAttribute(\"aria-label\");\n        closeEl.removeAttribute(\"role\");\n      });\n    }\n\n    // Remove event listeners\n    this.unbindEvents();\n\n    // Trigger destroy event\n    this.emitEvent(\"destroy\");\n  }\n\n  // Find focusable elements inside of modal window (used to prevent tabbing outside of modal)\n  // Ignore links inside of nested modals.\n  // https://bitsofco.de/accessible-modal-dialog/\n  getFocusableEls() {\n    let focusableEls = this.el.querySelectorAll(\n      'a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), [tabindex=\"0\"]'\n    );\n\n    // Convert NodeList to array\n    focusableEls = [...focusableEls];\n\n    // If modal contains a nested modal, filter out nested elements\n    if (this.el.querySelector(\".Modal\")) {\n      focusableEls = focusableEls.filter(\n        el => el.closest(\".Modal\").isSameNode(this.el)\n      );\n    }\n\n    return focusableEls;\n  }\n\n  // Get currently focused element\n  // https://stackoverflow.com/a/40873560/673457\n  // Could also use document.querySelector(\":focus\") but that’s likely less performant\n  getFocusedEl() {\n    if (\n      document.hasFocus() &&\n      document.activeElement !== document.body &&\n      document.activeElement !== document.documentElement\n    ) {\n      return document.activeElement;\n    }\n\n    return null;\n  }\n\n  focusDelay(el) {\n    var self = this;\n    // Use setTimeout() to ensure element is focused\n    // https://stackoverflow.com/questions/33955650/what-is-settimeout-doing-when-set-to-0-milliseconds/33955673\n    // https://stackoverflow.com/questions/779379/why-is-settimeoutfn-0-sometimes-useful\n    // https://blog.sessionstack.com/how-javascript-works-event-loop-and-the-rise-of-async-programming-5-ways-to-better-coding-with-2f077c4438b5\n    window.setTimeout(() => el.focus(), this.options.transitionSpeed);\n  }\n\n  windowClickHandler(evt) {\n    if (!this.isOpen) {\n      return false;\n    }\n\n    // Ignore click on the toggle button, which already has an event handler\n    let isToggle = Array.prototype.indexOf.call(this.toggleEls, evt.target.closest(\"[data-modal]\")) > -1;\n    // Don’t close if target is a child of the modal wrapper\n    let targetInsideWrapper = this.customContentEl && this.customContentEl.contains(evt.target);\n    // Don’t close if target is the modal wrapper itself\n    let targetIsWrapper = this.customContentEl.isSameNode(evt.target);\n\n    if (\n      !isToggle &&\n      !(targetInsideWrapper || targetIsWrapper)\n    ) {\n      this.close(evt);\n    }\n  }\n\n  keydownHandler(evt) {\n    if (!this.isOpen) {\n      return false;\n    }\n\n    // Close with escape key\n    if (evt.which === 27) {\n      this.close(evt);\n    }\n\n    // Prevent tabbing outside of modal\n    if (evt.which === 9) {\n      // If no focusable items, close the modal\n      if (!this.focusableEls.length) {\n        this.close(evt);\n        return false;\n      }\n\n      // Find previously focused element (since we’re listening to “keydown”)\n      let focusedEl = this.getFocusedEl();\n\n      // If tabbing forward and the last item is focued, focus the first item\n      if (!evt.shiftKey && focusedEl.isSameNode(this.lastFocusableEl)) {\n        // Prevent default since we're manually focusing the first element\n        evt.preventDefault();\n        this.firstFocusableEl.focus();\n      } else if (\n        // If tabbing backwards and the first item is focused, focus the last item\n        evt.shiftKey &&\n        (\n          focusedEl.isSameNode(this.firstFocusableEl) ||\n          focusedEl.isSameNode(this.contentEl)\n        )\n      ) {\n        evt.preventDefault();\n        this.lastFocusableEl.focus();\n      }\n    }\n  }\n\n  bindEvents() {\n    // Toggle buttons\n    if (this.hasToggles) {\n      // Note: Event callbacks need to be assigned to a var so they can be removed\n      // https://stackoverflow.com/a/22870717/673457\n      this.toggleClick = this.toggle.bind(this);\n\n      this.toggleEls.forEach(toggleEl => {\n        toggleEl.addEventListener(\"click\", this.toggleClick);\n      });\n    }\n\n    // Close buttons\n    if (this.closeEls.length) {\n      // Note: Event callbacks need to be assigned to a var so they can be removed\n      // https://stackoverflow.com/a/22870717/673457\n      this.closeClick = this.close.bind(this);\n\n      this.closeEls.forEach(closeEl => {\n        // Ignore close buttons in nested modals\n        if (closeEl.closest('.Modal').isSameNode(this.el)) {\n          closeEl.addEventListener(\"click\", this.closeClick);\n        }\n      });\n    }\n\n    // Close if click outside of modal content\n    this.windowClick = this.windowClickHandler.bind(this);\n    window.addEventListener(\"click\", this.windowClick);\n\n    // Keyboard events\n    this.keydown = this.keydownHandler.bind(this);\n    window.addEventListener(\"keydown\", this.keydown);\n  }\n\n  unbindEvents() {\n    // Toggle buttons\n    if (this.hasToggles) {\n      this.toggleEls.forEach(toggleEl => {\n        toggleEl.removeEventListener(\"click\", this.toggleClick);\n      });\n    }\n\n    // Close buttons\n    if (this.closeEls.length) {\n      this.closeEls.forEach(closeEl => {\n        closeEl.removeEventListener(\"click\", this.closeClick);\n      });\n    }\n\n    // Window events\n    window.removeEventListener(\"click\", this.windowClick);\n    window.removeEventListener(\"keydown\", this.keydown);\n  }\n\n  // Expand expandable\n  open(evt) {\n    if (this.isOpen) {\n      return false;\n    }\n\n    evt.preventDefault();\n\n    // Save currently focused element to focus on close\n    this.prevFocusedEl = this.getFocusedEl();\n\n    // Disable scrolling\n    scroll.freeze();\n\n    // Scroll modal content to top\n    // (without this, content will be vertically centered)\n    if (this.contentEl) {\n      this.contentEl.scrollTop = 0;\n    }\n\n    // Update modal aria attributes\n    this.el.setAttribute(\"aria-hidden\", \"false\");\n\n    // Add custom classes\n    if (this.options.activeClasses.length) {\n      this.el.classList.add(...this.options.activeClasses);\n    }\n\n    // Update toggle aria attributes\n    if (this.hasToggles) {\n      this.toggleEls.forEach(toggleEl => {\n        toggleEl.setAttribute(\"aria-expanded\", \"true\");\n\n        // Add custom classes\n        if (this.options.activeClasses.length) {\n          toggleEl.classList.add(...this.options.activeClasses);\n        }\n      });\n    }\n\n    // Focus modal on open\n    if (this.contentEl) {\n      this.contentEl.setAttribute(\"tabindex\", \"-1\");\n      this.focusDelay(this.contentEl);\n    } else {\n      this.el.setAttribute(\"tabindex\", \"-1\");\n      this.focusDelay(this.el);\n    }\n\n    // Update URL hash so users can link directly to the modal window content\n    // Use history.replaceState() to prevent adding a new history entry\n    // Note: If replaceState isn’t supported, modal-toggles.js won’t prevent the\n    // default click event, causing the hash to update and creating a new history entry.\n    // if (history.replaceState) {\n    //   history.replaceState(null, \"\", \"#\" + this.el.id);\n    // }\n\n    // Update state\n    this.isOpen = true;\n\n    // Trigger open event\n    this.emitEvent(\"open\");\n  }\n\n  // Collapse expandable\n  close(evt) {\n    if (!this.isOpen) {\n      return false;\n    }\n\n    evt.preventDefault();\n\n    // Clear hash using replaceState() to prevent adding a new history entry\n    // if (history.replaceState) {\n    //   history.replaceState(null, \"\", window.location.pathname);\n    // }\n\n    // Update modal aria attributes\n    this.el.setAttribute(\"aria-hidden\", \"true\");\n\n    // Remove custom classes\n    if (this.options.activeClasses.length) {\n      this.el.classList.remove(...this.options.activeClasses);\n    }\n\n    // Update toggle aria attributes\n    if (this.hasToggles) {\n      this.toggleEls.forEach(toggleEl => {\n        toggleEl.setAttribute(\"aria-expanded\", \"false\");\n\n        // Remove custom classes\n        if (this.options.activeClasses.length) {\n          toggleEl.classList.remove(...this.options.activeClasses);\n        }\n      });\n    }\n\n    // Enable scrolling\n    scroll.unfreeze();\n\n    // Shift focus to previously focused element\n    if (this.prevFocusedEl) {\n      this.focusDelay(this.prevFocusedEl);\n    } else if (this.hasToggles) {\n      // Focus the first toggle if nothing was previously focused\n      this.focusDelay(this.toggleEls[0]);\n    }\n\n    // Update state\n    this.isOpen = false;\n\n    // Trigger close event\n    this.emitEvent(\"close\");\n  }\n\n  // Toggle expandable\n  toggle(evt) {\n    if (this.isOpen) {\n      this.close(evt);\n    } else {\n      this.open(evt);\n    }\n  }\n}\n","//------------------------------------------------------------------------\n// Modal windows\n//------------------------------------------------------------------------\nimport Modal from \"../lib/modals\";\n\nclass ExplainerModal {\n  constructor(el) {\n    // NOTE: Consider moving this to a global var since it’s shared across scripts\n    this.activeClass = \"is-stuck\";\n    this.closeLinks = document.querySelectorAll(\".Explainer-cta-close\");\n    // Note: Ignore first child since we’re manually adding “is-stuck” class to prevent a FOUC\n    this.slides = document.querySelectorAll(\".Explainer-slide:not(:first-child)\");\n    this.modal = new Modal(el);\n\n    this.modal.on(\"close\", () => {\n      this.reset();\n    });\n\n    // Close modal and scroll to target element (based on hash in href)\n    this.closeLinks.forEach(el => {\n      el.addEventListener(\"click\", evt => {\n        evt.preventDefault();\n        this.modal.close(evt);\n\n        let targetEl = evt.currentTarget;\n        let scrollTarget = document.querySelector(targetEl.hash);\n\n        if (scrollTarget) {\n          // Use setTimeout since scrolling will still be disabled by the modal\n          setTimeout(() => {\n            scrollTarget.scrollIntoView();\n          }, 100);\n        }\n      });\n    });\n  }\n\n  // Reset explainer to first slide (remove active classes)\n  reset() {\n    this.slides.forEach(el => {\n      el.classList.remove(this.activeClass);\n    });\n  }\n}\n\nconst el = document.querySelector('.Explainer');\n\nif (el) {\n  let modal = new ExplainerModal(el);\n}\n","//------------------------------------------------------------------------\n// Modal windows\n//------------------------------------------------------------------------\nimport Modal from \"../lib/modals\";\n\ndocument.querySelectorAll(\".Modal:not(.Explainer)\").forEach(el => new Modal(el));\n","//------------------------------------------------------------------------\n// Trigger crossfade on scroll in explainer component\n//\n// https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver\n// https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API\n// https://css-tricks.com/a-few-functional-uses-for-intersection-observer-to-know-when-an-element-is-in-view/\n// https://alligator.io/js/intersection-observer/\n//------------------------------------------------------------------------\n// Polyfill (included here instead of polyfills.js since we need it in Safari 12/iOS 12.1)\n// https://github.com/w3c/IntersectionObserver/tree/master/polyfill\n// https://caniuse.com/#feat=intersectionobserver\nimport \"intersection-observer\";\n// import debounce from \"lodash/debounce\";\nimport throttle from \"lodash/throttle\";\n\nclass Explainer {\n  constructor(slides) {\n    this.slides = slides;\n    this.modalContent = document.querySelector(\".Explainer-slides\");\n    this.desktopNavLinks = document.querySelectorAll(\".ExplainerNavDesktop-link\");\n\n    // Get elements to watch on scroll\n    this.watchEls = [];\n    this.slides.forEach(el => {\n      let scrollContent = el.querySelector(\".Explainer-slide-content\");\n      if (scrollContent) {\n        this.watchEls.push(scrollContent);\n      }\n    });\n\n    // Breakpoint at which to init JS (must match $layout-explainer-wide-bp in _layout-vars.scss)\n    this.mediaQueryList = window.matchMedia(\"(min-width: 900px)\");\n\n    // Class name to toggle when element is visible in viewport\n    this.stickyClass = \"is-stuck\";\n\n    // Class name to toggle on nav links\n    this.activeClass = \"is-active\";\n\n    // Element height percentage visible at which point to show/hide the current slide\n    // https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API#Thresholds\n    this.threshold = [0.2, 0.8];\n\n    // Placeholder for element y-offset values to determine scroll direction\n    this.yOffsets = {};\n\n    // Create new IntersectionObserver\n    this.observer = new IntersectionObserver(\n      (entries, observer) => {\n        entries.forEach(entry => {\n          this.observerHandler(entry);\n        });\n      }, { threshold: this.threshold }\n    );\n\n    // Listen for breakpoint change\n    this.mediaQueryList.addListener(evt => {\n      if (evt.matches) {\n        this.init();\n      } else {\n        this.destroy();\n      }\n    });\n\n    // Init on load\n    if (this.mediaQueryList.matches) {\n      this.init();\n    }\n\n    // Listen to scroll event so we can disable pointer events on modal toggles\n    let self = this;\n    window.addEventListener(\n      \"wheel\",\n      throttle(function(event) {\n        self.disableHover(event);\n      }, 50),\n      true\n    );\n  }\n\n  disableHover(event) {\n    clearTimeout(this.scrollTimer);\n    this.modalContent.classList.add('disable-hover');\n\n    this.scrollTimer = setTimeout( () => {\n      this.modalContent.classList.remove('disable-hover');\n    }, 50);\n  }\n\n  reset() {\n    // Scroll back to top since the logic only works when scrolling from the top\n    this.modalContent.scrollTop = 0;\n\n    // Remove active classes\n    this.slides.forEach(el => {\n      el.classList.remove(this.stickyClass);\n    });\n\n    for (var i=0, len=this.desktopNavLinks.length; i<len; i++) {\n      let el = this.desktopNavLinks[i];\n      el.classList.toggle(this.activeClass, i === 0);\n    }\n  }\n\n  init() {\n    // IntersectionObserver is buggy on window resize so manually reset\n    // https://github.com/w3c/IntersectionObserver/issues/311\n    this.reset();\n\n    this.watchEls.forEach(el => {\n      this.observer.observe(el);\n    });\n  }\n\n  destroy() {\n    // Disconnect all watchers\n    this.observer.disconnect();\n    this.reset();\n  }\n\n  observerHandler(entry) {\n    let title = \"“\" + entry.target.innerText.substring(0, 20) + \"…”\";\n    let scrollDirection = null;\n\n    // Determine scroll direction by comparing current y-offset to previous value\n    // Note: This requires adding a unique ID to each target element so we can reference it.\n    if (this.yOffsets[entry.target.id]) {\n      scrollDirection = entry.boundingClientRect.top < this.yOffsets[entry.target.id] ? \"down\" : \"up\";\n    }\n\n    // Update current y-offset value\n    this.yOffsets[entry.target.id] = entry.boundingClientRect.top;\n\n    // Instead of toggling the “is-stuck” class on just the active slide,\n    // we’re leaving it on previously active slides when scrolling down.\n    // When scrolling up, we’re removing it as each slide exits the viewport.\n    // This prevent a flash of the first slide’s background on crossfade\n    // when a slide fades out before the next one fades in, which can happen\n    // if the slide contains very little content.\n\n    // NOTE: If a users scrolls up and down VERY quickly in rapid succession,\n    // it’s possible for the observer to miss an event, causing the wrong\n    // background image to show. This could be fixed by updating ALL slide\n    // classes each time an observer fires, but that may hurt performance.\n\n    // If event fires while scrolling down, show if element if not cutoff on top\n    // (if it’s touching the top it should already be visible)\n    if (scrollDirection == \"down\" && entry.intersectionRect.top !== 0) {\n      // console.log(\"ENTER:\", title);\n      let slideEl = entry.target.closest(\".Explainer-slide\");\n      slideEl.classList.add(this.stickyClass);\n      // Update active nav link class\n      this.updateDesktopNav(slideEl.id, \"down\");\n    }\n    // If event fires while scrolling up, hide element if not cutoff on top\n    // (if it’s touching the top we want it to be visible)\n    else if (scrollDirection == \"up\" && entry.intersectionRect.top !== 0) {\n      let slideEl = entry.target.closest(\".Explainer-slide\");\n      // console.log(\"EXIT:\", title);\n      slideEl.classList.remove(this.stickyClass);\n      // Update active nav link class\n      this.updateDesktopNav(slideEl.id, \"up\");\n    }\n  }\n\n  updateDesktopNav(id, scrollDirection) {\n    let activeId = id;\n\n    // When scrolling up, the id refers to the slide that just left the viewport,\n    // so we need to subtract 1 to get the currently active slide.\n    if (scrollDirection == \"up\") {\n      let idArray = activeId.split(\"_\");\n      activeId = idArray[0] + \"_\" + (parseInt(idArray[1], 10) - 1);\n    }\n\n    this.desktopNavLinks.forEach(el => {\n      // Check if link “href” matches active slide “id”\n      el.classList.toggle(this.activeClass, el.hash == \"#\" + activeId);\n    });\n  }\n}\n\n// Init\n// Note: Ignore first child since we’re manually adding “is-stuck” class to prevent a FOUC\nconst slides = document.querySelectorAll('.Explainer-slide:not(:first-child)');\n\nif (slides.length) {\n  new Explainer(slides);\n}\n"],"sourceRoot":""}