{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///(webpack)/buildin/global.js","webpack:///./app/javascript/packs/blog.js","webpack:///./node_modules/prismjs/components/prism-core.js","webpack:///./node_modules/prismjs/components/prism-clike.js","webpack:///./node_modules/prismjs/components/prism-ruby.js","webpack:///./node_modules/prismjs/plugins/line-numbers/prism-line-numbers.js","webpack:///./node_modules/prismjs/plugins/toolbar/prism-toolbar.js","webpack:///./node_modules/prismjs/plugins/copy-to-clipboard/prism-copy-to-clipboard.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","_typeof","iterator","constructor","g","this","Function","e","window","document","addEventListener","Prism","highlightAll","_self","lang","uniqueId","plainTextGrammar","_","manual","disableWorkerMessageHandler","util","encode","tokens","Token","type","content","alias","Array","isArray","map","replace","toString","slice","objId","obj","clone","deepClone","visited","id","forEach","v","getLanguage","element","exec","className","toLowerCase","parentElement","setLanguage","language","RegExp","classList","add","currentScript","Error","err","src","stack","scripts","getElementsByTagName","isActive","defaultActivation","no","contains","languages","plain","plaintext","text","txt","extend","redef","insertBefore","inside","before","insert","root","grammar","ret","token","newToken","old","DFS","callback","propertyType","plugins","async","highlightAllUnder","container","env","selector","hooks","run","elements","apply","querySelectorAll","highlightElement","parent","nodeName","code","textContent","insertHighlightedCode","highlightedCode","innerHTML","hasAttribute","setAttribute","Worker","worker","filename","onmessage","evt","data","postMessage","JSON","stringify","immediateClose","highlight","tokenize","rest","tokenList","LinkedList","addAfter","head","matchGrammar","list","array","node","next","tail","push","toArray","all","callbacks","length","matchedStr","matchPattern","pattern","pos","lookbehind","lastIndex","match","lookbehindLength","index","startNode","startPos","rematch","patterns","j","cause","patternObj","greedy","global","flags","source","currentNode","reach","str","removeCount","from","to","k","matchStr","after","removeFrom","prev","removeRange","nestedRematch","newNode","count","tag","classes","attributes","aliases","join","message","parse","close","script","highlightAutomaticallyCallback","readyState","defer","requestAnimationFrame","setTimeout","WorkerGlobalScope","self","clike","ruby","interpolation","function","percentExpression","symbolName","string","rb","PLUGIN_NAME","NEW_LINE_EXP","config","lineNumbers","getLine","number","tagName","lineNumberRows","querySelector","lineNumberStart","parseInt","getAttribute","lineNumberEnd","children","lineIndex","resize","resizeElements","assumeViewportIndependence","lastWidth","undefined","innerWidth","pre","parentNode","test","remove","lineNumbersWrapper","linesNum","lines","createElement","style","counterReset","appendChild","filter","whiteSpace","getComputedStyle","currentStyle","getStyles","infos","codeElement","lineNumberSizer","codeLines","split","display","oneLinerHeight","getBoundingClientRect","height","lineHeights","sizer","Boolean","info","line","childIndex","wrapper","lineNumber","noop","toolbar","registerButton","opts","onClick","url","href","console","warn","hook","elementCallbacks","order","trim","getOrder","item","template","registerClipboard","copyInfo","navigator","clipboard","writeText","getText","then","success","fallbackCopyTextToClipboard","copyTextToClipboard","textArea","top","left","position","body","focus","select","successful","execCommand","error","removeChild","settings","startElement","attr","getSettings","linkCopy","linkSpan","setState","resetText","getSelection","selectAllChildren","selectElementText","state"],"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,wBClFrD,SAASC,EAAQvB,GAAgC,OAAOuB,EAAU,mBAAqBjB,QAAU,iBAAmBA,OAAOkB,SAAW,SAAUxB,GAAK,cAAcA,CAAG,EAAI,SAAUA,GAAK,OAAOA,GAAK,mBAAqBM,QAAUN,EAAEyB,cAAgBnB,QAAUN,IAAMM,OAAOa,UAAY,gBAAkBnB,CAAG,EAAGuB,EAAQvB,EAAI,CAC7T,IAAI0B,EAGJA,EAAI,WACF,OAAOC,IACT,CAFI,GAGJ,IAEED,EAAIA,GAAK,IAAIE,SAAS,cAAb,EACX,CAAE,MAAOC,GAEiE,YAAjD,qBAAXC,OAAyB,YAAcP,EAAQO,WAAuBJ,EAAII,OACxF,CAMAxC,EAAOD,QAAUqC,C,uGCjBjBK,SAASC,iBAAiB,mBAAmB,WAC3CC,MAAMC,cACR,G,mBCJA,YAEA,IAaID,EAAQ,SAAUE,GAEpB,IAAIC,EAAO,0CACPC,EAAW,EAGXC,EAAmB,CAAC,EACpBC,EAAI,CAsBNC,OAAQL,EAAMF,OAASE,EAAMF,MAAMO,OAsBnCC,4BAA6BN,EAAMF,OAASE,EAAMF,MAAMQ,4BAUxDC,KAAM,CACJC,OAAQ,SAASA,EAAOC,GACtB,OAAIA,aAAkBC,EACb,IAAIA,EAAMD,EAAOE,KAAMH,EAAOC,EAAOG,SAAUH,EAAOI,OACpDC,MAAMC,QAAQN,GAChBA,EAAOO,IAAIR,GAEXC,EAAOQ,QAAQ,KAAM,SAASA,QAAQ,KAAM,QAAQA,QAAQ,UAAW,IAElF,EAiBAN,KAAM,SAAc9C,GAClB,OAAOC,OAAOkB,UAAUkC,SAAS3D,KAAKM,GAAGsD,MAAM,GAAI,EACrD,EAOAC,MAAO,SAAeC,GAMpB,OALKA,EAAU,MACbvD,OAAOC,eAAesD,EAAK,OAAQ,CACjChD,QAAS6B,IAGNmB,EAAU,IACnB,EAWAC,MAAO,SAASC,EAAU1D,EAAG2D,GAE3B,IAAIF,EACAG,EACJ,OAHAD,EAAUA,GAAW,CAAC,EAGdpB,EAAEG,KAAKI,KAAK9C,IAClB,IAAK,SAEH,GADA4D,EAAKrB,EAAEG,KAAKa,MAAMvD,GACd2D,EAAQC,GACV,OAAOD,EAAQC,GAIjB,IAAK,IAAI9C,KAFT2C,EAA0C,CAAC,EAC3CE,EAAQC,GAAMH,EACEzD,EACVA,EAAEoB,eAAeN,KACnB2C,EAAM3C,GAAO4C,EAAU1D,EAAEc,GAAM6C,IAGnC,OAAyBF,EAC3B,IAAK,QAEH,OADAG,EAAKrB,EAAEG,KAAKa,MAAMvD,GACd2D,EAAQC,GACHD,EAAQC,IAEjBH,EAAQ,GACRE,EAAQC,GAAMH,EACd,EAA2CI,SAAQ,SAAUC,EAAGvE,GAC9DkE,EAAMlE,GAAKmE,EAAUI,EAAGH,EAC1B,IACyBF,GAC3B,QACE,OAAOzD,EAEb,EASA+D,YAAa,SAAqBC,GAChC,KAAOA,GAAS,CACd,IAAIrE,EAAIyC,EAAK6B,KAAKD,EAAQE,WAC1B,GAAIvE,EACF,OAAOA,EAAE,GAAGwE,cAEdH,EAAUA,EAAQI,aACpB,CACA,MAAO,MACT,EAQAC,YAAa,SAAqBL,EAASM,GAGzCN,EAAQE,UAAYF,EAAQE,UAAUd,QAAQmB,OAAOnC,EAAM,MAAO,IAIlE4B,EAAQQ,UAAUC,IAAI,YAAcH,EACtC,EAQAI,cAAe,WACb,GAAwB,qBAAb3C,SACT,OAAO,KAET,GAAI,kBAAmBA,SACrB,OAAyBA,SAAS2C,cAOpC,IACE,MAAM,IAAIC,KACZ,CAAE,MAAOC,GAQP,IAAIC,GAAO,qCAAqCZ,KAAKW,EAAIE,QAAU,IAAI,GACvE,GAAID,EAAK,CACP,IAAIE,EAAUhD,SAASiD,qBAAqB,UAC5C,IAAK,IAAIzF,KAAKwF,EACZ,GAAIA,EAAQxF,GAAGsF,KAAOA,EACpB,OAAOE,EAAQxF,EAGrB,CACA,OAAO,IACT,CACF,EAoBA0F,SAAU,SAAkBjB,EAASE,EAAWgB,GAE9C,IADA,IAAIC,EAAK,MAAQjB,EACVF,GAAS,CACd,IAAIQ,EAAYR,EAAQQ,UACxB,GAAIA,EAAUY,SAASlB,GACrB,OAAO,EAET,GAAIM,EAAUY,SAASD,GACrB,OAAO,EAETnB,EAAUA,EAAQI,aACpB,CACA,QAASc,CACX,GASFG,UAAW,CAITC,MAAOhD,EACPiD,UAAWjD,EACXkD,KAAMlD,EACNmD,IAAKnD,EA6BLoD,OAAQ,SAAgB9B,EAAI+B,GAC1B,IAAIvD,EAAOG,EAAEG,KAAKe,MAAMlB,EAAE8C,UAAUzB,IACpC,IAAK,IAAI9C,KAAO6E,EACdvD,EAAKtB,GAAO6E,EAAM7E,GAEpB,OAAOsB,CACT,EA4EAwD,aAAc,SAAsBC,EAAQC,EAAQC,EAAQC,GAE1D,IAAIC,GADJD,EAAOA,GAA2BzD,EAAW,WAC1BsD,GAEfK,EAAM,CAAC,EACX,IAAK,IAAIC,KAASF,EAChB,GAAIA,EAAQ7E,eAAe+E,GAAQ,CACjC,GAAIA,GAASL,EACX,IAAK,IAAIM,KAAYL,EACfA,EAAO3E,eAAegF,KACxBF,EAAIE,GAAYL,EAAOK,IAMxBL,EAAO3E,eAAe+E,KACzBD,EAAIC,GAASF,EAAQE,GAEzB,CAEF,IAAIE,EAAML,EAAKH,GASf,OARAG,EAAKH,GAAUK,EAGf3D,EAAE8C,UAAUiB,IAAI/D,EAAE8C,WAAW,SAAUvE,EAAKN,GACtCA,IAAU6F,GAAOvF,GAAO+E,IAC1BlE,KAAKb,GAAOoF,EAEhB,IACOA,CACT,EAEAI,IAAK,SAASA,EAAItG,EAAGuG,EAAUzD,EAAMa,GACnCA,EAAUA,GAAW,CAAC,EACtB,IAAIJ,EAAQhB,EAAEG,KAAKa,MACnB,IAAK,IAAIhE,KAAKS,EACZ,GAAIA,EAAEoB,eAAe7B,GAAI,CACvBgH,EAAS7G,KAAKM,EAAGT,EAAGS,EAAET,GAAIuD,GAAQvD,GAClC,IAAI2B,EAAWlB,EAAET,GACbiH,EAAejE,EAAEG,KAAKI,KAAK5B,GACV,WAAjBsF,GAA8B7C,EAAQJ,EAAMrC,IAGpB,UAAjBsF,GAA6B7C,EAAQJ,EAAMrC,MACpDyC,EAAQJ,EAAMrC,KAAa,EAC3BoF,EAAIpF,EAAUqF,EAAUhH,EAAGoE,KAJ3BA,EAAQJ,EAAMrC,KAAa,EAC3BoF,EAAIpF,EAAUqF,EAAU,KAAM5C,GAKlC,CAEJ,GAEF8C,QAAS,CAAC,EAaVvE,aAAc,SAAsBwE,EAAOH,GACzChE,EAAEoE,kBAAkB5E,SAAU2E,EAAOH,EACvC,EAgBAI,kBAAmB,SAA2BC,EAAWF,EAAOH,GAC9D,IAAIM,EAAM,CACRN,SAAUA,EACVK,UAAWA,EACXE,SAAU,oGAEZvE,EAAEwE,MAAMC,IAAI,sBAAuBH,GACnCA,EAAII,SAAWhE,MAAM9B,UAAUmC,MAAM4D,MAAML,EAAID,UAAUO,iBAAiBN,EAAIC,WAC9EvE,EAAEwE,MAAMC,IAAI,gCAAiCH,GAC7C,IAAK,IAAW7C,EAAPzE,EAAI,EAAYyE,EAAU6C,EAAII,SAAS1H,MAC9CgD,EAAE6E,iBAAiBpD,GAAmB,IAAV0C,EAAgBG,EAAIN,SAEpD,EA6BAa,iBAAkB,SAA0BpD,EAAS0C,EAAOH,GAE1D,IAAIjC,EAAW/B,EAAEG,KAAKqB,YAAYC,GAC9BiC,EAAU1D,EAAE8C,UAAUf,GAG1B/B,EAAEG,KAAK2B,YAAYL,EAASM,GAG5B,IAAI+C,EAASrD,EAAQI,cACjBiD,GAA4C,QAAlCA,EAAOC,SAASnD,eAC5B5B,EAAEG,KAAK2B,YAAYgD,EAAQ/C,GAE7B,IACIuC,EAAM,CACR7C,QAASA,EACTM,SAAUA,EACV2B,QAASA,EACTsB,KALSvD,EAAQwD,aAOnB,SAASC,EAAsBC,GAC7Bb,EAAIa,gBAAkBA,EACtBnF,EAAEwE,MAAMC,IAAI,gBAAiBH,GAC7BA,EAAI7C,QAAQ2D,UAAYd,EAAIa,gBAC5BnF,EAAEwE,MAAMC,IAAI,kBAAmBH,GAC/BtE,EAAEwE,MAAMC,IAAI,WAAYH,GACxBN,GAAYA,EAAS7G,KAAKmH,EAAI7C,QAChC,CAQA,GAPAzB,EAAEwE,MAAMC,IAAI,sBAAuBH,IAGnCQ,EAASR,EAAI7C,QAAQI,gBAC2B,QAAlCiD,EAAOC,SAASnD,gBAA4BkD,EAAOO,aAAa,aAC5EP,EAAOQ,aAAa,WAAY,MAE7BhB,EAAIU,KAGP,OAFAhF,EAAEwE,MAAMC,IAAI,WAAYH,QACxBN,GAAYA,EAAS7G,KAAKmH,EAAI7C,UAIhC,GADAzB,EAAEwE,MAAMC,IAAI,mBAAoBH,GAC3BA,EAAIZ,QAIT,GAAIS,GAASvE,EAAM2F,OAAQ,CACzB,IAAIC,EAAS,IAAID,OAAOvF,EAAEyF,UAC1BD,EAAOE,UAAY,SAAUC,GAC3BT,EAAsBS,EAAIC,KAC5B,EACAJ,EAAOK,YAAYC,KAAKC,UAAU,CAChChE,SAAUuC,EAAIvC,SACdiD,KAAMV,EAAIU,KACVgB,gBAAgB,IAEpB,MACEd,EAAsBlF,EAAEiG,UAAU3B,EAAIU,KAAMV,EAAIZ,QAASY,EAAIvC,gBAd7DmD,EAAsBlF,EAAEG,KAAKC,OAAOkE,EAAIU,MAgB5C,EAqBAiB,UAAW,SAAmBhD,EAAMS,EAAS3B,GAC3C,IAAIuC,EAAM,CACRU,KAAM/B,EACNS,QAASA,EACT3B,SAAUA,GAGZ,GADA/B,EAAEwE,MAAMC,IAAI,kBAAmBH,IAC1BA,EAAIZ,QACP,MAAM,IAAItB,MAAM,iBAAmBkC,EAAIvC,SAAW,qBAIpD,OAFAuC,EAAIjE,OAASL,EAAEkG,SAAS5B,EAAIU,KAAMV,EAAIZ,SACtC1D,EAAEwE,MAAMC,IAAI,iBAAkBH,GACvBhE,EAAMyF,UAAU/F,EAAEG,KAAKC,OAAOkE,EAAIjE,QAASiE,EAAIvC,SACxD,EAyBAmE,SAAU,SAAkBjD,EAAMS,GAChC,IAAIyC,EAAOzC,EAAQyC,KACnB,GAAIA,EAAM,CACR,IAAK,IAAIvC,KAASuC,EAChBzC,EAAQE,GAASuC,EAAKvC,UAEjBF,EAAQyC,IACjB,CACA,IAAIC,EAAY,IAAIC,EAGpB,OAFAC,EAASF,EAAWA,EAAUG,KAAMtD,GACpCuD,EAAavD,EAAMmD,EAAW1C,EAAS0C,EAAUG,KAAM,GA2Y3D,SAAiBE,GACf,IAAIC,EAAQ,GACRC,EAAOF,EAAKF,KAAKK,KACrB,KAAOD,IAASF,EAAKI,MACnBH,EAAMI,KAAKH,EAAK1I,OAChB0I,EAAOA,EAAKC,KAEd,OAAOF,CACT,CAlZWK,CAAQX,EACjB,EAMA5B,MAAO,CACLwC,IAAK,CAAC,EAaN9E,IAAK,SAAa3E,EAAMyG,GACtB,IAAIQ,EAAQxE,EAAEwE,MAAMwC,IACpBxC,EAAMjH,GAAQiH,EAAMjH,IAAS,GAC7BiH,EAAMjH,GAAMuJ,KAAK9C,EACnB,EAUAS,IAAK,SAAalH,EAAM+G,GACtB,IAAI2C,EAAYjH,EAAEwE,MAAMwC,IAAIzJ,GAC5B,GAAK0J,GAAcA,EAAUC,OAG7B,IAAK,IAAWlD,EAAPhH,EAAI,EAAagH,EAAWiD,EAAUjK,MAC7CgH,EAASM,EAEb,GAEFhE,MAAOA,GAoBT,SAASA,EAAMC,EAAMC,EAASC,EAAO0G,GAUnC/H,KAAKmB,KAAOA,EASZnB,KAAKoB,QAAUA,EAQfpB,KAAKqB,MAAQA,EAEbrB,KAAK8H,OAAqC,GAA3BC,GAAc,IAAID,MACnC,CAwEA,SAASE,EAAaC,EAASC,EAAKrE,EAAMsE,GACxCF,EAAQG,UAAYF,EACpB,IAAIG,EAAQJ,EAAQ3F,KAAKuB,GACzB,GAAIwE,GAASF,GAAcE,EAAM,GAAI,CAEnC,IAAIC,EAAmBD,EAAM,GAAGP,OAChCO,EAAME,OAASD,EACfD,EAAM,GAAKA,EAAM,GAAG1G,MAAM2G,EAC5B,CACA,OAAOD,CACT,CAgBA,SAASjB,EAAavD,EAAMmD,EAAW1C,EAASkE,EAAWC,EAAUC,GACnE,IAAK,IAAIlE,KAASF,EAChB,GAAKA,EAAQ7E,eAAe+E,IAAWF,EAAQE,GAA/C,CAGA,IAAImE,EAAWrE,EAAQE,GACvBmE,EAAWrH,MAAMC,QAAQoH,GAAYA,EAAW,CAACA,GACjD,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAASb,SAAUc,EAAG,CACxC,GAAIF,GAAWA,EAAQG,OAASrE,EAAQ,IAAMoE,EAC5C,OAEF,IAAIE,EAAaH,EAASC,GACtB1E,EAAS4E,EAAW5E,OACpBiE,IAAeW,EAAWX,WAC1BY,IAAWD,EAAWC,OACtB1H,EAAQyH,EAAWzH,MACvB,GAAI0H,IAAWD,EAAWb,QAAQe,OAAQ,CAExC,IAAIC,EAAQH,EAAWb,QAAQvG,WAAW2G,MAAM,aAAa,GAC7DS,EAAWb,QAAUrF,OAAOkG,EAAWb,QAAQiB,OAAQD,EAAQ,IACjE,CAIA,IADA,IAAIhB,EAAUa,EAAWb,SAAWa,EAGhCK,EAAcX,EAAUhB,KAAMU,EAAMO,EAAUU,IAAgBnC,EAAUS,QACtEiB,GAAWR,GAAOQ,EAAQU,OADkDlB,GAAOiB,EAAYtK,MAAMiJ,OAAQqB,EAAcA,EAAY3B,KAAM,CAIjJ,IAAI6B,EAAMF,EAAYtK,MACtB,GAAImI,EAAUc,OAASjE,EAAKiE,OAE1B,OAEF,KAAIuB,aAAenI,GAAnB,CAGA,IACImH,EADAiB,EAAc,EAElB,GAAIP,EAAQ,CAEV,KADAV,EAAQL,EAAaC,EAASC,EAAKrE,EAAMsE,KAC3BE,EAAME,OAAS1E,EAAKiE,OAChC,MAEF,IAAIyB,EAAOlB,EAAME,MACbiB,EAAKnB,EAAME,MAAQF,EAAM,GAAGP,OAC5BpI,EAAIwI,EAIR,IADAxI,GAAKyJ,EAAYtK,MAAMiJ,OAChByB,GAAQ7J,GAEbA,IADAyJ,EAAcA,EAAY3B,MACT3I,MAAMiJ,OAOzB,GAHAI,EADAxI,GAAKyJ,EAAYtK,MAAMiJ,OAInBqB,EAAYtK,iBAAiBqC,EAC/B,SAIF,IAAK,IAAIuI,EAAIN,EAAaM,IAAMzC,EAAUS,OAAS/H,EAAI8J,GAAyB,kBAAZC,EAAE5K,OAAqB4K,EAAIA,EAAEjC,KAC/F8B,IACA5J,GAAK+J,EAAE5K,MAAMiJ,OAEfwB,IAGAD,EAAMxF,EAAKlC,MAAMuG,EAAKxI,GACtB2I,EAAME,OAASL,CACjB,MAEE,KADAG,EAAQL,EAAaC,EAAS,EAAGoB,EAAKlB,IAEpC,SAKAoB,EAAOlB,EAAME,MAAjB,IACImB,EAAWrB,EAAM,GACjBlE,EAASkF,EAAI1H,MAAM,EAAG4H,GACtBI,EAAQN,EAAI1H,MAAM4H,EAAOG,EAAS5B,QAClCsB,EAAQlB,EAAMmB,EAAIvB,OAClBY,GAAWU,EAAQV,EAAQU,QAC7BV,EAAQU,MAAQA,GAElB,IAAIQ,EAAaT,EAAYU,KAW7B,GAVI1F,IACFyF,EAAa1C,EAASF,EAAW4C,EAAYzF,GAC7C+D,GAAO/D,EAAO2D,QAEhBgC,EAAY9C,EAAW4C,EAAYN,GAEnCH,EAAcjC,EAASF,EAAW4C,EADpB,IAAI1I,EAAMsD,EAAON,EAAStD,EAAEkG,SAAS4C,EAAUxF,GAAUwF,EAAUrI,EAAOqI,IAEpFC,GACFzC,EAASF,EAAWmC,EAAaQ,GAE/BL,EAAc,EAAG,CAKnB,IAAIS,EAAgB,CAClBlB,MAAOrE,EAAQ,IAAMoE,EACrBQ,MAAOA,GAEThC,EAAavD,EAAMmD,EAAW1C,EAAS6E,EAAYU,KAAM3B,EAAK6B,GAG1DrB,GAAWqB,EAAcX,MAAQV,EAAQU,QAC3CV,EAAQU,MAAQW,EAAcX,MAElC,CA/EA,CAgFF,CACF,CAlHA,CAoHJ,CAeA,SAASnC,IAEP,IAAIE,EAAO,CACTtI,MAAO,KACPgL,KAAM,KACNrC,KAAM,MAGJC,EAAO,CACT5I,MAAO,KACPgL,KAAM1C,EACNK,KAAM,MAERL,EAAKK,KAAOC,EAGZzH,KAAKmH,KAAOA,EAEZnH,KAAKyH,KAAOA,EACZzH,KAAK8H,OAAS,CAChB,CAWA,SAASZ,EAASG,EAAME,EAAM1I,GAE5B,IAAI2I,EAAOD,EAAKC,KACZwC,EAAU,CACZnL,MAAOA,EACPgL,KAAMtC,EACNC,KAAMA,GAKR,OAHAD,EAAKC,KAAOwC,EACZxC,EAAKqC,KAAOG,EACZ3C,EAAKS,SACEkC,CACT,CASA,SAASF,EAAYzC,EAAME,EAAM0C,GAE/B,IADA,IAAIzC,EAAOD,EAAKC,KACP5J,EAAI,EAAGA,EAAIqM,GAASzC,IAASH,EAAKI,KAAM7J,IAC/C4J,EAAOA,EAAKA,KAEdD,EAAKC,KAAOA,EACZA,EAAKqC,KAAOtC,EACZF,EAAKS,QAAUlK,CACjB,CAeA,GApWA4C,EAAMF,MAAQM,EA8EdM,EAAMyF,UAAY,SAASA,EAAUtI,EAAGsE,GACtC,GAAgB,iBAALtE,EACT,OAAOA,EAET,GAAIiD,MAAMC,QAAQlD,GAAI,CACpB,IAAIsB,EAAI,GAIR,OAHAtB,EAAE6D,SAAQ,SAAUhC,GAClBP,GAAKgH,EAAUzG,EAAGyC,EACpB,IACOhD,CACT,CACA,IAAIuF,EAAM,CACR/D,KAAM9C,EAAE8C,KACRC,QAASuF,EAAUtI,EAAE+C,QAASuB,GAC9BuH,IAAK,OACLC,QAAS,CAAC,QAAS9L,EAAE8C,MACrBiJ,WAAY,CAAC,EACbzH,SAAUA,GAER0H,EAAUhM,EAAEgD,MACZgJ,IACE/I,MAAMC,QAAQ8I,GAChB/I,MAAM9B,UAAUkI,KAAKnC,MAAML,EAAIiF,QAASE,GAExCnF,EAAIiF,QAAQzC,KAAK2C,IAGrBzJ,EAAEwE,MAAMC,IAAI,OAAQH,GACpB,IAAIkF,EAAa,GACjB,IAAK,IAAIjM,KAAQ+G,EAAIkF,WACnBA,GAAc,IAAMjM,EAAO,MAAQ+G,EAAIkF,WAAWjM,IAAS,IAAIsD,QAAQ,KAAM,UAAY,IAE3F,MAAO,IAAMyD,EAAIgF,IAAM,WAAahF,EAAIiF,QAAQG,KAAK,KAAO,IAAMF,EAAa,IAAMlF,EAAI9D,QAAU,KAAO8D,EAAIgF,IAAM,GACtH,GAqPK1J,EAAMJ,SACT,OAAKI,EAAMH,kBAINO,EAAEE,6BAELN,EAAMH,iBAAiB,WAAW,SAAUkG,GAC1C,IAAIgE,EAAU7D,KAAK8D,MAAMjE,EAAIC,MACzB/F,EAAO8J,EAAQ5H,SACfiD,EAAO2E,EAAQ3E,KACfgB,EAAiB2D,EAAQ3D,eAC7BpG,EAAMiG,YAAY7F,EAAEiG,UAAUjB,EAAMhF,EAAE8C,UAAUjD,GAAOA,IACnDmG,GACFpG,EAAMiK,OAEV,IAAG,GAEE7J,GAfEA,EAmBX,IAAI8J,EAAS9J,EAAEG,KAAKgC,gBAOpB,SAAS4H,IACF/J,EAAEC,QACLD,EAAEL,cAEN,CACA,GAXImK,IACF9J,EAAEyF,SAAWqE,EAAOxH,IAChBwH,EAAOzE,aAAa,iBACtBrF,EAAEC,QAAS,KAQVD,EAAEC,OAAQ,CAOb,IAAI+J,EAAaxK,SAASwK,WACP,YAAfA,GAA2C,gBAAfA,GAAgCF,GAAUA,EAAOG,MAC/EzK,SAASC,iBAAiB,mBAAoBsK,GAE1CxK,OAAO2K,sBACT3K,OAAO2K,sBAAsBH,GAE7BxK,OAAO4K,WAAWJ,EAAgC,GAGxD,CACA,OAAO/J,CACT,CAjkCY,CAbkB,qBAAXT,OAAyBA,OACb,qBAAtB6K,mBAAqCC,gBAAgBD,kBAAoBC,KAChF,CAAC,GA6kCkCtN,EAAOD,UAC1CC,EAAOD,QAAU4C,GAIG,qBAAX0I,IACTA,EAAO1I,MAAQA,E,kCCvlCjBA,MAAMoD,UAAUwH,MAAQ,CACtB,QAAW,CAAC,CACVjD,QAAS,kCACTE,YAAY,EACZY,QAAQ,GACP,CACDd,QAAS,mBACTE,YAAY,EACZY,QAAQ,IAEV,OAAU,CACRd,QAAS,iDACTc,QAAQ,GAEV,aAAc,CACZd,QAAS,2FACTE,YAAY,EACZjE,OAAQ,CACN,YAAe,UAGnB,QAAW,6GACX,QAAW,qBACX,SAAY,cACZ,OAAU,4DACV,SAAY,+CACZ,YAAe,gB,iBCpBjB,SAAW5D,GACTA,EAAMoD,UAAUyH,KAAO7K,EAAMoD,UAAUK,OAAO,QAAS,CACrD,QAAW,CACTkE,QAAS,8BACTc,QAAQ,GAEV,aAAc,CACZd,QAAS,4EACTE,YAAY,EACZjE,OAAQ,CACN,YAAe,UAGnB,QAAW,mSACX,SAAY,4EACZ,YAAe,iBAEjB5D,EAAMoD,UAAUO,aAAa,OAAQ,WAAY,CAC/C,eAAgB,CACdgE,QAAS,KACT5G,MAAO,iBAGX,IAAI+J,EAAgB,CAClBnD,QAAS,oDACTE,YAAY,EACZjE,OAAQ,CACN,QAAW,CACT+D,QAAS,uBACTE,YAAY,EACZjE,OAAQ5D,EAAMoD,UAAUyH,MAE1B,UAAa,CACXlD,QAAS,WACT5G,MAAO,wBAINf,EAAMoD,UAAUyH,KAAKE,SAC5B,IAAIC,EAAoB,MAAQ,CAAC,oDAAoDpC,OAAQ,sDAAsDA,OAAQ,sDAAsDA,OAAQ,0DAA0DA,OAAQ,kDAAkDA,QAAQoB,KAAK,KAAO,IAC7ViB,EAAa,sEAAsErC,OACvF5I,EAAMoD,UAAUO,aAAa,OAAQ,UAAW,CAC9C,gBAAiB,CAAC,CAChBgE,QAASrF,OAAO,KAAKsG,OAASoC,EAAoB,mBAAmBpC,QACrEH,QAAQ,EACR7E,OAAQ,CACN,cAAiBkH,EACjB,MAAS,YAEV,CACDnD,QAAS,iGACTE,YAAY,EACZY,QAAQ,EACR7E,OAAQ,CACN,cAAiBkH,EACjB,MAAS,aAGb,SAAY,+BACZ,OAAU,CAAC,CACTnD,QAASrF,OAAO,YAAYsG,OAASqC,GACrCpD,YAAY,EACZY,QAAQ,GACP,CACDd,QAASrF,OAAO,oBAAoBsG,OAASqC,EAAa,aAAarC,QACvEf,YAAY,EACZY,QAAQ,IAEV,oBAAqB,CACnBd,QAAS,gCACTE,YAAY,EACZjE,OAAQ,CACN,SAAY,SACZ,QAAW,UACX,aAAc,OACd,YAAe,SAIrB5D,EAAMoD,UAAUO,aAAa,OAAQ,SAAU,CAC7C,iBAAkB,CAAC,CACjBgE,QAASrF,OAAO,cAAcsG,OAASoC,GACvCvC,QAAQ,EACR7E,OAAQ,CACN,cAAiBkH,EACjB,OAAU,YAEX,CACDnD,QAAS,oEACTc,QAAQ,EACR7E,OAAQ,CACN,cAAiBkH,EACjB,OAAU,YAEX,CACDnD,QAAS,kDACT5G,MAAO,iBACP0H,QAAQ,EACR7E,OAAQ,CACN,UAAa,CACX+D,QAAS,kCACT/D,OAAQ,CACN,OAAU,QACV,YAAe,aAGnB,cAAiBkH,EACjB,OAAU,YAEX,CACDnD,QAAS,oDACT5G,MAAO,iBACP0H,QAAQ,EACR7E,OAAQ,CACN,UAAa,CACX+D,QAAS,oCACT/D,OAAQ,CACN,OAAU,QACV,YAAe,iBAGnB,OAAU,aAGd,kBAAmB,CAAC,CAClB+D,QAASrF,OAAO,KAAKsG,OAASoC,GAC9BvC,QAAQ,EACR7E,OAAQ,CACN,cAAiBkH,EACjB,QAAW,CACTnD,QAAS,UACT5G,MAAO,YAGV,CACD4G,QAAS,0DACTc,QAAQ,EACR7E,OAAQ,CACN,cAAiBkH,EACjB,QAAW,CACTnD,QAAS,UACT5G,MAAO,sBAKRf,EAAMoD,UAAUyH,KAAKK,OAC5BlL,EAAMoD,UAAUO,aAAa,OAAQ,SAAU,CAC7C,QAAW,+OACX,SAAY,iCAEd3D,EAAMoD,UAAU+H,GAAKnL,EAAMoD,UAAUyH,IACtC,CAxJD,CAwJG7K,M,mCC9JH,WACE,GAAqB,qBAAVA,OAA6C,qBAAbF,SAA3C,CASA,IAAIsL,EAAc,eAOdC,EAAe,WAKfC,EAAStL,MAAMwE,QAAQ+G,YAAc,CAQvCC,QAAS,SAAiBzJ,EAAS0J,GACjC,GAAwB,QAApB1J,EAAQ2J,SAAsB3J,EAAQQ,UAAUY,SAASiI,GAA7D,CAGA,IAAIO,EAAiB5J,EAAQ6J,cAAc,sBAC3C,GAAKD,EAAL,CAGA,IAAIE,EAAkBC,SAAS/J,EAAQgK,aAAa,cAAe,KAAO,EACtEC,EAAgBH,GAAmBF,EAAeM,SAASzE,OAAS,GACpEiE,EAASI,IACXJ,EAASI,GAEPJ,EAASO,IACXP,EAASO,GAEX,IAAIE,EAAYT,EAASI,EACzB,OAAOF,EAAeM,SAASC,EAV/B,CAJA,CAeF,EASAC,OAAQ,SAAgBpK,GACtBqK,EAAe,CAACrK,GAClB,EAWAsK,4BAA4B,GA4F1BC,OAAYC,EAChB1M,OAAOE,iBAAiB,UAAU,WAC5BuL,EAAOe,4BAA8BC,IAAczM,OAAO2M,aAG9DF,EAAYzM,OAAO2M,WACnBJ,EAAepL,MAAM9B,UAAUmC,MAAM5D,KAAKqC,SAASoF,iBAAiB,OAASkG,KAC/E,IACApL,MAAM8E,MAAMtC,IAAI,YAAY,SAAUoC,GACpC,GAAKA,EAAIU,KAAT,CAGA,IAAIA,EAA6BV,EAAI7C,QACjC0K,EAAgCnH,EAAKoH,WAGzC,GAAKD,GAAQ,OAAOE,KAAKF,EAAIpH,YAKzBC,EAAKsG,cAAc,uBAKlB5L,MAAMS,KAAKuC,SAASsC,EAAM8F,GAA/B,CAKA9F,EAAK/C,UAAUqK,OAAOxB,GAEtBqB,EAAIlK,UAAUC,IAAI4I,GAClB,IAEIyB,EAFA9E,EAAQnD,EAAIU,KAAKyC,MAAMsD,GACvByB,EAAW/E,EAAQA,EAAMP,OAAS,EAAI,EAEtCuF,EAAQ,IAAI/L,MAAM8L,EAAW,GAAG9C,KAAK,kBACzC6C,EAAqB/M,SAASkN,cAAc,SACzBpH,aAAa,cAAe,QAC/CiH,EAAmB5K,UAAY,oBAC/B4K,EAAmBnH,UAAYqH,EAC3BN,EAAI9G,aAAa,gBACnB8G,EAAIQ,MAAMC,aAAe,eAAiBpB,SAASW,EAAIV,aAAa,cAAe,IAAM,IAE3FnH,EAAI7C,QAAQoL,YAAYN,GACxBT,EAAe,CAACK,IAChBzM,MAAM8E,MAAMC,IAAI,eAAgBH,EAnBhC,CAjBA,CAqCF,IACA5E,MAAM8E,MAAMtC,IAAI,gBAAgB,SAAUoC,GACxCA,EAAIJ,QAAUI,EAAIJ,SAAW,CAAC,EAC9BI,EAAIJ,QAAQ+G,aAAc,CAC5B,GAnNA,CA2EA,SAASa,EAAepH,GAMtB,GAAuB,IALvBA,EAAWA,EAASoI,QAAO,SAAUxN,GACnC,IACIyN,EA2ER,SAAmBtL,GACjB,IAAKA,EACH,OAAO,KAET,OAAOlC,OAAOyN,iBAAmBA,iBAAiBvL,GAAWA,EAAQwL,cAAgB,IACvF,CAjFqBC,CAAU5N,GACC,eAC5B,MAAsB,aAAfyN,GAA4C,aAAfA,CACtC,KACa7F,OAAb,CAGA,IAAIiG,EAAQzI,EAAS9D,KAAI,SAAUa,GACjC,IAAI2L,EAAc3L,EAAQ6J,cAAc,QACpCiB,EAAqB9K,EAAQ6J,cAAc,sBAC/C,GAAK8B,GAAgBb,EAArB,CAKA,IAAIc,EAAkB5L,EAAQ6J,cAAc,uBACxCgC,EAAYF,EAAYnI,YAAYsI,MAAMxC,GACzCsC,KACHA,EAAkB7N,SAASkN,cAAc,SACzB/K,UAAY,qBAC5ByL,EAAYP,YAAYQ,IAE1BA,EAAgBjI,UAAY,IAC5BiI,EAAgBV,MAAMa,QAAU,QAChC,IAAIC,EAAiBJ,EAAgBK,wBAAwBC,OAE7D,OADAN,EAAgBjI,UAAY,GACrB,CACL3D,QAASA,EACTgL,MAAOa,EACPM,YAAa,GACbH,eAAgBA,EAChBI,MAAOR,EAnBT,CAqBF,IAAGP,OAAOgB,SACVX,EAAM7L,SAAQ,SAAUyM,GACtB,IAAIV,EAAkBU,EAAKF,MACvBpB,EAAQsB,EAAKtB,MACbmB,EAAcG,EAAKH,YACnBH,EAAiBM,EAAKN,eAC1BG,EAAYnB,EAAMvF,OAAS,QAAK+E,EAChCQ,EAAMnL,SAAQ,SAAU0M,EAAMrG,GAC5B,GAAIqG,GAAQA,EAAK9G,OAAS,EAAG,CAC3B,IAAI5H,EAAI+N,EAAgBR,YAAYrN,SAASkN,cAAc,SAC3DpN,EAAEqN,MAAMa,QAAU,QAClBlO,EAAE2F,YAAc+I,CAClB,MACEJ,EAAYjG,GAAS8F,CAEzB,GACF,IACAN,EAAM7L,SAAQ,SAAUyM,GAItB,IAHA,IAAIV,EAAkBU,EAAKF,MACvBD,EAAcG,EAAKH,YACnBK,EAAa,EACRjR,EAAI,EAAGA,EAAI4Q,EAAY1G,OAAQlK,SACfiP,IAAnB2B,EAAY5Q,KACd4Q,EAAY5Q,GAAKqQ,EAAgB1B,SAASsC,KAAcP,wBAAwBC,OAGtF,IACAR,EAAM7L,SAAQ,SAAUyM,GACtB,IAAIV,EAAkBU,EAAKF,MACvBK,EAAUH,EAAKtM,QAAQ6J,cAAc,sBACzC+B,EAAgBV,MAAMa,QAAU,OAChCH,EAAgBjI,UAAY,GAC5B2I,EAAKH,YAAYtM,SAAQ,SAAUqM,EAAQQ,GACzCD,EAAQvC,SAASwC,GAAYxB,MAAMgB,OAASA,EAAS,IACvD,GACF,GA9DA,CA+DF,CAkED,CAvND,E,mCCAA,WACE,GAAqB,qBAAVjO,OAA6C,qBAAbF,SAA3C,CAGA,IAAIyH,EAAY,GACZrG,EAAM,CAAC,EACPwN,EAAO,WAAiB,EAC5B1O,MAAMwE,QAAQmK,QAAU,CAAC,EAgBzB,IAAIC,EAAiB5O,MAAMwE,QAAQmK,QAAQC,eAAiB,SAAU/P,EAAKgQ,GACzE,IAAIvK,EAEFA,EADkB,oBAATuK,EACEA,EAEA,SAAkBjK,GAC3B,IAAI7C,EAiBJ,MAhB4B,oBAAjB8M,EAAKC,UACd/M,EAAUjC,SAASkN,cAAc,WACzBnM,KAAO,SACfkB,EAAQhC,iBAAiB,SAAS,WAChC8O,EAAKC,QAAQrR,KAAKiC,KAAMkF,EAC1B,KAC6B,kBAAbiK,EAAKE,KACrBhN,EAAUjC,SAASkN,cAAc,MACzBgC,KAAOH,EAAKE,IAEpBhN,EAAUjC,SAASkN,cAAc,QAE/B6B,EAAK5M,WACPF,EAAQQ,UAAUC,IAAIqM,EAAK5M,WAE7BF,EAAQwD,YAAcsJ,EAAKtL,KACpBxB,CACT,EAEElD,KAAOqC,EACT+N,QAAQC,KAAK,mCAAqCrQ,EAAM,yBAG1D0I,EAAUH,KAAKlG,EAAIrC,GAAOyF,EAC5B,EA4BI6K,EAAOnP,MAAMwE,QAAQmK,QAAQQ,KAAO,SAAUvK,GAEhD,IAAI6H,EAAM7H,EAAI7C,QAAQ2K,WACtB,GAAKD,GAAQ,OAAOE,KAAKF,EAAIpH,YAKzBoH,EAAIC,WAAWnK,UAAUY,SAAS,gBAAtC,CAKA,IAAIqL,EAAU1O,SAASkN,cAAc,OACrCwB,EAAQjM,UAAUC,IAAI,gBACtBiK,EAAIC,WAAW/I,aAAa6K,EAAS/B,GACrC+B,EAAQrB,YAAYV,GAGpB,IAAIkC,EAAU7O,SAASkN,cAAc,OACrC2B,EAAQpM,UAAUC,IAAI,WAGtB,IAAI4M,EAAmB7H,EACnB8H,EA5CN,SAAkBtN,GAChB,KAAOA,GAAS,CACd,IAAIsN,EAAQtN,EAAQgK,aAAa,sBACjC,GAAa,MAATsD,EAEF,OADAA,EAAQA,EAAMC,QACJ9H,OACD6H,EAAMxB,MAAM,YAEZ,GAGX9L,EAAUA,EAAQI,aACpB,CACF,CA+BcoN,CAAS3K,EAAI7C,SACrBsN,IACFD,EAAmBC,EAAMnO,KAAI,SAAUrC,GACrC,OAAOqC,EAAIrC,IAAQ6P,CACrB,KAEFU,EAAiBxN,SAAQ,SAAU0C,GACjC,IAAIvC,EAAUuC,EAASM,GACvB,GAAK7C,EAAL,CAGA,IAAIyN,EAAO1P,SAASkN,cAAc,OAClCwC,EAAKjN,UAAUC,IAAI,gBACnBgN,EAAKrC,YAAYpL,GACjB4M,EAAQxB,YAAYqC,EAJpB,CAKF,IAGAhB,EAAQrB,YAAYwB,EAhCpB,CAiCF,EACAC,EAAe,SAAS,SAAUhK,GAChC,IAAI6H,EAAM7H,EAAI7C,QAAQ2K,WACtB,GAAKD,GAAQ,OAAOE,KAAKF,EAAIpH,WAGxBoH,EAAI9G,aAAa,cAAtB,CAGA,IAAI5D,EACA0N,EACAlM,EAAOkJ,EAAIV,aAAa,cAC5B,IAEE0D,EAAW3P,SAAS8L,cAAc,YAAcrI,EAClD,CAAE,MAAO3D,GAAc,CAYvB,OAXI6P,EACF1N,EAAU0N,EAAS3O,SAEf2L,EAAI9G,aAAa,aACnB5D,EAAUjC,SAASkN,cAAc,MACzBgC,KAAOvC,EAAIV,aAAa,YAEhChK,EAAUjC,SAASkN,cAAc,QAEnCjL,EAAQwD,YAAchC,GAEjBxB,CAnBP,CAoBF,IAKA/B,MAAM8E,MAAMtC,IAAI,WAAY2M,EA3J5B,CA4JD,CA/JD,E,iBCAA,WAoBE,SAASO,EAAkB3N,EAAS4N,GAClC5N,EAAQhC,iBAAiB,SAAS,YAoCpC,SAA6B4P,GACvBC,UAAUC,UACZD,UAAUC,UAAUC,UAAUH,EAASI,WAAWC,KAAKL,EAASM,SAAS,WAEvEC,EAA4BP,EAC9B,IAEAO,EAA4BP,EAEhC,CA5CIQ,CAAoBR,EACtB,GACF,CAKA,SAASO,EAA4BP,GACnC,IAAIS,EAAWtQ,SAASkN,cAAc,YACtCoD,EAAS7R,MAAQoR,EAASI,UAG1BK,EAASnD,MAAMoD,IAAM,IACrBD,EAASnD,MAAMqD,KAAO,IACtBF,EAASnD,MAAMsD,SAAW,QAC1BzQ,SAAS0Q,KAAKrD,YAAYiD,GAC1BA,EAASK,QACTL,EAASM,SACT,IACE,IAAIC,EAAa7Q,SAAS8Q,YAAY,QACtCnG,YAAW,WACLkG,EACFhB,EAASM,UAETN,EAASkB,OAEb,GAAG,EACL,CAAE,MAAOlO,GACP8H,YAAW,WACTkF,EAASkB,MAAMlO,EACjB,GAAG,EACL,CACA7C,SAAS0Q,KAAKM,YAAYV,EAC5B,CAtDqB,qBAAVpQ,OAA6C,qBAAbF,WAGtCE,MAAMwE,QAAQmK,QAsGnB3O,MAAMwE,QAAQmK,QAAQC,eAAe,qBAAqB,SAAUhK,GAClE,IAAI7C,EAAU6C,EAAI7C,QACdgP,EAvBN,SAAqBC,GAEnB,IAAID,EAAW,CACb,KAAQ,OACR,aAAc,uBACd,eAAgB,UAChB,eAAgB,KAGlB,IAAK,IAAIlS,KAAOkS,EAAU,CAGxB,IAFA,IAAIE,EAFO,gBAESpS,EAChBkD,EAAUiP,EACPjP,IAAYA,EAAQ4D,aAAasL,IACtClP,EAAUA,EAAQI,cAEhBJ,IACFgP,EAASlS,GAAOkD,EAAQgK,aAAakF,GAEzC,CACA,OAAOF,CACT,CAGiBG,CAAYnP,GACvBoP,EAAWrR,SAASkN,cAAc,UACtCmE,EAASlP,UAAY,2BACrBkP,EAASvL,aAAa,OAAQ,UAC9B,IAAIwL,EAAWtR,SAASkN,cAAc,QAmBtC,OAlBAmE,EAAShE,YAAYiE,GACrBC,EAAS,QACT3B,EAAkByB,EAAU,CAC1BpB,QAAS,WACP,OAAOhO,EAAQwD,WACjB,EACA0K,QAAS,WACPoB,EAAS,gBACTC,GACF,EACAT,MAAO,WACLQ,EAAS,cACT5G,YAAW,YApDjB,SAA2B1I,GAEzBlC,OAAO0R,eAAeC,kBAAkBzP,EAC1C,CAkDQ0P,CAAkB1P,EACpB,GAAG,GACHuP,GACF,IAEKH,EACP,SAASG,IACP7G,YAAW,WACT4G,EAAS,OACX,GAAGN,EAAS,gBACd,CAGA,SAASM,EAASK,GAChBN,EAAS7L,YAAcwL,EAASW,GAChCP,EAASvL,aAAa,kBAAmB8L,EAC3C,CACF,IA1IEzC,QAAQC,KAAK,0DA2IhB,CAhJD,E","file":"js/blog-4d563c6a1887561b6869.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 = 25);\n","function _typeof(o) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o; }, _typeof(o); }\nvar 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 === \"undefined\" ? \"undefined\" : _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;","import \"prismjs\"\n\ndocument.addEventListener(\"turbolinks:load\", () => {\n  Prism.highlightAll();\n});\n  \n","/// <reference lib=\"WebWorker\"/>\n\nvar _self = typeof window !== 'undefined' ? window // if in browser\n: typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope ? self // if in worker\n: {} // if in node js\n;\n\n/**\n * Prism: Lightweight, robust, elegant syntax highlighting\n *\n * @license MIT <https://opensource.org/licenses/MIT>\n * @author Lea Verou <https://lea.verou.me>\n * @namespace\n * @public\n */\nvar Prism = function (_self) {\n  // Private helper vars\n  var lang = /(?:^|\\s)lang(?:uage)?-([\\w-]+)(?=\\s|$)/i;\n  var uniqueId = 0;\n\n  // The grammar object for plaintext\n  var plainTextGrammar = {};\n  var _ = {\n    /**\n     * By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the\n     * current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load\n     * additional languages or plugins yourself.\n     *\n     * By setting this value to `true`, Prism will not automatically highlight all code elements on the page.\n     *\n     * You obviously have to change this value before the automatic highlighting started. To do this, you can add an\n     * empty Prism object into the global scope before loading the Prism script like this:\n     *\n     * ```js\n     * window.Prism = window.Prism || {};\n     * Prism.manual = true;\n     * // add a new <script> to load Prism's script\n     * ```\n     *\n     * @default false\n     * @type {boolean}\n     * @memberof Prism\n     * @public\n     */\n    manual: _self.Prism && _self.Prism.manual,\n    /**\n     * By default, if Prism is in a web worker, it assumes that it is in a worker it created itself, so it uses\n     * `addEventListener` to communicate with its parent instance. However, if you're using Prism manually in your\n     * own worker, you don't want it to do this.\n     *\n     * By setting this value to `true`, Prism will not add its own listeners to the worker.\n     *\n     * You obviously have to change this value before Prism executes. To do this, you can add an\n     * empty Prism object into the global scope before loading the Prism script like this:\n     *\n     * ```js\n     * window.Prism = window.Prism || {};\n     * Prism.disableWorkerMessageHandler = true;\n     * // Load Prism's script\n     * ```\n     *\n     * @default false\n     * @type {boolean}\n     * @memberof Prism\n     * @public\n     */\n    disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,\n    /**\n     * A namespace for utility methods.\n     *\n     * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may\n     * change or disappear at any time.\n     *\n     * @namespace\n     * @memberof Prism\n     */\n    util: {\n      encode: function encode(tokens) {\n        if (tokens instanceof Token) {\n          return new Token(tokens.type, encode(tokens.content), tokens.alias);\n        } else if (Array.isArray(tokens)) {\n          return tokens.map(encode);\n        } else {\n          return tokens.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/\\u00a0/g, ' ');\n        }\n      },\n      /**\n       * Returns the name of the type of the given value.\n       *\n       * @param {any} o\n       * @returns {string}\n       * @example\n       * type(null)      === 'Null'\n       * type(undefined) === 'Undefined'\n       * type(123)       === 'Number'\n       * type('foo')     === 'String'\n       * type(true)      === 'Boolean'\n       * type([1, 2])    === 'Array'\n       * type({})        === 'Object'\n       * type(String)    === 'Function'\n       * type(/abc+/)    === 'RegExp'\n       */\n      type: function type(o) {\n        return Object.prototype.toString.call(o).slice(8, -1);\n      },\n      /**\n       * Returns a unique number for the given object. Later calls will still return the same number.\n       *\n       * @param {Object} obj\n       * @returns {number}\n       */\n      objId: function objId(obj) {\n        if (!obj['__id']) {\n          Object.defineProperty(obj, '__id', {\n            value: ++uniqueId\n          });\n        }\n        return obj['__id'];\n      },\n      /**\n       * Creates a deep clone of the given object.\n       *\n       * The main intended use of this function is to clone language definitions.\n       *\n       * @param {T} o\n       * @param {Record<number, any>} [visited]\n       * @returns {T}\n       * @template T\n       */\n      clone: function deepClone(o, visited) {\n        visited = visited || {};\n        var clone;\n        var id;\n        switch (_.util.type(o)) {\n          case 'Object':\n            id = _.util.objId(o);\n            if (visited[id]) {\n              return visited[id];\n            }\n            clone = /** @type {Record<string, any>} */{};\n            visited[id] = clone;\n            for (var key in o) {\n              if (o.hasOwnProperty(key)) {\n                clone[key] = deepClone(o[key], visited);\n              }\n            }\n            return /** @type {any} */clone;\n          case 'Array':\n            id = _.util.objId(o);\n            if (visited[id]) {\n              return visited[id];\n            }\n            clone = [];\n            visited[id] = clone;\n            (/** @type {Array} */ /** @type {any} */o).forEach(function (v, i) {\n              clone[i] = deepClone(v, visited);\n            });\n            return /** @type {any} */clone;\n          default:\n            return o;\n        }\n      },\n      /**\n       * Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class.\n       *\n       * If no language is set for the element or the element is `null` or `undefined`, `none` will be returned.\n       *\n       * @param {Element} element\n       * @returns {string}\n       */\n      getLanguage: function getLanguage(element) {\n        while (element) {\n          var m = lang.exec(element.className);\n          if (m) {\n            return m[1].toLowerCase();\n          }\n          element = element.parentElement;\n        }\n        return 'none';\n      },\n      /**\n       * Sets the Prism `language-xxxx` class of the given element.\n       *\n       * @param {Element} element\n       * @param {string} language\n       * @returns {void}\n       */\n      setLanguage: function setLanguage(element, language) {\n        // remove all `language-xxxx` classes\n        // (this might leave behind a leading space)\n        element.className = element.className.replace(RegExp(lang, 'gi'), '');\n\n        // add the new `language-xxxx` class\n        // (using `classList` will automatically clean up spaces for us)\n        element.classList.add('language-' + language);\n      },\n      /**\n       * Returns the script element that is currently executing.\n       *\n       * This does __not__ work for line script element.\n       *\n       * @returns {HTMLScriptElement | null}\n       */\n      currentScript: function currentScript() {\n        if (typeof document === 'undefined') {\n          return null;\n        }\n        if ('currentScript' in document && 1 < 2 /* hack to trip TS' flow analysis */) {\n          return /** @type {any} */document.currentScript;\n        }\n\n        // IE11 workaround\n        // we'll get the src of the current script by parsing IE11's error stack trace\n        // this will not work for inline scripts\n\n        try {\n          throw new Error();\n        } catch (err) {\n          // Get file src url from stack. Specifically works with the format of stack traces in IE.\n          // A stack will look like this:\n          //\n          // Error\n          //    at _.util.currentScript (http://localhost/components/prism-core.js:119:5)\n          //    at Global code (http://localhost/components/prism-core.js:606:1)\n\n          var src = (/at [^(\\r\\n]*\\((.*):[^:]+:[^:]+\\)$/i.exec(err.stack) || [])[1];\n          if (src) {\n            var scripts = document.getElementsByTagName('script');\n            for (var i in scripts) {\n              if (scripts[i].src == src) {\n                return scripts[i];\n              }\n            }\n          }\n          return null;\n        }\n      },\n      /**\n       * Returns whether a given class is active for `element`.\n       *\n       * The class can be activated if `element` or one of its ancestors has the given class and it can be deactivated\n       * if `element` or one of its ancestors has the negated version of the given class. The _negated version_ of the\n       * given class is just the given class with a `no-` prefix.\n       *\n       * Whether the class is active is determined by the closest ancestor of `element` (where `element` itself is\n       * closest ancestor) that has the given class or the negated version of it. If neither `element` nor any of its\n       * ancestors have the given class or the negated version of it, then the default activation will be returned.\n       *\n       * In the paradoxical situation where the closest ancestor contains __both__ the given class and the negated\n       * version of it, the class is considered active.\n       *\n       * @param {Element} element\n       * @param {string} className\n       * @param {boolean} [defaultActivation=false]\n       * @returns {boolean}\n       */\n      isActive: function isActive(element, className, defaultActivation) {\n        var no = 'no-' + className;\n        while (element) {\n          var classList = element.classList;\n          if (classList.contains(className)) {\n            return true;\n          }\n          if (classList.contains(no)) {\n            return false;\n          }\n          element = element.parentElement;\n        }\n        return !!defaultActivation;\n      }\n    },\n    /**\n     * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.\n     *\n     * @namespace\n     * @memberof Prism\n     * @public\n     */\n    languages: {\n      /**\n       * The grammar for plain, unformatted text.\n       */\n      plain: plainTextGrammar,\n      plaintext: plainTextGrammar,\n      text: plainTextGrammar,\n      txt: plainTextGrammar,\n      /**\n       * Creates a deep copy of the language with the given id and appends the given tokens.\n       *\n       * If a token in `redef` also appears in the copied language, then the existing token in the copied language\n       * will be overwritten at its original position.\n       *\n       * ## Best practices\n       *\n       * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)\n       * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to\n       * understand the language definition because, normally, the order of tokens matters in Prism grammars.\n       *\n       * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.\n       * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.\n       *\n       * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.\n       * @param {Grammar} redef The new tokens to append.\n       * @returns {Grammar} The new language created.\n       * @public\n       * @example\n       * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {\n       *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token\n       *     // at its original position\n       *     'comment': { ... },\n       *     // CSS doesn't have a 'color' token, so this token will be appended\n       *     'color': /\\b(?:red|green|blue)\\b/\n       * });\n       */\n      extend: function extend(id, redef) {\n        var lang = _.util.clone(_.languages[id]);\n        for (var key in redef) {\n          lang[key] = redef[key];\n        }\n        return lang;\n      },\n      /**\n       * Inserts tokens _before_ another token in a language definition or any other grammar.\n       *\n       * ## Usage\n       *\n       * This helper method makes it easy to modify existing languages. For example, the CSS language definition\n       * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded\n       * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the\n       * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do\n       * this:\n       *\n       * ```js\n       * Prism.languages.markup.style = {\n       *     // token\n       * };\n       * ```\n       *\n       * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens\n       * before existing tokens. For the CSS example above, you would use it like this:\n       *\n       * ```js\n       * Prism.languages.insertBefore('markup', 'cdata', {\n       *     'style': {\n       *         // token\n       *     }\n       * });\n       * ```\n       *\n       * ## Special cases\n       *\n       * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar\n       * will be ignored.\n       *\n       * This behavior can be used to insert tokens after `before`:\n       *\n       * ```js\n       * Prism.languages.insertBefore('markup', 'comment', {\n       *     'comment': Prism.languages.markup.comment,\n       *     // tokens after 'comment'\n       * });\n       * ```\n       *\n       * ## Limitations\n       *\n       * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object\n       * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave\n       * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily\n       * deleting properties which is necessary to insert at arbitrary positions.\n       *\n       * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.\n       * Instead, it will create a new object and replace all references to the target object with the new one. This\n       * can be done without temporarily deleting properties, so the iteration order is well-defined.\n       *\n       * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if\n       * you hold the target object in a variable, then the value of the variable will not change.\n       *\n       * ```js\n       * var oldMarkup = Prism.languages.markup;\n       * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });\n       *\n       * assert(oldMarkup !== Prism.languages.markup);\n       * assert(newMarkup === Prism.languages.markup);\n       * ```\n       *\n       * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the\n       * object to be modified.\n       * @param {string} before The key to insert before.\n       * @param {Grammar} insert An object containing the key-value pairs to be inserted.\n       * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the\n       * object to be modified.\n       *\n       * Defaults to `Prism.languages`.\n       * @returns {Grammar} The new grammar object.\n       * @public\n       */\n      insertBefore: function insertBefore(inside, before, insert, root) {\n        root = root || (/** @type {any} */_.languages);\n        var grammar = root[inside];\n        /** @type {Grammar} */\n        var ret = {};\n        for (var token in grammar) {\n          if (grammar.hasOwnProperty(token)) {\n            if (token == before) {\n              for (var newToken in insert) {\n                if (insert.hasOwnProperty(newToken)) {\n                  ret[newToken] = insert[newToken];\n                }\n              }\n            }\n\n            // Do not insert token which also occur in insert. See #1525\n            if (!insert.hasOwnProperty(token)) {\n              ret[token] = grammar[token];\n            }\n          }\n        }\n        var old = root[inside];\n        root[inside] = ret;\n\n        // Update references in other language definitions\n        _.languages.DFS(_.languages, function (key, value) {\n          if (value === old && key != inside) {\n            this[key] = ret;\n          }\n        });\n        return ret;\n      },\n      // Traverse a language definition with Depth First Search\n      DFS: function DFS(o, callback, type, visited) {\n        visited = visited || {};\n        var objId = _.util.objId;\n        for (var i in o) {\n          if (o.hasOwnProperty(i)) {\n            callback.call(o, i, o[i], type || i);\n            var property = o[i];\n            var propertyType = _.util.type(property);\n            if (propertyType === 'Object' && !visited[objId(property)]) {\n              visited[objId(property)] = true;\n              DFS(property, callback, null, visited);\n            } else if (propertyType === 'Array' && !visited[objId(property)]) {\n              visited[objId(property)] = true;\n              DFS(property, callback, i, visited);\n            }\n          }\n        }\n      }\n    },\n    plugins: {},\n    /**\n     * This is the most high-level function in Prism’s API.\n     * It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on\n     * each one of them.\n     *\n     * This is equivalent to `Prism.highlightAllUnder(document, async, callback)`.\n     *\n     * @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}.\n     * @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}.\n     * @memberof Prism\n     * @public\n     */\n    highlightAll: function highlightAll(async, callback) {\n      _.highlightAllUnder(document, async, callback);\n    },\n    /**\n     * Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls\n     * {@link Prism.highlightElement} on each one of them.\n     *\n     * The following hooks will be run:\n     * 1. `before-highlightall`\n     * 2. `before-all-elements-highlight`\n     * 3. All hooks of {@link Prism.highlightElement} for each element.\n     *\n     * @param {ParentNode} container The root element, whose descendants that have a `.language-xxxx` class will be highlighted.\n     * @param {boolean} [async=false] Whether each element is to be highlighted asynchronously using Web Workers.\n     * @param {HighlightCallback} [callback] An optional callback to be invoked on each element after its highlighting is done.\n     * @memberof Prism\n     * @public\n     */\n    highlightAllUnder: function highlightAllUnder(container, async, callback) {\n      var env = {\n        callback: callback,\n        container: container,\n        selector: 'code[class*=\"language-\"], [class*=\"language-\"] code, code[class*=\"lang-\"], [class*=\"lang-\"] code'\n      };\n      _.hooks.run('before-highlightall', env);\n      env.elements = Array.prototype.slice.apply(env.container.querySelectorAll(env.selector));\n      _.hooks.run('before-all-elements-highlight', env);\n      for (var i = 0, element; element = env.elements[i++];) {\n        _.highlightElement(element, async === true, env.callback);\n      }\n    },\n    /**\n     * Highlights the code inside a single element.\n     *\n     * The following hooks will be run:\n     * 1. `before-sanity-check`\n     * 2. `before-highlight`\n     * 3. All hooks of {@link Prism.highlight}. These hooks will be run by an asynchronous worker if `async` is `true`.\n     * 4. `before-insert`\n     * 5. `after-highlight`\n     * 6. `complete`\n     *\n     * Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for\n     * the element's language.\n     *\n     * @param {Element} element The element containing the code.\n     * It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier.\n     * @param {boolean} [async=false] Whether the element is to be highlighted asynchronously using Web Workers\n     * to improve performance and avoid blocking the UI when highlighting very large chunks of code. This option is\n     * [disabled by default](https://prismjs.com/faq.html#why-is-asynchronous-highlighting-disabled-by-default).\n     *\n     * Note: All language definitions required to highlight the code must be included in the main `prism.js` file for\n     * asynchronous highlighting to work. You can build your own bundle on the\n     * [Download page](https://prismjs.com/download.html).\n     * @param {HighlightCallback} [callback] An optional callback to be invoked after the highlighting is done.\n     * Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously.\n     * @memberof Prism\n     * @public\n     */\n    highlightElement: function highlightElement(element, async, callback) {\n      // Find language\n      var language = _.util.getLanguage(element);\n      var grammar = _.languages[language];\n\n      // Set language on the element, if not present\n      _.util.setLanguage(element, language);\n\n      // Set language on the parent, for styling\n      var parent = element.parentElement;\n      if (parent && parent.nodeName.toLowerCase() === 'pre') {\n        _.util.setLanguage(parent, language);\n      }\n      var code = element.textContent;\n      var env = {\n        element: element,\n        language: language,\n        grammar: grammar,\n        code: code\n      };\n      function insertHighlightedCode(highlightedCode) {\n        env.highlightedCode = highlightedCode;\n        _.hooks.run('before-insert', env);\n        env.element.innerHTML = env.highlightedCode;\n        _.hooks.run('after-highlight', env);\n        _.hooks.run('complete', env);\n        callback && callback.call(env.element);\n      }\n      _.hooks.run('before-sanity-check', env);\n\n      // plugins may change/add the parent/element\n      parent = env.element.parentElement;\n      if (parent && parent.nodeName.toLowerCase() === 'pre' && !parent.hasAttribute('tabindex')) {\n        parent.setAttribute('tabindex', '0');\n      }\n      if (!env.code) {\n        _.hooks.run('complete', env);\n        callback && callback.call(env.element);\n        return;\n      }\n      _.hooks.run('before-highlight', env);\n      if (!env.grammar) {\n        insertHighlightedCode(_.util.encode(env.code));\n        return;\n      }\n      if (async && _self.Worker) {\n        var worker = new Worker(_.filename);\n        worker.onmessage = function (evt) {\n          insertHighlightedCode(evt.data);\n        };\n        worker.postMessage(JSON.stringify({\n          language: env.language,\n          code: env.code,\n          immediateClose: true\n        }));\n      } else {\n        insertHighlightedCode(_.highlight(env.code, env.grammar, env.language));\n      }\n    },\n    /**\n     * Low-level function, only use if you know what you’re doing. It accepts a string of text as input\n     * and the language definitions to use, and returns a string with the HTML produced.\n     *\n     * The following hooks will be run:\n     * 1. `before-tokenize`\n     * 2. `after-tokenize`\n     * 3. `wrap`: On each {@link Token}.\n     *\n     * @param {string} text A string with the code to be highlighted.\n     * @param {Grammar} grammar An object containing the tokens to use.\n     *\n     * Usually a language definition like `Prism.languages.markup`.\n     * @param {string} language The name of the language definition passed to `grammar`.\n     * @returns {string} The highlighted HTML.\n     * @memberof Prism\n     * @public\n     * @example\n     * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');\n     */\n    highlight: function highlight(text, grammar, language) {\n      var env = {\n        code: text,\n        grammar: grammar,\n        language: language\n      };\n      _.hooks.run('before-tokenize', env);\n      if (!env.grammar) {\n        throw new Error('The language \"' + env.language + '\" has no grammar.');\n      }\n      env.tokens = _.tokenize(env.code, env.grammar);\n      _.hooks.run('after-tokenize', env);\n      return Token.stringify(_.util.encode(env.tokens), env.language);\n    },\n    /**\n     * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input\n     * and the language definitions to use, and returns an array with the tokenized code.\n     *\n     * When the language definition includes nested tokens, the function is called recursively on each of these tokens.\n     *\n     * This method could be useful in other contexts as well, as a very crude parser.\n     *\n     * @param {string} text A string with the code to be highlighted.\n     * @param {Grammar} grammar An object containing the tokens to use.\n     *\n     * Usually a language definition like `Prism.languages.markup`.\n     * @returns {TokenStream} An array of strings and tokens, a token stream.\n     * @memberof Prism\n     * @public\n     * @example\n     * let code = `var foo = 0;`;\n     * let tokens = Prism.tokenize(code, Prism.languages.javascript);\n     * tokens.forEach(token => {\n     *     if (token instanceof Prism.Token && token.type === 'number') {\n     *         console.log(`Found numeric literal: ${token.content}`);\n     *     }\n     * });\n     */\n    tokenize: function tokenize(text, grammar) {\n      var rest = grammar.rest;\n      if (rest) {\n        for (var token in rest) {\n          grammar[token] = rest[token];\n        }\n        delete grammar.rest;\n      }\n      var tokenList = new LinkedList();\n      addAfter(tokenList, tokenList.head, text);\n      matchGrammar(text, tokenList, grammar, tokenList.head, 0);\n      return toArray(tokenList);\n    },\n    /**\n     * @namespace\n     * @memberof Prism\n     * @public\n     */\n    hooks: {\n      all: {},\n      /**\n       * Adds the given callback to the list of callbacks for the given hook.\n       *\n       * The callback will be invoked when the hook it is registered for is run.\n       * Hooks are usually directly run by a highlight function but you can also run hooks yourself.\n       *\n       * One callback function can be registered to multiple hooks and the same hook multiple times.\n       *\n       * @param {string} name The name of the hook.\n       * @param {HookCallback} callback The callback function which is given environment variables.\n       * @public\n       */\n      add: function add(name, callback) {\n        var hooks = _.hooks.all;\n        hooks[name] = hooks[name] || [];\n        hooks[name].push(callback);\n      },\n      /**\n       * Runs a hook invoking all registered callbacks with the given environment variables.\n       *\n       * Callbacks will be invoked synchronously and in the order in which they were registered.\n       *\n       * @param {string} name The name of the hook.\n       * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.\n       * @public\n       */\n      run: function run(name, env) {\n        var callbacks = _.hooks.all[name];\n        if (!callbacks || !callbacks.length) {\n          return;\n        }\n        for (var i = 0, callback; callback = callbacks[i++];) {\n          callback(env);\n        }\n      }\n    },\n    Token: Token\n  };\n  _self.Prism = _;\n\n  // Typescript note:\n  // The following can be used to import the Token type in JSDoc:\n  //\n  //   @typedef {InstanceType<import(\"./prism-core\")[\"Token\"]>} Token\n\n  /**\n   * Creates a new token.\n   *\n   * @param {string} type See {@link Token#type type}\n   * @param {string | TokenStream} content See {@link Token#content content}\n   * @param {string|string[]} [alias] The alias(es) of the token.\n   * @param {string} [matchedStr=\"\"] A copy of the full string this token was created from.\n   * @class\n   * @global\n   * @public\n   */\n  function Token(type, content, alias, matchedStr) {\n    /**\n     * The type of the token.\n     *\n     * This is usually the key of a pattern in a {@link Grammar}.\n     *\n     * @type {string}\n     * @see GrammarToken\n     * @public\n     */\n    this.type = type;\n    /**\n     * The strings or tokens contained by this token.\n     *\n     * This will be a token stream if the pattern matched also defined an `inside` grammar.\n     *\n     * @type {string | TokenStream}\n     * @public\n     */\n    this.content = content;\n    /**\n     * The alias(es) of the token.\n     *\n     * @type {string|string[]}\n     * @see GrammarToken\n     * @public\n     */\n    this.alias = alias;\n    // Copy of the full string this token was created from\n    this.length = (matchedStr || '').length | 0;\n  }\n\n  /**\n   * A token stream is an array of strings and {@link Token Token} objects.\n   *\n   * Token streams have to fulfill a few properties that are assumed by most functions (mostly internal ones) that process\n   * them.\n   *\n   * 1. No adjacent strings.\n   * 2. No empty strings.\n   *\n   *    The only exception here is the token stream that only contains the empty string and nothing else.\n   *\n   * @typedef {Array<string | Token>} TokenStream\n   * @global\n   * @public\n   */\n\n  /**\n   * Converts the given token or token stream to an HTML representation.\n   *\n   * The following hooks will be run:\n   * 1. `wrap`: On each {@link Token}.\n   *\n   * @param {string | Token | TokenStream} o The token or token stream to be converted.\n   * @param {string} language The name of current language.\n   * @returns {string} The HTML representation of the token or token stream.\n   * @memberof Token\n   * @static\n   */\n  Token.stringify = function stringify(o, language) {\n    if (typeof o == 'string') {\n      return o;\n    }\n    if (Array.isArray(o)) {\n      var s = '';\n      o.forEach(function (e) {\n        s += stringify(e, language);\n      });\n      return s;\n    }\n    var env = {\n      type: o.type,\n      content: stringify(o.content, language),\n      tag: 'span',\n      classes: ['token', o.type],\n      attributes: {},\n      language: language\n    };\n    var aliases = o.alias;\n    if (aliases) {\n      if (Array.isArray(aliases)) {\n        Array.prototype.push.apply(env.classes, aliases);\n      } else {\n        env.classes.push(aliases);\n      }\n    }\n    _.hooks.run('wrap', env);\n    var attributes = '';\n    for (var name in env.attributes) {\n      attributes += ' ' + name + '=\"' + (env.attributes[name] || '').replace(/\"/g, '&quot;') + '\"';\n    }\n    return '<' + env.tag + ' class=\"' + env.classes.join(' ') + '\"' + attributes + '>' + env.content + '</' + env.tag + '>';\n  };\n\n  /**\n   * @param {RegExp} pattern\n   * @param {number} pos\n   * @param {string} text\n   * @param {boolean} lookbehind\n   * @returns {RegExpExecArray | null}\n   */\n  function matchPattern(pattern, pos, text, lookbehind) {\n    pattern.lastIndex = pos;\n    var match = pattern.exec(text);\n    if (match && lookbehind && match[1]) {\n      // change the match to remove the text matched by the Prism lookbehind group\n      var lookbehindLength = match[1].length;\n      match.index += lookbehindLength;\n      match[0] = match[0].slice(lookbehindLength);\n    }\n    return match;\n  }\n\n  /**\n   * @param {string} text\n   * @param {LinkedList<string | Token>} tokenList\n   * @param {any} grammar\n   * @param {LinkedListNode<string | Token>} startNode\n   * @param {number} startPos\n   * @param {RematchOptions} [rematch]\n   * @returns {void}\n   * @private\n   *\n   * @typedef RematchOptions\n   * @property {string} cause\n   * @property {number} reach\n   */\n  function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {\n    for (var token in grammar) {\n      if (!grammar.hasOwnProperty(token) || !grammar[token]) {\n        continue;\n      }\n      var patterns = grammar[token];\n      patterns = Array.isArray(patterns) ? patterns : [patterns];\n      for (var j = 0; j < patterns.length; ++j) {\n        if (rematch && rematch.cause == token + ',' + j) {\n          return;\n        }\n        var patternObj = patterns[j];\n        var inside = patternObj.inside;\n        var lookbehind = !!patternObj.lookbehind;\n        var greedy = !!patternObj.greedy;\n        var alias = patternObj.alias;\n        if (greedy && !patternObj.pattern.global) {\n          // Without the global flag, lastIndex won't work\n          var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];\n          patternObj.pattern = RegExp(patternObj.pattern.source, flags + 'g');\n        }\n\n        /** @type {RegExp} */\n        var pattern = patternObj.pattern || patternObj;\n        for (\n        // iterate the token list and keep track of the current token/string position\n        var currentNode = startNode.next, pos = startPos; currentNode !== tokenList.tail; pos += currentNode.value.length, currentNode = currentNode.next) {\n          if (rematch && pos >= rematch.reach) {\n            break;\n          }\n          var str = currentNode.value;\n          if (tokenList.length > text.length) {\n            // Something went terribly wrong, ABORT, ABORT!\n            return;\n          }\n          if (str instanceof Token) {\n            continue;\n          }\n          var removeCount = 1; // this is the to parameter of removeBetween\n          var match;\n          if (greedy) {\n            match = matchPattern(pattern, pos, text, lookbehind);\n            if (!match || match.index >= text.length) {\n              break;\n            }\n            var from = match.index;\n            var to = match.index + match[0].length;\n            var p = pos;\n\n            // find the node that contains the match\n            p += currentNode.value.length;\n            while (from >= p) {\n              currentNode = currentNode.next;\n              p += currentNode.value.length;\n            }\n            // adjust pos (and p)\n            p -= currentNode.value.length;\n            pos = p;\n\n            // the current node is a Token, then the match starts inside another Token, which is invalid\n            if (currentNode.value instanceof Token) {\n              continue;\n            }\n\n            // find the last node which is affected by this match\n            for (var k = currentNode; k !== tokenList.tail && (p < to || typeof k.value === 'string'); k = k.next) {\n              removeCount++;\n              p += k.value.length;\n            }\n            removeCount--;\n\n            // replace with the new match\n            str = text.slice(pos, p);\n            match.index -= pos;\n          } else {\n            match = matchPattern(pattern, 0, str, lookbehind);\n            if (!match) {\n              continue;\n            }\n          }\n\n          // eslint-disable-next-line no-redeclare\n          var from = match.index;\n          var matchStr = match[0];\n          var before = str.slice(0, from);\n          var after = str.slice(from + matchStr.length);\n          var reach = pos + str.length;\n          if (rematch && reach > rematch.reach) {\n            rematch.reach = reach;\n          }\n          var removeFrom = currentNode.prev;\n          if (before) {\n            removeFrom = addAfter(tokenList, removeFrom, before);\n            pos += before.length;\n          }\n          removeRange(tokenList, removeFrom, removeCount);\n          var wrapped = new Token(token, inside ? _.tokenize(matchStr, inside) : matchStr, alias, matchStr);\n          currentNode = addAfter(tokenList, removeFrom, wrapped);\n          if (after) {\n            addAfter(tokenList, currentNode, after);\n          }\n          if (removeCount > 1) {\n            // at least one Token object was removed, so we have to do some rematching\n            // this can only happen if the current pattern is greedy\n\n            /** @type {RematchOptions} */\n            var nestedRematch = {\n              cause: token + ',' + j,\n              reach: reach\n            };\n            matchGrammar(text, tokenList, grammar, currentNode.prev, pos, nestedRematch);\n\n            // the reach might have been extended because of the rematching\n            if (rematch && nestedRematch.reach > rematch.reach) {\n              rematch.reach = nestedRematch.reach;\n            }\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * @typedef LinkedListNode\n   * @property {T} value\n   * @property {LinkedListNode<T> | null} prev The previous node.\n   * @property {LinkedListNode<T> | null} next The next node.\n   * @template T\n   * @private\n   */\n\n  /**\n   * @template T\n   * @private\n   */\n  function LinkedList() {\n    /** @type {LinkedListNode<T>} */\n    var head = {\n      value: null,\n      prev: null,\n      next: null\n    };\n    /** @type {LinkedListNode<T>} */\n    var tail = {\n      value: null,\n      prev: head,\n      next: null\n    };\n    head.next = tail;\n\n    /** @type {LinkedListNode<T>} */\n    this.head = head;\n    /** @type {LinkedListNode<T>} */\n    this.tail = tail;\n    this.length = 0;\n  }\n\n  /**\n   * Adds a new node with the given value to the list.\n   *\n   * @param {LinkedList<T>} list\n   * @param {LinkedListNode<T>} node\n   * @param {T} value\n   * @returns {LinkedListNode<T>} The added node.\n   * @template T\n   */\n  function addAfter(list, node, value) {\n    // assumes that node != list.tail && values.length >= 0\n    var next = node.next;\n    var newNode = {\n      value: value,\n      prev: node,\n      next: next\n    };\n    node.next = newNode;\n    next.prev = newNode;\n    list.length++;\n    return newNode;\n  }\n  /**\n   * Removes `count` nodes after the given node. The given node will not be removed.\n   *\n   * @param {LinkedList<T>} list\n   * @param {LinkedListNode<T>} node\n   * @param {number} count\n   * @template T\n   */\n  function removeRange(list, node, count) {\n    var next = node.next;\n    for (var i = 0; i < count && next !== list.tail; i++) {\n      next = next.next;\n    }\n    node.next = next;\n    next.prev = node;\n    list.length -= i;\n  }\n  /**\n   * @param {LinkedList<T>} list\n   * @returns {T[]}\n   * @template T\n   */\n  function toArray(list) {\n    var array = [];\n    var node = list.head.next;\n    while (node !== list.tail) {\n      array.push(node.value);\n      node = node.next;\n    }\n    return array;\n  }\n  if (!_self.document) {\n    if (!_self.addEventListener) {\n      // in Node.js\n      return _;\n    }\n    if (!_.disableWorkerMessageHandler) {\n      // In worker\n      _self.addEventListener('message', function (evt) {\n        var message = JSON.parse(evt.data);\n        var lang = message.language;\n        var code = message.code;\n        var immediateClose = message.immediateClose;\n        _self.postMessage(_.highlight(code, _.languages[lang], lang));\n        if (immediateClose) {\n          _self.close();\n        }\n      }, false);\n    }\n    return _;\n  }\n\n  // Get current script and highlight\n  var script = _.util.currentScript();\n  if (script) {\n    _.filename = script.src;\n    if (script.hasAttribute('data-manual')) {\n      _.manual = true;\n    }\n  }\n  function highlightAutomaticallyCallback() {\n    if (!_.manual) {\n      _.highlightAll();\n    }\n  }\n  if (!_.manual) {\n    // If the document state is \"loading\", then we'll use DOMContentLoaded.\n    // If the document state is \"interactive\" and the prism.js script is deferred, then we'll also use the\n    // DOMContentLoaded event because there might be some plugins or languages which have also been deferred and they\n    // might take longer one animation frame to execute which can create a race condition where only some plugins have\n    // been loaded when Prism.highlightAll() is executed, depending on how fast resources are loaded.\n    // See https://github.com/PrismJS/prism/issues/2102\n    var readyState = document.readyState;\n    if (readyState === 'loading' || readyState === 'interactive' && script && script.defer) {\n      document.addEventListener('DOMContentLoaded', highlightAutomaticallyCallback);\n    } else {\n      if (window.requestAnimationFrame) {\n        window.requestAnimationFrame(highlightAutomaticallyCallback);\n      } else {\n        window.setTimeout(highlightAutomaticallyCallback, 16);\n      }\n    }\n  }\n  return _;\n}(_self);\nif (typeof module !== 'undefined' && module.exports) {\n  module.exports = Prism;\n}\n\n// hack for components to work correctly in node.js\nif (typeof global !== 'undefined') {\n  global.Prism = Prism;\n}\n\n// some additional documentation/types\n\n/**\n * The expansion of a simple `RegExp` literal to support additional properties.\n *\n * @typedef GrammarToken\n * @property {RegExp} pattern The regular expression of the token.\n * @property {boolean} [lookbehind=false] If `true`, then the first capturing group of `pattern` will (effectively)\n * behave as a lookbehind group meaning that the captured text will not be part of the matched text of the new token.\n * @property {boolean} [greedy=false] Whether the token is greedy.\n * @property {string|string[]} [alias] An optional alias or list of aliases.\n * @property {Grammar} [inside] The nested grammar of this token.\n *\n * The `inside` grammar will be used to tokenize the text value of each token of this kind.\n *\n * This can be used to make nested and even recursive language definitions.\n *\n * Note: This can cause infinite recursion. Be careful when you embed different languages or even the same language into\n * each another.\n * @global\n * @public\n */\n\n/**\n * @typedef Grammar\n * @type {Object<string, RegExp | GrammarToken | Array<RegExp | GrammarToken>>}\n * @property {Grammar} [rest] An optional grammar object that will be appended to this grammar.\n * @global\n * @public\n */\n\n/**\n * A function which will invoked after an element was successfully highlighted.\n *\n * @callback HighlightCallback\n * @param {Element} element The element successfully highlighted.\n * @returns {void}\n * @global\n * @public\n */\n\n/**\n * @callback HookCallback\n * @param {Object<string, any>} env The environment variables of the hook.\n * @returns {void}\n * @global\n * @public\n */","Prism.languages.clike = {\n  'comment': [{\n    pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n    lookbehind: true,\n    greedy: true\n  }, {\n    pattern: /(^|[^\\\\:])\\/\\/.*/,\n    lookbehind: true,\n    greedy: true\n  }],\n  'string': {\n    pattern: /([\"'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/,\n    greedy: true\n  },\n  'class-name': {\n    pattern: /(\\b(?:class|extends|implements|instanceof|interface|new|trait)\\s+|\\bcatch\\s+\\()[\\w.\\\\]+/i,\n    lookbehind: true,\n    inside: {\n      'punctuation': /[.\\\\]/\n    }\n  },\n  'keyword': /\\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\\b/,\n  'boolean': /\\b(?:false|true)\\b/,\n  'function': /\\b\\w+(?=\\()/,\n  'number': /\\b0x[\\da-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?/i,\n  'operator': /[<>]=?|[!=]=?=?|--?|\\+\\+?|&&?|\\|\\|?|[?*/~^%]/,\n  'punctuation': /[{}[\\];(),.:]/\n};","/**\n * Original by Samuel Flores\n *\n * Adds the following new token classes:\n *     constant, builtin, variable, symbol, regex\n */\n(function (Prism) {\n  Prism.languages.ruby = Prism.languages.extend('clike', {\n    'comment': {\n      pattern: /#.*|^=begin\\s[\\s\\S]*?^=end/m,\n      greedy: true\n    },\n    'class-name': {\n      pattern: /(\\b(?:class|module)\\s+|\\bcatch\\s+\\()[\\w.\\\\]+|\\b[A-Z_]\\w*(?=\\s*\\.\\s*new\\b)/,\n      lookbehind: true,\n      inside: {\n        'punctuation': /[.\\\\]/\n      }\n    },\n    'keyword': /\\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\\b/,\n    'operator': /\\.{2,3}|&\\.|===|<?=>|[!=]?~|(?:&&|\\|\\||<<|>>|\\*\\*|[+\\-*/%<>!^&|=])=?|[?:]/,\n    'punctuation': /[(){}[\\].,;]/\n  });\n  Prism.languages.insertBefore('ruby', 'operator', {\n    'double-colon': {\n      pattern: /::/,\n      alias: 'punctuation'\n    }\n  });\n  var interpolation = {\n    pattern: /((?:^|[^\\\\])(?:\\\\{2})*)#\\{(?:[^{}]|\\{[^{}]*\\})*\\}/,\n    lookbehind: true,\n    inside: {\n      'content': {\n        pattern: /^(#\\{)[\\s\\S]+(?=\\}$)/,\n        lookbehind: true,\n        inside: Prism.languages.ruby\n      },\n      'delimiter': {\n        pattern: /^#\\{|\\}$/,\n        alias: 'punctuation'\n      }\n    }\n  };\n  delete Prism.languages.ruby.function;\n  var percentExpression = '(?:' + [/([^a-zA-Z0-9\\s{(\\[<=])(?:(?!\\1)[^\\\\]|\\\\[\\s\\S])*\\1/.source, /\\((?:[^()\\\\]|\\\\[\\s\\S]|\\((?:[^()\\\\]|\\\\[\\s\\S])*\\))*\\)/.source, /\\{(?:[^{}\\\\]|\\\\[\\s\\S]|\\{(?:[^{}\\\\]|\\\\[\\s\\S])*\\})*\\}/.source, /\\[(?:[^\\[\\]\\\\]|\\\\[\\s\\S]|\\[(?:[^\\[\\]\\\\]|\\\\[\\s\\S])*\\])*\\]/.source, /<(?:[^<>\\\\]|\\\\[\\s\\S]|<(?:[^<>\\\\]|\\\\[\\s\\S])*>)*>/.source].join('|') + ')';\n  var symbolName = /(?:\"(?:\\\\.|[^\"\\\\\\r\\n])*\"|(?:\\b[a-zA-Z_]\\w*|[^\\s\\0-\\x7F]+)[?!]?|\\$.)/.source;\n  Prism.languages.insertBefore('ruby', 'keyword', {\n    'regex-literal': [{\n      pattern: RegExp(/%r/.source + percentExpression + /[egimnosux]{0,6}/.source),\n      greedy: true,\n      inside: {\n        'interpolation': interpolation,\n        'regex': /[\\s\\S]+/\n      }\n    }, {\n      pattern: /(^|[^/])\\/(?!\\/)(?:\\[[^\\r\\n\\]]+\\]|\\\\.|[^[/\\\\\\r\\n])+\\/[egimnosux]{0,6}(?=\\s*(?:$|[\\r\\n,.;})#]))/,\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        'interpolation': interpolation,\n        'regex': /[\\s\\S]+/\n      }\n    }],\n    'variable': /[@$]+[a-zA-Z_]\\w*(?:[?!]|\\b)/,\n    'symbol': [{\n      pattern: RegExp(/(^|[^:]):/.source + symbolName),\n      lookbehind: true,\n      greedy: true\n    }, {\n      pattern: RegExp(/([\\r\\n{(,][ \\t]*)/.source + symbolName + /(?=:(?!:))/.source),\n      lookbehind: true,\n      greedy: true\n    }],\n    'method-definition': {\n      pattern: /(\\bdef\\s+)\\w+(?:\\s*\\.\\s*\\w+)?/,\n      lookbehind: true,\n      inside: {\n        'function': /\\b\\w+$/,\n        'keyword': /^self\\b/,\n        'class-name': /^\\w+/,\n        'punctuation': /\\./\n      }\n    }\n  });\n  Prism.languages.insertBefore('ruby', 'string', {\n    'string-literal': [{\n      pattern: RegExp(/%[qQiIwWs]?/.source + percentExpression),\n      greedy: true,\n      inside: {\n        'interpolation': interpolation,\n        'string': /[\\s\\S]+/\n      }\n    }, {\n      pattern: /(\"|')(?:#\\{[^}]+\\}|#(?!\\{)|\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\#\\r\\n])*\\1/,\n      greedy: true,\n      inside: {\n        'interpolation': interpolation,\n        'string': /[\\s\\S]+/\n      }\n    }, {\n      pattern: /<<[-~]?([a-z_]\\w*)[\\r\\n](?:.*[\\r\\n])*?[\\t ]*\\1/i,\n      alias: 'heredoc-string',\n      greedy: true,\n      inside: {\n        'delimiter': {\n          pattern: /^<<[-~]?[a-z_]\\w*|\\b[a-z_]\\w*$/i,\n          inside: {\n            'symbol': /\\b\\w+/,\n            'punctuation': /^<<[-~]?/\n          }\n        },\n        'interpolation': interpolation,\n        'string': /[\\s\\S]+/\n      }\n    }, {\n      pattern: /<<[-~]?'([a-z_]\\w*)'[\\r\\n](?:.*[\\r\\n])*?[\\t ]*\\1/i,\n      alias: 'heredoc-string',\n      greedy: true,\n      inside: {\n        'delimiter': {\n          pattern: /^<<[-~]?'[a-z_]\\w*'|\\b[a-z_]\\w*$/i,\n          inside: {\n            'symbol': /\\b\\w+/,\n            'punctuation': /^<<[-~]?'|'$/\n          }\n        },\n        'string': /[\\s\\S]+/\n      }\n    }],\n    'command-literal': [{\n      pattern: RegExp(/%x/.source + percentExpression),\n      greedy: true,\n      inside: {\n        'interpolation': interpolation,\n        'command': {\n          pattern: /[\\s\\S]+/,\n          alias: 'string'\n        }\n      }\n    }, {\n      pattern: /`(?:#\\{[^}]+\\}|#(?!\\{)|\\\\(?:\\r\\n|[\\s\\S])|[^\\\\`#\\r\\n])*`/,\n      greedy: true,\n      inside: {\n        'interpolation': interpolation,\n        'command': {\n          pattern: /[\\s\\S]+/,\n          alias: 'string'\n        }\n      }\n    }]\n  });\n  delete Prism.languages.ruby.string;\n  Prism.languages.insertBefore('ruby', 'number', {\n    'builtin': /\\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\\b/,\n    'constant': /\\b[A-Z][A-Z0-9_]*(?:[?!]|\\b)/\n  });\n  Prism.languages.rb = Prism.languages.ruby;\n})(Prism);","(function () {\n  if (typeof Prism === 'undefined' || typeof document === 'undefined') {\n    return;\n  }\n\n  /**\n   * Plugin name which is used as a class name for <pre> which is activating the plugin\n   *\n   * @type {string}\n   */\n  var PLUGIN_NAME = 'line-numbers';\n\n  /**\n   * Regular expression used for determining line breaks\n   *\n   * @type {RegExp}\n   */\n  var NEW_LINE_EXP = /\\n(?!$)/g;\n\n  /**\n   * Global exports\n   */\n  var config = Prism.plugins.lineNumbers = {\n    /**\n     * Get node for provided line number\n     *\n     * @param {Element} element pre element\n     * @param {number} number line number\n     * @returns {Element|undefined}\n     */\n    getLine: function getLine(element, number) {\n      if (element.tagName !== 'PRE' || !element.classList.contains(PLUGIN_NAME)) {\n        return;\n      }\n      var lineNumberRows = element.querySelector('.line-numbers-rows');\n      if (!lineNumberRows) {\n        return;\n      }\n      var lineNumberStart = parseInt(element.getAttribute('data-start'), 10) || 1;\n      var lineNumberEnd = lineNumberStart + (lineNumberRows.children.length - 1);\n      if (number < lineNumberStart) {\n        number = lineNumberStart;\n      }\n      if (number > lineNumberEnd) {\n        number = lineNumberEnd;\n      }\n      var lineIndex = number - lineNumberStart;\n      return lineNumberRows.children[lineIndex];\n    },\n    /**\n     * Resizes the line numbers of the given element.\n     *\n     * This function will not add line numbers. It will only resize existing ones.\n     *\n     * @param {HTMLElement} element A `<pre>` element with line numbers.\n     * @returns {void}\n     */\n    resize: function resize(element) {\n      resizeElements([element]);\n    },\n    /**\n     * Whether the plugin can assume that the units font sizes and margins are not depended on the size of\n     * the current viewport.\n     *\n     * Setting this to `true` will allow the plugin to do certain optimizations for better performance.\n     *\n     * Set this to `false` if you use any of the following CSS units: `vh`, `vw`, `vmin`, `vmax`.\n     *\n     * @type {boolean}\n     */\n    assumeViewportIndependence: true\n  };\n\n  /**\n   * Resizes the given elements.\n   *\n   * @param {HTMLElement[]} elements\n   */\n  function resizeElements(elements) {\n    elements = elements.filter(function (e) {\n      var codeStyles = getStyles(e);\n      var whiteSpace = codeStyles['white-space'];\n      return whiteSpace === 'pre-wrap' || whiteSpace === 'pre-line';\n    });\n    if (elements.length == 0) {\n      return;\n    }\n    var infos = elements.map(function (element) {\n      var codeElement = element.querySelector('code');\n      var lineNumbersWrapper = element.querySelector('.line-numbers-rows');\n      if (!codeElement || !lineNumbersWrapper) {\n        return undefined;\n      }\n\n      /** @type {HTMLElement} */\n      var lineNumberSizer = element.querySelector('.line-numbers-sizer');\n      var codeLines = codeElement.textContent.split(NEW_LINE_EXP);\n      if (!lineNumberSizer) {\n        lineNumberSizer = document.createElement('span');\n        lineNumberSizer.className = 'line-numbers-sizer';\n        codeElement.appendChild(lineNumberSizer);\n      }\n      lineNumberSizer.innerHTML = '0';\n      lineNumberSizer.style.display = 'block';\n      var oneLinerHeight = lineNumberSizer.getBoundingClientRect().height;\n      lineNumberSizer.innerHTML = '';\n      return {\n        element: element,\n        lines: codeLines,\n        lineHeights: [],\n        oneLinerHeight: oneLinerHeight,\n        sizer: lineNumberSizer\n      };\n    }).filter(Boolean);\n    infos.forEach(function (info) {\n      var lineNumberSizer = info.sizer;\n      var lines = info.lines;\n      var lineHeights = info.lineHeights;\n      var oneLinerHeight = info.oneLinerHeight;\n      lineHeights[lines.length - 1] = undefined;\n      lines.forEach(function (line, index) {\n        if (line && line.length > 1) {\n          var e = lineNumberSizer.appendChild(document.createElement('span'));\n          e.style.display = 'block';\n          e.textContent = line;\n        } else {\n          lineHeights[index] = oneLinerHeight;\n        }\n      });\n    });\n    infos.forEach(function (info) {\n      var lineNumberSizer = info.sizer;\n      var lineHeights = info.lineHeights;\n      var childIndex = 0;\n      for (var i = 0; i < lineHeights.length; i++) {\n        if (lineHeights[i] === undefined) {\n          lineHeights[i] = lineNumberSizer.children[childIndex++].getBoundingClientRect().height;\n        }\n      }\n    });\n    infos.forEach(function (info) {\n      var lineNumberSizer = info.sizer;\n      var wrapper = info.element.querySelector('.line-numbers-rows');\n      lineNumberSizer.style.display = 'none';\n      lineNumberSizer.innerHTML = '';\n      info.lineHeights.forEach(function (height, lineNumber) {\n        wrapper.children[lineNumber].style.height = height + 'px';\n      });\n    });\n  }\n\n  /**\n   * Returns style declarations for the element\n   *\n   * @param {Element} element\n   */\n  function getStyles(element) {\n    if (!element) {\n      return null;\n    }\n    return window.getComputedStyle ? getComputedStyle(element) : element.currentStyle || null;\n  }\n  var lastWidth = undefined;\n  window.addEventListener('resize', function () {\n    if (config.assumeViewportIndependence && lastWidth === window.innerWidth) {\n      return;\n    }\n    lastWidth = window.innerWidth;\n    resizeElements(Array.prototype.slice.call(document.querySelectorAll('pre.' + PLUGIN_NAME)));\n  });\n  Prism.hooks.add('complete', function (env) {\n    if (!env.code) {\n      return;\n    }\n    var code = /** @type {Element} */env.element;\n    var pre = /** @type {HTMLElement} */code.parentNode;\n\n    // works only for <code> wrapped inside <pre> (not inline)\n    if (!pre || !/pre/i.test(pre.nodeName)) {\n      return;\n    }\n\n    // Abort if line numbers already exists\n    if (code.querySelector('.line-numbers-rows')) {\n      return;\n    }\n\n    // only add line numbers if <code> or one of its ancestors has the `line-numbers` class\n    if (!Prism.util.isActive(code, PLUGIN_NAME)) {\n      return;\n    }\n\n    // Remove the class 'line-numbers' from the <code>\n    code.classList.remove(PLUGIN_NAME);\n    // Add the class 'line-numbers' to the <pre>\n    pre.classList.add(PLUGIN_NAME);\n    var match = env.code.match(NEW_LINE_EXP);\n    var linesNum = match ? match.length + 1 : 1;\n    var lineNumbersWrapper;\n    var lines = new Array(linesNum + 1).join('<span></span>');\n    lineNumbersWrapper = document.createElement('span');\n    lineNumbersWrapper.setAttribute('aria-hidden', 'true');\n    lineNumbersWrapper.className = 'line-numbers-rows';\n    lineNumbersWrapper.innerHTML = lines;\n    if (pre.hasAttribute('data-start')) {\n      pre.style.counterReset = 'linenumber ' + (parseInt(pre.getAttribute('data-start'), 10) - 1);\n    }\n    env.element.appendChild(lineNumbersWrapper);\n    resizeElements([pre]);\n    Prism.hooks.run('line-numbers', env);\n  });\n  Prism.hooks.add('line-numbers', function (env) {\n    env.plugins = env.plugins || {};\n    env.plugins.lineNumbers = true;\n  });\n})();","(function () {\n  if (typeof Prism === 'undefined' || typeof document === 'undefined') {\n    return;\n  }\n  var callbacks = [];\n  var map = {};\n  var noop = function noop() {};\n  Prism.plugins.toolbar = {};\n\n  /**\n   * @typedef ButtonOptions\n   * @property {string} text The text displayed.\n   * @property {string} [url] The URL of the link which will be created.\n   * @property {Function} [onClick] The event listener for the `click` event of the created button.\n   * @property {string} [className] The class attribute to include with element.\n   */\n\n  /**\n   * Register a button callback with the toolbar.\n   *\n   * @param {string} key\n   * @param {ButtonOptions|Function} opts\n   */\n  var registerButton = Prism.plugins.toolbar.registerButton = function (key, opts) {\n    var callback;\n    if (typeof opts === 'function') {\n      callback = opts;\n    } else {\n      callback = function callback(env) {\n        var element;\n        if (typeof opts.onClick === 'function') {\n          element = document.createElement('button');\n          element.type = 'button';\n          element.addEventListener('click', function () {\n            opts.onClick.call(this, env);\n          });\n        } else if (typeof opts.url === 'string') {\n          element = document.createElement('a');\n          element.href = opts.url;\n        } else {\n          element = document.createElement('span');\n        }\n        if (opts.className) {\n          element.classList.add(opts.className);\n        }\n        element.textContent = opts.text;\n        return element;\n      };\n    }\n    if (key in map) {\n      console.warn('There is a button with the key \"' + key + '\" registered already.');\n      return;\n    }\n    callbacks.push(map[key] = callback);\n  };\n\n  /**\n   * Returns the callback order of the given element.\n   *\n   * @param {HTMLElement} element\n   * @returns {string[] | undefined}\n   */\n  function getOrder(element) {\n    while (element) {\n      var order = element.getAttribute('data-toolbar-order');\n      if (order != null) {\n        order = order.trim();\n        if (order.length) {\n          return order.split(/\\s*,\\s*/g);\n        } else {\n          return [];\n        }\n      }\n      element = element.parentElement;\n    }\n  }\n\n  /**\n   * Post-highlight Prism hook callback.\n   *\n   * @param env\n   */\n  var hook = Prism.plugins.toolbar.hook = function (env) {\n    // Check if inline or actual code block (credit to line-numbers plugin)\n    var pre = env.element.parentNode;\n    if (!pre || !/pre/i.test(pre.nodeName)) {\n      return;\n    }\n\n    // Autoloader rehighlights, so only do this once.\n    if (pre.parentNode.classList.contains('code-toolbar')) {\n      return;\n    }\n\n    // Create wrapper for <pre> to prevent scrolling toolbar with content\n    var wrapper = document.createElement('div');\n    wrapper.classList.add('code-toolbar');\n    pre.parentNode.insertBefore(wrapper, pre);\n    wrapper.appendChild(pre);\n\n    // Setup the toolbar\n    var toolbar = document.createElement('div');\n    toolbar.classList.add('toolbar');\n\n    // order callbacks\n    var elementCallbacks = callbacks;\n    var order = getOrder(env.element);\n    if (order) {\n      elementCallbacks = order.map(function (key) {\n        return map[key] || noop;\n      });\n    }\n    elementCallbacks.forEach(function (callback) {\n      var element = callback(env);\n      if (!element) {\n        return;\n      }\n      var item = document.createElement('div');\n      item.classList.add('toolbar-item');\n      item.appendChild(element);\n      toolbar.appendChild(item);\n    });\n\n    // Add our toolbar to the currently created wrapper of <pre> tag\n    wrapper.appendChild(toolbar);\n  };\n  registerButton('label', function (env) {\n    var pre = env.element.parentNode;\n    if (!pre || !/pre/i.test(pre.nodeName)) {\n      return;\n    }\n    if (!pre.hasAttribute('data-label')) {\n      return;\n    }\n    var element;\n    var template;\n    var text = pre.getAttribute('data-label');\n    try {\n      // Any normal text will blow up this selector.\n      template = document.querySelector('template#' + text);\n    } catch (e) {/* noop */}\n    if (template) {\n      element = template.content;\n    } else {\n      if (pre.hasAttribute('data-url')) {\n        element = document.createElement('a');\n        element.href = pre.getAttribute('data-url');\n      } else {\n        element = document.createElement('span');\n      }\n      element.textContent = text;\n    }\n    return element;\n  });\n\n  /**\n   * Register the toolbar with Prism.\n   */\n  Prism.hooks.add('complete', hook);\n})();","(function () {\n  if (typeof Prism === 'undefined' || typeof document === 'undefined') {\n    return;\n  }\n  if (!Prism.plugins.toolbar) {\n    console.warn('Copy to Clipboard plugin loaded before Toolbar plugin.');\n    return;\n  }\n\n  /**\n   * When the given elements is clicked by the user, the given text will be copied to clipboard.\n   *\n   * @param {HTMLElement} element\n   * @param {CopyInfo} copyInfo\n   *\n   * @typedef CopyInfo\n   * @property {() => string} getText\n   * @property {() => void} success\n   * @property {(reason: unknown) => void} error\n   */\n  function registerClipboard(element, copyInfo) {\n    element.addEventListener('click', function () {\n      copyTextToClipboard(copyInfo);\n    });\n  }\n\n  // https://stackoverflow.com/a/30810322/7595472\n\n  /** @param {CopyInfo} copyInfo */\n  function fallbackCopyTextToClipboard(copyInfo) {\n    var textArea = document.createElement('textarea');\n    textArea.value = copyInfo.getText();\n\n    // Avoid scrolling to bottom\n    textArea.style.top = '0';\n    textArea.style.left = '0';\n    textArea.style.position = 'fixed';\n    document.body.appendChild(textArea);\n    textArea.focus();\n    textArea.select();\n    try {\n      var successful = document.execCommand('copy');\n      setTimeout(function () {\n        if (successful) {\n          copyInfo.success();\n        } else {\n          copyInfo.error();\n        }\n      }, 1);\n    } catch (err) {\n      setTimeout(function () {\n        copyInfo.error(err);\n      }, 1);\n    }\n    document.body.removeChild(textArea);\n  }\n  /** @param {CopyInfo} copyInfo */\n  function copyTextToClipboard(copyInfo) {\n    if (navigator.clipboard) {\n      navigator.clipboard.writeText(copyInfo.getText()).then(copyInfo.success, function () {\n        // try the fallback in case `writeText` didn't work\n        fallbackCopyTextToClipboard(copyInfo);\n      });\n    } else {\n      fallbackCopyTextToClipboard(copyInfo);\n    }\n  }\n\n  /**\n   * Selects the text content of the given element.\n   *\n   * @param {Element} element\n   */\n  function selectElementText(element) {\n    // https://stackoverflow.com/a/20079910/7595472\n    window.getSelection().selectAllChildren(element);\n  }\n\n  /**\n   * Traverses up the DOM tree to find data attributes that override the default plugin settings.\n   *\n   * @param {Element} startElement An element to start from.\n   * @returns {Settings} The plugin settings.\n   * @typedef {Record<\"copy\" | \"copy-error\" | \"copy-success\" | \"copy-timeout\", string | number>} Settings\n   */\n  function getSettings(startElement) {\n    /** @type {Settings} */\n    var settings = {\n      'copy': 'Copy',\n      'copy-error': 'Press Ctrl+C to copy',\n      'copy-success': 'Copied!',\n      'copy-timeout': 5000\n    };\n    var prefix = 'data-prismjs-';\n    for (var key in settings) {\n      var attr = prefix + key;\n      var element = startElement;\n      while (element && !element.hasAttribute(attr)) {\n        element = element.parentElement;\n      }\n      if (element) {\n        settings[key] = element.getAttribute(attr);\n      }\n    }\n    return settings;\n  }\n  Prism.plugins.toolbar.registerButton('copy-to-clipboard', function (env) {\n    var element = env.element;\n    var settings = getSettings(element);\n    var linkCopy = document.createElement('button');\n    linkCopy.className = 'copy-to-clipboard-button';\n    linkCopy.setAttribute('type', 'button');\n    var linkSpan = document.createElement('span');\n    linkCopy.appendChild(linkSpan);\n    setState('copy');\n    registerClipboard(linkCopy, {\n      getText: function getText() {\n        return element.textContent;\n      },\n      success: function success() {\n        setState('copy-success');\n        resetText();\n      },\n      error: function error() {\n        setState('copy-error');\n        setTimeout(function () {\n          selectElementText(element);\n        }, 1);\n        resetText();\n      }\n    });\n    return linkCopy;\n    function resetText() {\n      setTimeout(function () {\n        setState('copy');\n      }, settings['copy-timeout']);\n    }\n\n    /** @param {\"copy\" | \"copy-error\" | \"copy-success\"} state */\n    function setState(state) {\n      linkSpan.textContent = settings[state];\n      linkCopy.setAttribute('data-copy-state', state);\n    }\n  });\n})();"],"sourceRoot":""}