{"version":3,"file":"static/js/3236.507c7752.js","mappings":"sGAEAA,EAAOC,QAAU,CACbC,KAAM,CACFC,MAAO,MACPC,OAAQ,IACRC,KAAM,sVACNC,UAAW,0BAEfC,KAAM,CACFJ,MAAO,MACPC,OAAQ,IACRC,KAAM,yTACNC,UAAW,0BAEf,eAAgB,CACZH,MAAO,IACPC,OAAQ,IACRC,KAAM,obACNC,UAAW,0BAEfE,QAAS,CACLL,MAAO,IACPC,OAAQ,IACRC,KAAM,4MACNC,UAAW,0BAEfG,IAAK,CACDN,MAAO,IACPC,OAAQ,IACRC,KAAM,8KACNC,UAAW,0BAEfI,UAAW,CACPP,MAAO,IACPC,OAAQ,IACRC,KAAM,qHACNC,UAAW,0BAEfK,WAAY,CACRR,MAAO,IACPC,OAAQ,IACRC,KAAM,qEACNC,UAAW,0BAEfM,UAAW,CACPT,MAAO,IACPC,OAAQ,IACRC,KAAM,uaACNC,UAAW,0BAEfO,cAAe,CACXV,MAAO,KACPC,OAAQ,IACRC,KAAM,wDACNC,UAAW,0BAEfQ,gBAAiB,CACbX,MAAO,KACPC,OAAQ,IACRC,KAAM,wGACNC,UAAW,0BAEfS,WAAY,CACRZ,MAAO,KACPC,OAAQ,IACRC,KAAM,qMACNC,UAAW,0BAEf,SAAU,CACNH,MAAO,IACPC,OAAQ,IACRC,KAAM,wcACNC,UAAW,0BAEf,YAAa,CACTH,MAAO,IACPC,OAAQ,IACRC,KAAM,ogBACNC,UAAW,0BAEfU,OAAQ,CACJb,MAAO,IACPC,OAAQ,IACRC,KAAM,6dACNC,UAAW,0BAEfW,MAAO,CACHd,MAAO,IACPC,OAAQ,IACRC,KAAM,qdACNC,UAAW,0BAEfY,SAAU,CACNf,MAAO,MACPC,OAAQ,IACRC,KAAM,2bACNC,UAAW,0BAEfa,KAAM,CACFhB,MAAO,MACPC,OAAQ,IACRC,KAAM,uZACNC,UAAW,0BAEfc,aAAc,CACVjB,MAAO,GACPC,OAAQ,GACRC,KAAM,s0BACNC,UAAW,2BAEfe,eAAgB,CACZlB,MAAO,GACPC,OAAQ,GACRC,KAAM,uYACNC,UAAW,yBAEfgB,MAAO,CACHnB,MAAO,KACPC,OAAQ,IACRC,KAAM,qiBACNC,UAAW,0BAEfiB,UAAW,CACPpB,MAAO,IACPC,OAAQ,IACRC,KAAM,2YACNC,UAAW,0BAEfkB,SAAU,CACNrB,MAAO,GACPC,OAAQ,GACRC,KAAM,8eACNC,UAAW,2BAEfmB,SAAU,CACNtB,MAAO,GACPC,OAAQ,GACRC,KAAM,4EACNC,UAAW,2BAEfoB,WAAY,CACRvB,MAAO,GACPC,OAAQ,GACRC,KAAM,yPACNC,UAAW,2BAEfqB,WAAY,CACRxB,MAAO,GACPC,OAAQ,GACRC,KAAM,0OACNC,UAAW,2BAEfsB,UAAW,CACPzB,MAAO,IACPC,OAAQ,IACRC,KAAM,6LACNC,UAAW,8BAEfuB,OAAQ,CACJ1B,MAAO,KACPC,OAAQ,KACRC,KAAM,kQACNC,UAAW,uBAEfwB,cAAe,CACXC,KAAM,gBACNC,IAAK,CACD,iEACA,SACA,WACA,uBACA,uBACA,uBACA,uBACA,uBACA,uBACA,YACA,UACA,kCACA,mBACA,+EACA,mDACA,kDACA,kDACA,kDACA,kDACA,kDACA,yFACA,yFACA,yFACA,2FACA,QACA,UACFC,KAAK,K,uBChMf,IAAIC,EAAYC,EAAQ,OAEpBC,EAASD,EAAAA,OAAAA,OAGTE,EAAO,oCAMXrC,EAAOC,QAAU,SAAqBqC,GAKlC,MAJgB,kBAANA,IACNA,EAAIA,EAAEC,QAAQF,EAAM,KAGrBH,EAAUI,GAAWE,OAAOF,GAExBF,CACX,C,uBCnBA,IAAIK,EAAKN,EAAQ,OAajBnC,EAAOC,QAAU,SAAyByC,EAAYC,EAAUC,GAC5D,IAAIC,EAASH,EAAWI,UAAU,KAAOF,EAAIL,QAAQ,MAAO,MACvDQ,KAAKJ,GAAU,SAASK,GAAM,OAAOA,EAAG,GAAGC,MAAMC,GAAK,IAE3DL,EAAOM,OAAOC,SAEdP,EAAOQ,QAAQC,OAAO,KACjBC,KAAK,QAASX,GAEnBC,EAAOW,QAIP,IAAIC,EAAIf,EAAWgB,QAAQ,aAAe,iBAAmB,QAG7D,OAFAb,EAAOc,MAAK,SAASX,GAAMA,EAAG,GAAGS,GAAKhB,EAAGmB,OAAOC,KAAO,IAEhDhB,CACX,C,0CC5BA,IAAIiB,EAAe3B,EAAAA,OAAAA,aAEf4B,EAAS,CAETC,KAAM,SAASC,GAKX,GAAGA,EAAQC,eAAeJ,EAAc,OAAOG,EAE/C,IAAIE,EAAK,IAAIL,EACTM,EAAa,IAAIN,EAyDrB,OAlDAG,EAAQC,IAAMC,EAUdF,EAAQI,YAAcD,EAWtBH,EAAQK,GAAKH,EAAGG,GAAGC,KAAKJ,GACxBF,EAAQO,KAAOL,EAAGK,KAAKD,KAAKJ,GAC5BF,EAAQQ,eAAiBN,EAAGM,eAAeF,KAAKJ,GAChDF,EAAQS,mBAAqBP,EAAGO,mBAAmBH,KAAKJ,GAMxDF,EAAQU,YAAcP,EAAWE,GAAGC,KAAKH,GACzCH,EAAQW,cAAgBR,EAAWI,KAAKD,KAAKH,GAC7CH,EAAQY,wBAA0BT,EAAWK,eAAeF,KAAKH,GACjEH,EAAQa,4BAA8BV,EAAWM,mBAAmBH,KAAKH,GAQzEH,EAAQc,KAAO,SAASC,EAAOjC,GACN,qBAAXkC,QACNA,OAAOhB,GAASiB,QAAQF,EAAOjC,GAGnCoB,EAAGY,KAAKC,EAAOjC,GACfqB,EAAWW,KAAKC,EAAOjC,EAC3B,EAEOkB,CACX,EAQAkB,eAAgB,SAASlB,EAASe,EAAOjC,GACrC,IAAIqC,EACAC,EAMiB,qBAAXJ,SACNG,EAAqBH,OAAOhB,GAASkB,eAAeH,EAAOjC,IAM/D,IAAIoB,EAAKF,EAAQC,IACjB,IAAIC,EAAI,OAAOiB,EAEf,IAwBIE,EAxBAC,EAAWpB,EAAGqB,QAAQR,GAC1B,IAAIO,EAAU,OAAOH,EAGrB,SAASK,EAAMC,GAMX,OAAGA,EAAQC,UACPxB,EAAGM,eAAeO,EAAOU,EAAQC,UAC7BD,EAAQE,WAAZ,GACIF,EAAQE,OAAQ,EACTF,EAAQC,SAASF,MAAMtB,EAAI,CAACpB,MAGhC2C,EAAQD,MAAMtB,EAAI,CAACpB,GAElC,CAMA,IAHAwC,EAAWM,MAAMC,QAAQP,GAAYA,EAAW,CAACA,GAG7CD,EAAI,EAAGA,EAAIC,EAASQ,OAAS,EAAGT,IAChCG,EAAMF,EAASD,IAUnB,OAPAD,EAAwBI,EAAMF,EAASD,SAOTU,IAAvBZ,EACHA,EACAC,CACR,EAEAY,MAAO,SAAShC,GAeZ,cAdOA,EAAQC,WACRD,EAAQK,UACRL,EAAQO,YACRP,EAAQQ,sBACRR,EAAQS,0BACRT,EAAQc,YAERd,EAAQC,WACRD,EAAQI,mBACRJ,EAAQU,mBACRV,EAAQW,qBACRX,EAAQY,+BACRZ,EAAQa,4BAERb,CACX,GAIJjE,EAAOC,QAAU8D,C,wBC/JjB,IA6EImC,EAAeC,EAAaC,EA7E5BC,EAAMlE,EAAAA,OAAAA,IAOV,SAASmE,EAAkBC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GACnD,IAAIC,EAAIN,EAAKF,EACTS,EAAIL,EAAKJ,EACTU,EAAIJ,EAAKF,EACTO,EAAIR,EAAKF,EACTW,EAAIP,EAAKJ,EACTY,EAAIN,EAAKF,EACTS,EAAMN,EAAIK,EAAIH,EAAIC,EAGtB,GAAW,IAARG,EAAW,OAAO,KACrB,IAAIC,GAAKN,EAAII,EAAIH,EAAIE,GAAKE,EACtBE,GAAKP,EAAIE,EAAIH,EAAII,GAAKE,EAE1B,OAAGE,EAAI,GAAKA,EAAI,GAAKD,EAAI,GAAKA,EAAI,EAAU,KAErC,CAACE,EAAGjB,EAAKQ,EAAIO,EAAGG,EAAGjB,EAAKU,EAAII,EACvC,CAiCA,SAASI,EAAcC,EAAKC,EAAKC,EAAMC,EAAKC,GACxC,IAAIC,EAAQF,EAAMH,EAAMI,EAAMH,EAC9B,GAAGI,EAAO,EAEN,OAAOF,EAAMA,EAAMC,EAAMA,EACtB,GAAGC,EAAOH,EAAM,CAEnB,IAAII,EAAMH,EAAMH,EACZO,EAAMH,EAAMH,EAChB,OAAOK,EAAMA,EAAMC,EAAMA,CAC7B,CAEI,IAAIC,EAAeL,EAAMF,EAAMG,EAAMJ,EACrC,OAAOQ,EAAeA,EAAeN,CAE7C,CAlEA5H,EAAQqG,kBAAoBA,EAuB5BrG,EAAQmI,gBAAkB,SAAyB7B,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GAC3E,GAAGR,EAAkBC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GAAK,OAAO,EAG7D,IAAIuB,EAAM5B,EAAKF,EACX+B,EAAM5B,EAAKF,EACX+B,EAAM1B,EAAKF,EACX6B,EAAM1B,EAAKF,EACX6B,EAAOJ,EAAMA,EAAMC,EAAMA,EACzBI,EAAOH,EAAMA,EAAMC,EAAMA,EAGzBG,EAAQC,KAAKC,IACbnB,EAAcW,EAAKC,EAAKG,EAAM9B,EAAKJ,EAAIK,EAAKJ,GAC5CkB,EAAcW,EAAKC,EAAKG,EAAM5B,EAAKN,EAAIO,EAAKN,GAC5CkB,EAAca,EAAKC,EAAKE,EAAMnC,EAAKI,EAAIH,EAAKI,GAC5Cc,EAAca,EAAKC,EAAKE,EAAMjC,EAAKE,EAAID,EAAKE,IAGhD,OAAOgC,KAAKE,KAAKH,EACrB,EA+BA1I,EAAQ8I,gBAAkB,SAAyB1I,EAAM2I,EAAcC,EAAgBC,GAMnF,GALG7I,IAAS8F,GAAe+C,IAAc9C,IACrCF,EAAgB,CAAC,EACjBC,EAAc9F,EACd+F,EAAmB8C,GAEpBhD,EAAc+C,GACb,OAAO/C,EAAc+C,GAKzB,IAAIE,EAAK9I,EAAK+I,iBAAiB/C,EAAI4C,EAAiBC,EAAY,EAAGF,IAC/DK,EAAKhJ,EAAK+I,iBAAiB/C,EAAI4C,EAAiBC,EAAY,EAAGF,IAE/DM,EAAQV,KAAKW,MAAMF,EAAG5B,EAAI0B,EAAG1B,IAAM4B,EAAG7B,EAAI2B,EAAG3B,IAG7CgC,EAAUnJ,EAAK+I,iBAAiB/C,EAAI4C,EAAgBD,IAIpDS,EAAM,CAACjC,GAHU,EAAZgC,EAAQhC,EAAQ2B,EAAG3B,EAAI6B,EAAG7B,GAAK,EAGvBC,GAFI,EAAZ+B,EAAQ/B,EAAQ0B,EAAG1B,EAAI4B,EAAG5B,GAAK,EAEjB6B,MAAOA,GAE9B,OADApD,EAAc+C,GAAkBQ,EACzBA,CACX,EAEAxJ,EAAQyJ,mBAAqB,WACzBvD,EAAc,IAClB,EA0BAlG,EAAQ0J,kBAAoB,SAA2BtJ,EAAMuJ,EAAQC,GACjE,IASIC,EAAKC,EATLC,EAAOJ,EAAOI,KACdC,EAAQL,EAAOK,MACfC,EAAMN,EAAOM,IACbC,EAASP,EAAOO,OAEhBC,EAAO,EACPC,EAAShK,EAAKiK,iBACdC,EAAOF,EAIX,SAASG,EAAcC,GACnB,IAAIC,EAAKrK,EAAK+I,iBAAiBqB,GAGpB,IAARA,EAAWX,EAAMY,EACZD,IAAQJ,IAAQN,EAAUW,GAElC,IAAIC,EAAMD,EAAGlD,EAAIwC,EAAQA,EAAOU,EAAGlD,EAAKkD,EAAGlD,EAAIyC,EAAQS,EAAGlD,EAAIyC,EAAQ,EAClEW,EAAMF,EAAGjD,EAAIyC,EAAOA,EAAMQ,EAAGjD,EAAKiD,EAAGjD,EAAI0C,EAASO,EAAGjD,EAAI0C,EAAS,EACtE,OAAOvB,KAAKE,KAAK6B,EAAKA,EAAKC,EAAKA,EACpC,CAGA,IADA,IAAIC,EAAaL,EAAcJ,GACzBS,GAAY,CAEd,IADAT,GAAQS,EAAahB,GACXU,EAAM,OAChBM,EAAaL,EAAcJ,EAC/B,CAGA,IADAS,EAAaL,EAAcD,GACrBM,GAAY,CAEd,GAAGT,GADHG,GAAQM,EAAahB,GACL,OAChBgB,EAAaL,EAAcD,EAC/B,CAEA,MAAO,CACH1B,IAAKuB,EACLU,IAAKP,EACLE,IAAKF,EAAOH,EACZW,MAAOV,EACPW,SAAmB,IAATZ,GAAcG,IAASF,GAC7BzB,KAAKqC,IAAInB,EAAItC,EAAIuC,EAAQvC,GAAK,IAC9BoB,KAAKqC,IAAInB,EAAIrC,EAAIsC,EAAQtC,GAAK,GAE1C,EAcAxH,EAAQiL,gBAAkB,SAAyB7K,EAAM8K,EAAKC,EAAOC,GAkBjE,IAfA,IAWIC,EACAZ,EACAa,EAbAC,GAFJH,EAAOA,GAAQ,CAAC,GAEMG,YAAcnL,EAAKiK,iBACrCmB,EAAYJ,EAAKI,WAAa,KAC9BC,EAAiBL,EAAKK,gBAAkB,GAIxCC,EAAMtL,EAAK+I,iBAAiB,GAAGgC,GAAS/K,EAAK+I,iBAAiBoC,GAAYJ,IAAU,EAAI,EAExF9F,EAAI,EACJsG,EAAK,EACLC,EAAKL,EAKHlG,EAAIoG,GAAgB,CAKtB,GAJAJ,GAAOM,EAAKC,GAAM,EAElBN,GADAb,EAAKrK,EAAK+I,iBAAiBkC,IACjBF,GAASD,EAEhBvC,KAAKqC,IAAIM,GAAQE,EAChB,OAAOf,EAEJiB,EAAMJ,EAAO,EACZM,EAAKP,EAELM,EAAKN,EAEThG,GAER,CACA,OAAOoF,CACX,C,wBCvOAzK,EAAQ6L,QAAU,EAAlB7L,OAAAA,QAGAkC,EAAQ,MAGRA,EAAQ,OASR,IANA,IAAI4J,EAAW5J,EAAQ,OACnB6J,EAAW/L,EAAQ+L,SAAWD,EAASC,SAGvCC,EAAU9J,EAAQ,OAClB+J,EAAcC,OAAOC,KAAKH,GACtB3G,EAAI,EAAGA,EAAI4G,EAAYnG,OAAQT,IAAK,CACxC,IAAIvD,EAAOmK,EAAY5G,GAED,MAAnBvD,EAAKsK,OAAO,KAAYpM,EAAQ8B,GAAQkK,EAAQlK,IACnDiK,EAAS,CACLM,WAAY,YACZvK,KAAMA,EACNwK,GAAIN,EAAQlK,IAEpB,CAGAiK,EAAS7J,EAAQ,QAGjB6J,EAAS,CACL7J,EAAQ,OACRA,EAAQ,OACRA,EAAQ,OACRA,EAAQ,OACRA,EAAQ,OACRA,EAAQ,MACRA,EAAQ,OACRA,EAAQ,OACRA,EAAQ,OACRA,EAAQ,OACRA,EAAQ,OACRA,EAAQ,OACRA,EAAQ,OACRA,EAAQ,OACRA,EAAQ,OACRA,EAAQ,SAIZ6J,EAAS,CACL7J,EAAQ,KACRA,EAAQ,SAITqK,OAAOC,eAAiB5G,MAAMC,QAAQ0G,OAAOC,iBAC5CT,EAASQ,OAAOC,sBACTD,OAAOC,eAIlBxM,EAAQyM,MAAQ,EAAhBzM,MAGA,IAAI0M,EAAKxK,EAAQ,OACbyK,EAAQzK,EAAQ,OAEpBlC,EAAQ2M,MAAQ,CACZC,OAAQD,EAAMC,OACdC,UAAWF,EAAME,UACjBC,gBAAiBH,EAAMG,iBAE3B9M,EAAQ0M,GAAK,CACTK,MAAOL,EAAGK,MACVC,QAASN,EAAGM,QACZC,UAAWP,EAAGO,UACdC,YAAaR,EAAGQ,aAEpBlN,EAAQmN,SAAW,EAAnBnN,OACAA,EAAQoN,WAAa,EAArBpN,M,wBCjFA,IAAIqN,EAAYnL,EAAAA,OAAAA,OAEZoL,EAAgBpL,EAAQ,OAExB2D,EAAUD,MAAMC,QAEhB0H,EAAKC,YACLC,EAAKC,SAET,SAASC,EAAa7G,GAClB,OAAOyG,EAAGK,OAAO9G,MAAQA,aAAa2G,EAC1C,CAGA,SAASI,EAAoB/G,GACzB,OAAOjB,EAAQiB,IAAM6G,EAAa7G,EACtC,CAJA9G,EAAQ2N,aAAeA,EAKvB3N,EAAQ6N,oBAAsBA,EAa9B7N,EAAQ8N,UAHR,SAAmBhH,GACf,OAAQ+G,EAAoB/G,EAAE,GAClC,EAWA9G,EAAQ+N,YAAc,SAASvE,EAAKwE,GAShC,OANInI,EAAQ2D,KAAMA,EAAM,IAIxBA,EAAI1D,OAASkI,EAENxE,CACX,EAEA,IAAIyE,EAAc,CACdC,IAAkC,qBAAtBC,uBAAoCpI,EACpCoI,kBAEZC,GAAyB,qBAAdC,eAA4BtI,EAC5BsI,UAEXC,GAA0B,qBAAfC,gBAA6BxI,EAC7BwI,WAEXC,GAA0B,qBAAfC,gBAA6B1I,EAC7B0I,WAEXC,GAA2B,qBAAhBC,iBAA8B5I,EAC9B4I,YAEXC,GAA0B,qBAAfC,gBAA6B9I,EAC7B8I,WAEXC,GAA2B,qBAAhBC,iBAA8BhJ,EAC9BgJ,YAEXC,GAA4B,qBAAjBC,kBAA+BlJ,EAC/BkJ,aAEXC,GAA4B,qBAAjBC,kBAA+BpJ,EAC/BoJ,cAsBf,SAASC,EAActI,GACnB,OAAOA,EAAEuI,cAAgB7B,WAC7B,CAgKA,SAAS8B,EAAWC,EAAGjD,EAAIkD,GACvB,GAAG3B,EAAoB0B,GAAI,CACvB,GAAG1B,EAAoB0B,EAAE,IAAK,CAE1B,IADA,IAAI/E,EAAMgF,EACFnK,EAAI,EAAGA,EAAIkK,EAAEzJ,OAAQT,IACzBmF,EAAM8B,EAAG9B,EAAK+E,EAAElK,GAAGS,QAEvB,OAAO0E,CACX,CACI,OAAO+E,EAAEzJ,MAEjB,CACA,OAAO,CACX,CAzLAmI,EAAYwB,OAASxB,EAAYC,IACjCD,EAAYyB,MAAQzB,EAAYK,GAChCL,EAAY0B,KAAO1B,EAAYG,GAC/BH,EAAY2B,OAAS3B,EAAYS,GACjCT,EAAY4B,MAAQ5B,EAAYO,GAChCP,EAAY6B,OAAS7B,EAAYa,GACjCb,EAAY8B,MAAQ9B,EAAYW,GAChCX,EAAY+B,QAAU/B,EAAYe,GAClCf,EAAYgC,QAAUhC,EAAYiB,GAKlClP,EAAQoP,cAAgBA,EAExBpP,EAAQkQ,qBAAuB,SAASC,GACpC,IAAI3G,EAAM,GACNnH,EAuER,SAA8BA,GAC1B,MAAO,CACH+N,MAAO/N,EAAE+N,MACTC,MAAOhO,EAAEgO,MACTC,MAAOjO,EAAEiO,MAEjB,CA7EYC,CAAqBJ,GACzBE,EAAQhO,EAAEgO,MAEVG,EAAIvC,EAAYoC,GACpB,IAAIG,EAAG,MAAM,IAAIC,MAAM,oBAAsBJ,EAAQ,KACrD,IAAIK,EAAoBF,EAAEE,kBAEtB9G,EAASvH,EAAE+N,MACXhB,EAAcxF,KACdA,EAASyD,EAAUzD,IAEvB,IAAI0G,OAAoBvK,IAAZ1D,EAAEiO,MAEV,CAAC1G,EAAO+G,WAAaD,IAEpB,GAAKrO,EAAEiO,OAAOM,MAAM,KAEzBN,EAAMO,UACN,IAEIC,EAAIC,EAFJC,EAAOV,EAAMxK,OAGbmL,GAAMX,EAAM,GAEZY,EAAWR,EAAoBO,EAC/BE,EAAM,EAEV,GAAY,IAATH,EACCxH,EAAM,IAAIgH,EAAE5G,QACT,GAAY,IAAToH,EAEN,IADAF,GAAMR,EAAM,GACRS,EAAI,EAAGA,EAAID,EAAIC,IACfvH,EAAIuH,GAAK,IAAIP,EAAE5G,EAAQuH,EAAKF,GAC5BE,GAAOD,MAER,IAAY,IAATF,EAWN,MAAM,IAAIP,MAAM,SAAWO,EAAO,oCAAsC3O,EAAEiO,MAAQ,KAVlFQ,GAAMR,EAAM,GAEZ,IADA,IAAIc,GAAMd,EAAM,GACR9M,EAAI,EAAGA,EAAI4N,EAAI5N,IAEnB,IADAgG,EAAIhG,GAAK,GACLuN,EAAI,EAAGA,EAAID,EAAIC,IACfvH,EAAIhG,GAAGuN,GAAK,IAAIP,EAAE5G,EAAQuH,EAAKF,GAC/BE,GAAOD,CAKnB,CASA,OANA1H,EAAI4G,MAAQ/N,EAAE+N,MACd5G,EAAI6G,MAAQhO,EAAEgO,MACd7G,EAAI8G,MAAQA,EAAMO,UAAU7O,KAAK,KAEjCmO,EAAIkB,YAAc7H,EAEXA,CACX,EAEAxJ,EAAQsR,iBAAmB,SAASjP,GAChC,OACIiL,EAAcjL,IACdA,EAAEkP,eAAe,UAAgC,kBAAZlP,EAAEgO,OAEvChO,EAAEkP,eAAe,WAAgC,kBAAZlP,EAAE+N,OAAsBhB,EAAc/M,EAAE+N,eAEhErK,IAAZ1D,EAAEiO,OACCjO,EAAEkP,eAAe,WAAgC,kBAAZlP,EAAEiO,OAAyC,kBAAZjO,EAAEiO,OAGlF,EAiBAtQ,EAAQwR,OAAS,WACb,IAIIC,EAAcC,EAAMrM,EAAGsM,EAAMC,EAAMC,EAAMrI,EAAKuH,EAJ9Ce,EAAO,GACPC,GAAW,EACXC,EAAW,EAIf,IAAI3M,EAAI,EAAGA,EAAI4M,UAAUnM,OAAQT,KAE7BwM,GADAF,EAAOM,UAAU5M,IACLS,UAEL4L,EAAMI,EAAKI,KAAKP,IAEfD,EAAOC,EACPC,EAAOC,GAGRhM,EAAQ8L,GACPF,GAAe,GAEfM,GAAW,EACPC,EAEMP,IAAiBE,EAAKtC,cAG5BoC,GAAe,GAJfA,EAAeE,EAAKtC,aAQ5B2C,GAAYH,GAIpB,IAAIG,EAAU,MAAO,GACrB,IAAIF,EAAKhM,OAAQ,OAAO4L,EAExB,GAAGK,EAAU,OAAOL,EAAKF,OAAOhM,MAAMkM,EAAMI,GAC5C,GAAGL,EAAc,CAIb,KAFAjI,EAAM,IAAIiI,EAAaO,IACnBG,IAAIT,GACJrM,EAAI,EAAGA,EAAIyM,EAAKhM,OAAQT,IACxBsM,EAAOG,EAAKzM,GACZmE,EAAI2I,IAAIR,EAAMC,GACdA,GAAQD,EAAK7L,OAEjB,OAAO0D,CACX,CAIA,IADAA,EAAM,IAAI5D,MAAMoM,GACZjB,EAAI,EAAGA,EAAIW,EAAK5L,OAAQiL,IAAKvH,EAAIuH,GAAKW,EAAKX,GAC/C,IAAI1L,EAAI,EAAGA,EAAIyM,EAAKhM,OAAQT,IAAK,CAE7B,IADAsM,EAAOG,EAAKzM,GACR0L,EAAI,EAAGA,EAAIY,EAAK7L,OAAQiL,IAAKvH,EAAIoI,EAAOb,GAAKY,EAAKZ,GACtDa,GAAQb,CACZ,CACA,OAAOvH,CACX,EAEAxJ,EAAQoS,aAAe,SAAS7C,GAC5B,OAAOD,EAAWC,EAAG5G,KAAKkC,IAAK,EACnC,EAEA7K,EAAQqS,aAAe,SAAS9C,GAC5B,OAAOD,EAAWC,EAAG5G,KAAKC,IAAK0J,IACnC,C,wBCnQA,IAAIC,EAAiBrQ,EAAQ,OAEzBsQ,EAAwB,QAoB5BzS,EAAOC,QAAU,SAAwByS,EAASrS,EAAMsS,EAASC,GAG7D,IAAItN,EAAGuN,EAAKC,EAFZH,EAAUA,GAAW,OACrBC,EAAYA,GAAa,QAEzB,IAAIG,EAAc,CAAC,EAEhB1S,GAAQA,EAAK0F,QACZ+M,EAAWN,EAAeE,EAASrS,GACnCwS,EAAMC,EAASE,OAEfH,EAAMH,EAGVrS,EAAOA,GAAQ,GAGf,IAAI4S,EAAc,CAAC,EACnB,GAAGJ,EACC,IAAIvN,EAAI,EAAGA,EAAIuN,EAAI9M,OAAQT,IACvB2N,EAAYJ,EAAIvN,GAAGqN,IAAYrN,EAIvC,IAAI4N,EAAoBT,EAAsBU,KAAKP,GAE/CQ,EAAM,CACNhB,IAAK,SAASrQ,EAAMsR,GAChB,IAAIC,EAAuB,OAAVD,EA7BjB,EAJD,EAoCC,IAAIR,EAAK,CACL,IAAIC,GAjCR,IAiCoBQ,EAAsB,OAEtCT,EAAM,GACNC,EAASV,IAAIS,EACjB,CAEA,IAAIU,EAAMN,EAAYlR,GACtB,QAAWiE,IAARuN,EAAmB,CAClB,GAzCJ,IAyCOD,EAAsB,OAEzBA,GA5CL,EA6CKC,EAAMV,EAAI9M,OACVkN,EAAYlR,GAAQwR,CACxB,MAAUF,KAAWH,EAAoBL,EAAIU,GAAKX,GAAaJ,EAAeK,EAAIU,GAAMX,GAAWI,SAC/FM,GAjDJ,GAoDA,IAAIE,EAAWX,EAAIU,GAAOV,EAAIU,IAAQ,CAAC,EAiBvC,OAhBAC,EAASb,GAAW5Q,EAEjBmR,EACCM,EAASZ,GAAaS,EAEtBb,EAAegB,EAAUZ,GAAWR,IAAIiB,GAK/B,OAAVA,IACCC,IAA0B,GAG9BP,EAAYQ,GAAOR,EAAYQ,GAAOD,EAE/BF,CACX,EACAJ,IAAK,SAASjR,GACV,GAAI8Q,EAAJ,CAEA,IAAIU,EAAMN,EAAYlR,GAEtB,YAAWiE,IAARuN,OACC,EACML,EACCL,EAAIU,GAAKX,GAETJ,EAAeK,EAAIU,GAAMX,GAAWI,KAThC,CAWnB,EACAS,OAAQ,SAAS1R,EAAM2R,GACnB,IAAIH,EAAMN,EAAYlR,GAEtB,YAAWiE,IAARuN,IACHR,EAAYQ,GAzFb,EAyFoBR,EAAYQ,GAE/BN,EAAYS,GAAWH,SAChBN,EAAYlR,GAEnB8Q,EAAIU,GAAKZ,GAAWe,GANSN,CASjC,EACAhQ,OAAQ,SAASrB,GACb,IAAIwR,EAAMN,EAAYlR,GAEtB,QAAWiE,IAARuN,EAAmB,OAAOH,EAE7B,IAAIO,EAASd,EAAIU,GACjB,GAAGpH,OAAOC,KAAKuH,GAAQ5N,OAAS,EAI5B,OADAgN,EAAYQ,GA1GhB,EA0GuBR,EAAYQ,GACxBH,EAAIhB,IAAIrQ,EAAM,MAGzB,GAAGmR,EAAmB,CAClB,IAAI5N,EAAIiO,EAAKjO,EAAIuN,EAAI9M,OAAQT,IACzByN,EAAYzN,GA/GrB,EA+G0ByN,EAAYzN,GAEjC,IAAIA,EAAIiO,EAAKjO,EAAIuN,EAAI9M,OAAQT,IACzB2N,EAAYJ,EAAIvN,GAAGqN,MAEvBE,EAAIe,OAAOL,EAAK,UACTN,EAAYlR,EACvB,MAGIyQ,EAAemB,EAAQf,GAAWR,IAAI,MAOtCW,EAAYQ,GAjIhB,EAiIuBR,EAAYQ,GAGnC,OAAOH,CACX,EACAS,gBAAiB,WAIb,IAHA,IAAIC,EAAMP,EACNQ,EAAS,CAAC,EACVC,EAAU7H,OAAOC,KAAK2G,GAClBzN,EAAI,EAAGA,EAAI0O,EAAQjO,OAAQT,IAC/BiO,EAAMS,EAAQ1O,GACdwO,EAAOzT,EAAO,IAAMkT,EAAM,IACvBV,EAAIU,IA9IZ,EA+IYR,EAAYQ,KACXQ,EAAOD,EAAO,IAAMnB,GAAWE,EAAIU,GAAKZ,IA/IpD,EAiJWI,EAAYQ,KAEPQ,EAAOD,EAAO,IAAMlB,GADrBM,EAhJf,EAiJkDH,EAAYQ,GAAgB,KAAOV,EAAIU,GAAKX,GAjJ9F,EAmJkDG,EAAYQ,GAAgB,KAAOf,EAAeK,EAAIU,GAAMX,GAAWI,QAIjHe,EAAOD,GAAQ,KAIvB,OAAOC,CACX,GAGJ,OAAOX,CACX,C,oBCnLApT,EAAOC,QAAU,SAAuBmT,GAKpC,OAAG5G,QAAUA,OAAOyH,SAAWzH,OAAOyH,QAAQC,SACK,oBAAxC/H,OAAOgI,UAAUC,SAASC,KAAKjB,GAIE,oBAAxCjH,OAAOgI,UAAUC,SAASC,KAAKjB,IAC/BjH,OAAOmI,eAAelB,GAAK5B,eAAe,iBAElD,C,oBCQAxR,EAAOC,QAAU,SAAsBsU,GAKnC,IAJA,IAAIC,EAAO,CAAC,EACR/K,EAAM,GACNuH,EAAI,EAEA1L,EAAI,EAAGA,EAAIiP,EAAMxO,OAAQT,IAAK,CAClC,IAAImP,EAAOF,EAAMjP,GAEC,IAAfkP,EAAKC,KACJD,EAAKC,GAAQ,EACbhL,EAAIuH,KAAOyD,EAEnB,CAEA,OAAOhL,CACX,C,wBCrCA,IAAIiL,EAAYvS,EAAQ,OACpBkE,EAAMqO,EAAUrO,IAChBsO,EAAUD,EAAUC,QAEpBC,EAAKhM,KAAKgM,GACVC,EAAQ,EAAID,EAehB,SAASE,EAAaC,GAClB,OAAOnM,KAAKqC,IAAI8J,EAAM,GAAKA,EAAM,IAAMF,EAAQ,KACnD,CAUA,SAASG,EAAWjO,EAAGC,GACnB,OAAO2N,EAAQ3N,EAAID,EAAG8N,EAC1B,CAoBA,SAASI,EAAoBlO,EAAGgO,GAC5B,GAAGD,EAAaC,GAAQ,OAAO,EAE/B,IAAIG,EAAIC,EAELJ,EAAM,GAAKA,EAAM,IAChBG,EAAKH,EAAM,GACXI,EAAKJ,EAAM,KAEXG,EAAKH,EAAM,GACXI,EAAKJ,EAAM,KAGfG,EAAK7O,EAAI6O,EAAIL,KACbM,EAAK9O,EAAI8O,EAAIN,MACDM,GAAMN,GAElB,IAAIO,EAAK/O,EAAIU,EAAG8N,GACZQ,EAAKD,EAAKP,EAEd,OAAQO,GAAMF,GAAME,GAAMD,GAAQE,GAAMH,GAAMG,GAAMF,CACxD,CA4BA,SAASG,EAAMC,EAAIC,EAAIJ,EAAIC,EAAII,EAAIC,EAAI1K,GACnCyK,EAAKA,GAAM,EACXC,EAAKA,GAAM,EAEX,IACIC,EAAQC,EAAMC,EACdC,EAAQC,EAFRC,EAAWlB,EAAa,CAACM,EAAIC,IA2BjC,SAAS3K,EAAGuL,EAAGlP,GACX,MAAO,CAACkP,EAAIrN,KAAKsN,IAAInP,GAAK0O,EAAIC,EAAKO,EAAIrN,KAAKuN,IAAIpP,GACpD,CAzBGiP,GACCL,EAAS,EACTC,EAAOhB,EACPiB,EAAOhB,GAEJO,EAAKC,GACJM,EAASP,EACTS,EAAOR,IAEPM,EAASN,EACTQ,EAAOT,GAIZG,EAAKC,GACJM,EAASP,EACTQ,EAAOP,IAEPM,EAASN,EACTO,EAAOR,GAQX,IAKIa,EALAC,EAAWzN,KAAKqC,IAAI4K,EAAOF,IAAWf,EAAK,EAAI,EACnD,SAAS0B,EAAIL,EAAGlP,EAAGwP,GACf,MAAO,IAAM,CAACN,EAAGA,GAAK,IAAM,CAAC,EAAGI,EAAUE,GAAM,IAAM7L,EAAGuL,EAAGlP,EAChE,CA8BA,OA1BGiP,EAEKI,EADU,OAAXN,EACK,IAAMpL,EAAGqL,EAAMJ,GACfW,EAAIP,EAAMH,EAAM,GAChBU,EAAIP,EAAMF,EAAM,GAAK,IAErB,IAAMnL,EAAGoL,EAAQH,GACjBW,EAAIR,EAAQF,EAAM,GAClBU,EAAIR,EAAQD,EAAM,GAFlB,KAGMnL,EAAGqL,EAAMJ,GACfW,EAAIP,EAAMH,EAAM,GAChBU,EAAIP,EAAMF,EAAM,GAAK,IAGf,OAAXC,GACCM,EAAI,IAAM1L,EAAGqL,EAAMJ,GAAUW,EAAIP,EAAMF,EAAM,GAC1C7K,IAAUoL,GAAK,UAElBA,EAAI,IAAM1L,EAAGoL,EAAQH,GACjB,IAAMjL,EAAGqL,EAAMJ,GACfW,EAAIP,EAAMF,EAAM,GAChB,IAAMnL,EAAGoL,EAAQD,GACjBS,EAAIR,EAAQH,EAAQ,GAAK,IAI9BS,CACX,CA6CApW,EAAOC,QAAU,CACbuW,QAnNJ,SAAiBC,GAAO,OAAOA,EAAM,IAAM7B,CAAI,EAoN3C8B,QAlNJ,SAAiBC,GAAO,OAAOA,EAAM/B,EAAK,GAAK,EAmN3CI,WAAYA,EACZ4B,UAlLJ,SAAmB7P,EAAGC,GAClB,OAAO4B,KAAKqC,IAAI+J,EAAWjO,EAAGC,GAClC,EAiLI8N,aAAcA,EACdG,oBAAqBA,EACrB4B,iBA1IJ,SAA0BZ,EAAGlP,EAAG+P,EAAO/B,GACnC,QAAIE,EAAoBlO,EAAGgO,KAIxB+B,EAAM,GAAKA,EAAM,IAChBvB,EAAKuB,EAAM,GACXtB,EAAKsB,EAAM,KAEXvB,EAAKuB,EAAM,GACXtB,EAAKsB,EAAM,IAGRb,GAAKV,GAAMU,GAAKT,GAVvB,IAAID,EAAIC,CAWZ,EA6HIuB,QAzCJ,SAAiBd,EAAGb,EAAIC,EAAII,EAAIC,GAC5B,OAAOJ,EAAM,KAAMW,EAAGb,EAAIC,EAAII,EAAIC,EAAI,EAC1C,EAwCIsB,WA5BJ,SAAoBf,EAAGb,EAAIC,EAAII,EAAIC,GAC/B,OAAOJ,EAAM,KAAMW,EAAGb,EAAIC,EAAII,EAAIC,EAAI,EAC1C,EA2BIuB,YAdJ,SAAqB1B,EAAIC,EAAIJ,EAAIC,EAAII,EAAIC,GACrC,OAAOJ,EAAMC,EAAIC,EAAIJ,EAAIC,EAAII,EAAIC,EAAI,EACzC,E,oBClNA1V,EAAOC,QAAU,SAAyBiX,GACnCA,EAAGC,0BACF3K,OAAO4K,oBAAoB,SAAUF,EAAGC,gCACjCD,EAAGC,wBAElB,C,oBCVAnX,EAAOC,QAAU,SAA0BuH,EAAG6P,GAC1C,IAAIA,EAAO,OAAO7P,EAMlB,IAAI8P,EAAQ,EAAI1O,KAAKqC,IAAIoM,GACrBE,EAAQD,EAAQ,GAChBA,EAAQ9P,EACR8P,EAAQD,GACRC,EAAQ9P,EAAI6P,EAKZG,EAAQC,OAAOF,GAAMxR,OACzB,GAAGyR,EAAQ,GAAI,CACX,IAAIE,EAAQD,OAAOJ,GAAOtR,OAG1B,GAAGyR,GAFSC,OAAOjQ,GAAGzB,OAEF2R,EAAO,CACvB,IAAIC,EAAIC,WAAWL,GAAMM,YAAY,KACb,IAArBF,EAAEG,QAAQ,QAAcP,GAAQI,EACvC,CACJ,CAEA,OAAOJ,CACX,C,oBCTA,SAASQ,EAAWtD,GAChB,OAAwB,IAAjBA,EAAKuD,OAChB,CAEA,SAASC,EAAexD,GACpB,IAAIxR,EAAQwR,EAAK,GAAGxR,MACpB,OAAyB,IAAlBA,EAAM+U,SAAsC,IAAlB/U,EAAMiV,OAC3C,CAnBAlY,EAAOC,QAAU,SAAuBkY,GAIpC,IAHA,IAoBgBC,EApBZC,GAoBYD,EApBUD,EAsBtBtS,MAAMC,QAAQsS,IACdvS,MAAMC,QAAQsS,EAAK,KACnBA,EAAK,GAAG,IACRA,EAAK,GAAG,GAAGnV,MAzBwBgV,EAAiBF,GACpDtO,EAAM,GAEFnE,EAAI,EAAGA,EAAI6S,EAAUpS,OAAQT,IAAK,CACtC,IAAImP,EAAO0D,EAAU7S,GAClB+S,EAAS5D,IAAOhL,EAAI0I,KAAKsC,EAChC,CAEA,OAAOhL,CACX,C,sBCPAxJ,EAAQqY,aAAe,SAAsBjN,GACzC,MACmB,SAAjBA,EAAKkN,SACa,SAAjBlN,EAAKkN,SAAsBlN,EAAK7D,GAAK,EAAI,CAEhD,EAEAvH,EAAQuY,eAAiB,SAAwBnN,GAC7C,MACqB,WAAjBA,EAAKkN,SACa,SAAjBlN,EAAKkN,SAAsBlN,EAAK7D,EAAI,EAAI,GAAK6D,EAAK7D,EAAI,EAAI,CAEnE,EAEAvH,EAAQwY,cAAgB,SAAuBpN,GAC3C,MACmB,UAAjBA,EAAKkN,SACa,SAAjBlN,EAAKkN,SAAsBlN,EAAK7D,GAAK,EAAI,CAEhD,EAEAvH,EAAQyY,YAAc,SAAqBrN,GACvC,MACqB,QAAjBA,EAAKsN,SACa,SAAjBtN,EAAKsN,SAAsBtN,EAAK5D,GAAK,EAAI,CAElD,EAEAxH,EAAQ2Y,eAAiB,SAAwBvN,GAC7C,MACqB,WAAjBA,EAAKsN,SACa,SAAjBtN,EAAKsN,SAAsBtN,EAAK5D,EAAI,EAAI,GAAK4D,EAAK5D,EAAI,EAAI,CAEnE,EAEAxH,EAAQ4Y,eAAiB,SAAwBxN,GAC7C,MACmB,WAAjBA,EAAKsN,SACa,SAAjBtN,EAAKsN,SAAsBtN,EAAK5D,GAAK,EAAI,CAEhD,C,wBClDA,IAAIvF,EAAYC,EAAQ,OACpB2W,EAAY3W,EAAQ,OAEpB4W,EAAiB5W,EAAQ,OACzB6W,EAAc7W,EAAQ,OACtB8W,EAAQ9W,EAAQ,MAChB+W,EAAc/W,EAAAA,OAAAA,YAEdqQ,EAAiBrQ,EAAQ,OACzBgX,EAAehX,EAAAA,OAAAA,QACfwS,EAAUxS,EAAAA,OAAAA,QACV2L,EAAsB3L,EAAAA,OAAAA,oBACtBoP,EAAmBpP,EAAAA,OAAAA,iBACnBgO,EAAuBhO,EAAAA,OAAAA,qBAkiB3B,SAASiX,EAAS/F,EAAOhI,GACrB,IAAIgO,EAAepZ,EAAQqZ,cAAcjO,EAAKkO,SAE9C,GAAGlO,EAAKmO,SAAW1L,EAAoBuF,GAAQ,OAAO,EAEtD,GAAGgG,EAAaI,iBACZ,OAAOJ,EAAaI,iBAAiBpG,EAAOhI,GAGhD,IAAIqO,EAAS,CAAC,EACVjQ,EAAMiQ,EACNC,EAAW,CAAEvH,IAAK,SAAS9P,GAAKmH,EAAMnH,CAAG,GAK7C,OADA+W,EAAaO,eAAevG,EAAOsG,EAAUD,EAAQrO,GAC9C5B,IAAQiQ,CACnB,CAjjBAzZ,EAAQqZ,cAAgB,CACpBO,WAAY,CAERC,YAAa,CACT,sBACA,6DACA,mDACA,+BACA,wCACA,8DACA,oCACA,cACA,cACA,cACA,6CACA,iFACA,wBACA,qBACA,qBACA,qDACA,kEACA,mCACA,oDACA,yDACA,+DACA,sDACA,mDACA,mDACF7X,KAAK,KACP8X,aAAc,GACdC,UAAW,CAAC,QACZJ,eAAgB,SAAStX,EAAG2X,EAASC,GACjCD,EAAQ7H,IACJtE,EAAoBxL,GAAKA,EACzBiP,EAAiBjP,GAAK6N,EAAqB7N,GAC3C4X,EAER,GAEJC,WAAY,CACRL,YAAa,CACT,yDACA,gBACF7X,KAAK,KACP8X,aAAc,CAAC,UACfC,UAAW,CAAC,OAAQ,eAAgB,WACpCJ,eAAgB,SAAStX,EAAG2X,EAASC,EAAM7O,GACpCA,EAAK+O,eAAc9X,GAAKA,IACI,IAA5B+I,EAAKgP,OAAOvC,QAAQxV,GAAW2X,EAAQ7H,IAAI8H,GACzCD,EAAQ7H,IAAI9P,EACrB,EACAmX,iBAAkB,SAASnX,EAAG+I,GACvBA,EAAK+O,eAAc9X,GAAKA,GAG3B,IADA,IAAI+X,EAAShP,EAAKgP,OACV/U,EAAI,EAAGA,EAAI+U,EAAOtU,OAAQT,IAAK,CACnC,IAAI7B,EAAIgU,OAAO4C,EAAO/U,IAEtB,GAAoB,MAAhB7B,EAAE4I,OAAO,IAAyC,MAA3B5I,EAAE4I,OAAO5I,EAAEsC,OAAS,IAE3C,GADY,IAAIuU,OAAO7W,EAAE8W,OAAO,EAAG9W,EAAEsC,OAAS,IACrCoN,KAAK7Q,GAAI,OAAO,OACtB,GAAGA,IAAM+X,EAAO/U,GAAI,OAAO,CACtC,CACA,OAAO,CACX,GAEJkV,QAAS,CACLV,YAAa,gCACbC,aAAc,GACdC,UAAW,CAAC,QACZJ,eAAgB,SAAStX,EAAG2X,EAASC,IACxB,IAAN5X,IAAoB,IAANA,EAAa2X,EAAQ7H,IAAI9P,GACrC2X,EAAQ7H,IAAI8H,EACrB,GAEJO,OAAQ,CACJX,YAAa,CACT,8BACA,mCACA,4DACA,8BACF7X,KAAK,KACP8X,aAAc,GACdC,UAAW,CAAC,OAAQ,MAAO,MAAO,WAClCJ,eAAgB,SAAStX,EAAG2X,EAASC,EAAM7O,IACnCnJ,EAAUI,SACQ0D,IAAbqF,EAAKxC,KAAqBvG,EAAI+I,EAAKxC,UACtB7C,IAAbqF,EAAKP,KAAqBxI,EAAI+I,EAAKP,IACxCmP,EAAQ7H,IAAI8H,GACTD,EAAQ7H,KAAK9P,EACxB,GAEJoY,QAAS,CACLZ,YAAa,CACT,4CACA,4DACA,8BACF7X,KAAK,KACP8X,aAAc,GACdC,UAAW,CAAC,OAAQ,MAAO,MAAO,WAClCJ,eAAgB,SAAStX,EAAG2X,EAASC,EAAM7O,GACpC/I,EAAI,IAAMJ,EAAUI,SACD0D,IAAbqF,EAAKxC,KAAqBvG,EAAI+I,EAAKxC,UACtB7C,IAAbqF,EAAKP,KAAqBxI,EAAI+I,EAAKP,IACxCmP,EAAQ7H,IAAI8H,GACTD,EAAQ7H,KAAK9P,EACxB,GAEJqY,OAAQ,CACJb,YAAa,CACT,kBACA,8DACA,yBACF7X,KAAK,KACP8X,aAAc,GAEdC,UAAW,CAAC,OAAQ,UAAW,SAAU,UAAW,UACpDJ,eAAgB,SAAStX,EAAG2X,EAASC,EAAM7O,GACvC,GAAgB,kBAAN/I,EAAgB,CACtB,IAAIsY,EAA2B,kBAANtY,GAEN,IAAhB+I,EAAKwP,QAAoBD,EACvBX,EAAQ7H,IAAIqF,OAAOnV,IADgB2X,EAAQ7H,IAAI8H,EAExD,MAAU7O,EAAKyP,UAAYxY,EAAG2X,EAAQ7H,IAAI8H,GACrCD,EAAQ7H,IAAI9P,EACrB,GAEJyY,MAAO,CACHjB,YAAa,CACT,6BACA,qBACA,yBACA,gCACA,sCACA,mCACA,oCACA,0EACF7X,KAAK,KACP8X,aAAc,GACdC,UAAW,CAAC,OAAQ,WACpBJ,eAAgB,SAAStX,EAAG2X,EAASC,GAC9BpB,EAAUxW,GAAG0Y,UAAWf,EAAQ7H,IAAI9P,GAClC2X,EAAQ7H,IAAI8H,EACrB,GAEJe,UAAW,CACPnB,YAAa,CACT,oBACA,+CACF7X,KAAK,KACP8X,aAAc,GACdC,UAAW,CAAC,QACZJ,eAAgB,SAAStX,EAAG2X,EAASC,GAI7BrU,MAAMC,QAAQxD,IAAOA,EAAEyD,QACnBzD,EAAE4Y,OAJV,SAAiBH,GACb,OAAOjC,EAAUiC,GAAOC,SAC5B,IAE0Bf,EAAQ7H,IAAI9P,GADH2X,EAAQ7H,IAAI8H,EAGnD,GAEJiB,WAAY,CACRrB,YAAa,CACT,+CACA,UAAW3N,OAAOC,KAAK4M,EAAYoC,QAAQnZ,KAAK,MAAO,IACvD,uDACA,wDACA,uCACA,gDACFA,KAAK,KACP8X,aAAc,GACdC,UAAW,CAAC,QACZJ,eAAgB,SAAStX,EAAG2X,EAASC,GACjCD,EAAQ7H,IAAI4G,EAAYhG,IAAI1Q,EAAG4X,GACnC,GAEJmB,MAAO,CACHvB,YAAa,CACT,8CACF7X,KAAK,KACP8X,aAAc,GACdC,UAAW,CAAC,OAAQ,WACpBJ,eAAgB,SAAStX,EAAG2X,EAASC,GACxB,SAAN5X,EAAc2X,EAAQ7H,IAAI,QACpBlQ,EAAUI,GACd2X,EAAQ7H,IAAIuC,GAASrS,EAAG,MADN2X,EAAQ7H,IAAI8H,EAEvC,GAEJoB,UAAW,CACPxB,YAAa,CACT,6DACA,6DACA,8BACF7X,KAAK,KACP8X,aAAc,CAAC,QACfC,UAAW,CAAC,SACZJ,eAAgB,SAAStX,EAAG2X,EAASC,EAAM7O,GACvC,IAAIkQ,EAAQlQ,EAAKkQ,OAASpC,EAAae,GACvB,kBAAN5X,GAAkBiZ,EAAMpI,KAAK7Q,GACnC2X,EAAQ7H,IAAI9P,GAGhB2X,EAAQ7H,IAAI8H,EAChB,EACAT,iBAAkB,SAASnX,EAAG+I,GAC1B,IAAI6O,EAAO7O,EAAK6O,KAEhB,OAAG5X,IAAM4X,GACO,kBAAN5X,KACP6W,EAAae,GAAM/G,KAAK7Q,EAG/B,GAEJkZ,SAAU,CACN1B,YAAa,CACT,+CACA,gCACA,iDACA,4BACA,0CACF7X,KAAK,KACP8X,aAAc,CAAC,SACfC,UAAW,CAAC,OAAQ,SAAU,WAC9BJ,eAAgB,SAAStX,EAAG2X,EAASC,EAAM7O,GACvC,IAAuC,KAAnCA,EAAKoQ,QAAU,IAAI3D,QAAQxV,GAI/B,GAAgB,kBAANA,EAAV,CAMA,IAFA,IAAIoZ,EAASpZ,EAAEuO,MAAM,KACjBvL,EAAI,EACFA,EAAIoW,EAAO3V,QAAQ,CACrB,IAAI4V,EAAKD,EAAOpW,IACe,IAA5B+F,EAAKuQ,MAAM9D,QAAQ6D,IAAcD,EAAO5D,QAAQ6D,GAAMrW,EACrDoW,EAAO9H,OAAOtO,EAAG,GACdA,GACX,CACIoW,EAAO3V,OACNkU,EAAQ7H,IAAIsJ,EAAOzZ,KAAK,MADVgY,EAAQ7H,IAAI8H,EAT/B,MAFID,EAAQ7H,IAAI8H,QAJZD,EAAQ7H,IAAI9P,EAiBpB,GAEJuZ,IAAK,CACD/B,YAAa,YACbC,aAAc,GACdC,UAAW,CAAC,OAAQ,SAAU,WAC9BJ,eAAgB,SAAStX,EAAG2X,EAASC,QACxBlU,IAAN1D,EACC2X,EAAQ7H,IAAI8H,GAEZD,EAAQ7H,IACJb,EAAiBjP,GAAK6N,EAAqB7N,GAC3CA,EAGZ,GAEJwZ,WAAY,CACRhC,YAAa,CACT,mCACF7X,KAAK,KACP8X,aAAc,CAAC,SAMfC,UAAW,CAAC,OAAQ,aAAc,cAClCJ,eAAgB,SAAStX,EAAG2X,EAASC,EAAM7O,GAEvC,SAAS0Q,EAAWzZ,EAAG+I,EAAM6O,GACzB,IAAIzQ,EACAuS,EAAW,CAAC5J,IAAK,SAAS9P,GAAKmH,EAAMnH,CAAG,GAM5C,YAJY0D,IAATkU,IAAoBA,EAAO7O,EAAK6O,MAEnCja,EAAQqZ,cAAcjO,EAAKkO,SAASK,eAAetX,EAAG0Z,EAAU9B,EAAM7O,GAE/D5B,CACX,CAIA,GAFG8H,EAAiBjP,KAAIA,EAAI6N,EAAqB7N,IAE7CwL,EAAoBxL,GAAxB,CAKA,IASIgD,EAAG0L,EAAGiL,EAAKxH,EAAMyH,EAAMC,EATvBC,EAA2B,IAApB/Q,EAAKgR,YAAyC,QAApBhR,EAAKgR,YAAwBxW,MAAMC,QAAQxD,IAAMwL,EAAoBxL,EAAE,IAExGga,EAAQjR,EAAKiR,MACbC,EAAO,GACPC,EAAa3W,MAAMC,QAAQwW,GAC3BG,EAAeD,GAAcJ,GAAQtO,EAAoBwO,EAAM,IAC/DI,EAAiBN,GAAQI,IAAeC,EACxChS,EAAO+R,IAAeE,EAAkBJ,EAAMvW,OAASzD,EAAEyD,OAM7D,GAFAmU,EAAOrU,MAAMC,QAAQoU,GAAQA,EAAO,GAEjCkC,EACC,IAAI9W,EAAI,EAAGA,EAAImF,EAAKnF,IAOhB,IANAiX,EAAKjX,GAAK,GACV2W,EAAMnO,EAAoBxL,EAAEgD,IAAMhD,EAAEgD,GAAK,GACtB4W,EAAhBQ,EAAuBJ,EAAMvW,OACxByW,EAAmBF,EAAMhX,GAAGS,OACxBkW,EAAIlW,OAEZiL,EAAI,EAAGA,EAAIkL,EAAMlL,IACEyD,EAAhBiI,EAAuBJ,EAAMtL,GACxBwL,EAAmBF,EAAMhX,GAAG0L,GACxBsL,OAGAtW,KADZmW,EAAOJ,EAAWE,EAAIjL,GAAIyD,GAAOyF,EAAK5U,IAAM,IAAI0L,OACzBuL,EAAKjX,GAAG0L,GAAKmL,QAI5C,IAAI7W,EAAI,EAAGA,EAAImF,EAAKnF,SAEJU,KADZmW,EAAOJ,EAAWzZ,EAAEgD,GAAIkX,EAAaF,EAAMhX,GAAKgX,EAAOpC,EAAK5U,OACrCiX,EAAKjX,GAAK6W,GAIzClC,EAAQ7H,IAAImK,EAvCZ,MAFItC,EAAQ7H,IAAI8H,EA0CpB,EACAT,iBAAkB,SAASnX,EAAG+I,GAC1B,IAAIyC,EAAoBxL,GAAI,OAAO,EAEnC,IAAIga,EAAQjR,EAAKiR,MACbE,EAAa3W,MAAMC,QAAQwW,GAC3BF,EAA2B,IAApB/Q,EAAKgR,WAGhB,IAAIhR,EAAKsR,YAAcra,EAAEyD,SAAWuW,EAAMvW,OAAQ,OAAO,EAGzD,IAAI,IAAIT,EAAI,EAAGA,EAAIhD,EAAEyD,OAAQT,IACzB,GAAG8W,EAAM,CACL,IAAItO,EAAoBxL,EAAEgD,MAAS+F,EAAKsR,YAAcra,EAAEgD,GAAGS,SAAWuW,EAAMhX,GAAGS,OAC3E,OAAO,EAEX,IAAI,IAAIiL,EAAI,EAAGA,EAAI1O,EAAEgD,GAAGS,OAAQiL,IAC5B,IAAIoI,EAAS9W,EAAEgD,GAAG0L,GAAIwL,EAAaF,EAAMhX,GAAG0L,GAAKsL,GAC7C,OAAO,CAGnB,MAAO,IAAIlD,EAAS9W,EAAEgD,GAAIkX,EAAaF,EAAMhX,GAAKgX,GAAQ,OAAO,EAGrE,OAAO,CACX,IAgBRrc,EAAQ2c,OAAS,SAASC,EAAaC,EAAcC,EAAYC,EAAW9C,GACxE,IAAI7O,EAAOmH,EAAeuK,EAAYC,GAAWhK,MAC7CiK,EAASzK,EAAeqK,EAAaG,GACrC/C,EAAUzH,EAAesK,EAAcE,GACvC1a,EAAI2a,EAAOjK,MAEXkK,EAAWJ,EAAaK,UAS5B,QARSnX,IAAN1D,GAAmB4a,IAClB5a,EAAIkQ,EAAe0K,EAAUF,GAAWhK,MAExCkK,EAAW,QAGHlX,IAATkU,IAAoBA,EAAO7O,EAAK6O,MAEhC7O,EAAKmO,QAAS,CACb,GAAG1L,EAAoBxL,GASnB,OADA2X,EAAQ7H,IAAI9P,GACLA,EAEP,GAAGiP,EAAiBjP,GAGhB,OAFAA,EAAI6N,EAAqB7N,GACzB2X,EAAQ7H,IAAI9P,GACLA,CAGnB,CAEA,IAAIsX,EAAiB3Z,EAAQqZ,cAAcjO,EAAKkO,SAASK,eACzDA,EAAetX,EAAG2X,EAASC,EAAM7O,GAEjC,IAAI5B,EAAMwQ,EAAQjH,MAQlB,OALGkK,GAAYzT,IAAQyQ,IAASd,EAAS9W,EAAG+I,KAExCuO,EADAtX,EAAIkQ,EAAe0K,EAAUF,GAAWhK,MACtBiH,EAASC,EAAM7O,GACjC5B,EAAMwQ,EAAQjH,OAEXvJ,CACX,EASAxJ,EAAQmd,QAAU,SAASP,EAAaC,EAAcC,EAAYC,EAAW9C,GACzE,IAAI+C,EAASzK,EAAeqK,EAAaG,GACrC/C,EAAUha,EAAQ2c,OAAOC,EAAaC,EAAcC,EAAYC,EAAW9C,GAC3EmD,EAAQJ,EAAOjK,MAEnB,YAAkBhN,IAAVqX,GAAiC,OAAVA,GAAkBpD,CACrD,EAOAha,EAAQqd,WAAa,SAASV,EAAQrZ,EAAMga,GACxC,IAAI9T,EAAM,CAAC,EAQX,OANA8T,EAAUA,GAAW,CAAC,EAEtB9T,EAAI+T,OAASZ,EAAOrZ,EAAO,UAAWga,EAAQC,QAC9C/T,EAAIgU,KAAOb,EAAOrZ,EAAO,QAASga,EAAQE,MAC1ChU,EAAIsR,MAAQ6B,EAAOrZ,EAAO,SAAUga,EAAQxC,OAErCtR,CACX,EAKAxJ,EAAQyd,cAAgB,SAASd,EAAQrZ,EAAMoa,EAAaC,GAExD,GADYhB,EAAOrZ,EAAO,UAChB,CACNqZ,EAAOrZ,EAAO,aACdqZ,EAAOrZ,EAAO,SACd,IACIsa,EAAyB,YADdjB,EAAOrZ,EAAO,aAG7B,IAAIqa,EAAqB,CACrB,IAAIE,EAAUlB,EAAOrZ,EAAO,WAAYsa,EACpCF,OACA3X,GAGJ4W,EAAOrZ,EAAO,WAAYsa,EACtB5E,EAAM8E,SAASD,GACfH,EAER,CAEAf,EAAOrZ,EAAO,aAAcsa,EACxB,GACA,EAER,CACJ,EAUA5d,EAAQ+d,gBAAkB,SAASC,EAASC,EAAUC,GAClD,IAIIjE,EAJAkE,EAAcF,EAASG,QAAQtB,WAC/BuB,EAAQF,EAAYG,UAAYH,EAAcrF,EAE9CyF,EAASF,EAAMC,UAGnB,GAA6B,IAA1BJ,EAAUM,YAAmB,CAC5B,IAAI7C,EAAwB,QAAhB4C,EAAOtE,KACfsE,EAAO5C,MAAM8C,QACbF,EAAOtE,KAAKrJ,MAAM,KAEtB+K,EAAMhI,OAAOgI,EAAM9D,QAAQ,QAAS,GACpCoC,EAAO0B,EAAM3Z,KAAK,IACtB,CAEA,OAAOhC,EAAQ2c,OAAOqB,EAASC,EAAUI,EAAO,YAAapE,EACjE,EAaAja,EAAQ0e,6BAA+B,SAAST,EAAUtB,GACtD,GAAIsB,EAASU,OAAb,CAEA,IAIIC,EACAC,EALAC,EAAKb,EAASU,OAAOI,QAEzB,QAAUhZ,IAAP+Y,EAUCjR,EAAoBiR,IAAQb,EAASe,UAAaf,EAASgB,aAC3DL,EAAUE,EACVD,EAAW5F,EAAc6F,GAG7BnC,EAAO,0BAA2BiC,GAClCjC,EAAO,4BAA6BkC,EApBT,CAqB/B,EAoBA7e,EAAQmZ,SAAWA,C,wBCjkBnB,IAAI3W,EAAKN,EAAQ,OACbgd,EAAUhd,EAAQ,OAClBid,EAASjd,EAAQ,OACjBkd,EAASld,EAAQ,OAoCrB,SAASmd,EAAcC,GACnB,IAAIC,EAAWD,GAAMA,EAAGE,WACrBD,GAAUA,EAASE,YAAYH,EACtC,CAeA,SAASI,EAAoBzc,EAAK0c,EAAUC,GACxC,IAAIC,EAAK,mBAAqB5c,EAC1B6c,EAAQC,SAASC,eAAeH,GAChCC,KACAA,EAAQC,SAASE,cAAc,UACzBC,aAAa,KAAML,GAEzBC,EAAMK,YAAYJ,SAASK,eAAe,KAC1CL,SAASM,KAAKF,YAAYL,IAE9B,IAAIQ,EAAaR,EAAMS,MAEpBD,EAAWE,WACVF,EAAWE,WAAWb,EAAW,IAAMC,EAAc,IAAK,GACpDU,EAAWG,QACjBH,EAAWG,QAAQd,EAAUC,EAAa,GACvCV,EAAQwB,KAAK,sBACxB,CAiCA,SAASC,EAA0BC,GAC/B,IAAId,EAAQvT,OAAOsU,iBAAiBD,EAAS,MACzCvgB,EACFyf,EAAMgB,iBAAiB,sBACvBhB,EAAMgB,iBAAiB,mBACvBhB,EAAMgB,iBAAiB,kBACvBhB,EAAMgB,iBAAiB,iBACvBhB,EAAMgB,iBAAiB,aAGzB,MAAiB,SAAdzgB,EAA6B,KAEzBA,EACFiC,QAAQ,SAAU,IAClBA,QAAQ,KAAM,IACdmc,MAAM,GAAI,GACV7N,MAAM,KACNmQ,KAAI,SAAS/S,GAAK,OAAQA,CAAG,GACtC,CAIA,SAASgT,EAAuBJ,GAE5B,IADA,IAAIK,EAAc,GACZC,EAAuBN,IACzBK,EAAY/O,KAAK0O,GACjBA,EAAUA,EAAQpB,WAEtB,OAAOyB,CACX,CAEA,SAASC,EAAuBN,GAC5B,OAAOA,IAAYA,aAAmBO,SAAWP,aAAmBQ,YACxE,CAYArhB,EAAOC,QAAU,CACbqhB,YA5IJ,SAAqBpK,GACjB,IAAIqK,EAEJ,GAAiB,kBAAPrK,EAAiB,CAGvB,GAAiB,QAFjBqK,EAAYvB,SAASC,eAAe/I,IAGhC,MAAM,IAAIxG,MAAM,2BAA8BwG,EAAK,yBAGvD,OAAOqK,CACX,CAAO,GAAU,OAAPrK,QAAsBlR,IAAPkR,EACrB,MAAM,IAAIxG,MAAM,6CAIpB,OAAOwG,CACX,EA4HIsK,UA1HJ,SAAmBjC,GACf,IAAIkC,EAAMhf,EAAGmB,OAAO2b,GACpB,OAAOkC,EAAIC,iBAAkBL,aACzBI,EAAIhE,QACJgE,EAAI/d,QAAQ,iBACpB,EAsHI4b,cAAeA,EACfqC,aA3GJ,SAAsB/B,EAAUC,GAC5BF,EAAoB,SAAUC,EAAUC,EAC5C,EA0GIF,oBAAqBA,EACrBiC,uBA/EJ,SAAgC1e,GAC5B,IAAI4c,EAAK,mBAAqB5c,EAC1B6c,EAAQC,SAASC,eAAeH,GACjCC,GAAOT,EAAcS,EAC5B,EA4EI8B,uBA1EJ,SAAgChB,GAC5B,IAAIK,EAAcD,EAAuBJ,GAErCpX,EAAM,CACN,EAAG,EAAG,EAAG,EACT,EAAG,EAAG,EAAG,EACT,EAAG,EAAG,EAAG,EACT,EAAG,EAAG,EAAG,GASb,OAPAyX,EAAYY,SAAQ,SAAS3a,GACzB,IAAIG,EAAIsZ,EAA0BzZ,GAClC,GAAGG,EAAG,CACF,IAAIya,EAAI3C,EAAO4C,iBAAiB1a,GAChCmC,EAAM4V,EAAO4C,SAASxY,EAAKA,EAAKsY,EACpC,CACJ,IACOtY,CACX,EA0DImX,0BAA2BA,EAC3BK,uBAAwBA,EACxBiB,cApBJ,SAAuBnb,EAAGC,GACtB,OACID,GAAKC,GACLD,EAAEmD,MAAQlD,EAAEkD,KACZnD,EAAEiD,OAAShD,EAAEgD,MACbjD,EAAEkD,QAAUjD,EAAEiD,OACdlD,EAAEoD,SAAWnD,EAAEmD,MAEvB,E,wBCtJA,IAAIoD,EAAgBpL,EAAQ,OACxB2D,EAAUD,MAAMC,QAiDpB,SAASqc,EAAQC,EAAQC,EAAQC,EAAaC,GAC1C,IAGIC,EAAOC,EAAKC,EAAKC,EAAMC,EAAaC,EAAOC,EAH3CC,EAASX,EAAO,GAChBrc,EAASqc,EAAOrc,OAMpB,GAAc,IAAXA,GAAgBD,EAAQid,IAAWjd,EAAQsc,EAAO,KAAyB,IAAlBW,EAAOhd,OAAc,CAG7E,GAFA+c,EAxDR,SAA8BE,EAAQD,GAClC,IAAIzd,EAAG+N,EACP,IAAI/N,EAAI,EAAGA,EAAI0d,EAAOjd,OAAQT,IAAK,CAE/B,GAAa,QADb+N,EAAQ2P,EAAO1d,KACwB,kBAAX+N,EACxB,OAAO,OAEE,IAAVA,IACC0P,EAAOzd,GAAK+N,EAEpB,CACA,OAAO,CACX,CA4CwB4P,CAAqBb,EAAO,GAAIW,GAE7CD,EACC,OAAOC,EAEPA,EAAOnP,OAAO,EAAGmP,EAAOhd,OAEhC,CAEA,IAAI,IAAIT,EAAI,EAAGA,EAAIS,EAAQT,IAGvB,IAAImd,KAFJD,EAAQJ,EAAO9c,GAGXod,EAAMK,EAAON,GACbE,EAAOH,EAAMC,GAEVF,GAAiBzc,EAAQ6c,GAGxBI,EAAON,GAAOE,EACRN,GAAUM,IAASpV,EAAcoV,KAAUC,EAAc9c,EAAQ6c,MAGpEC,GACCA,GAAc,EACdC,EAAQH,GAAO5c,EAAQ4c,GAAOA,EAAM,IAEpCG,EAAQH,GAAOnV,EAAcmV,GAAOA,EAAM,CAAC,EAI/CK,EAAON,GAAON,EAAQ,CAACU,EAAOF,GAAON,EAAQC,EAAaC,KACpC,qBAATI,GAAwBL,KAGrCS,EAAON,GAAOE,GAK1B,OAAOI,CACX,CAnFA9iB,EAAQijB,WAAa,WACjB,OAAOf,EAAQjQ,WAAW,GAAO,GAAO,EAC5C,EAEAjS,EAAQkjB,WAAa,WACjB,OAAOhB,EAAQjQ,WAAW,GAAM,GAAO,EAC3C,EAEAjS,EAAQmjB,cAAgB,WACpB,OAAOjB,EAAQjQ,WAAW,GAAM,GAAM,EAC1C,EAEAjS,EAAQojB,mBAAqB,WACzB,OAAOlB,EAAQjQ,WAAW,GAAM,GAAO,EAC3C,C,wBC/BA,IAAInG,EAAW5J,EAAQ,OAWvBnC,EAAOC,QAAU,SAAkBiX,EAAIS,GAcnC,IAbA,IAAI2L,EAASpM,EAAGqM,SAASD,OAajBhe,EAAI,EAAGA,EAAI,EAAGA,IAAK,CAEvB,IADA,IAAIke,EAAUtM,EAAGqM,SAASC,QAClBxS,EAAI,EAAGA,EAAI,EAAGA,IAAK,CACvB,IAAIyS,GAAQD,EAAQF,IAAW,CAAC,GAAGI,WACnC,GAAGD,EAAM,CACL,IAAIha,EAAMga,EAAK9L,GACf,GAAGlO,EAAK,OAAOA,CACnB,CACA+Z,EAAUzX,EAAS4X,cACvB,CAEA,IAAIC,EAAaN,EAAOzS,MAAM,KAAK,GACnC,GAAG+S,IAAeN,EAAQ,MAC1BA,EAASM,CACb,CAEA,OAAOjM,CACX,C,wBC1CA,IAAI0H,EAASld,EAAQ,OAErBlC,EAAQ4jB,YAAc,SAASC,EAAWC,GAEtC,IADA,IAAIxP,EAAQ,IAAI1O,MAAMie,GACdxe,EAAI,EAAGA,EAAIwe,EAAWxe,IAAKiP,EAAMjP,GAAK,IAAIO,MAAMke,GACxD,OAAOxP,CACX,EAOAtU,EAAQ+jB,gBAAkB,SAASxU,GAC/B,IAEIlK,EAAG0L,EAFHiT,EAAS,EACTC,EAAO1U,EAAEzJ,OAGb,IAAIT,EAAI,EAAGA,EAAI4e,EAAM5e,IAAK2e,EAASrb,KAAKkC,IAAImZ,EAAQzU,EAAElK,GAAGS,QAEzD,IAAIuB,EAAI,IAAIzB,MAAMoe,GAClB,IAAI3e,EAAI,EAAGA,EAAI2e,EAAQ3e,IAEnB,IADAgC,EAAEhC,GAAK,IAAIO,MAAMqe,GACblT,EAAI,EAAGA,EAAIkT,EAAMlT,IAAK1J,EAAEhC,GAAG0L,GAAKxB,EAAEwB,GAAG1L,GAG7C,OAAOgC,CACX,EAGArH,EAAQkkB,IAAM,SAAS3c,EAAGC,GACtB,IAAKD,EAAEzB,SAAU0B,EAAE1B,QAAWyB,EAAEzB,SAAW0B,EAAE1B,OAAQ,OAAO,KAE5D,IACI0D,EACAnE,EAFAmF,EAAMjD,EAAEzB,OAIZ,GAAGyB,EAAE,GAAGzB,OAGJ,IADA0D,EAAM,IAAI5D,MAAM4E,GACZnF,EAAI,EAAGA,EAAImF,EAAKnF,IAAKmE,EAAInE,GAAKrF,EAAQkkB,IAAI3c,EAAElC,GAAImC,QACjD,GAAGA,EAAE,GAAG1B,OAAQ,CAEnB,IAAIqe,EAAankB,EAAQ+jB,gBAAgBvc,GAEzC,IADAgC,EAAM,IAAI5D,MAAMue,EAAWre,QACvBT,EAAI,EAAGA,EAAI8e,EAAWre,OAAQT,IAAKmE,EAAInE,GAAKrF,EAAQkkB,IAAI3c,EAAG4c,EAAW9e,GAC9E,MAGI,IADAmE,EAAM,EACFnE,EAAI,EAAGA,EAAImF,EAAKnF,IAAKmE,GAAOjC,EAAElC,GAAKmC,EAAEnC,GAG7C,OAAOmE,CACX,EAGAxJ,EAAQokB,kBAAoB,SAAS7c,EAAGC,GACpC,MAAO,CAAC,CAAC,EAAG,EAAGD,GAAI,CAAC,EAAG,EAAGC,GAAI,CAAC,EAAG,EAAG,GACzC,EAGAxH,EAAQqkB,eAAiB,SAASC,GAC9B,IAAIxd,EAAIwd,EAAQ3b,KAAKgM,GAAK,IAC1B,MAAO,CAAC,CAAChM,KAAKsN,IAAInP,IAAK6B,KAAKuN,IAAIpP,GAAI,GAC5B,CAAC6B,KAAKuN,IAAIpP,GAAI6B,KAAKsN,IAAInP,GAAI,GAC3B,CAAC,EAAG,EAAG,GACnB,EAGA9G,EAAQukB,iBAAmB,SAASzd,EAAGS,EAAGC,GACtC,OAAOxH,EAAQkkB,IACXlkB,EAAQkkB,IAAIlkB,EAAQokB,kBAAkB7c,EAAGC,GAC7BxH,EAAQqkB,eAAevd,IACnC9G,EAAQokB,mBAAmB7c,GAAIC,GACvC,EAIAxH,EAAQwkB,iBAAmB,SAASnkB,GAChC,OAAO,WACH,IAAIyR,EAAOG,UACPwS,EAA2B,IAArBxS,UAAUnM,OAAegM,EAAK,GAAK,CAACA,EAAK,GAAIA,EAAK,GAAIA,EAAK,IAAM,GAC3E,OAAO9R,EAAQkkB,IAAI7jB,EAAW,CAACokB,EAAI,GAAIA,EAAI,GAAIA,EAAI,GAAI,IAAIhG,MAAM,EAAG,EACxE,CACJ,EAGAze,EAAQ0kB,iBAAmB,SAASrkB,GAChC,OAAO,WACH,IAAIyR,EAAOG,UACQ,IAAhBH,EAAKhM,SACJgM,EAAOA,EAAK,IAEhB,IAAI6S,EAA0B,IAArB1S,UAAUnM,OAAegM,EAAK,GAAK,CAACA,EAAK,GAAIA,EAAK,IAC3D,OAAO9R,EAAQkkB,IAAI7jB,EAAW,CAACskB,EAAG,GAAIA,EAAG,GAAI,IAAIlG,MAAM,EAAG,EAC9D,CACJ,EAGAze,EAAQ4kB,kBAAoB,SAASvkB,GACjC,IAAIwkB,EAAK7kB,EAAQ0kB,iBAAiBrkB,GAClC,OAAO,SAASykB,GACZ,OAAOD,EAAGC,EAAIrG,MAAM,EAAG,IAAIjN,OAAOqT,EAAGC,EAAIrG,MAAM,EAAG,IACtD,CACJ,EAEAze,EAAQ+hB,iBAAmB,SAASD,GAChC,GAAGA,EAAG,CACF,IAAItX,EAAMsX,EAAEhc,OACZ,GAAW,KAAR0E,EAAY,OAAOsX,EACtB,GAAW,IAARtX,EAEC,MAAO,CACHsX,EAAE,GAAIA,EAAE,GAAI,EAAG,EACfA,EAAE,GAAIA,EAAE,GAAI,EAAG,EACf,EAAG,EAAG,EAAG,EACTA,EAAE,GAAIA,EAAE,GAAI,EAAG,EAG3B,CACA,MAAO,CACH,EAAG,EAAG,EAAG,EACT,EAAG,EAAG,EAAG,EACT,EAAG,EAAG,EAAG,EACT,EAAG,EAAG,EAAG,EAEjB,EAGA9hB,EAAQ+kB,uBAAyB,SAASjD,GACtC,IAAItY,EAAM,GAEV,OADA4V,EAAO4F,OAAOxb,EAAKsY,GACZ,CACH,CAACtY,EAAI,GAAIA,EAAI,GAAIA,EAAI,GAAIA,EAAI,IAC7B,CAACA,EAAI,GAAIA,EAAI,GAAIA,EAAI,GAAIA,EAAI,IAC7B,CAACA,EAAI,GAAIA,EAAI,GAAIA,EAAI,IAAKA,EAAI,KAC9B,CAACA,EAAI,IAAKA,EAAI,IAAKA,EAAI,IAAKA,EAAI,KAExC,C,oBCnIAzJ,EAAOC,QAAU,SAAyBiX,GACtC,IAAIgO,EAAahO,EAAGiO,YAEjBD,EAAWE,WAAaF,EAAWE,UAAU3H,QAC5CyH,EAAWE,UAAUzhB,MAAK,SAASuD,GAC5BA,EAAEme,MAAMne,EAAEme,KAAKC,MAAM,CAACvK,OAAO,EAAMwK,OAAO,GACjD,GAER,C,oBCZAvlB,EAAOC,QAAU,SAAkBiH,GAAK,OAAOA,CAAG,C,wBCHlD,IAiFIse,EAAQC,EAjFRC,EAAavjB,EAAAA,MAAAA,GACbD,EAAYC,EAAQ,OAEpBwjB,EAAUxjB,EAAQ,OAClBkE,EAAMlE,EAAAA,OAAAA,IAENyjB,EAAYzjB,EAAQ,OACpBC,EAASwjB,EAAUxjB,OACnByjB,EAASD,EAAUC,OACnBC,EAAUF,EAAUE,QACpBC,EAASH,EAAUG,OACnBC,EAASJ,EAAUI,OACnBC,EAAUL,EAAUK,QAEpBla,EAAW5J,EAAQ,OAEnB+jB,EAAY/jB,EAAAA,MAAAA,GAEZgkB,EAAkB,sIAElBC,EAAqB,wIAGrBC,GAAS,IAAIC,MAAOC,cAAgB,GAExC,SAASC,EAAgBC,GACrB,OACIA,GACA1a,EAAS2a,mBAAmBC,WACR,kBAAbF,GAAsC,cAAbA,CAExC,CA0MA,SAASG,EAAKzb,EAAK0b,GACf,OAAOpP,OAAOtM,EAAMvC,KAAKke,IAAI,GAAID,IAAStM,OAAO,EACrD,CArMAta,EAAQ8mB,UAAY,SAASN,EAAUO,GACnC,IAAIC,EAaR,SAAoBR,EAAUS,GAC1B,OAAGV,EAAgBC,GACRS,EACHnb,EAASob,mBAAmB,YAAa,oBAAoBV,GAC7D1a,EAASob,mBAAmB,YAAa,kBAAkBV,GAExDS,EAAS,aAAe,YAEvC,CArBgBE,CAAWX,IAAYO,GACnC,GAAGA,EAAY,EAAG,OAAOC,EAEzB,IAAI3kB,EAAIrC,EAAQonB,YAAYJ,EAAOR,GAEnC,OADAnkB,GAAKujB,GAAUmB,EAAY,GACpB/mB,EAAQqnB,YAAYhlB,EAAG,EAAGmkB,EACrC,EAoBAxmB,EAAQsnB,UAAY,SAASd,GACzB,OAAGD,EAAgBC,GACR1a,EAASob,mBAAmB,YAAa,aAAaV,GAEtD,CAAC,aAAc,aAE9B,EAGAxmB,EAAQunB,SAAW,SAASllB,GACxB,MAAoB,kBAANA,GAAwB,OAANA,GAAmC,oBAAdA,EAAEmlB,OAC3D,EA6DAxnB,EAAQonB,YAAc,SAAS1P,EAAG8O,GAE9B,GAAGxmB,EAAQunB,SAAS7P,GAAI,CAGpB,IAAI+P,EAAW/P,EAAEgQ,oBAAsB5B,EACnC6B,GAAejQ,EAAEkQ,gBAAkBlQ,EAAEmQ,cAAgB/B,GACpDpO,EAAEoQ,gBAAkBpQ,EAAEqQ,cAAgBhC,GACtCrO,EAAEsQ,qBAAuBtQ,EAAEuQ,mBAEhC,GAAGN,EAAa,CACZ,IAAIO,EAAO,EAAIpC,EACf2B,EAAWA,EAAWS,EAAO,EAAI9hB,EAAIuhB,EAAcF,EAAWS,EAAO,EAAGA,EAC5E,CAEA,OADAxQ,EAAInV,OAAOmV,GAAK+P,IACRlC,GAAU7N,GAAK8N,EAAe9N,EAC/BvV,CACX,CAEA,GAAgB,kBAANuV,GAA+B,kBAANA,EAAgB,OAAOvV,EAE1DuV,EAAIF,OAAOE,GAEX,IAAIyQ,EAAU5B,EAAgBC,GAI1BvR,EAAKyC,EAAEtL,OAAO,IACf+b,GAAmB,MAAPlT,GAAqB,MAAPA,IACzByC,EAAIA,EAAE4C,OAAO,GACbkM,EAAW,IAGf,IAAI4B,EAAYD,GAAqC,YAA1B3B,EAASlM,OAAO,EAAG,GAE1C+N,EAAQ3Q,EAAE2Q,MAAMD,EAAYjC,EAAqBD,GACrD,IAAImC,EAAO,OAAOlmB,EAClB,IAAIqF,EAAI6gB,EAAM,GACVvG,EAAIuG,EAAM,IAAM,IAChBphB,EAAI1E,OAAO8lB,EAAM,IAAM,GACvBC,EAAI/lB,OAAO8lB,EAAM,IAAM,GACvBE,EAAIhmB,OAAO8lB,EAAM,IAAM,GACvBG,EAAIjmB,OAAO8lB,EAAM,KAAO,GAE5B,GAAGF,EAAS,CAER,GAAgB,IAAb3gB,EAAE1B,OAAc,OAAO3D,EAG1B,IAAIsmB,EAFJjhB,EAAIjF,OAAOiF,GAGX,IACI,IAAIkhB,EAAc5c,EAASob,mBAAmB,YAAa,SAAzCpb,CAAmD0a,GACrE,GAAG4B,EAAW,CACV,IAAIO,EAA2C,MAA3B7G,EAAE1V,OAAO0V,EAAEhc,OAAS,GACxCgc,EAAI8G,SAAS9G,EAAG,IAChB2G,EAAQC,EAAYG,QAAQrhB,EAAGkhB,EAAYI,aAAathB,EAAGsa,EAAG6G,GAAgB1hB,EAClF,MACIwhB,EAAQC,EAAYG,QAAQrhB,EAAGjF,OAAOuf,GAAI7a,EAElD,CAAE,MAAMC,GAAK,OAAO/E,CAAQ,CAE5B,OAAIsmB,GAEKA,EAAMM,OAAS/C,GAAWJ,EAC9B0C,EAAIzC,EAAY0C,EAAIzC,EAAW0C,EAAIzC,EAHtB5jB,CAItB,CAGIqF,EADY,IAAbA,EAAE1B,QACIvD,OAAOiF,GAAK,IAAO4e,GAAU,IAAMA,EACjC7jB,OAAOiF,GAIlBsa,GAAK,EAKL,IAAIkH,EAAO,IAAI3C,KAAKA,KAAK4C,IAAI,IAAMnH,EAAG7a,EAAGqhB,EAAGC,IAG5C,OAFAS,EAAKE,eAAe1hB,GAEjBwhB,EAAKG,gBAAkBrH,GACvBkH,EAAKI,eAAiBniB,EADW9E,EAG7B6mB,EAAKxB,UAAYgB,EAAIzC,CAChC,EAEAR,EAASvlB,EAAQulB,OAASvlB,EAAQonB,YAAY,SAC9C5B,EAASxlB,EAAQwlB,OAASxlB,EAAQonB,YAAY,4BAG9CpnB,EAAQqpB,WAAa,SAAS3R,EAAG8O,GAC7B,OAAQxmB,EAAQonB,YAAY1P,EAAG8O,KAAcrkB,CACjD,EAeA,IAAImnB,EAAa,GAAK1D,EAClB2D,EAAa,EAAI1D,EACjB2D,EAAU,EAAI1D,EAyElB,SAAS2D,EAAYC,EAASC,EAAG7H,EAAGpK,EAAGkS,GAEnC,IAAGD,GAAK7H,GAAKpK,GAAKkS,KACdF,GAAW,IAAM/C,EAAKgD,EAAG,GAAK,IAAMhD,EAAK7E,EAAG,IACzCpK,GAAKkS,KACJF,GAAW,IAAM/C,EAAKjP,EAAG,GACtBkS,IAAQ,CAEP,IADA,IAAIhD,EAAS,EACPgD,EAAS,KAAO,GAClBhD,GAAU,EACVgD,GAAU,GAEdF,GAAW,IAAM/C,EAAKiD,EAAQhD,EAClC,CAGR,OAAO8C,CACX,CAzFA1pB,EAAQqnB,YAAc,SAASwC,EAAI7T,EAAGwQ,GAClC,GAAiB,kBAAPqD,KAAqBA,GAAMtE,GAAUsE,GAAMrE,GAAS,OAAOrjB,EAEjE6T,IAAGA,EAAI,GAEX,IAEI0T,EAASC,EAAG7H,EAAGpK,EAAGkS,EAAQ3iB,EAF1B6iB,EAAanhB,KAAKohB,MAA0B,GAApB3jB,EAAIyjB,EAAK,IAAM,IACvCG,EAAYrhB,KAAKshB,MAAMJ,EAAKC,EAAa,IAG7C,GAAGvD,EAAgBC,GAAW,CAC1B,IAAI0D,EAASvhB,KAAKohB,MAAMC,EAAYpE,GAAUI,EAC1CmE,EAASxhB,KAAKohB,MAAM3jB,EAAIyjB,EAAIjE,IAChC,IACI8D,EAAU5d,EAASob,mBAAmB,YAAa,SAAzCpb,CAAmD0a,GACxD4D,OAAOF,GAAQG,WAAW,aACnC,CAAE,MAAMnjB,GAEJwiB,EAAUzD,EAAU,YAAVA,CAAuB,IAAII,KAAK2D,GAC9C,CAKA,GAAyB,MAAtBN,EAAQtd,OAAO,GACd,KAAMsd,EAAQ5jB,OAAS,IAAI4jB,EAAU,KAAOA,EAAQpP,OAAO,QAE3D,KAAMoP,EAAQ5jB,OAAS,IAAI4jB,EAAU,IAAMA,EAK/CC,EAAK3T,EAAIsT,EAAc3gB,KAAKohB,MAAMI,EAAStE,GAAW,EACtD/D,EAAK9L,EAAIsT,EAAc3gB,KAAKohB,MAAOI,EAAStE,EAAWC,GAAU,EACjEpO,EAAK1B,EAAIuT,EAAc5gB,KAAKohB,MAAOI,EAASrE,EAAUC,GAAU,EAChE6D,EAAU5T,EAAIwT,EAAYW,EAASpE,EAAU,GAAK+D,EAAa,CACnE,MACI7iB,EAAI,IAAIof,KAAK2D,GAEbN,EAAUzD,EAAU,WAAVA,CAAsBhf,GAGhC0iB,EAAK3T,EAAIsT,EAAcriB,EAAEqjB,cAAgB,EACzCxI,EAAK9L,EAAIsT,EAAcriB,EAAE2gB,gBAAkB,EAE3ClQ,EAAK1B,EAAIuT,EAActiB,EAAE6gB,gBAAkB,EAE3C8B,EAAU5T,EAAIwT,EAAoC,GAAzBviB,EAAE+gB,qBAA4B8B,EAAa,EAGxE,OAAOL,EAAYC,EAASC,EAAG7H,EAAGpK,EAAGkS,EACzC,EAQA5pB,EAAQuqB,iBAAmB,SAASV,GAChC,KAAKA,GAAMtE,EAASK,GAAUiE,GAAMrE,EAASI,GAAS,OAAOzjB,EAE7D,IAAI2nB,EAAanhB,KAAKohB,MAA0B,GAApB3jB,EAAIyjB,EAAK,IAAM,IACvC5iB,EAAI,IAAIof,KAAK1d,KAAKshB,MAAMJ,EAAKC,EAAa,KAO9C,OAAOL,EANOhE,EAAW,WAAXA,CAAuBxe,GAC7BA,EAAEujB,WACFvjB,EAAE4gB,aACF5gB,EAAE8gB,aAC4B,GAAzB9gB,EAAE+gB,qBAA4B8B,EAG/C,EAwBA9pB,EAAQyqB,UAAY,SAASpoB,EAAG4X,EAAMuM,GAElC,GAAGnkB,IAAMF,EAAQ,OAAO8X,EACxB,GAAGja,EAAQunB,SAASllB,IAAoB,kBAANA,GAAkBqoB,SAASroB,GAAK,CAG9D,GAAGkkB,EAAgBC,GAEf,OADAd,EAAQiF,MAAM,kEAAmEtoB,GAC1E4X,EAOX,KADA5X,EAAIrC,EAAQuqB,kBAAkBloB,UACZ0D,IAATkU,EAAoB,OAAOA,CACxC,MAAO,IAAIja,EAAQqpB,WAAWhnB,EAAGmkB,GAE7B,OADAd,EAAQiF,MAAM,oBAAqBtoB,GAC5B4X,EAEX,OAAO5X,CACX,EAYA,IAAIuoB,EAAY,SACZC,EAAgB,MAChBC,EAAoB,CACpB,EAAG,IACH,EAAG,IACH,EAAG,IACH,EAAG,KAEP,SAASC,EAAcC,EAAKzjB,EAAG0jB,EAAWzE,GACtCwE,EAAMA,EAAI1oB,QAAQsoB,GAAW,SAASvC,GAClC,IAAIzB,EAASje,KAAKC,KAAMyf,EAAMjc,OAAO,IAAO,EAAG,GAI/C,OAHiB7E,EAAI,IAAO,EAAK,GAC5B2jB,QAAQtE,GACRtM,OAAO,GAAGhY,QAAQ,MAAO,KAAO,GAEzC,IAEA,IAAI2E,EAAI,IAAIof,KAAK1d,KAAKohB,MAAMxiB,EAAI,MAMhC,GAJAyjB,EAAMA,EAAI1oB,QAAQuoB,GAAe,WAC7B,OAAOC,EAAkBG,EAAU,KAAVA,CAAgBhkB,GAC7C,IAEGsf,EAAgBC,GACf,IACIwE,EAAMlf,EAASob,mBAAmB,YAAa,cAAzCpb,CAAwDkf,EAAKzjB,EAAGif,EAC1E,CAAE,MAAMtf,GACJ,MAAO,SACX,CAEJ,OAAO+jB,EAAUD,EAAVC,CAAehkB,EAC1B,CAQA,IAAIkkB,EAAa,CAAC,GAAI,KAAM,MAAO,OAAQ,SAsD3CnrB,EAAQqqB,WAAa,SAAS9iB,EAAGyjB,EAAKI,EAAIH,EAAWzE,EAAU6E,GAG3D,GAFA7E,EAAWD,EAAgBC,IAAaA,GAEpCwE,EACA,GAAU,MAAPI,EAAYJ,EAAMK,EAAYC,UAC5B,GAAU,MAAPF,EAAYJ,EAAMK,EAAYE,UACjC,IAAU,MAAPH,EAGJ,OA9DZ,SAAoB7jB,EAAG6jB,GACnB,IAAII,EAAWplB,EAAImB,EAAI,IAAMqe,GAEzB6F,EAAU9E,EAAKhe,KAAKohB,MAAMyB,EAAW3F,GAAU,GAAK,IACpDc,EAAKvgB,EAAIuC,KAAKohB,MAAMyB,EAAW1F,GAAS,IAAK,GAEjD,GAAU,MAAPsF,EAAY,CACPnpB,EAAUmpB,KAAKA,EAAK,GAiBxB,IAEIM,GAAU,IAFJ/iB,KAAKC,IAAIxC,EAAImB,EAAIwe,EAAQ,IAAKoF,EAAWC,KAE1BF,QAAQE,GAAI9Q,OAAO,GACzC8Q,EAAK,IACJM,EAASA,EAAOppB,QAAQ,MAAO,IAAIA,QAAQ,QAAS,KAGxDmpB,GAAW,IAAMC,CACrB,CACA,OAAOD,CACX,CA4BmBE,CAAWpkB,EAAG6jB,GAAM,KAAOL,EAAcM,EAAYO,aAAcrkB,EAAG0jB,EAAWzE,GAFxFwE,EAAMK,EAAYQ,SAAW,KAAOR,EAAYC,IAGpD,CAGJ,OAAOP,EAAcC,EAAKzjB,EAAG0jB,EAAWzE,EAC5C,EA4BA,IAAIsF,EAAY,EAAIlG,EACpB5lB,EAAQ+rB,eAAiB,SAASlC,EAAImC,EAAQxF,GAC1CA,EAAWD,EAAgBC,IAAaA,EAKxC,IAAI2D,EAAS/jB,EAAIyjB,EAAIjE,GAGrB,GAFAiE,EAAKlhB,KAAKshB,MAAMJ,EAAKM,GAElB3D,EACC,IACI,IAAI0D,EAASvhB,KAAKshB,MAAMJ,EAAKjE,GAAUI,EACnC0C,EAAc5c,EAASob,mBAAmB,YAAa,SAAzCpb,CAAmD0a,GACjEiC,EAAQC,EAAY0B,OAAOF,GAK/B,OAHG8B,EAAS,GAAItD,EAAYuD,IAAIxD,EAAOuD,EAAQ,KAC1CtD,EAAYuD,IAAIxD,EAAOuD,EAAS,GAAI,MAEjCvD,EAAMM,OAAS/C,GAAWJ,EAASuE,CAC/C,CAAE,MAAMjjB,GACJwe,EAAQiF,MAAM,cAAgBd,EAAK,gBAAkBrD,EAEzD,CAGJ,IAAIhf,EAAI,IAAI6e,KAAKwD,EAAKiC,GACtB,OAAOtkB,EAAE0kB,YAAY1kB,EAAE2hB,cAAgB6C,GAAU7B,EAAS2B,CAC9D,EAQA9rB,EAAQmsB,eAAiB,SAASrpB,EAAM0jB,GAapC,IAZA,IAIIvf,EACAmlB,EALAC,EAAa,EACbC,EAAc,EACdC,EAAY,EACZC,EAAa,EAIb9D,EACAnC,EAAgBC,IAChB1a,EAASob,mBAAmB,YAAa,SAAzCpb,CAAmD0a,GAG/CnhB,EAAI,EAAGA,EAAIvC,EAAKgD,OAAQT,IAI5B,GAHA+mB,EAAKtpB,EAAKuC,GAGNpD,EAAUmqB,IAMd,KAAGA,EAAKxG,GAER,GAAG8C,EACC,IAEmB,KADfzhB,EAAIyhB,EAAY0B,OAAOgC,EAAKxG,EAASI,IAChCyG,MACgB,IAAdxlB,EAAEskB,QAAec,IACfC,IACFC,GACX,CAAE,MAAMrlB,GACJ,MAIkB,KADtBD,EAAI,IAAIof,KAAK+F,IACRhD,aACsB,IAApBniB,EAAEkiB,cAAqBkD,IACrBC,IACFC,SAtBPC,IA0BRD,GADAD,GAAeD,EAGf,IAAIK,EAAY5pB,EAAKgD,OAAS0mB,EAE9B,MAAO,CACHH,WAAYA,EAAaK,EACzBJ,YAAaA,EAAcI,EAC3BH,UAAWA,EAAYG,EAE/B,C,wBCvlBA,IAAIlqB,EAAKN,EAAQ,OACb+jB,EAAY/jB,EAAAA,MAAAA,GACZyqB,EAAWzqB,EAAAA,OAAAA,GACXD,EAAYC,EAAQ,OAEpB0qB,EAAe1qB,EAAQ,OACvB2qB,EAAWD,EAAaE,QACxBC,GAAYF,EACZ1qB,EAASyqB,EAAazqB,OAEtB6qB,EAAMjtB,EAAOC,QAAU,CAAC,EAE5BgtB,EAAIC,aAAe,SAAsBC,GACrC,OACKA,GACD,YAAYha,KAAKga,IACjB,SAASha,KAAKga,GACTA,EAEQ,QAAdA,EAA4B,KAC5B,OAAOha,KAAKga,GAAmB,KAC/B,OAAOha,KAAKga,GAAmB,MAG7B,WAAWha,KAAKga,IAAe,SAASha,KAAKga,GAAmB,IAAMA,EAEpEA,CACX,EAEA,IAAIC,EAAiB,CAAC,EACtBH,EAAII,cAAgB,SAASjmB,GACzB,IAAIqb,EAAMhL,OAAOrQ,GACbgmB,EAAe3K,KACf2K,EAAe3K,GAAO,EACtBwK,EAAItM,KAAK,4BAA8B8B,EAAM,KAErD,EAEAwK,EAAIK,SAAW,SAASja,GACpB,OAAOoE,OAAOpE,EAClB,EAEA4Z,EAAIM,aAAe,SAASJ,GACxB,IAAI5gB,EACJ,IACIA,EAAKqgB,EAASK,EAAIC,aAAaC,GACnC,CAAE,MAAMhmB,GAEJ,OADA8lB,EAAII,cAAcF,GACXF,EAAIK,QACf,CAEA,OAAO/gB,CACX,EAEA0gB,EAAIza,eAAiBrQ,EAAQ,OAC7B8qB,EAAIO,eAAiBrrB,EAAQ,OAC7B8qB,EAAIQ,aAAetrB,EAAQ,OAC3B8qB,EAAI1f,cAAgBpL,EAAQ,OAC5B8qB,EAAIS,WAAavrB,EAAQ,OACzB8qB,EAAIU,kBAAoBxrB,EAAQ,OAEhC,IAAIyrB,EAAczrB,EAAQ,OAC1B8qB,EAAI5d,cAAgBue,EAAYve,cAChC4d,EAAIrf,aAAeggB,EAAYhgB,aAC/Bqf,EAAInf,oBAAsB8f,EAAY9f,oBACtCmf,EAAIlf,UAAY6f,EAAY7f,UAC5Bkf,EAAIjf,YAAc4f,EAAY5f,YAC9Bif,EAAIxb,OAASmc,EAAYnc,OACzBwb,EAAI5a,aAAeub,EAAYvb,aAC/B4a,EAAI3a,aAAesb,EAAYtb,aAE/B,IAAIoC,EAAYvS,EAAQ,OACxB8qB,EAAI5mB,IAAMqO,EAAUrO,IACpB4mB,EAAItY,QAAUD,EAAUC,QAExB,IAAIkZ,EAAe1rB,EAAQ,OAC3B8qB,EAAI3T,cAAgBuU,EAAavU,cACjC2T,EAAIrQ,OAASiR,EAAajR,OAC1BqQ,EAAI7P,QAAUyQ,EAAazQ,QAC3B6P,EAAI3P,WAAauQ,EAAavQ,WAC9B2P,EAAIvP,cAAgBmQ,EAAanQ,cACjCuP,EAAIjP,gBAAkB6P,EAAa7P,gBACnCiP,EAAItO,6BAA+BkP,EAAalP,6BAChDsO,EAAI7T,SAAWyU,EAAazU,SAE5B,IAAI0U,EAAc3rB,EAAQ,OAC1B8qB,EAAI5F,YAAcyG,EAAYzG,YAC9B4F,EAAI3D,WAAawE,EAAYxE,WAC7B2D,EAAI3F,YAAcwG,EAAYxG,YAC9B2F,EAAIzC,iBAAmBsD,EAAYtD,iBACnCyC,EAAIvC,UAAYoD,EAAYpD,UAC5BuC,EAAIzF,SAAWsG,EAAYtG,SAC3ByF,EAAI3C,WAAawD,EAAYxD,WAC7B2C,EAAIjB,eAAiB8B,EAAY9B,eACjCiB,EAAIlG,UAAY+G,EAAY/G,UAC5BkG,EAAI1F,UAAYuG,EAAYvG,UAC5B0F,EAAIb,eAAiB0B,EAAY1B,eACjCa,EAAIzH,OAASsI,EAAYtI,OACzByH,EAAIxH,OAASqI,EAAYrI,OAEzB,IAAIsI,EAAe5rB,EAAQ,OAC3B8qB,EAAIe,QAAUD,EAAaC,QAC3Bf,EAAIgB,UAAYF,EAAaE,UAC7BhB,EAAIiB,UAAYH,EAAaG,UAC7BjB,EAAIkB,aAAeJ,EAAaI,aAChClB,EAAImB,QAAUL,EAAaK,QAC3BnB,EAAIoB,KAAON,EAAaM,KACxBpB,EAAIqB,eAAiBP,EAAaO,eAElCrB,EAAIsB,eAAiBpsB,EAAQ,OAE7B,IAAIqsB,EAAcrsB,EAAQ,OAC1B8qB,EAAIwB,QAAUD,EAAYC,QAC1BxB,EAAIxiB,IAAM+jB,EAAY/jB,IACtBwiB,EAAIyB,KAAOF,EAAYE,KACvBzB,EAAI0B,OAASH,EAAYG,OACzB1B,EAAI2B,SAAWJ,EAAYI,SAC3B3B,EAAI4B,SAAWL,EAAYK,SAC3B5B,EAAI6B,MAAQN,EAAYM,MACxB7B,EAAI8B,OAASP,EAAYO,OAEzB,IAAIC,EAAe7sB,EAAQ,OAC3B8qB,EAAIpJ,YAAcmL,EAAanL,YAC/BoJ,EAAIjJ,gBAAkBgL,EAAahL,gBACnCiJ,EAAI9I,IAAM6K,EAAa7K,IACvB8I,EAAI5I,kBAAoB2K,EAAa3K,kBACrC4I,EAAI3I,eAAiB0K,EAAa1K,eAClC2I,EAAIzI,iBAAmBwK,EAAaxK,iBACpCyI,EAAIxI,iBAAmBuK,EAAavK,iBACpCwI,EAAItI,iBAAmBqK,EAAarK,iBACpCsI,EAAIpI,kBAAoBmK,EAAanK,kBACrCoI,EAAIjL,iBAAmBgN,EAAahN,iBACpCiL,EAAIjI,uBAAyBgK,EAAahK,uBAE1C,IAAIiK,EAAe9sB,EAAQ,OAC3B8qB,EAAIzW,QAAUyY,EAAazY,QAC3ByW,EAAIvW,QAAUuY,EAAavY,QAC3BuW,EAAIjY,WAAaia,EAAaja,WAC9BiY,EAAIrW,UAAYqY,EAAarY,UAC7BqW,EAAInY,aAAema,EAAana,aAChCmY,EAAIhY,oBAAsBga,EAAaha,oBACvCgY,EAAIpW,iBAAmBoY,EAAapY,iBACpCoW,EAAIlW,QAAUkY,EAAalY,QAC3BkW,EAAIjW,WAAaiY,EAAajY,WAC9BiW,EAAIhW,YAAcgY,EAAahY,YAE/B,IAAIiY,EAAc/sB,EAAQ,OAC1B8qB,EAAI3U,aAAe4W,EAAY5W,aAC/B2U,EAAIzU,eAAiB0W,EAAY1W,eACjCyU,EAAIxU,cAAgByW,EAAYzW,cAChCwU,EAAIvU,YAAcwW,EAAYxW,YAC9BuU,EAAIrU,eAAiBsW,EAAYtW,eACjCqU,EAAIpU,eAAiBqW,EAAYrW,eAEjC,IAAIsW,EAAehtB,EAAQ,OAC3B8qB,EAAI3mB,kBAAoB6oB,EAAa7oB,kBACrC2mB,EAAI7kB,gBAAkB+mB,EAAa/mB,gBACnC6kB,EAAIlkB,gBAAkBomB,EAAapmB,gBACnCkkB,EAAIvjB,mBAAqBylB,EAAazlB,mBACtCujB,EAAItjB,kBAAoBwlB,EAAaxlB,kBACrCsjB,EAAI/hB,gBAAkBikB,EAAajkB,gBAEnC,IAAIkkB,EAAejtB,EAAQ,OAC3B8qB,EAAI/J,WAAakM,EAAalM,WAC9B+J,EAAI9J,WAAaiM,EAAajM,WAC9B8J,EAAI7J,cAAgBgM,EAAahM,cACjC6J,EAAI5J,mBAAqB+L,EAAa/L,mBAEtC,IAAIgM,EAAgBltB,EAAQ,OAC5B8qB,EAAIqC,IAAMD,EAAcC,IACxBrC,EAAItM,KAAO0O,EAAc1O,KACzBsM,EAAIrC,MAAQyE,EAAczE,MAE1B,IAAI2E,EAAcptB,EAAQ,OAC1B8qB,EAAI9T,aAAeoW,EAAYC,QAE/B,IAAIC,EAAiBttB,EAAQ,OAC7B8qB,EAAIyC,SAAWD,EAAeC,SAC9BzC,EAAI0C,aAAeF,EAAeG,KAClC3C,EAAI4C,cAAgBJ,EAAenK,MAEnC,IAAIwK,EAAY3tB,EAAQ,OA2ZxB,SAAS4tB,EAAqBC,GAC1B,IAAIC,EAAmB,CAAC,EACxB,IAAI,IAAIxsB,KAAKusB,EAET,IADA,IAAIE,EAAMF,EAAcvsB,GAChBuN,EAAI,EAAGA,EAAIkf,EAAInqB,OAAQiL,IAC3Bif,EAAiBC,EAAIlf,KAAOvN,EAGpC,OAAOwsB,CACX,CAnaAhD,EAAI3L,YAAcwO,EAAUxO,YAC5B2L,EAAIzL,UAAYsO,EAAUtO,UAC1ByL,EAAI3N,cAAgBwQ,EAAUxQ,cAC9B2N,EAAItL,aAAemO,EAAUnO,aAC7BsL,EAAItN,oBAAsBmQ,EAAUnQ,oBACpCsN,EAAIrL,uBAAyBkO,EAAUlO,uBACvCqL,EAAIpL,uBAAyBiO,EAAUjO,uBACvCoL,EAAIrM,0BAA4BkP,EAAUlP,0BAC1CqM,EAAIhM,uBAAyB6O,EAAU7O,uBACvCgM,EAAI/K,cAAgB4N,EAAU5N,cAE9B+K,EAAIkD,gBAAkBhuB,EAAQ,OAC9B8qB,EAAImD,sBAAwBjuB,EAAQ,OAEpC8qB,EAAIoD,gBAAkBluB,EAAQ,MAE9B8qB,EAAIqD,EAAInuB,EAAQ,OAEhB8qB,EAAIsD,SAAWpuB,EAAQ,OAEvB8qB,EAAIuD,aAAeruB,EAAQ,OAC3B8qB,EAAIwD,cAAgBtuB,EAAQ,OAC5B8qB,EAAIyD,WAAavuB,EAAQ,OAEzB8qB,EAAI0D,UAAYxuB,EAAQ,OAExB8qB,EAAI2D,YAAczuB,EAAQ,MAE1B8qB,EAAI4D,aAAe,SAAsBvuB,GACrC,OAAIJ,EAAUI,IACdA,EAAIE,OAAOF,IACCwqB,GAAYxqB,EAAI0qB,EAAY5qB,EAASE,EAFxBF,CAG7B,EAUA6qB,EAAI6D,QAAU,SAASxuB,EAAGmI,GACtB,aAAWzE,IAARyE,GAAqBnI,GAAKmI,KACtBvI,EAAUI,IAAOA,GAAK,GAAOA,EAAI,IAAM,EAClD,EAEA2qB,EAAI8D,KAAO5uB,EAAQ,OACnB8qB,EAAI+D,SAAW7uB,EAAQ,OASvB8qB,EAAIgE,OAAS,SAAS3uB,EAAG4uB,GAErB,IADA,IAAIznB,EAAM,IAAI5D,MAAMqrB,GACZ5rB,EAAI,EAAGA,EAAI4rB,EAAK5rB,IACpBmE,EAAInE,GAAKhD,EAEb,OAAOmH,CACX,EAOAwjB,EAAIkE,UAAY,SAAS/Y,EAAMgZ,EAAUC,EAAOC,GACxCD,IAAOA,EAAQ,KACfC,IAAOA,EAAQ,KACnB,IAAI,IAAIhsB,EAAI,EAAGA,EAAI8rB,EAASrrB,OAAQT,IAAK,CACrC,IAAI/B,EAAO6tB,EAAS9rB,GAChBisB,EAAKtE,EAAIza,eAAe4F,EAAM7U,EAAKhB,QAAQ,IAAK8uB,IAChDG,EAAKvE,EAAIza,eAAe4F,EAAM7U,EAAKhB,QAAQ,IAAK+uB,IAChDG,EAAOF,EAAGve,MACdue,EAAGnf,IAAIof,EAAGxe,OACVwe,EAAGpf,IAAIqf,EACX,CACJ,EAKAxE,EAAIyE,WAAa,SAAoBC,GACjCA,EAAKlS,WAAWW,YAAYuR,EAChC,EAKA1E,EAAI2E,iBAAmB,SAASC,GAC5B,OAAOA,EAAUC,aAAaC,SAAS,EAC3C,EAGA9E,EAAI+E,UAAY,SAAS1vB,EAAG2vB,EAAIC,GAC5B,OAAGD,EAAKC,EAAWtpB,KAAKkC,IAAIonB,EAAItpB,KAAKC,IAAIopB,EAAI3vB,IACtCsG,KAAKkC,IAAImnB,EAAIrpB,KAAKC,IAAIqpB,EAAI5vB,GACrC,EAOA2qB,EAAIkF,cAAgB,SAASprB,EAAGC,EAAGorB,GAE/B,OADAA,EAAMA,GAAO,EACLrrB,EAAEiD,MAAQhD,EAAEiD,MAAQmoB,GACpBprB,EAAEgD,MAAQjD,EAAEkD,MAAQmoB,GACpBrrB,EAAEmD,KAAOlD,EAAEmD,OAASioB,GACpBprB,EAAEkD,KAAOnD,EAAEoD,OAASioB,CAChC,EAWAnF,EAAIoF,UAAY,SAAS9d,EAAO+d,EAAM/rB,EAAIE,EAAI4E,GAG1C,IAFA,IAAIZ,EAAM8J,EAAMxO,OACZ0D,EAAM,IAAI5D,MAAM4E,GACZnF,EAAI,EAAGA,EAAImF,EAAKnF,IAAKmE,EAAInE,GAAKgtB,EAAK/d,EAAMjP,GAAIiB,EAAIE,EAAI4E,GAC7D,OAAO5B,CACX,EAYAwjB,EAAIsF,QAAU,SAASA,EAAQC,EAAUC,EAAMC,EAAMC,GAGjD,GAFID,IAAMA,EAAO,SACL1sB,IAATysB,IAAoBA,EAAO,IAC3BA,GAAQ,EAAG,MAAO,IAErB,IAEIntB,EAAG0B,EAFH6f,EAASje,KAAK0mB,IAAI1mB,KAAKke,IAAI,EAAG2L,IAAS7pB,KAAK0mB,IAAIoD,GAChDE,EAAM,GAGV,IAAIttB,EAAI,EAAGuhB,IAAWtU,IAAUjN,GAAK,EACjCuhB,EAASje,KAAK0mB,IAAI1mB,KAAKke,IAAI,EAAG2L,EAAOntB,IAAMsD,KAAK0mB,IAAIoD,GAAQptB,EAGhE,IAAIutB,EAAMhM,EAASje,KAAKohB,MAAMnD,GAE9B,IAAIvhB,EAAI,EAAGA,EAAIsD,KAAKohB,MAAMnD,GAASvhB,IAE/BstB,EADIhqB,KAAKohB,MAAMphB,KAAKkqB,SAAWJ,GAAMte,SAASse,GACpCE,EAGXC,IACC7rB,EAAI4B,KAAKke,IAAI4L,EAAMG,GAEnBD,EADIhqB,KAAKohB,MAAMphB,KAAKkqB,SAAW9rB,GAAGoN,SAASse,GACjCE,GAGd,IAAIG,EAASlK,SAAS+J,EAAKF,GAC3B,OAAIF,GAAYA,EAASI,IACnBG,IAAWxgB,KAAYwgB,GAAUnqB,KAAKke,IAAI,EAAG2L,GAC5CE,EAAa,IACZ1F,EAAItM,KAAK,6BACFiS,GAEJL,EAAQC,EAAUC,EAAMC,GAAOC,GAAc,GAAK,GAC/CC,CAClB,EAEA3F,EAAI+F,cAAgB,SAASC,EAAKC,GAU1BD,IAAKA,EAAM,CAAC,GACZC,IAASA,EAAU,OAEvB,IAAIC,EAAO,CACXA,WAAkB,GAElBA,WAAkB,SAASC,GACvBA,EAAOF,GAAWD,EAClBE,EAAKC,EAAOrxB,MAAQqxB,EACpBD,EAAKE,WAAWlhB,KAAKihB,EACzB,GAGA,OADAD,EAAK,IAAMD,GAAWD,EACfE,CACX,EAOAlG,EAAIqG,OAAS,SAASC,EAASC,GAE3B,IADAA,EAAO5qB,KAAKshB,MAAMsJ,IAAS,GACjB,EAAG,OAAOD,EAEpB,IAKIjuB,EACA0L,EACAvN,EACAnB,EARAmxB,EAAOF,EAAQxtB,OACf2tB,EAAQ,EAAID,EACZE,EAAO,EAAIH,EAAO,EAClBI,EAAI,IAAI/tB,MAAM8tB,GACdE,EAAW,IAAIhuB,MAAM4tB,GAOzB,IAAInuB,EAAI,EAAGA,EAAIquB,EAAMruB,IACjBsuB,EAAEtuB,IAAM,EAAIsD,KAAKsN,IAAItN,KAAKgM,IAAMtP,EAAI,GAAKkuB,KAAU,EAAIA,GAI3D,IAAIluB,EAAI,EAAGA,EAAImuB,EAAMnuB,IAAK,CAEtB,IADAhD,EAAI,EACA0O,EAAI,EAAGA,EAAI2iB,EAAM3iB,KACjBvN,EAAI6B,EAAI0L,EAAI,EAAIwiB,IAGRC,EAAMhwB,GAAKiwB,EAAQ9qB,KAAKshB,MAAMzmB,EAAIiwB,GAClCjwB,GAAKiwB,IAAOjwB,GAAKiwB,EAAQ9qB,KAAKohB,MAAMvmB,EAAIiwB,IAG7CjwB,EAAI,EAAGA,GAAM,EAAIA,EACZA,GAAKgwB,IAAMhwB,EAAIiwB,EAAQ,EAAIjwB,GAEnCnB,GAAKixB,EAAQ9vB,GAAKmwB,EAAE5iB,GAExB6iB,EAASvuB,GAAKhD,CAClB,CAEA,OAAOuxB,CACX,EAaA5G,EAAI6G,YAAc,SAASC,EAAUC,EAAKC,GACtC,IAAIC,EAEJ,SAASC,IACL,OAAOlH,EAAI6G,YAAYC,EAAUC,EAAKC,EAC1C,CAEA,KAAMF,EAAShuB,QAIX,IAFAmuB,GADAE,EAAML,EAASngB,OAAO,EAAG,GAAG,IAClBogB,KAEAE,EAAIG,KACV,OAAOH,EAAIG,KAAKF,GAIxB,OAAOF,GAAaA,EAAUD,EAClC,EAOA/G,EAAIqH,mBAAqB,SAASC,GAC9B,MAAsB,MAAnBA,EAAIha,QAAQ,GAAmBga,EAAIha,OAAO,EAAGga,EAAIxuB,OAAS,GACtDwuB,CACX,EAEAtH,EAAIuH,UAAY,SAAS3X,EAAaC,EAAcsU,GAMhD,GAAIvU,EAAJ,CAEA,IAEIvX,EACA6F,EAHAspB,GAAS,EACTC,GAAS,EAIb,IAAIpvB,EAAI,EAAGA,EAAI8rB,EAASrrB,OAAQT,SAEjBU,KADXmF,EAAM0R,EAAYuU,EAAS9rB,MACK,OAAR6F,EAAcspB,GAAS,EAC1CC,GAAS,EAGlB,GAAGD,IAAWC,EACV,IAAIpvB,EAAI,EAAGA,EAAI8rB,EAASrrB,OAAQT,IAC5BuX,EAAYuU,EAAS9rB,IAAMwX,EAAasU,EAAS9rB,GAflC,CAkB3B,EAWA2nB,EAAI0H,WAAa,SAASC,EAAW5xB,EAAI6xB,EAAQtoB,GAC7C,IAAIuoB,EAAsB,oBAAPvoB,EACnB,GAAG0gB,EAAInf,oBAAoB8mB,GAEvB,IADA,IAAIG,EAAOnsB,KAAKC,IAAI+rB,EAAU7uB,OAAQ/C,EAAG+C,QACjCT,EAAI,EAAGA,EAAIyvB,EAAMzvB,IAAK,CAC1B,IAAIhD,EAAIsyB,EAAUtvB,GAClBtC,EAAGsC,GAAGuvB,GAAUC,EAAQvoB,EAAGjK,GAAKA,CACpC,CAER,EAGA2qB,EAAI+H,uBAAyB,SAASJ,EAAW5xB,EAAI6xB,GACjD,OAAO5H,EAAI0H,WAAWC,EAAW5xB,EAAI6xB,GAAQ,SAASvyB,GAClD,IAAIsxB,GAAKtxB,EACT,OAAQqoB,SAASiJ,IAASA,EAAI,EAAIA,EAAZ,CAC1B,GACJ,EAYA3G,EAAIgI,UAAY,SAASL,EAAW5xB,EAAI6xB,EAAQtoB,GAG5C,GAFAA,EAAKA,GAAM0gB,EAAI+D,SAEZ/D,EAAInf,oBAAoB8mB,GACvB,IAAI,IAAItvB,EAAI,EAAGA,EAAItC,EAAG+C,OAAQT,IAC1BtC,EAAGsC,GAAGuvB,GAAUtoB,EAAGqoB,EAAUtvB,GAGzC,EAWA2nB,EAAIiI,WAAa,SAASjyB,EAAOkyB,EAAUrhB,EAAMvH,GAC7CA,EAAKA,GAAM0gB,EAAI+D,SAEf,IAAI7lB,EAAM8hB,EAAIza,eAAevP,EAAO6Q,GAAMd,MAE1C,OAAGia,EAAInf,oBAAoB3C,GACpBtF,MAAMC,QAAQqvB,IAAalI,EAAInf,oBAAoB3C,EAAIgqB,EAAS,KACxD5oB,EAAGpB,EAAIgqB,EAAS,IAAIA,EAAS,KAE7B5oB,EAAGpB,EAAIgqB,IAGXhqB,CAEf,EAWA8hB,EAAImI,cAAgB,SAASC,EAAQpyB,EAAOqyB,EAASC,GACjD,GAAGD,KAAWD,EAAQ,OAAOA,EAAOC,GAMpC,IAAIE,EAAWvI,EAAIza,eAAevP,EAAOsyB,GAAUviB,MACnD,OAAInN,MAAMC,QAAQ0vB,QAAlB,EAAoCA,CACxC,EA0BAvI,EAAIwI,YAAc,SAASC,EAAWzyB,EAAO0yB,GACzC,IAEI1F,EAOoB3tB,EATpBszB,EAAiB3yB,EAAM2yB,eACvB5F,EAAgB/sB,EAAM4yB,eAIvB7F,IACCC,EAAmBF,EAAqBC,IAO5C,IAAI,IAAI1qB,EAAI,EAAGA,EAAIswB,EAAe7vB,OAAQT,IAAK,CAC3C,IAAIwwB,EAAUF,EAAetwB,GAE7B,GAAG2nB,EAAI6D,QAAQgF,IACX7I,EAAInf,oBAAoBgoB,IAAY7I,EAAI6D,QAAQgF,EAAQ,KAAO7I,EAAI6D,QAAQgF,EAAQ,IACrF,CACE,IAAIX,EAAWlF,EAAmBA,EAAiB6F,GAAWA,EAC1DC,EAAUJ,EAAmBA,EAAiBR,GAAYA,OAVrDnvB,KADO1D,EAaEyzB,IAZIzzB,EAAIozB,EAAU3vB,SAahC2vB,EAAUK,GAAS9W,SAAW,EAEtC,CACJ,CACJ,EAEAgO,EAAI+I,qBAAuB,SAAS/yB,GAChC,IAAI2yB,EAAiB3yB,EAAM2yB,eACvB5F,EAAgB/sB,EAAM4yB,eAE1B,GAAG7F,EAAe,CAId,IAHA,IAAIC,EAAmBF,EAAqBC,GACxCvmB,EAAM,GAEFnE,EAAI,EAAGA,EAAIswB,EAAe7vB,OAAQT,IAAK,CAC3C,IAAIwwB,EAAUF,EAAetwB,GAC7B,GAAG2nB,EAAI6D,QAAQgF,GAAU,CACrB,IAAIX,EAAWlF,EAAiB6F,GAC7B7I,EAAI6D,QAAQqE,IACX1rB,EAAI0I,KAAKgjB,EAEjB,CACJ,CAEA,OAAO1rB,CACX,CACI,OAAOmsB,CAEf,EAYA3I,EAAIgJ,eAAiB,SAAShzB,EAAOizB,GACjC,IAAInT,EAASmT,EAAcnT,OAE3B,GAAqB,kBAAXA,GAAuBA,EAAQ,CACrC,IAAIxO,EAAQ0Y,EAAIza,eAAevP,EAAO8f,GAAQ/P,MAC9C,QAAOia,EAAInf,oBAAoByG,IAASA,CAC5C,CAAO,QAAG0Y,EAAInf,oBAAoBiV,IACvBA,CAIf,EAiDAkK,EAAIkJ,UAzCJ,SAASA,EAAUC,EAAMC,EAAMpD,GAC3B,IAAIqD,EAAS,CAAC,EACK,kBAATD,IAAmBA,EAAO,CAAC,GAErC,IAGI/wB,EAAG7B,EAAGnB,EAHNi0B,EAAmB,YAARtD,GAAqB,EAAI,EAEpC7mB,EAAOD,OAAOC,KAAKgqB,GAGvB,IAAI9wB,EAAI,EAAGA,EAAI8G,EAAKrG,OAAQT,IAExBhD,EAAI8zB,EADJ3yB,EAAI2I,EAAK9G,IAEU,MAAhB7B,EAAE4I,OAAO,IAA2B,oBAAN/J,IACnB,WAANmB,EAAgB6yB,EAAO7yB,GAAKnB,EAC5BuD,MAAMC,QAAQxD,GAEdg0B,EAAO7yB,GADF,eAANA,IAAoC,IAAd8yB,EACTj0B,EAAEoc,QAEFpc,EAAEoc,MAAM,EAAG6X,GAErBtJ,EAAIrf,aAAatL,GAEnBg0B,EAAO7yB,IADM,IAAd8yB,EACaj0B,EAAEk0B,WAEFl0B,EAAEk0B,SAAS,EAAGD,GAEMD,EAAO7yB,GAArCnB,GAAmB,kBAANA,EAA6B6zB,EAAUC,EAAK3yB,GAAI4yB,EAAK5yB,GAAIwvB,GAC/D3wB,GAIrB,IADA8J,EAAOD,OAAOC,KAAKiqB,GACf/wB,EAAI,EAAGA,EAAI8G,EAAKrG,OAAQT,IAGR,kBADhBhD,EAAI+zB,EADJ5yB,EAAI2I,EAAK9G,MAEqB7B,KAAK6yB,GAAgC,kBAAdA,EAAO7yB,KACxD6yB,EAAO7yB,GAAKnB,GAIpB,OAAOg0B,CACX,EAGArJ,EAAIwJ,UAAY,SAAS9e,GACrB,OAAOA,EAAEtL,OAAO,GAAGqqB,cAAgB/e,EAAE4C,OAAO,EAChD,EAEA0S,EAAI0J,YAAc,SAAShf,EAAGif,GAC1B,IAAI,IAAItxB,EAAI,EAAGA,EAAIsxB,EAAU7wB,OAAQT,IACjC,IAAgC,IAA7BqS,EAAEG,QAAQ8e,EAAUtxB,IAAY,OAAO,EAE9C,OAAO,CACX,EAEA2nB,EAAI4J,KAAO,WACP,MAA8C,qBAAhCrqB,OAAOsqB,UAAUC,UACnC,EAEA,IAAIC,EAAkB,2BACtB/J,EAAIgK,SAAW,WACX,OAAOD,EAAgB7jB,KAAK3G,OAAOsqB,UAAUI,UACjD,EAEA,IAAIC,EAAe,mBACnBlK,EAAImK,MAAQ,WACR,OAAOD,EAAahkB,KAAK3G,OAAOsqB,UAAUI,UAC9C,EAEA,IAAIG,EAAwB,sBAC5BpK,EAAIqK,kBAAoB,WACpB,IAAIhP,EAAQ+O,EAAsBE,KAAK/qB,OAAOsqB,UAAUI,WACxD,GAAG5O,GAA0B,IAAjBA,EAAMviB,OAAc,CAC5B,IAAIyxB,EAAa3O,SAASP,EAAM,IAChC,IAAImP,MAAMD,GACN,OAAOA,CAEf,CACA,OAAO,IACX,EAEAvK,EAAIyK,cAAgB,SAAStkB,GACzB,OAAOA,aAAe3Q,EAAGovB,SAC7B,EA8BA5E,EAAI0K,aAAe,SAASC,EAAQC,EAAUC,EAAWC,GACrD,IAAIC,EAAMJ,EAAOh0B,OAAOi0B,GAAYC,EAAY,IAAMA,EAAY,KAClE,GAAGE,EAAIva,OAAQ,OAAOua,EAEtB,IAAIC,EAAQL,EAAOt0B,OAAOu0B,GAI1B,OAHGC,GAAWG,EAAMv0B,QAAQo0B,GAAW,GACpCC,GAASE,EAAM5jB,KAAK0jB,GAEhBE,CACX,EAYAhL,EAAIiL,iBAAmB,SAASN,EAAQC,EAAU/X,EAAIiY,GAClD,IAAIC,EAAMJ,EAAOh0B,OAAOi0B,EAAW,IAAM/X,GACzC,GAAGkY,EAAIva,OAAQ,OAAOua,EAEtB,IAAIC,EAAQL,EAAOt0B,OAAOu0B,GAAUt0B,KAAK,KAAMuc,GAG/C,OAFGiY,GAASE,EAAM5jB,KAAK0jB,GAEhBE,CACX,EAiBAhL,EAAIkL,eAAiB,SAAS93B,EAAMgT,GAKhC,IAJA,IACI+kB,EADAhsB,EAAO/L,EAAKwQ,MAAM,KAElBuC,EAAMglB,EAAS,CAAC,EAEZ9yB,EAAI,EAAGA,EAAI8G,EAAKrG,OAAQT,IAAK,CACjC,IAAImd,EAAMrW,EAAK9G,GACXia,EAAK,KAEL8Y,EAAQjsB,EAAK9G,GAAGgjB,MAAM,oBAEvB+P,GACC5V,EAAM4V,EAAM,GACZ9Y,EAAK8Y,EAAM,GAEXD,EAASA,EAAO3V,GAAO,GAEpBnd,IAAM8G,EAAKrG,OAAS,EACnBqyB,EAAO7Y,GAAMlM,EAEb+kB,EAAO7Y,GAAM,CAAC,EAGlB6Y,EAASA,EAAO7Y,KAEbja,IAAM8G,EAAKrG,OAAS,EACnBqyB,EAAO3V,GAAOpP,EAEd+kB,EAAO3V,GAAO,CAAC,EAGnB2V,EAASA,EAAO3V,GAExB,CAEA,OAAOrP,CACX,EA8BA,IAAIklB,EAAsB,qBACtBC,EAAuB,kCAE3B,SAASC,EAASC,GAEd,MAA4B,OAArBA,EAAK/Z,MAAM,EAAG,EACzB,CAEAuO,EAAIyL,kBAAoB,SAAS31B,GAC7B,IAAIulB,EAAO7F,EAAKgW,EAAME,EAAOplB,EAAKqlB,EAAMC,EACxC,GAAmB,kBAAT91B,IAAsB8C,MAAMC,QAAQ/C,GAC1C,IAAI0f,KAAO1f,EACP,GAAGA,EAAKyO,eAAeiR,GACnB,GAAI6F,EAAQ7F,EAAI6F,MAAMgQ,GAAuB,CAGzC,GAFAK,EAAQ51B,EAAK0f,GAEV+V,EADHC,EAAOnQ,EAAM,IACM,gBAEZvlB,EAAK0f,GAEZ1f,EAAK01B,GAAQxL,EAAI5J,mBAAmBtgB,EAAK01B,IAAS,CAAC,EAAGxL,EAAIkL,eAAe1V,EAAKwK,EAAIyL,kBAAkBC,IAAQF,GAChH,MAAO,GAAInQ,EAAQ7F,EAAI6F,MAAMiQ,GAAwB,CAIjD,GAHAI,EAAQ51B,EAAK0f,GAGV+V,EADHC,EAAOnQ,EAAM,IACM,SAQnB,GANA/U,EAAMsV,SAASP,EAAM,WAEdvlB,EAAK0f,GAEZ1f,EAAK01B,GAAQ11B,EAAK01B,IAAS,GAEX,MAAbnQ,EAAM,GAGLuQ,EAAevQ,EAAM,GACrBsQ,EAAO71B,EAAK01B,GAAMllB,GAAOxQ,EAAK01B,GAAMllB,IAAQ,CAAC,EAc7C0Z,EAAI5J,mBAAmBuV,EAAM3L,EAAIkL,eAAeU,EAAc5L,EAAIyL,kBAAkBC,SACjF,CAIH,GAAGH,EAASC,GAAO,SACnB11B,EAAK01B,GAAMllB,GAAO0Z,EAAIyL,kBAAkBC,EAC5C,CACJ,KAAO,CACH,GAAGH,EAAS/V,GAAM,SAClB1f,EAAK0f,GAAOwK,EAAIyL,kBAAkB31B,EAAK0f,GAC3C,CAKZ,OAAO1f,CACX,EAuBAkqB,EAAI6L,YAAc,SAASzlB,EAAO0lB,EAAYC,GAG1C,GAFIA,IAAmBA,GAAoB,GAElB,kBAAfD,GAAiD,IAAtBA,EAAWhzB,OAC5C,MAAM,IAAI2K,MAAM,6CAGA,kBAAV2C,IACNA,EAAQoE,OAAOpE,IAGnB,IAAI4lB,EAAc,eACdC,EAAaH,EAAW1sB,OAAO,GAC/B8sB,EAAUJ,EAAW1sB,OAAO,GAE5B7E,EAAI6L,EAAMxC,MAAM,KAChBtK,EAAKiB,EAAE,GACPf,EAAKe,EAAEzB,OAAS,EAAImzB,EAAa1xB,EAAE,GAAK,GAG5C,GAAG2xB,IAAY3xB,EAAEzB,OAAS,GAAKQ,EAAGR,OAAS,GAAKizB,GAC5C,KAAMC,EAAY9lB,KAAK5M,IACnBA,EAAKA,EAAGhE,QAAQ02B,EAAa,KAAOE,EAAU,MAItD,OAAO5yB,EAAKE,CAChB,EAEAwmB,EAAImM,sBAAwB,iCAC5B,IAAI3mB,EAAwB,QAc5Bwa,EAAIoM,eAAiB,SAAS1e,EAAQvH,GAGlC,IAAIkmB,EAAc,CAAC,EAEnB,OAAO3e,EAAOpY,QAAQ0qB,EAAImM,uBAAuB,SAASG,EAAO9W,GAC7D,IAAIngB,EAOJ,OANGmQ,EAAsBU,KAAKsP,GAC1BngB,EAAI8Q,EAAIqP,IAER6W,EAAY7W,GAAO6W,EAAY7W,IAAQwK,EAAIza,eAAeY,EAAKqP,GAAKzP,IACpE1Q,EAAIg3B,EAAY7W,MAEbwK,EAAIuM,iBAAiBl3B,GAAKA,EAAI,EACzC,GACJ,EAEA,IAAIm3B,EAAwB,CACxB3uB,IAAK,GACL4uB,MAAO,EACP33B,KAAM,iBAEVkrB,EAAI0M,oBAAsB,WACtB,OAAOC,EAAqBn0B,MAAMg0B,EAAuBvnB,UAC7D,EAEA,IAAI2nB,EAAuB,CACvB/uB,IAAK,GACL4uB,MAAO,EACP33B,KAAM,gBAEVkrB,EAAI6M,mBAAqB,WACrB,OAAOF,EAAqBn0B,MAAMo0B,EAAsB3nB,UAC5D,EAMA,IAAI6nB,EAAiB,iCAMrB,IAAIC,EAAgC,CAChClvB,IAAK,GACL4uB,MAAO,EACP33B,KAAM,eACNk4B,cAAc,GAElBhN,EAAIiN,4BAA8B,WAC9B,OAAON,EAAqBn0B,MAAMu0B,EAA+B9nB,UACrE,EAEA,IAAIioB,EAAmC,UAiBvC,SAASP,EAAqBjf,EAAQyf,EAAQC,GAC1C,IAAIhvB,EAAOxH,KACPkO,EAAOG,UACPkoB,IAAQA,EAAS,CAAC,GAGtB,IAAId,EAAc,CAAC,EAEnB,OAAO3e,EAAOpY,QAAQ0qB,EAAImM,uBAAuB,SAAS9Q,EAAOgS,EAAQC,GACrE,IAIIC,EACW,YAAXF,GACW,YAAXA,EAEAG,EACW,aAAXH,GACW,aAAXA,EAEAI,EACW,YAAXJ,GACW,YAAXA,EAEAK,EAfW,WAAXL,GACW,WAAXA,GAcsBE,GAAgBE,GAAgBD,EAEtDhY,EAAM6X,GACPE,GAAgBC,KAAmBhY,EAAMA,EAAImY,UAAU,KACvDF,GAAgBD,KAAmBhY,EAAMA,EAAImY,UAAU,EAAGnY,EAAI1c,OAAS,IAI1E,IASIsN,EAKID,EAAK9N,EAdTu1B,EAAW,KACXC,EAAe,KACnB,GAAGzvB,EAAK4uB,aAAc,CAClB,IAAIc,EApEhB,SAAuBC,GACnB,IAAI1S,EAAQ0S,EAAS1S,MAAMyR,GAC3B,OAAGzR,EAAc,CAAE7F,IAAK6F,EAAM,GAAI2S,GAAI3S,EAAM,GAAI7N,OAAQjY,OAAO8lB,EAAM,KAC9D,CAAE7F,IAAKuY,EAAUC,GAAI,KAAMxgB,OAAQ,KAC9C,CAgEyBygB,CAAczY,GAC3BA,EAAMsY,EAAOtY,IACboY,EAAWE,EAAOE,GAClBH,EAAeC,EAAOtgB,MAC1B,CAGA,GAAGkgB,GAEC,QAAa30B,KADbqN,EAAQ+mB,EAAO3X,IACS,MAAO,QAG/B,IAAInd,EAAI,EAAGA,EAAIyM,EAAKhM,OAAQT,IAExB,GADA8N,EAAMrB,EAAKzM,GACX,CACA,GAAG8N,EAAI5B,eAAeiR,GAAM,CACxBpP,EAAQD,EAAIqP,GACZ,KACJ,CAOA,GALIhQ,EAAsBU,KAAKsP,KAC3BpP,EAAQ4Z,EAAIza,eAAeY,EAAKqP,GAAKzP,OACrCK,EAAQimB,EAAY7W,IAAQwK,EAAIza,eAAeY,EAAKqP,GAAKzP,SAC/CsmB,EAAY7W,GAAOpP,SAEpBrN,IAAVqN,EAAqB,KAXP,CAqBzB,QALarN,IAAVqN,IACiB,MAAbwnB,IAAkBxnB,GAASynB,GACd,MAAbD,IAAkBxnB,GAASynB,SAGrB90B,IAAVqN,GAAuBhI,EAWtB,OAVGA,EAAKquB,MAAQruB,EAAKP,MACjBmiB,EAAItM,KAAK,aAAgB8B,EAAM,QAAWpX,EAAKtJ,KAAO,wBACtDsR,EAAQiV,GAGTjd,EAAKquB,QAAUruB,EAAKP,KACnBmiB,EAAItM,KAAK,YAActV,EAAKtJ,KAAO,sDAEvCsJ,EAAKquB,QAEEpR,EAGX,GAAGiS,EAAQ,CACP,IAAItP,EAMJ,GALiB,MAAdsP,EAAO,KAENlnB,GADA4X,EAAMoP,EAAWA,EAAS9M,aAAeN,EAAIM,cACjCgN,EAAOh4B,QAAQ43B,EAAkC,IAArDlP,CAA0D5X,IAGrD,MAAdknB,EAAO,GAAY,CAClBtP,EAAMoP,EAAWA,EAAS3U,WAAaQ,EACvC,IAAI4D,EAAKmD,EAAI5F,YAAYhU,GACzBA,EAAQ4Z,EAAI3C,WAAWR,EAAIyQ,EAAOh4B,QAAQ43B,EAAkC,KAAK,EAAOlP,EAC5F,CACJ,KAAO,CACH,IAAIkQ,EAAW1Y,EAAM,QAClB2X,EAAO5oB,eAAe2pB,KAAW9nB,EAAQ+mB,EAAOe,GACvD,CAQA,OANGR,IACCtnB,EAAQ,IAAMA,EAAQ,KACnBmnB,GAAgBC,KAAmBpnB,EAAQ,IAAMA,IACjDqnB,GAAgBD,KAAmBpnB,GAAgB,MAGnDA,CACX,GACJ,CAOA4Z,EAAImO,YAAc,SAASr0B,EAAGC,GAI1B,IAHA,IAAIq0B,EAAIzyB,KAAKC,IAAI9B,EAAEhB,OAAQiB,EAAEjB,QAAU,EACnCu1B,EAAO,EACPC,EAAO,EACHj2B,EAAI,EAAGA,EAAI+1B,EAAG/1B,IAAK,CACvB,IAAIk2B,EAAQz0B,EAAE00B,WAAWn2B,IAAM,EAC3Bo2B,EAAQ10B,EAAEy0B,WAAWn2B,IAAM,EAC3Bq2B,EAASH,GATT,IAS2BA,GAR3B,GASAI,EAASF,GAVT,IAU2BA,GAT3B,GAcJ,GAHGC,IAAQL,EAAO,GAAKA,EAAOE,EAZ1B,IAaDI,IAAQL,EAAO,GAAKA,EAAOG,EAb1B,KAeAC,IAAWC,EAAQ,CACnB,GAAGN,IAASC,EAAM,OAAOD,EAAOC,EAChC,GAAGC,IAAUE,EAAO,OAAOF,EAAQE,CACvC,CACJ,CACA,OAAOH,EAAOD,CAClB,EAGA,IAAIO,EAAW,IAEf5O,EAAI6O,iBAAmB,WACnBD,EAAW,GACf,EAEA5O,EAAI8O,aAAe,WACf,IAAIC,EAAUH,EAId,OAHAA,GAAY,MAAQA,EAAW,GAAK,WAGjCjzB,KAAKqC,IAAI4wB,EAAWG,GAAW,UAAkB/O,EAAI8O,eACjDF,EAAW,UACtB,EAgBA5O,EAAIgP,SAAW,SAAS5G,EAAQpyB,EAAOi5B,GACnC,IAAIC,EAAOt2B,MAAMC,QAAQo2B,GACrB,SAAS55B,GAAK45B,EAAQ/pB,KAAK7P,EAAI,EAC/B,SAASA,GAAK45B,EAAQE,KAAO95B,CAAG,EAEhC+5B,EAAMpP,EAAImI,cAAcC,EAAQpyB,EAAO,MAAO,aAClD,GAAGgqB,EAAIuM,iBAAiB6C,GAAM,OAAOF,EAAKE,GAE1C,IAAIC,EAAKrP,EAAImI,cAAcC,EAAQpyB,EAAO,KAAM,QAChD,OAAGgqB,EAAIuM,iBAAiB8C,GAAYH,EAAKG,QAAzC,CACJ,EAGArP,EAAIuM,iBAAmB,SAASl3B,GAC5B,OAAOA,GAAW,IAANA,CAChB,EAMA2qB,EAAIsP,cAAgB,SAASC,EAAOvuB,GAChCA,EAAIA,GAAK,EAET,IADA,IAAIsmB,GAAO3rB,KAAKshB,MAAM,IAAMsS,EAAQ5zB,KAAKke,IAAI,GAAI7Y,IAAMrF,KAAKke,IAAI,GAAK7Y,IAAIkd,QAAQld,GAAK,IAC9E3I,EAAI,EAAGA,EAAI2I,EAAG3I,KACO,IAAtBivB,EAAIzc,QAAQ,OAEXyc,GADAA,EAAMA,EAAIhyB,QAAQ,KAAM,MACdA,QAAQ,KAAM,MAGhC,OAAOgyB,CACX,EAEAtH,EAAIwP,SAAW,SAASvlB,GACpB,IAAIwlB,EAAUlwB,OAAOsU,iBAAiB5J,GAAIwlB,QAC1C,OAAQA,GAAuB,SAAZA,CACvB,EAEAzP,EAAI0P,aAAe,SAASn1B,EAAGC,GAC3B,OAAQD,GAAKC,EAAK,aAAeD,EAAI,IAAMC,EAAI,IAAM,EACzD,EAEAwlB,EAAI2P,UAAY,SAAS71B,GACrB,OAAOA,EAAI,UAAYA,EAAI,IAAM,EACrC,EAEAkmB,EAAI4P,SAAW,SAASllB,GACpB,OAAa,IAANA,EAAU,SAAWA,EAAI,IAAM,EAC1C,EAcAsV,EAAI6P,iBAAmB,SAASx8B,GAC5B,IAAIy8B,EAAWz8B,EAAUy8B,SACrBC,EAAQ18B,EAAU08B,MAClBC,EAAQ38B,EAAU28B,MAClBC,EAAU58B,EAAU48B,QACpBC,EAAU78B,EAAU68B,QACpBC,EAAU98B,EAAU88B,SAAW,EAC/BC,EAAU/8B,EAAU+8B,SAAW,EAC/BC,EAASh9B,EAAUg9B,OACnBhmB,EAAQhX,EAAUgX,MAItB,OAHIA,EACIA,EAAQ,IAAGA,EAAQ,GADhBA,EAAQ,EAIf2V,EAAI0P,aACAO,EAAU5lB,GAAS0lB,EAAQI,GAC3BD,EAAU7lB,GAAS2lB,EAAQI,IAE/BpQ,EAAI4P,SAASvlB,IACZgmB,EACG,UAAYA,GACPP,EAAW,GAAK,IAAMC,EAAQ,IAAMC,GACzC,IAAM,GAGlB,EAEAhQ,EAAIsQ,sBAAwB,SAAS5lB,EAAGrX,GACpCqX,EAAEpU,KAAK,YAAa0pB,EAAI6P,iBAAiBx8B,IACzCqX,EAAEoI,MAAM,UAAWzf,EAAUgX,MAAQ,KAAO,OAChD,EAEA2V,EAAIuQ,sBAAwB,SAAStmB,EAAIumB,GACrC,IAAIh0B,EAAMwjB,EAAI/J,WAAW,CAAC,EAAGua,GAK7B,OAJAh0B,EAAIgU,KAAO7U,KAAKkC,IACZ2yB,EAAShgB,KACTvG,EAAGiO,YAAYuY,YAAYC,SAAW,GAEnCl0B,CACX,EAWAwjB,EAAI2Q,MAAQ,SAAS/qB,EAAKgrB,EAAeC,GACrC,IAAIrzB,EAAMoI,EAAI9M,OACd,OAAG0E,EAAM,EACEoI,EAAI6L,MAAM,GAAI,GAAGzc,KAAK47B,GAAiBC,EAAgBjrB,EAAIpI,EAAM,GAErEoI,EAAI5Q,KAAK47B,EACpB,EAEA5Q,EAAI8Q,QAAU,SAAStgB,GACnB,OAAO7U,KAAKshB,MAAM,IAAMzM,EAC5B,EAEA,IAAIugB,EAAiB/Q,EAAIqK,oBAErB2G,EAA0C,OAAnBD,GAA2BA,EAAiB,GAOvE/Q,EAAIiR,uBAAyB,WACzB,OAAGD,EAEQ,CACHx7B,EAAGuC,MAAMm5B,OACT17B,EAAGuC,MAAMo5B,QAGN,CACH37B,EAAGuC,MAAMq5B,QACT57B,EAAGuC,MAAMs5B,QAGrB,C,oBCj5CAt+B,EAAOC,QAAU,CACboG,IAhBJ,SAAa/D,EAAG4E,GACZ,IAAIuC,EAAMnH,EAAI4E,EACd,OAAOuC,EAAM,EAAIA,EAAMvC,EAAIuC,CAC/B,EAcIkL,QARJ,SAAiBrS,EAAG4E,GAChB,OAAO0B,KAAKqC,IAAI3I,GAAM4E,EAAI,EACtB5E,EAAIsG,KAAKshB,MAAM5nB,EAAI4E,GAAKA,EACxB5E,CACR,E,wBCfA,IAAIi8B,EAAap8B,EAAAA,OAAAA,WAEbouB,EAAWpuB,EAAQ,OAEnBgd,EAAUnf,EAAOC,QAAU,CAAC,EAQhCkf,EAAQmQ,IAAM,WACV,IAAIhqB,EAEJ,GAAGi5B,EAAWC,QAAU,EAAG,CACvB,IAAIC,EAAW,CAAC,QAChB,IAAIn5B,EAAI,EAAGA,EAAI4M,UAAUnM,OAAQT,IAC7Bm5B,EAAStsB,KAAKD,UAAU5M,IAE5Bo5B,QAAQz7B,MAAMwC,MAAMi5B,QAASD,EACjC,CAEA,GAAGF,EAAWI,gBAAkB,EAAG,CAC/B,IAAIC,EAAQ,GACZ,IAAIt5B,EAAI,EAAGA,EAAI4M,UAAUnM,OAAQT,IAC7Bs5B,EAAMzsB,KAAKD,UAAU5M,IAEzBirB,EAASqO,EAAM38B,KAAK,QAAS,OACjC,CACJ,EAEAkd,EAAQwB,KAAO,WACX,IAAIrb,EAEJ,GAAGi5B,EAAWC,QAAU,EAAG,CACvB,IAAIC,EAAW,CAAC,SAChB,IAAIn5B,EAAI,EAAGA,EAAI4M,UAAUnM,OAAQT,IAC7Bm5B,EAAStsB,KAAKD,UAAU5M,IAE5Bo5B,QAAQz7B,MAAMwC,MAAMi5B,QAASD,EACjC,CAEA,GAAGF,EAAWI,gBAAkB,EAAG,CAC/B,IAAIC,EAAQ,GACZ,IAAIt5B,EAAI,EAAGA,EAAI4M,UAAUnM,OAAQT,IAC7Bs5B,EAAMzsB,KAAKD,UAAU5M,IAEzBirB,EAASqO,EAAM38B,KAAK,QAAS,QACjC,CACJ,EAEAkd,EAAQyL,MAAQ,WACZ,IAAItlB,EAEJ,GAAGi5B,EAAWC,QAAU,EAAG,CACvB,IAAIC,EAAW,CAAC,UAChB,IAAIn5B,EAAI,EAAGA,EAAI4M,UAAUnM,OAAQT,IAC7Bm5B,EAAStsB,KAAKD,UAAU5M,IAE5Bo5B,QAAQ9T,MAAMnlB,MAAMi5B,QAASD,EACjC,CAEA,GAAGF,EAAWI,gBAAkB,EAAG,CAC/B,IAAIC,EAAQ,GACZ,IAAIt5B,EAAI,EAAGA,EAAI4M,UAAUnM,OAAQT,IAC7Bs5B,EAAMzsB,KAAKD,UAAU5M,IAEzBirB,EAASqO,EAAM38B,KAAK,QAAS,QACjC,CACJ,C","sources":["../node_modules/plotly.js/src/fonts/ploticon.js","../node_modules/plotly.js/src/lib/clean_number.js","../node_modules/plotly.js/src/lib/make_trace_groups.js","../node_modules/plotly.js/src/lib/events.js","../node_modules/plotly.js/src/lib/geometry2d.js","../node_modules/plotly.js/src/core.js","../node_modules/plotly.js/src/lib/array.js","../node_modules/plotly.js/src/lib/keyed_container.js","../node_modules/plotly.js/src/lib/is_plain_object.js","../node_modules/plotly.js/src/lib/filter_unique.js","../node_modules/plotly.js/src/lib/angles.js","../node_modules/plotly.js/src/lib/clear_responsive.js","../node_modules/plotly.js/src/lib/increment.js","../node_modules/plotly.js/src/lib/filter_visible.js","../node_modules/plotly.js/src/lib/anchor_utils.js","../node_modules/plotly.js/src/lib/coerce.js","../node_modules/plotly.js/src/lib/dom.js","../node_modules/plotly.js/src/lib/extend.js","../node_modules/plotly.js/src/lib/localize.js","../node_modules/plotly.js/src/lib/matrix.js","../node_modules/plotly.js/src/lib/clear_gl_canvases.js","../node_modules/plotly.js/src/lib/identity.js","../node_modules/plotly.js/src/lib/dates.js","../node_modules/plotly.js/src/lib/index.js","../node_modules/plotly.js/src/lib/mod.js","../node_modules/plotly.js/src/lib/loggers.js"],"sourcesContent":["'use strict';\n\nmodule.exports = {\n    undo: {\n        width: 857.1,\n        height: 1000,\n        path: 'm857 350q0-87-34-166t-91-137-137-92-166-34q-96 0-183 41t-147 114q-4 6-4 13t5 11l76 77q6 5 14 5 9-1 13-7 41-53 100-82t126-29q58 0 110 23t92 61 61 91 22 111-22 111-61 91-92 61-110 23q-55 0-105-20t-90-57l77-77q17-16 8-38-10-23-33-23h-250q-15 0-25 11t-11 25v250q0 24 22 33 22 10 39-8l72-72q60 57 137 88t159 31q87 0 166-34t137-92 91-137 34-166z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    home: {\n        width: 928.6,\n        height: 1000,\n        path: 'm786 296v-267q0-15-11-26t-25-10h-214v214h-143v-214h-214q-15 0-25 10t-11 26v267q0 1 0 2t0 2l321 264 321-264q1-1 1-4z m124 39l-34-41q-5-5-12-6h-2q-7 0-12 3l-386 322-386-322q-7-4-13-4-7 2-12 7l-35 41q-4 5-3 13t6 12l401 334q18 15 42 15t43-15l136-114v109q0 8 5 13t13 5h107q8 0 13-5t5-13v-227l122-102q5-5 6-12t-4-13z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    'camera-retro': {\n        width: 1000,\n        height: 1000,\n        path: 'm518 386q0 8-5 13t-13 5q-37 0-63-27t-26-63q0-8 5-13t13-5 12 5 5 13q0 23 16 38t38 16q8 0 13 5t5 13z m125-73q0-59-42-101t-101-42-101 42-42 101 42 101 101 42 101-42 42-101z m-572-320h858v71h-858v-71z m643 320q0 89-62 152t-152 62-151-62-63-152 63-151 151-63 152 63 62 151z m-571 358h214v72h-214v-72z m-72-107h858v143h-462l-36-71h-360v-72z m929 143v-714q0-30-21-51t-50-21h-858q-29 0-50 21t-21 51v714q0 30 21 51t50 21h858q29 0 50-21t21-51z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    zoombox: {\n        width: 1000,\n        height: 1000,\n        path: 'm1000-25l-250 251c40 63 63 138 63 218 0 224-182 406-407 406-224 0-406-182-406-406s183-406 407-406c80 0 155 22 218 62l250-250 125 125z m-812 250l0 438 437 0 0-438-437 0z m62 375l313 0 0-312-313 0 0 312z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    pan: {\n        width: 1000,\n        height: 1000,\n        path: 'm1000 350l-187 188 0-125-250 0 0 250 125 0-188 187-187-187 125 0 0-250-250 0 0 125-188-188 186-187 0 125 252 0 0-250-125 0 187-188 188 188-125 0 0 250 250 0 0-126 187 188z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    zoom_plus: {\n        width: 875,\n        height: 1000,\n        path: 'm1 787l0-875 875 0 0 875-875 0z m687-500l-187 0 0-187-125 0 0 187-188 0 0 125 188 0 0 187 125 0 0-187 187 0 0-125z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    zoom_minus: {\n        width: 875,\n        height: 1000,\n        path: 'm0 788l0-876 875 0 0 876-875 0z m688-500l-500 0 0 125 500 0 0-125z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    autoscale: {\n        width: 1000,\n        height: 1000,\n        path: 'm250 850l-187 0-63 0 0-62 0-188 63 0 0 188 187 0 0 62z m688 0l-188 0 0-62 188 0 0-188 62 0 0 188 0 62-62 0z m-875-938l0 188-63 0 0-188 0-62 63 0 187 0 0 62-187 0z m875 188l0-188-188 0 0-62 188 0 62 0 0 62 0 188-62 0z m-125 188l-1 0-93-94-156 156 156 156 92-93 2 0 0 250-250 0 0-2 93-92-156-156-156 156 94 92 0 2-250 0 0-250 0 0 93 93 157-156-157-156-93 94 0 0 0-250 250 0 0 0-94 93 156 157 156-157-93-93 0 0 250 0 0 250z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    tooltip_basic: {\n        width: 1500,\n        height: 1000,\n        path: 'm375 725l0 0-375-375 375-374 0-1 1125 0 0 750-1125 0z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    tooltip_compare: {\n        width: 1125,\n        height: 1000,\n        path: 'm187 786l0 2-187-188 188-187 0 0 937 0 0 373-938 0z m0-499l0 1-187-188 188-188 0 0 937 0 0 376-938-1z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    plotlylogo: {\n        width: 1542,\n        height: 1000,\n        path: 'm0-10h182v-140h-182v140z m228 146h183v-286h-183v286z m225 714h182v-1000h-182v1000z m225-285h182v-715h-182v715z m225 142h183v-857h-183v857z m231-428h182v-429h-182v429z m225-291h183v-138h-183v138z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    'z-axis': {\n        width: 1000,\n        height: 1000,\n        path: 'm833 5l-17 108v41l-130-65 130-66c0 0 0 38 0 39 0-1 36-14 39-25 4-15-6-22-16-30-15-12-39-16-56-20-90-22-187-23-279-23-261 0-341 34-353 59 3 60 228 110 228 110-140-8-351-35-351-116 0-120 293-142 474-142 155 0 477 22 477 142 0 50-74 79-163 96z m-374 94c-58-5-99-21-99-40 0-24 65-43 144-43 79 0 143 19 143 43 0 19-42 34-98 40v216h87l-132 135-133-135h88v-216z m167 515h-136v1c16 16 31 34 46 52l84 109v54h-230v-71h124v-1c-16-17-28-32-44-51l-89-114v-51h245v72z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    '3d_rotate': {\n        width: 1000,\n        height: 1000,\n        path: 'm922 660c-5 4-9 7-14 11-359 263-580-31-580-31l-102 28 58-400c0 1 1 1 2 2 118 108 351 249 351 249s-62 27-100 42c88 83 222 183 347 122 16-8 30-17 44-27-2 1-4 2-6 4z m36-329c0 0 64 229-88 296-62 27-124 14-175-11 157-78 225-208 249-266 8-19 11-31 11-31 2 5 6 15 11 32-5-13-8-20-8-20z m-775-239c70-31 117-50 198-32-121 80-199 346-199 346l-96-15-58-12c0 0 55-226 155-287z m603 133l-317-139c0 0 4-4 19-14 7-5 24-15 24-15s-177-147-389 4c235-287 536-112 536-112l31-22 100 299-4-1z m-298-153c6-4 14-9 24-15 0 0-17 10-24 15z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    camera: {\n        width: 1000,\n        height: 1000,\n        path: 'm500 450c-83 0-150-67-150-150 0-83 67-150 150-150 83 0 150 67 150 150 0 83-67 150-150 150z m400 150h-120c-16 0-34 13-39 29l-31 93c-6 15-23 28-40 28h-340c-16 0-34-13-39-28l-31-94c-6-15-23-28-40-28h-120c-55 0-100-45-100-100v-450c0-55 45-100 100-100h800c55 0 100 45 100 100v450c0 55-45 100-100 100z m-400-550c-138 0-250 112-250 250 0 138 112 250 250 250 138 0 250-112 250-250 0-138-112-250-250-250z m365 380c-19 0-35 16-35 35 0 19 16 35 35 35 19 0 35-16 35-35 0-19-16-35-35-35z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    movie: {\n        width: 1000,\n        height: 1000,\n        path: 'm938 413l-188-125c0 37-17 71-44 94 64 38 107 107 107 187 0 121-98 219-219 219-121 0-219-98-219-219 0-61 25-117 66-156h-115c30 33 49 76 49 125 0 103-84 187-187 187s-188-84-188-187c0-57 26-107 65-141-38-22-65-62-65-109v-250c0-70 56-126 125-126h500c69 0 125 56 125 126l188-126c34 0 62 28 62 63v375c0 35-28 63-62 63z m-750 0c-69 0-125 56-125 125s56 125 125 125 125-56 125-125-56-125-125-125z m406-1c-87 0-157 70-157 157 0 86 70 156 157 156s156-70 156-156-70-157-156-157z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    question: {\n        width: 857.1,\n        height: 1000,\n        path: 'm500 82v107q0 8-5 13t-13 5h-107q-8 0-13-5t-5-13v-107q0-8 5-13t13-5h107q8 0 13 5t5 13z m143 375q0 49-31 91t-77 65-95 23q-136 0-207-119-9-14 4-24l74-55q4-4 10-4 9 0 14 7 30 38 48 51 19 14 48 14 27 0 48-15t21-33q0-21-11-34t-38-25q-35-16-65-48t-29-70v-20q0-8 5-13t13-5h107q8 0 13 5t5 13q0 10 12 27t30 28q18 10 28 16t25 19 25 27 16 34 7 45z m214-107q0-117-57-215t-156-156-215-58-216 58-155 156-58 215 58 215 155 156 216 58 215-58 156-156 57-215z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    disk: {\n        width: 857.1,\n        height: 1000,\n        path: 'm214-7h429v214h-429v-214z m500 0h72v500q0 8-6 21t-11 20l-157 156q-5 6-19 12t-22 5v-232q0-22-15-38t-38-16h-322q-22 0-37 16t-16 38v232h-72v-714h72v232q0 22 16 38t37 16h465q22 0 38-16t15-38v-232z m-214 518v178q0 8-5 13t-13 5h-107q-7 0-13-5t-5-13v-178q0-8 5-13t13-5h107q7 0 13 5t5 13z m357-18v-518q0-22-15-38t-38-16h-750q-23 0-38 16t-16 38v750q0 22 16 38t38 16h517q23 0 50-12t42-26l156-157q16-15 27-42t11-49z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    drawopenpath: {\n        width: 70,\n        height: 70,\n        path: 'M33.21,85.65a7.31,7.31,0,0,1-2.59-.48c-8.16-3.11-9.27-19.8-9.88-41.3-.1-3.58-.19-6.68-.35-9-.15-2.1-.67-3.48-1.43-3.79-2.13-.88-7.91,2.32-12,5.86L3,32.38c1.87-1.64,11.55-9.66,18.27-6.9,2.13.87,4.75,3.14,5.17,9,.17,2.43.26,5.59.36,9.25a224.17,224.17,0,0,0,1.5,23.4c1.54,10.76,4,12.22,4.48,12.4.84.32,2.79-.46,5.76-3.59L43,80.07C41.53,81.57,37.68,85.64,33.21,85.65ZM74.81,69a11.34,11.34,0,0,0,6.09-6.72L87.26,44.5,74.72,32,56.9,38.35c-2.37.86-5.57,3.42-6.61,6L38.65,72.14l8.42,8.43ZM55,46.27a7.91,7.91,0,0,1,3.64-3.17l14.8-5.3,8,8L76.11,60.6l-.06.19a6.37,6.37,0,0,1-3,3.43L48.25,74.59,44.62,71Zm16.57,7.82A6.9,6.9,0,1,0,64.64,61,6.91,6.91,0,0,0,71.54,54.09Zm-4.05,0a2.85,2.85,0,1,1-2.85-2.85A2.86,2.86,0,0,1,67.49,54.09Zm-4.13,5.22L60.5,56.45,44.26,72.7l2.86,2.86ZM97.83,35.67,84.14,22l-8.57,8.57L89.26,44.24Zm-13.69-8,8,8-2.85,2.85-8-8Z',\n        transform: 'matrix(1 0 0 1 -15 -15)'\n    },\n    drawclosedpath: {\n        width: 90,\n        height: 90,\n        path: 'M88.41,21.12a26.56,26.56,0,0,0-36.18,0l-2.07,2-2.07-2a26.57,26.57,0,0,0-36.18,0,23.74,23.74,0,0,0,0,34.8L48,90.12a3.22,3.22,0,0,0,4.42,0l36-34.21a23.73,23.73,0,0,0,0-34.79ZM84,51.24,50.16,83.35,16.35,51.25a17.28,17.28,0,0,1,0-25.47,20,20,0,0,1,27.3,0l4.29,4.07a3.23,3.23,0,0,0,4.44,0l4.29-4.07a20,20,0,0,1,27.3,0,17.27,17.27,0,0,1,0,25.46ZM66.76,47.68h-33v6.91h33ZM53.35,35H46.44V68h6.91Z',\n        transform: 'matrix(1 0 0 1 -5 -5)'\n    },\n    lasso: {\n        width: 1031,\n        height: 1000,\n        path: 'm1018 538c-36 207-290 336-568 286-277-48-473-256-436-463 10-57 36-108 76-151-13-66 11-137 68-183 34-28 75-41 114-42l-55-70 0 0c-2-1-3-2-4-3-10-14-8-34 5-45 14-11 34-8 45 4 1 1 2 3 2 5l0 0 113 140c16 11 31 24 45 40 4 3 6 7 8 11 48-3 100 0 151 9 278 48 473 255 436 462z m-624-379c-80 14-149 48-197 96 42 42 109 47 156 9 33-26 47-66 41-105z m-187-74c-19 16-33 37-39 60 50-32 109-55 174-68-42-25-95-24-135 8z m360 75c-34-7-69-9-102-8 8 62-16 128-68 170-73 59-175 54-244-5-9 20-16 40-20 61-28 159 121 317 333 354s407-60 434-217c28-159-121-318-333-355z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    selectbox: {\n        width: 1000,\n        height: 1000,\n        path: 'm0 850l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m285 0l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m-857-286l0-143 143 0 0 143-143 0z m857 0l0-143 143 0 0 143-143 0z m-857-285l0-143 143 0 0 143-143 0z m857 0l0-143 143 0 0 143-143 0z m-857-286l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m285 0l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    drawline: {\n        width: 70,\n        height: 70,\n        path: 'M60.64,62.3a11.29,11.29,0,0,0,6.09-6.72l6.35-17.72L60.54,25.31l-17.82,6.4c-2.36.86-5.57,3.41-6.6,6L24.48,65.5l8.42,8.42ZM40.79,39.63a7.89,7.89,0,0,1,3.65-3.17l14.79-5.31,8,8L61.94,54l-.06.19a6.44,6.44,0,0,1-3,3.43L34.07,68l-3.62-3.63Zm16.57,7.81a6.9,6.9,0,1,0-6.89,6.9A6.9,6.9,0,0,0,57.36,47.44Zm-4,0a2.86,2.86,0,1,1-2.85-2.85A2.86,2.86,0,0,1,53.32,47.44Zm-4.13,5.22L46.33,49.8,30.08,66.05l2.86,2.86ZM83.65,29,70,15.34,61.4,23.9,75.09,37.59ZM70,21.06l8,8-2.84,2.85-8-8ZM87,80.49H10.67V87H87Z',\n        transform: 'matrix(1 0 0 1 -15 -15)'\n    },\n    drawrect: {\n        width: 80,\n        height: 80,\n        path: 'M78,22V79H21V22H78m9-9H12V88H87V13ZM68,46.22H31V54H68ZM53,32H45.22V69H53Z',\n        transform: 'matrix(1 0 0 1 -10 -10)'\n    },\n    drawcircle: {\n        width: 80,\n        height: 80,\n        path: 'M50,84.72C26.84,84.72,8,69.28,8,50.3S26.84,15.87,50,15.87,92,31.31,92,50.3,73.16,84.72,50,84.72Zm0-60.59c-18.6,0-33.74,11.74-33.74,26.17S31.4,76.46,50,76.46,83.74,64.72,83.74,50.3,68.6,24.13,50,24.13Zm17.15,22h-34v7.11h34Zm-13.8-13H46.24v34h7.11Z',\n        transform: 'matrix(1 0 0 1 -10 -10)'\n    },\n    eraseshape: {\n        width: 80,\n        height: 80,\n        path: 'M82.77,78H31.85L6,49.57,31.85,21.14H82.77a8.72,8.72,0,0,1,8.65,8.77V69.24A8.72,8.72,0,0,1,82.77,78ZM35.46,69.84H82.77a.57.57,0,0,0,.49-.6V29.91a.57.57,0,0,0-.49-.61H35.46L17,49.57Zm32.68-34.7-24,24,5,5,24-24Zm-19,.53-5,5,24,24,5-5Z',\n        transform: 'matrix(1 0 0 1 -10 -10)'\n    },\n    spikeline: {\n        width: 1000,\n        height: 1000,\n        path: 'M512 409c0-57-46-104-103-104-57 0-104 47-104 104 0 57 47 103 104 103 57 0 103-46 103-103z m-327-39l92 0 0 92-92 0z m-185 0l92 0 0 92-92 0z m370-186l92 0 0 93-92 0z m0-184l92 0 0 92-92 0z',\n        transform: 'matrix(1.5 0 0 -1.5 0 850)'\n    },\n    pencil: {\n        width: 1792,\n        height: 1792,\n        path: 'M491 1536l91-91-235-235-91 91v107h128v128h107zm523-928q0-22-22-22-10 0-17 7l-542 542q-7 7-7 17 0 22 22 22 10 0 17-7l542-542q7-7 7-17zm-54-192l416 416-832 832h-416v-416zm683 96q0 53-37 90l-166 166-416-416 166-165q36-38 90-38 53 0 91 38l235 234q37 39 37 91z',\n        transform: 'matrix(1 0 0 1 0 1)'\n    },\n    newplotlylogo: {\n        name: 'newplotlylogo',\n        svg: [\n            '<svg xmlns=\\'http://www.w3.org/2000/svg\\' viewBox=\\'0 0 132 132\\'>',\n            '<defs>',\n            ' <style>',\n            '  .cls-0{fill:#000;}',\n            '  .cls-1{fill:#FFF;}',\n            '  .cls-2{fill:#F26;}',\n            '  .cls-3{fill:#D69;}',\n            '  .cls-4{fill:#BAC;}',\n            '  .cls-5{fill:#9EF;}',\n            ' </style>',\n            '</defs>',\n            ' <title>plotly-logomark</title>',\n            ' <g id=\\'symbol\\'>',\n            '  <rect class=\\'cls-0\\' x=\\'0\\' y=\\'0\\' width=\\'132\\' height=\\'132\\' rx=\\'18\\' ry=\\'18\\'/>',\n            '  <circle class=\\'cls-5\\' cx=\\'102\\' cy=\\'30\\' r=\\'6\\'/>',\n            '  <circle class=\\'cls-4\\' cx=\\'78\\' cy=\\'30\\' r=\\'6\\'/>',\n            '  <circle class=\\'cls-4\\' cx=\\'78\\' cy=\\'54\\' r=\\'6\\'/>',\n            '  <circle class=\\'cls-3\\' cx=\\'54\\' cy=\\'30\\' r=\\'6\\'/>',\n            '  <circle class=\\'cls-2\\' cx=\\'30\\' cy=\\'30\\' r=\\'6\\'/>',\n            '  <circle class=\\'cls-2\\' cx=\\'30\\' cy=\\'54\\' r=\\'6\\'/>',\n            '  <path class=\\'cls-1\\' d=\\'M30,72a6,6,0,0,0-6,6v24a6,6,0,0,0,12,0V78A6,6,0,0,0,30,72Z\\'/>',\n            '  <path class=\\'cls-1\\' d=\\'M78,72a6,6,0,0,0-6,6v24a6,6,0,0,0,12,0V78A6,6,0,0,0,78,72Z\\'/>',\n            '  <path class=\\'cls-1\\' d=\\'M54,48a6,6,0,0,0-6,6v48a6,6,0,0,0,12,0V54A6,6,0,0,0,54,48Z\\'/>',\n            '  <path class=\\'cls-1\\' d=\\'M102,48a6,6,0,0,0-6,6v48a6,6,0,0,0,12,0V54A6,6,0,0,0,102,48Z\\'/>',\n            ' </g>',\n            '</svg>'\n        ].join('')\n    }\n};\n","'use strict';\n\nvar isNumeric = require('fast-isnumeric');\n\nvar BADNUM = require('../constants/numerical').BADNUM;\n\n// precompile for speed\nvar JUNK = /^['\"%,$#\\s']+|[, ]|['\"%,$#\\s']+$/g;\n\n/**\n * cleanNumber: remove common leading and trailing cruft\n * Always returns either a number or BADNUM.\n */\nmodule.exports = function cleanNumber(v) {\n    if(typeof v === 'string') {\n        v = v.replace(JUNK, '');\n    }\n\n    if(isNumeric(v)) return Number(v);\n\n    return BADNUM;\n};\n","'use strict';\n\nvar d3 = require('@plotly/d3');\n\n/**\n * General helper to manage trace groups based on calcdata\n *\n * @param {d3.selection} traceLayer: a selection containing a single group\n *     to draw these traces into\n * @param {array} cdModule: array of calcdata items for this\n *     module and subplot combination. Assumes the calcdata item for each\n *     trace is an array with the fullData trace attached to the first item.\n * @param {string} cls: the class attribute to give each trace group\n *     so you can give multiple classes separated by spaces\n */\nmodule.exports = function makeTraceGroups(traceLayer, cdModule, cls) {\n    var traces = traceLayer.selectAll('g.' + cls.replace(/\\s/g, '.'))\n        .data(cdModule, function(cd) { return cd[0].trace.uid; });\n\n    traces.exit().remove();\n\n    traces.enter().append('g')\n        .attr('class', cls);\n\n    traces.order();\n\n    // stash ref node to trace group in calcdata,\n    // useful for (fast) styleOnSelect\n    var k = traceLayer.classed('rangeplot') ? 'nodeRangePlot3' : 'node3';\n    traces.each(function(cd) { cd[0][k] = d3.select(this); });\n\n    return traces;\n};\n","'use strict';\n\n/* global jQuery:false */\n\nvar EventEmitter = require('events').EventEmitter;\n\nvar Events = {\n\n    init: function(plotObj) {\n        /*\n         * If we have already instantiated an emitter for this plot\n         * return early.\n         */\n        if(plotObj._ev instanceof EventEmitter) return plotObj;\n\n        var ev = new EventEmitter();\n        var internalEv = new EventEmitter();\n\n        /*\n         * Assign to plot._ev while we still live in a land\n         * where plot is a DOM element with stuff attached to it.\n         * In the future we can make plot the event emitter itself.\n         */\n        plotObj._ev = ev;\n\n        /*\n         * Create a second event handler that will manage events *internally*.\n         * This allows parts of plotly to respond to thing like relayout without\n         * having to use the user-facing event handler. They cannot peacefully\n         * coexist on the same handler because a user invoking\n         * plotObj.removeAllListeners() would detach internal events, breaking\n         * plotly.\n         */\n        plotObj._internalEv = internalEv;\n\n        /*\n         * Assign bound methods from the ev to the plot object. These methods\n         * will reference the 'this' of plot._ev even though they are methods\n         * of plot. This will keep the event machinery away from the plot object\n         * which currently is often a DOM element but presents an API that will\n         * continue to function when plot becomes an emitter. Not all EventEmitter\n         * methods have been bound to `plot` as some do not currently add value to\n         * the Plotly event API.\n         */\n        plotObj.on = ev.on.bind(ev);\n        plotObj.once = ev.once.bind(ev);\n        plotObj.removeListener = ev.removeListener.bind(ev);\n        plotObj.removeAllListeners = ev.removeAllListeners.bind(ev);\n\n        /*\n         * Create functions for managing internal events. These are *only* triggered\n         * by the mirroring of external events via the emit function.\n         */\n        plotObj._internalOn = internalEv.on.bind(internalEv);\n        plotObj._internalOnce = internalEv.once.bind(internalEv);\n        plotObj._removeInternalListener = internalEv.removeListener.bind(internalEv);\n        plotObj._removeAllInternalListeners = internalEv.removeAllListeners.bind(internalEv);\n\n        /*\n         * We must wrap emit to continue to support JQuery events. The idea\n         * is to check to see if the user is using JQuery events, if they are\n         * we emit JQuery events to trigger user handlers as well as the EventEmitter\n         * events.\n         */\n        plotObj.emit = function(event, data) {\n            if(typeof jQuery !== 'undefined') {\n                jQuery(plotObj).trigger(event, data);\n            }\n\n            ev.emit(event, data);\n            internalEv.emit(event, data);\n        };\n\n        return plotObj;\n    },\n\n    /*\n     * This function behaves like jQuery's triggerHandler. It calls\n     * all handlers for a particular event and returns the return value\n     * of the LAST handler. This function also triggers jQuery's\n     * triggerHandler for backwards compatibility.\n     */\n    triggerHandler: function(plotObj, event, data) {\n        var jQueryHandlerValue;\n        var nodeEventHandlerValue;\n\n        /*\n         * If jQuery exists run all its handlers for this event and\n         * collect the return value of the LAST handler function\n         */\n        if(typeof jQuery !== 'undefined') {\n            jQueryHandlerValue = jQuery(plotObj).triggerHandler(event, data);\n        }\n\n        /*\n         * Now run all the node style event handlers\n         */\n        var ev = plotObj._ev;\n        if(!ev) return jQueryHandlerValue;\n\n        var handlers = ev._events[event];\n        if(!handlers) return jQueryHandlerValue;\n\n        // making sure 'this' is the EventEmitter instance\n        function apply(handler) {\n            // The 'once' case, we can't just call handler() as we need\n            // the return value here. So,\n            // - remove handler\n            // - call listener and grab return value!\n            // - stash 'fired' key to not call handler twice\n            if(handler.listener) {\n                ev.removeListener(event, handler.listener);\n                if(!handler.fired) {\n                    handler.fired = true;\n                    return handler.listener.apply(ev, [data]);\n                }\n            } else {\n                return handler.apply(ev, [data]);\n            }\n        }\n\n        // handlers can be function or an array of functions\n        handlers = Array.isArray(handlers) ? handlers : [handlers];\n\n        var i;\n        for(i = 0; i < handlers.length - 1; i++) {\n            apply(handlers[i]);\n        }\n        // now call the final handler and collect its value\n        nodeEventHandlerValue = apply(handlers[i]);\n\n        /*\n         * Return either the jQuery handler value if it exists or the\n         * nodeEventHandler value. jQuery event value supersedes nodejs\n         * events for backwards compatibility reasons.\n         */\n        return jQueryHandlerValue !== undefined ?\n            jQueryHandlerValue :\n            nodeEventHandlerValue;\n    },\n\n    purge: function(plotObj) {\n        delete plotObj._ev;\n        delete plotObj.on;\n        delete plotObj.once;\n        delete plotObj.removeListener;\n        delete plotObj.removeAllListeners;\n        delete plotObj.emit;\n\n        delete plotObj._ev;\n        delete plotObj._internalEv;\n        delete plotObj._internalOn;\n        delete plotObj._internalOnce;\n        delete plotObj._removeInternalListener;\n        delete plotObj._removeAllInternalListeners;\n\n        return plotObj;\n    }\n\n};\n\nmodule.exports = Events;\n","'use strict';\n\nvar mod = require('./mod').mod;\n\n/*\n * look for intersection of two line segments\n *   (1->2 and 3->4) - returns array [x,y] if they do, null if not\n */\nexports.segmentsIntersect = segmentsIntersect;\nfunction segmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4) {\n    var a = x2 - x1;\n    var b = x3 - x1;\n    var c = x4 - x3;\n    var d = y2 - y1;\n    var e = y3 - y1;\n    var f = y4 - y3;\n    var det = a * f - c * d;\n    // parallel lines? intersection is undefined\n    // ignore the case where they are colinear\n    if(det === 0) return null;\n    var t = (b * f - c * e) / det;\n    var u = (b * d - a * e) / det;\n    // segments do not intersect?\n    if(u < 0 || u > 1 || t < 0 || t > 1) return null;\n\n    return {x: x1 + a * t, y: y1 + d * t};\n}\n\n/*\n * find the minimum distance between two line segments (1->2 and 3->4)\n */\nexports.segmentDistance = function segmentDistance(x1, y1, x2, y2, x3, y3, x4, y4) {\n    if(segmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4)) return 0;\n\n    // the two segments and their lengths squared\n    var x12 = x2 - x1;\n    var y12 = y2 - y1;\n    var x34 = x4 - x3;\n    var y34 = y4 - y3;\n    var ll12 = x12 * x12 + y12 * y12;\n    var ll34 = x34 * x34 + y34 * y34;\n\n    // calculate distance squared, then take the sqrt at the very end\n    var dist2 = Math.min(\n        perpDistance2(x12, y12, ll12, x3 - x1, y3 - y1),\n        perpDistance2(x12, y12, ll12, x4 - x1, y4 - y1),\n        perpDistance2(x34, y34, ll34, x1 - x3, y1 - y3),\n        perpDistance2(x34, y34, ll34, x2 - x3, y2 - y3)\n    );\n\n    return Math.sqrt(dist2);\n};\n\n/*\n * distance squared from segment ab to point c\n * [xab, yab] is the vector b-a\n * [xac, yac] is the vector c-a\n * llab is the length squared of (b-a), just to simplify calculation\n */\nfunction perpDistance2(xab, yab, llab, xac, yac) {\n    var fcAB = (xac * xab + yac * yab);\n    if(fcAB < 0) {\n        // point c is closer to point a\n        return xac * xac + yac * yac;\n    } else if(fcAB > llab) {\n        // point c is closer to point b\n        var xbc = xac - xab;\n        var ybc = yac - yab;\n        return xbc * xbc + ybc * ybc;\n    } else {\n        // perpendicular distance is the shortest\n        var crossProduct = xac * yab - yac * xab;\n        return crossProduct * crossProduct / llab;\n    }\n}\n\n// a very short-term cache for getTextLocation, just because\n// we're often looping over the same locations multiple times\n// invalidated as soon as we look at a different path\nvar locationCache, workingPath, workingTextWidth;\n\n// turn a path and position along it into x, y, and angle for the given text\nexports.getTextLocation = function getTextLocation(path, totalPathLen, positionOnPath, textWidth) {\n    if(path !== workingPath || textWidth !== workingTextWidth) {\n        locationCache = {};\n        workingPath = path;\n        workingTextWidth = textWidth;\n    }\n    if(locationCache[positionOnPath]) {\n        return locationCache[positionOnPath];\n    }\n\n    // for the angle, use points on the path separated by the text width\n    // even though due to curvature, the text will cover a bit more than that\n    var p0 = path.getPointAtLength(mod(positionOnPath - textWidth / 2, totalPathLen));\n    var p1 = path.getPointAtLength(mod(positionOnPath + textWidth / 2, totalPathLen));\n    // note: atan handles 1/0 nicely\n    var theta = Math.atan((p1.y - p0.y) / (p1.x - p0.x));\n    // center the text at 2/3 of the center position plus 1/3 the p0/p1 midpoint\n    // that's the average position of this segment, assuming it's roughly quadratic\n    var pCenter = path.getPointAtLength(mod(positionOnPath, totalPathLen));\n    var x = (pCenter.x * 4 + p0.x + p1.x) / 6;\n    var y = (pCenter.y * 4 + p0.y + p1.y) / 6;\n\n    var out = {x: x, y: y, theta: theta};\n    locationCache[positionOnPath] = out;\n    return out;\n};\n\nexports.clearLocationCache = function() {\n    workingPath = null;\n};\n\n/*\n * Find the segment of `path` that's within the visible area\n * given by `bounds` {left, right, top, bottom}, to within a\n * precision of `buffer` px\n *\n * returns: undefined if nothing is visible, else object:\n * {\n *   min: position where the path first enters bounds, or 0 if it\n *        starts within bounds\n *   max: position where the path last exits bounds, or the path length\n *        if it finishes within bounds\n *   len: max - min, ie the length of visible path\n *   total: the total path length - just included so the caller doesn't\n *        need to call path.getTotalLength() again\n *   isClosed: true iff the start and end points of the path are both visible\n *        and are at the same point\n * }\n *\n * Works by starting from either end and repeatedly finding the distance from\n * that point to the plot area, and if it's outside the plot, moving along the\n * path by that distance (because the plot must be at least that far away on\n * the path). Note that if a path enters, exits, and re-enters the plot, we\n * will not capture this behavior.\n */\nexports.getVisibleSegment = function getVisibleSegment(path, bounds, buffer) {\n    var left = bounds.left;\n    var right = bounds.right;\n    var top = bounds.top;\n    var bottom = bounds.bottom;\n\n    var pMin = 0;\n    var pTotal = path.getTotalLength();\n    var pMax = pTotal;\n\n    var pt0, ptTotal;\n\n    function getDistToPlot(len) {\n        var pt = path.getPointAtLength(len);\n\n        // hold on to the start and end points for `closed`\n        if(len === 0) pt0 = pt;\n        else if(len === pTotal) ptTotal = pt;\n\n        var dx = (pt.x < left) ? left - pt.x : (pt.x > right ? pt.x - right : 0);\n        var dy = (pt.y < top) ? top - pt.y : (pt.y > bottom ? pt.y - bottom : 0);\n        return Math.sqrt(dx * dx + dy * dy);\n    }\n\n    var distToPlot = getDistToPlot(pMin);\n    while(distToPlot) {\n        pMin += distToPlot + buffer;\n        if(pMin > pMax) return;\n        distToPlot = getDistToPlot(pMin);\n    }\n\n    distToPlot = getDistToPlot(pMax);\n    while(distToPlot) {\n        pMax -= distToPlot + buffer;\n        if(pMin > pMax) return;\n        distToPlot = getDistToPlot(pMax);\n    }\n\n    return {\n        min: pMin,\n        max: pMax,\n        len: pMax - pMin,\n        total: pTotal,\n        isClosed: pMin === 0 && pMax === pTotal &&\n            Math.abs(pt0.x - ptTotal.x) < 0.1 &&\n            Math.abs(pt0.y - ptTotal.y) < 0.1\n    };\n};\n\n/**\n * Find point on SVG path corresponding to a given constraint coordinate\n *\n * @param {SVGPathElement} path\n * @param {Number} val : constraint coordinate value\n * @param {String} coord : 'x' or 'y' the constraint coordinate\n * @param {Object} opts :\n *  - {Number} pathLength : supply total path length before hand\n *  - {Number} tolerance\n *  - {Number} iterationLimit\n * @return {SVGPoint}\n */\nexports.findPointOnPath = function findPointOnPath(path, val, coord, opts) {\n    opts = opts || {};\n\n    var pathLength = opts.pathLength || path.getTotalLength();\n    var tolerance = opts.tolerance || 1e-3;\n    var iterationLimit = opts.iterationLimit || 30;\n\n    // if path starts at a val greater than the path tail (like on vertical violins),\n    // we must flip the sign of the computed diff.\n    var mul = path.getPointAtLength(0)[coord] > path.getPointAtLength(pathLength)[coord] ? -1 : 1;\n\n    var i = 0;\n    var b0 = 0;\n    var b1 = pathLength;\n    var mid;\n    var pt;\n    var diff;\n\n    while(i < iterationLimit) {\n        mid = (b0 + b1) / 2;\n        pt = path.getPointAtLength(mid);\n        diff = pt[coord] - val;\n\n        if(Math.abs(diff) < tolerance) {\n            return pt;\n        } else {\n            if(mul * diff > 0) {\n                b1 = mid;\n            } else {\n                b0 = mid;\n            }\n            i++;\n        }\n    }\n    return pt;\n};\n","'use strict';\n\nexports.version = require('./version').version;\n\n// inject promise polyfill\nrequire('native-promise-only');\n\n// inject plot css\nrequire('../build/plotcss');\n\n// include registry module and expose register method\nvar Registry = require('./registry');\nvar register = exports.register = Registry.register;\n\n// expose plot api methods\nvar plotApi = require('./plot_api');\nvar methodNames = Object.keys(plotApi);\nfor(var i = 0; i < methodNames.length; i++) {\n    var name = methodNames[i];\n    // _ -> private API methods, but still registered for internal use\n    if(name.charAt(0) !== '_') exports[name] = plotApi[name];\n    register({\n        moduleType: 'apiMethod',\n        name: name,\n        fn: plotApi[name]\n    });\n}\n\n// scatter is the only trace included by default\nregister(require('./traces/scatter'));\n\n// register all registrable components modules\nregister([\n    require('./components/annotations'),\n    require('./components/annotations3d'),\n    require('./components/selections'),\n    require('./components/shapes'),\n    require('./components/images'),\n    require('./components/updatemenus'),\n    require('./components/sliders'),\n    require('./components/rangeslider'),\n    require('./components/rangeselector'),\n    require('./components/grid'),\n    require('./components/errorbars'),\n    require('./components/colorscale'),\n    require('./components/colorbar'),\n    require('./components/legend'), // legend needs to come after shape | legend defaults depends on shapes\n    require('./components/fx'), // fx needs to come after legend | unified hover defaults depends on legends\n    require('./components/modebar')\n]);\n\n// locales en and en-US are required for default behavior\nregister([\n    require('./locale-en'),\n    require('./locale-en-us')\n]);\n\n// locales that are present in the window should be loaded\nif(window.PlotlyLocales && Array.isArray(window.PlotlyLocales)) {\n    register(window.PlotlyLocales);\n    delete window.PlotlyLocales;\n}\n\n// plot icons\nexports.Icons = require('./fonts/ploticon');\n\n// unofficial 'beta' plot methods, use at your own risk\nvar Fx = require('./components/fx');\nvar Plots = require('./plots/plots');\n\nexports.Plots = {\n    resize: Plots.resize,\n    graphJson: Plots.graphJson,\n    sendDataToCloud: Plots.sendDataToCloud\n};\nexports.Fx = {\n    hover: Fx.hover,\n    unhover: Fx.unhover,\n    loneHover: Fx.loneHover,\n    loneUnhover: Fx.loneUnhover\n};\nexports.Snapshot = require('./snapshot');\nexports.PlotSchema = require('./plot_api/plot_schema');\n","'use strict';\nvar b64decode = require('base64-arraybuffer').decode;\n\nvar isPlainObject = require('./is_plain_object');\n\nvar isArray = Array.isArray;\n\nvar ab = ArrayBuffer;\nvar dv = DataView;\n\nfunction isTypedArray(a) {\n    return ab.isView(a) && !(a instanceof dv);\n}\nexports.isTypedArray = isTypedArray;\n\nfunction isArrayOrTypedArray(a) {\n    return isArray(a) || isTypedArray(a);\n}\nexports.isArrayOrTypedArray = isArrayOrTypedArray;\n\n/*\n * Test whether an input object is 1D.\n *\n * Assumes we already know the object is an array.\n *\n * Looks only at the first element, if the dimensionality is\n * not consistent we won't figure that out here.\n */\nfunction isArray1D(a) {\n    return !isArrayOrTypedArray(a[0]);\n}\nexports.isArray1D = isArray1D;\n\n/*\n * Ensures an array has the right amount of storage space. If it doesn't\n * exist, it creates an array. If it does exist, it returns it if too\n * short or truncates it in-place.\n *\n * The goal is to just reuse memory to avoid a bit of excessive garbage\n * collection.\n */\nexports.ensureArray = function(out, n) {\n    // TODO: typed array support here? This is only used in\n    // traces/carpet/compute_control_points\n    if(!isArray(out)) out = [];\n\n    // If too long, truncate. (If too short, it will grow\n    // automatically so we don't care about that case)\n    out.length = n;\n\n    return out;\n};\n\nvar typedArrays = {\n    u1c: typeof Uint8ClampedArray === 'undefined' ? undefined :\n                Uint8ClampedArray, // not supported in numpy?\n\n    i1: typeof Int8Array === 'undefined' ? undefined :\n               Int8Array,\n\n    u1: typeof Uint8Array === 'undefined' ? undefined :\n               Uint8Array,\n\n    i2: typeof Int16Array === 'undefined' ? undefined :\n               Int16Array,\n\n    u2: typeof Uint16Array === 'undefined' ? undefined :\n               Uint16Array,\n\n    i4: typeof Int32Array === 'undefined' ? undefined :\n               Int32Array,\n\n    u4: typeof Uint32Array === 'undefined' ? undefined :\n               Uint32Array,\n\n    f4: typeof Float32Array === 'undefined' ? undefined :\n               Float32Array,\n\n    f8: typeof Float64Array === 'undefined' ? undefined :\n               Float64Array,\n\n    /* TODO: potentially add Big Int\n\n    i8: typeof BigInt64Array === 'undefined' ? undefined :\n               BigInt64Array,\n\n    u8: typeof BigUint64Array === 'undefined' ? undefined :\n               BigUint64Array,\n    */\n};\n\ntypedArrays.uint8c = typedArrays.u1c;\ntypedArrays.uint8 = typedArrays.u1;\ntypedArrays.int8 = typedArrays.i1;\ntypedArrays.uint16 = typedArrays.u2;\ntypedArrays.int16 = typedArrays.i2;\ntypedArrays.uint32 = typedArrays.u4;\ntypedArrays.int32 = typedArrays.i4;\ntypedArrays.float32 = typedArrays.f4;\ntypedArrays.float64 = typedArrays.f8;\n\nfunction isArrayBuffer(a) {\n    return a.constructor === ArrayBuffer;\n}\nexports.isArrayBuffer = isArrayBuffer;\n\nexports.decodeTypedArraySpec = function(vIn) {\n    var out = [];\n    var v = coerceTypedArraySpec(vIn);\n    var dtype = v.dtype;\n\n    var T = typedArrays[dtype];\n    if(!T) throw new Error('Error in dtype: \"' + dtype + '\"');\n    var BYTES_PER_ELEMENT = T.BYTES_PER_ELEMENT;\n\n    var buffer = v.bdata;\n    if(!isArrayBuffer(buffer)) {\n        buffer = b64decode(buffer);\n    }\n    var shape = v.shape === undefined ?\n        // detect 1-d length\n        [buffer.byteLength / BYTES_PER_ELEMENT] :\n        // convert number to string and split to array\n        ('' + v.shape).split(',');\n\n    shape.reverse(); // i.e. to match numpy order\n    var ndim = shape.length;\n\n    var nj, j;\n    var ni = +shape[0];\n\n    var rowBytes = BYTES_PER_ELEMENT * ni;\n    var pos = 0;\n\n    if(ndim === 1) {\n        out = new T(buffer);\n    } else if(ndim === 2) {\n        nj = +shape[1];\n        for(j = 0; j < nj; j++) {\n            out[j] = new T(buffer, pos, ni);\n            pos += rowBytes;\n        }\n    } else if(ndim === 3) {\n        nj = +shape[1];\n        var nk = +shape[2];\n        for(var k = 0; k < nk; k++) {\n            out[k] = [];\n            for(j = 0; j < nj; j++) {\n                out[k][j] = new T(buffer, pos, ni);\n                pos += rowBytes;\n            }\n        }\n    } else {\n        throw new Error('ndim: ' + ndim + 'is not supported with the shape:\"' + v.shape + '\"');\n    }\n\n    // attach bdata, dtype & shape to array for json export\n    out.bdata = v.bdata;\n    out.dtype = v.dtype;\n    out.shape = shape.reverse().join(',');\n\n    vIn._inputArray = out;\n\n    return out;\n};\n\nexports.isTypedArraySpec = function(v) {\n    return (\n        isPlainObject(v) &&\n        v.hasOwnProperty('dtype') && (typeof v.dtype === 'string') &&\n\n        v.hasOwnProperty('bdata') && (typeof v.bdata === 'string' || isArrayBuffer(v.bdata)) &&\n\n        (v.shape === undefined || (\n            v.hasOwnProperty('shape') && (typeof v.shape === 'string' || typeof v.shape === 'number')\n        ))\n    );\n};\n\nfunction coerceTypedArraySpec(v) {\n    return {\n        bdata: v.bdata,\n        dtype: v.dtype,\n        shape: v.shape\n    };\n}\n\n/*\n * TypedArray-compatible concatenation of n arrays\n * if all arrays are the same type it will preserve that type,\n * otherwise it falls back on Array.\n * Also tries to avoid copying, in case one array has zero length\n * But never mutates an existing array\n */\nexports.concat = function() {\n    var args = [];\n    var allArray = true;\n    var totalLen = 0;\n\n    var _constructor, arg0, i, argi, posi, leni, out, j;\n\n    for(i = 0; i < arguments.length; i++) {\n        argi = arguments[i];\n        leni = argi.length;\n        if(leni) {\n            if(arg0) args.push(argi);\n            else {\n                arg0 = argi;\n                posi = leni;\n            }\n\n            if(isArray(argi)) {\n                _constructor = false;\n            } else {\n                allArray = false;\n                if(!totalLen) {\n                    _constructor = argi.constructor;\n                } else if(_constructor !== argi.constructor) {\n                    // TODO: in principle we could upgrade here,\n                    // ie keep typed array but convert all to Float64Array?\n                    _constructor = false;\n                }\n            }\n\n            totalLen += leni;\n        }\n    }\n\n    if(!totalLen) return [];\n    if(!args.length) return arg0;\n\n    if(allArray) return arg0.concat.apply(arg0, args);\n    if(_constructor) {\n        // matching typed arrays\n        out = new _constructor(totalLen);\n        out.set(arg0);\n        for(i = 0; i < args.length; i++) {\n            argi = args[i];\n            out.set(argi, posi);\n            posi += argi.length;\n        }\n        return out;\n    }\n\n    // mismatched types or Array + typed\n    out = new Array(totalLen);\n    for(j = 0; j < arg0.length; j++) out[j] = arg0[j];\n    for(i = 0; i < args.length; i++) {\n        argi = args[i];\n        for(j = 0; j < argi.length; j++) out[posi + j] = argi[j];\n        posi += j;\n    }\n    return out;\n};\n\nexports.maxRowLength = function(z) {\n    return _rowLength(z, Math.max, 0);\n};\n\nexports.minRowLength = function(z) {\n    return _rowLength(z, Math.min, Infinity);\n};\n\nfunction _rowLength(z, fn, len0) {\n    if(isArrayOrTypedArray(z)) {\n        if(isArrayOrTypedArray(z[0])) {\n            var len = len0;\n            for(var i = 0; i < z.length; i++) {\n                len = fn(len, z[i].length);\n            }\n            return len;\n        } else {\n            return z.length;\n        }\n    }\n    return 0;\n}\n","'use strict';\n\nvar nestedProperty = require('./nested_property');\n\nvar SIMPLE_PROPERTY_REGEX = /^\\w*$/;\n\n// bitmask for deciding what's updated. Sometimes the name needs to be updated,\n// sometimes the value needs to be updated, and sometimes both do. This is just\n// a simple way to track what's updated such that it's a simple OR operation to\n// assimilate new updates.\n//\n// The only exception is the UNSET bit that tracks when we need to explicitly\n// unset and remove the property. This concrn arises because of the special\n// way in which nestedProperty handles null/undefined. When you specify `null`,\n// it prunes any unused items in the tree. I ran into some issues with it getting\n// null vs undefined confused, so UNSET is just a bit that forces the property\n// update to send `null`, removing the property explicitly rather than setting\n// it to undefined.\nvar NONE = 0;\nvar NAME = 1;\nvar VALUE = 2;\nvar BOTH = 3;\nvar UNSET = 4;\n\nmodule.exports = function keyedContainer(baseObj, path, keyName, valueName) {\n    keyName = keyName || 'name';\n    valueName = valueName || 'value';\n    var i, arr, baseProp;\n    var changeTypes = {};\n\n    if(path && path.length) {\n        baseProp = nestedProperty(baseObj, path);\n        arr = baseProp.get();\n    } else {\n        arr = baseObj;\n    }\n\n    path = path || '';\n\n    // Construct an index:\n    var indexLookup = {};\n    if(arr) {\n        for(i = 0; i < arr.length; i++) {\n            indexLookup[arr[i][keyName]] = i;\n        }\n    }\n\n    var isSimpleValueProp = SIMPLE_PROPERTY_REGEX.test(valueName);\n\n    var obj = {\n        set: function(name, value) {\n            var changeType = value === null ? UNSET : NONE;\n\n            // create the base array if necessary\n            if(!arr) {\n                if(!baseProp || changeType === UNSET) return;\n\n                arr = [];\n                baseProp.set(arr);\n            }\n\n            var idx = indexLookup[name];\n            if(idx === undefined) {\n                if(changeType === UNSET) return;\n\n                changeType = changeType | BOTH;\n                idx = arr.length;\n                indexLookup[name] = idx;\n            } else if(value !== (isSimpleValueProp ? arr[idx][valueName] : nestedProperty(arr[idx], valueName).get())) {\n                changeType = changeType | VALUE;\n            }\n\n            var newValue = arr[idx] = arr[idx] || {};\n            newValue[keyName] = name;\n\n            if(isSimpleValueProp) {\n                newValue[valueName] = value;\n            } else {\n                nestedProperty(newValue, valueName).set(value);\n            }\n\n            // If it's not an unset, force that bit to be unset. This is all related to the fact\n            // that undefined and null are a bit specially implemented in nestedProperties.\n            if(value !== null) {\n                changeType = changeType & ~UNSET;\n            }\n\n            changeTypes[idx] = changeTypes[idx] | changeType;\n\n            return obj;\n        },\n        get: function(name) {\n            if(!arr) return;\n\n            var idx = indexLookup[name];\n\n            if(idx === undefined) {\n                return undefined;\n            } else if(isSimpleValueProp) {\n                return arr[idx][valueName];\n            } else {\n                return nestedProperty(arr[idx], valueName).get();\n            }\n        },\n        rename: function(name, newName) {\n            var idx = indexLookup[name];\n\n            if(idx === undefined) return obj;\n            changeTypes[idx] = changeTypes[idx] | NAME;\n\n            indexLookup[newName] = idx;\n            delete indexLookup[name];\n\n            arr[idx][keyName] = newName;\n\n            return obj;\n        },\n        remove: function(name) {\n            var idx = indexLookup[name];\n\n            if(idx === undefined) return obj;\n\n            var object = arr[idx];\n            if(Object.keys(object).length > 2) {\n                // This object contains more than just the key/value, so unset\n                // the value without modifying the entry otherwise:\n                changeTypes[idx] = changeTypes[idx] | VALUE;\n                return obj.set(name, null);\n            }\n\n            if(isSimpleValueProp) {\n                for(i = idx; i < arr.length; i++) {\n                    changeTypes[i] = changeTypes[i] | BOTH;\n                }\n                for(i = idx; i < arr.length; i++) {\n                    indexLookup[arr[i][keyName]]--;\n                }\n                arr.splice(idx, 1);\n                delete(indexLookup[name]);\n            } else {\n                // Perform this update *strictly* so we can check whether the result's\n                // been pruned. If so, it's a removal. If not, it's a value unset only.\n                nestedProperty(object, valueName).set(null);\n\n                // Now check if the top level nested property has any keys left. If so,\n                // the object still has values so we only want to unset the key. If not,\n                // the entire object can be removed since there's no other data.\n                // var topLevelKeys = Object.keys(object[valueName.split('.')[0]] || []);\n\n                changeTypes[idx] = changeTypes[idx] | VALUE | UNSET;\n            }\n\n            return obj;\n        },\n        constructUpdate: function() {\n            var astr, idx;\n            var update = {};\n            var changed = Object.keys(changeTypes);\n            for(var i = 0; i < changed.length; i++) {\n                idx = changed[i];\n                astr = path + '[' + idx + ']';\n                if(arr[idx]) {\n                    if(changeTypes[idx] & NAME) {\n                        update[astr + '.' + keyName] = arr[idx][keyName];\n                    }\n                    if(changeTypes[idx] & VALUE) {\n                        if(isSimpleValueProp) {\n                            update[astr + '.' + valueName] = (changeTypes[idx] & UNSET) ? null : arr[idx][valueName];\n                        } else {\n                            update[astr + '.' + valueName] = (changeTypes[idx] & UNSET) ? null : nestedProperty(arr[idx], valueName).get();\n                        }\n                    }\n                } else {\n                    update[astr] = null;\n                }\n            }\n\n            return update;\n        }\n    };\n\n    return obj;\n};\n","'use strict';\n\n// more info: http://stackoverflow.com/questions/18531624/isplainobject-thing\nmodule.exports = function isPlainObject(obj) {\n    // We need to be a little less strict in the `imagetest` container because\n    // of how async image requests are handled.\n    //\n    // N.B. isPlainObject(new Constructor()) will return true in `imagetest`\n    if(window && window.process && window.process.versions) {\n        return Object.prototype.toString.call(obj) === '[object Object]';\n    }\n\n    return (\n        Object.prototype.toString.call(obj) === '[object Object]' &&\n        Object.getPrototypeOf(obj).hasOwnProperty('hasOwnProperty')\n    );\n};\n","'use strict';\n\n\n/**\n * Return news array containing only the unique items\n * found in input array.\n *\n * IMPORTANT: Note that items are considered unique\n * if `String({})` is unique. For example;\n *\n *  Lib.filterUnique([ { a: 1 }, { b: 2 } ])\n *\n *  returns [{ a: 1 }]\n *\n * and\n *\n *  Lib.filterUnique([ '1', 1 ])\n *\n *  returns ['1']\n *\n *\n * @param {array} array base array\n * @return {array} new filtered array\n */\nmodule.exports = function filterUnique(array) {\n    var seen = {};\n    var out = [];\n    var j = 0;\n\n    for(var i = 0; i < array.length; i++) {\n        var item = array[i];\n\n        if(seen[item] !== 1) {\n            seen[item] = 1;\n            out[j++] = item;\n        }\n    }\n\n    return out;\n};\n","'use strict';\n\nvar modModule = require('./mod');\nvar mod = modModule.mod;\nvar modHalf = modModule.modHalf;\n\nvar PI = Math.PI;\nvar twoPI = 2 * PI;\n\nfunction deg2rad(deg) { return deg / 180 * PI; }\n\nfunction rad2deg(rad) { return rad / PI * 180; }\n\n/**\n * is sector a full circle?\n * ... this comes up a lot in SVG path-drawing routines\n *\n * N.B. we consider all sectors that span more that 2pi 'full' circles\n *\n * @param {2-item array} aBnds : angular bounds in *radians*\n * @return {boolean}\n */\nfunction isFullCircle(aBnds) {\n    return Math.abs(aBnds[1] - aBnds[0]) > twoPI - 1e-14;\n}\n\n/**\n * angular delta between angle 'a' and 'b'\n * solution taken from: https://stackoverflow.com/a/2007279\n *\n * @param {number} a : first angle in *radians*\n * @param {number} b : second angle in *radians*\n * @return {number} angular delta in *radians*\n */\nfunction angleDelta(a, b) {\n    return modHalf(b - a, twoPI);\n}\n\n/**\n * angular distance between angle 'a' and 'b'\n *\n * @param {number} a : first angle in *radians*\n * @param {number} b : second angle in *radians*\n * @return {number} angular distance in *radians*\n */\nfunction angleDist(a, b) {\n    return Math.abs(angleDelta(a, b));\n}\n\n/**\n * is angle inside sector?\n *\n * @param {number} a : angle to test in *radians*\n * @param {2-item array} aBnds : sector's angular bounds in *radians*\n * @param {boolean}\n */\nfunction isAngleInsideSector(a, aBnds) {\n    if(isFullCircle(aBnds)) return true;\n\n    var s0, s1;\n\n    if(aBnds[0] < aBnds[1]) {\n        s0 = aBnds[0];\n        s1 = aBnds[1];\n    } else {\n        s0 = aBnds[1];\n        s1 = aBnds[0];\n    }\n\n    s0 = mod(s0, twoPI);\n    s1 = mod(s1, twoPI);\n    if(s0 > s1) s1 += twoPI;\n\n    var a0 = mod(a, twoPI);\n    var a1 = a0 + twoPI;\n\n    return (a0 >= s0 && a0 <= s1) || (a1 >= s0 && a1 <= s1);\n}\n\n/**\n * is pt (r,a) inside sector?\n *\n * @param {number} r : pt's radial coordinate\n * @param {number} a : pt's angular coordinate in *radians*\n * @param {2-item array} rBnds : sector's radial bounds\n * @param {2-item array} aBnds : sector's angular bounds in *radians*\n * @return {boolean}\n */\nfunction isPtInsideSector(r, a, rBnds, aBnds) {\n    if(!isAngleInsideSector(a, aBnds)) return false;\n\n    var r0, r1;\n\n    if(rBnds[0] < rBnds[1]) {\n        r0 = rBnds[0];\n        r1 = rBnds[1];\n    } else {\n        r0 = rBnds[1];\n        r1 = rBnds[0];\n    }\n\n    return r >= r0 && r <= r1;\n}\n\n// common to pathArc, pathSector and pathAnnulus\nfunction _path(r0, r1, a0, a1, cx, cy, isClosed) {\n    cx = cx || 0;\n    cy = cy || 0;\n\n    var isCircle = isFullCircle([a0, a1]);\n    var aStart, aMid, aEnd;\n    var rStart, rEnd;\n\n    if(isCircle) {\n        aStart = 0;\n        aMid = PI;\n        aEnd = twoPI;\n    } else {\n        if(a0 < a1) {\n            aStart = a0;\n            aEnd = a1;\n        } else {\n            aStart = a1;\n            aEnd = a0;\n        }\n    }\n\n    if(r0 < r1) {\n        rStart = r0;\n        rEnd = r1;\n    } else {\n        rStart = r1;\n        rEnd = r0;\n    }\n\n    // N.B. svg coordinates here, where y increases downward\n    function pt(r, a) {\n        return [r * Math.cos(a) + cx, cy - r * Math.sin(a)];\n    }\n\n    var largeArc = Math.abs(aEnd - aStart) <= PI ? 0 : 1;\n    function arc(r, a, cw) {\n        return 'A' + [r, r] + ' ' + [0, largeArc, cw] + ' ' + pt(r, a);\n    }\n\n    var p;\n\n    if(isCircle) {\n        if(rStart === null) {\n            p = 'M' + pt(rEnd, aStart) +\n                arc(rEnd, aMid, 0) +\n                arc(rEnd, aEnd, 0) + 'Z';\n        } else {\n            p = 'M' + pt(rStart, aStart) +\n                arc(rStart, aMid, 0) +\n                arc(rStart, aEnd, 0) + 'Z' +\n                'M' + pt(rEnd, aStart) +\n                arc(rEnd, aMid, 1) +\n                arc(rEnd, aEnd, 1) + 'Z';\n        }\n    } else {\n        if(rStart === null) {\n            p = 'M' + pt(rEnd, aStart) + arc(rEnd, aEnd, 0);\n            if(isClosed) p += 'L0,0Z';\n        } else {\n            p = 'M' + pt(rStart, aStart) +\n                'L' + pt(rEnd, aStart) +\n                arc(rEnd, aEnd, 0) +\n                'L' + pt(rStart, aEnd) +\n                arc(rStart, aStart, 1) + 'Z';\n        }\n    }\n\n    return p;\n}\n\n/**\n * path an arc\n *\n * @param {number} r : radius\n * @param {number} a0 : first angular coordinate in *radians*\n * @param {number} a1 : second angular coordinate in *radians*\n * @param {number (optional)} cx : x coordinate of center\n * @param {number (optional)} cy : y coordinate of center\n * @return {string} svg path\n */\nfunction pathArc(r, a0, a1, cx, cy) {\n    return _path(null, r, a0, a1, cx, cy, 0);\n}\n\n/**\n * path a sector\n *\n * @param {number} r : radius\n * @param {number} a0 : first angular coordinate in *radians*\n * @param {number} a1 : second angular coordinate in *radians*\n * @param {number (optional)} cx : x coordinate of center\n * @param {number (optional)} cy : y coordinate of center\n * @return {string} svg path\n */\nfunction pathSector(r, a0, a1, cx, cy) {\n    return _path(null, r, a0, a1, cx, cy, 1);\n}\n\n/**\n * path an annulus\n *\n * @param {number} r0 : first radial coordinate\n * @param {number} r1 : second radial coordinate\n * @param {number} a0 : first angular coordinate in *radians*\n * @param {number} a1 : second angular coordinate in *radians*\n * @param {number (optional)} cx : x coordinate of center\n * @param {number (optional)} cy : y coordinate of center\n * @return {string} svg path\n */\nfunction pathAnnulus(r0, r1, a0, a1, cx, cy) {\n    return _path(r0, r1, a0, a1, cx, cy, 1);\n}\n\nmodule.exports = {\n    deg2rad: deg2rad,\n    rad2deg: rad2deg,\n    angleDelta: angleDelta,\n    angleDist: angleDist,\n    isFullCircle: isFullCircle,\n    isAngleInsideSector: isAngleInsideSector,\n    isPtInsideSector: isPtInsideSector,\n    pathArc: pathArc,\n    pathSector: pathSector,\n    pathAnnulus: pathAnnulus\n};\n","'use strict';\n\n/**\n * Clear responsive handlers (if any).\n *\n * @param {DOM node or object} gd : graph div object\n */\nmodule.exports = function clearResponsive(gd) {\n    if(gd._responsiveChartHandler) {\n        window.removeEventListener('resize', gd._responsiveChartHandler);\n        delete gd._responsiveChartHandler;\n    }\n};\n","'use strict';\n\nmodule.exports = function incrementNumeric(x, delta) {\n    if(!delta) return x;\n\n    // Note 1:\n    // 0.3 != 0.1 + 0.2 == 0.30000000000000004\n    // but 0.3 == (10 * 0.1 + 10 * 0.2) / 10\n    // Attempt to use integer steps to increment\n    var scale = 1 / Math.abs(delta);\n    var newX = (scale > 1) ? (\n        scale * x +\n        scale * delta\n    ) / scale : x + delta;\n\n    // Note 2:\n    // now we may also consider rounding to cover few more edge cases\n    // e.g. 0.3 * 3 = 0.8999999999999999\n    var lenX1 = String(newX).length;\n    if(lenX1 > 16) {\n        var lenDt = String(delta).length;\n        var lenX0 = String(x).length;\n\n        if(lenX1 >= lenX0 + lenDt) { // likely a rounding error!\n            var s = parseFloat(newX).toPrecision(12);\n            if(s.indexOf('e+') === -1) newX = +s;\n        }\n    }\n\n    return newX;\n};\n","'use strict';\n\n/** Filter out object items with visible !== true\n *  insider array container.\n *\n *  @param {array of objects} container\n *  @return {array of objects} of length <= container\n *\n */\nmodule.exports = function filterVisible(container) {\n    var filterFn = isCalcData(container) ? calcDataFilter : baseFilter;\n    var out = [];\n\n    for(var i = 0; i < container.length; i++) {\n        var item = container[i];\n        if(filterFn(item)) out.push(item);\n    }\n\n    return out;\n};\n\nfunction baseFilter(item) {\n    return item.visible === true;\n}\n\nfunction calcDataFilter(item) {\n    var trace = item[0].trace;\n    return trace.visible === true && trace._length !== 0;\n}\n\nfunction isCalcData(cont) {\n    return (\n        Array.isArray(cont) &&\n        Array.isArray(cont[0]) &&\n        cont[0][0] &&\n        cont[0][0].trace\n    );\n}\n","'use strict';\n\n\n/**\n * Determine the position anchor property of x/y xanchor/yanchor components.\n *\n * - values < 1/3 align the low side at that fraction,\n * - values [1/3, 2/3] align the center at that fraction,\n * - values > 2/3 align the right at that fraction.\n */\n\n\nexports.isLeftAnchor = function isLeftAnchor(opts) {\n    return (\n      opts.xanchor === 'left' ||\n      (opts.xanchor === 'auto' && opts.x <= 1 / 3)\n    );\n};\n\nexports.isCenterAnchor = function isCenterAnchor(opts) {\n    return (\n        opts.xanchor === 'center' ||\n        (opts.xanchor === 'auto' && opts.x > 1 / 3 && opts.x < 2 / 3)\n    );\n};\n\nexports.isRightAnchor = function isRightAnchor(opts) {\n    return (\n      opts.xanchor === 'right' ||\n      (opts.xanchor === 'auto' && opts.x >= 2 / 3)\n    );\n};\n\nexports.isTopAnchor = function isTopAnchor(opts) {\n    return (\n        opts.yanchor === 'top' ||\n        (opts.yanchor === 'auto' && opts.y >= 2 / 3)\n    );\n};\n\nexports.isMiddleAnchor = function isMiddleAnchor(opts) {\n    return (\n        opts.yanchor === 'middle' ||\n        (opts.yanchor === 'auto' && opts.y > 1 / 3 && opts.y < 2 / 3)\n    );\n};\n\nexports.isBottomAnchor = function isBottomAnchor(opts) {\n    return (\n      opts.yanchor === 'bottom' ||\n      (opts.yanchor === 'auto' && opts.y <= 1 / 3)\n    );\n};\n","'use strict';\n\nvar isNumeric = require('fast-isnumeric');\nvar tinycolor = require('tinycolor2');\n\nvar baseTraceAttrs = require('../plots/attributes');\nvar colorscales = require('../components/colorscale/scales');\nvar Color = require('../components/color');\nvar DESELECTDIM = require('../constants/interactions').DESELECTDIM;\n\nvar nestedProperty = require('./nested_property');\nvar counterRegex = require('./regex').counter;\nvar modHalf = require('./mod').modHalf;\nvar isArrayOrTypedArray = require('./array').isArrayOrTypedArray;\nvar isTypedArraySpec = require('./array').isTypedArraySpec;\nvar decodeTypedArraySpec = require('./array').decodeTypedArraySpec;\n\nexports.valObjectMeta = {\n    data_array: {\n        // You can use *dflt=[] to force said array to exist though.\n        description: [\n            'An {array} of data.',\n            'The value must represent an {array} or it will be ignored,',\n            'but this array can be provided in several forms:',\n            '(1) a regular {array} object',\n            '(2) a typed array (e.g. Float32Array)',\n            '(3) an object with keys dtype, bdata, and optionally shape.',\n            'In this 3rd form, dtype is one of',\n            '*f8*, *f4*.',\n            '*i4*, *u4*,',\n            '*i2*, *u2*,',\n            '*i1*, *u1* or *u1c* for Uint8ClampedArray.',\n            'In addition to shorthand `dtype` above one could also use the following forms:',\n            '*float64*, *float32*,',\n            '*int32*, *uint32*,',\n            '*int16*, *uint16*,',\n            '*int8*, *uint8* or *uint8c* for Uint8ClampedArray.',\n            '`bdata` is either a base64-encoded string or the ArrayBuffer of',\n            'an integer or float typed array.',\n            'For either multi-dimensional arrays you must also',\n            'provide its dimensions separated by comma via `shape`.',\n            'For example using `dtype`: *f4* and `shape`: *5,100* you can',\n            'declare a 2-D array that has 5 rows and 100 columns',\n            'containing float32 values i.e. 4 bits per value.',\n            '`shape` is optional for one dimensional arrays.'\n        ].join(' '),\n        requiredOpts: [],\n        otherOpts: ['dflt'],\n        coerceFunction: function(v, propOut, dflt) {\n            propOut.set(\n                isArrayOrTypedArray(v) ? v :\n                isTypedArraySpec(v) ? decodeTypedArraySpec(v) :\n                dflt\n            );\n        }\n    },\n    enumerated: {\n        description: [\n            'Enumerated value type. The available values are listed',\n            'in `values`.'\n        ].join(' '),\n        requiredOpts: ['values'],\n        otherOpts: ['dflt', 'coerceNumber', 'arrayOk'],\n        coerceFunction: function(v, propOut, dflt, opts) {\n            if(opts.coerceNumber) v = +v;\n            if(opts.values.indexOf(v) === -1) propOut.set(dflt);\n            else propOut.set(v);\n        },\n        validateFunction: function(v, opts) {\n            if(opts.coerceNumber) v = +v;\n\n            var values = opts.values;\n            for(var i = 0; i < values.length; i++) {\n                var k = String(values[i]);\n\n                if((k.charAt(0) === '/' && k.charAt(k.length - 1) === '/')) {\n                    var regex = new RegExp(k.substr(1, k.length - 2));\n                    if(regex.test(v)) return true;\n                } else if(v === values[i]) return true;\n            }\n            return false;\n        }\n    },\n    boolean: {\n        description: 'A boolean (true/false) value.',\n        requiredOpts: [],\n        otherOpts: ['dflt'],\n        coerceFunction: function(v, propOut, dflt) {\n            if(v === true || v === false) propOut.set(v);\n            else propOut.set(dflt);\n        }\n    },\n    number: {\n        description: [\n            'A number or a numeric value',\n            '(e.g. a number inside a string).',\n            'When applicable, values greater (less) than `max` (`min`)',\n            'are coerced to the `dflt`.'\n        ].join(' '),\n        requiredOpts: [],\n        otherOpts: ['dflt', 'min', 'max', 'arrayOk'],\n        coerceFunction: function(v, propOut, dflt, opts) {\n            if(!isNumeric(v) ||\n                    (opts.min !== undefined && v < opts.min) ||\n                    (opts.max !== undefined && v > opts.max)) {\n                propOut.set(dflt);\n            } else propOut.set(+v);\n        }\n    },\n    integer: {\n        description: [\n            'An integer or an integer inside a string.',\n            'When applicable, values greater (less) than `max` (`min`)',\n            'are coerced to the `dflt`.'\n        ].join(' '),\n        requiredOpts: [],\n        otherOpts: ['dflt', 'min', 'max', 'arrayOk'],\n        coerceFunction: function(v, propOut, dflt, opts) {\n            if(v % 1 || !isNumeric(v) ||\n                    (opts.min !== undefined && v < opts.min) ||\n                    (opts.max !== undefined && v > opts.max)) {\n                propOut.set(dflt);\n            } else propOut.set(+v);\n        }\n    },\n    string: {\n        description: [\n            'A string value.',\n            'Numbers are converted to strings except for attributes with',\n            '`strict` set to true.'\n        ].join(' '),\n        requiredOpts: [],\n        // TODO 'values shouldn't be in there (edge case: 'dash' in Scatter)\n        otherOpts: ['dflt', 'noBlank', 'strict', 'arrayOk', 'values'],\n        coerceFunction: function(v, propOut, dflt, opts) {\n            if(typeof v !== 'string') {\n                var okToCoerce = (typeof v === 'number');\n\n                if(opts.strict === true || !okToCoerce) propOut.set(dflt);\n                else propOut.set(String(v));\n            } else if(opts.noBlank && !v) propOut.set(dflt);\n            else propOut.set(v);\n        }\n    },\n    color: {\n        description: [\n            'A string describing color.',\n            'Supported formats:',\n            '- hex (e.g. \\'#d3d3d3\\')',\n            '- rgb (e.g. \\'rgb(255, 0, 0)\\')',\n            '- rgba (e.g. \\'rgb(255, 0, 0, 0.5)\\')',\n            '- hsl (e.g. \\'hsl(0, 100%, 50%)\\')',\n            '- hsv (e.g. \\'hsv(0, 100%, 100%)\\')',\n            '- named colors (full list: http://www.w3.org/TR/css3-color/#svg-color)'\n        ].join(' '),\n        requiredOpts: [],\n        otherOpts: ['dflt', 'arrayOk'],\n        coerceFunction: function(v, propOut, dflt) {\n            if(tinycolor(v).isValid()) propOut.set(v);\n            else propOut.set(dflt);\n        }\n    },\n    colorlist: {\n        description: [\n            'A list of colors.',\n            'Must be an {array} containing valid colors.',\n        ].join(' '),\n        requiredOpts: [],\n        otherOpts: ['dflt'],\n        coerceFunction: function(v, propOut, dflt) {\n            function isColor(color) {\n                return tinycolor(color).isValid();\n            }\n            if(!Array.isArray(v) || !v.length) propOut.set(dflt);\n            else if(v.every(isColor)) propOut.set(v);\n            else propOut.set(dflt);\n        }\n    },\n    colorscale: {\n        description: [\n            'A Plotly colorscale either picked by a name:',\n            '(any of', Object.keys(colorscales.scales).join(', '), ')',\n            'customized as an {array} of 2-element {arrays} where',\n            'the first element is the normalized color level value',\n            '(starting at *0* and ending at *1*),',\n            'and the second item is a valid color string.'\n        ].join(' '),\n        requiredOpts: [],\n        otherOpts: ['dflt'],\n        coerceFunction: function(v, propOut, dflt) {\n            propOut.set(colorscales.get(v, dflt));\n        }\n    },\n    angle: {\n        description: [\n            'A number (in degree) between -180 and 180.'\n        ].join(' '),\n        requiredOpts: [],\n        otherOpts: ['dflt', 'arrayOk'],\n        coerceFunction: function(v, propOut, dflt) {\n            if(v === 'auto') propOut.set('auto');\n            else if(!isNumeric(v)) propOut.set(dflt);\n            else propOut.set(modHalf(+v, 360));\n        }\n    },\n    subplotid: {\n        description: [\n            'An id string of a subplot type (given by dflt), optionally',\n            'followed by an integer >1. e.g. if dflt=\\'geo\\', we can have',\n            '\\'geo\\', \\'geo2\\', \\'geo3\\', ...'\n        ].join(' '),\n        requiredOpts: ['dflt'],\n        otherOpts: ['regex'],\n        coerceFunction: function(v, propOut, dflt, opts) {\n            var regex = opts.regex || counterRegex(dflt);\n            if(typeof v === 'string' && regex.test(v)) {\n                propOut.set(v);\n                return;\n            }\n            propOut.set(dflt);\n        },\n        validateFunction: function(v, opts) {\n            var dflt = opts.dflt;\n\n            if(v === dflt) return true;\n            if(typeof v !== 'string') return false;\n            if(counterRegex(dflt).test(v)) return true;\n\n            return false;\n        }\n    },\n    flaglist: {\n        description: [\n            'A string representing a combination of flags',\n            '(order does not matter here).',\n            'Combine any of the available `flags` with *+*.',\n            '(e.g. (\\'lines+markers\\')).',\n            'Values in `extras` cannot be combined.'\n        ].join(' '),\n        requiredOpts: ['flags'],\n        otherOpts: ['dflt', 'extras', 'arrayOk'],\n        coerceFunction: function(v, propOut, dflt, opts) {\n            if((opts.extras || []).indexOf(v) !== -1) {\n                propOut.set(v);\n                return;\n            }\n            if(typeof v !== 'string') {\n                propOut.set(dflt);\n                return;\n            }\n            var vParts = v.split('+');\n            var i = 0;\n            while(i < vParts.length) {\n                var vi = vParts[i];\n                if(opts.flags.indexOf(vi) === -1 || vParts.indexOf(vi) < i) {\n                    vParts.splice(i, 1);\n                } else i++;\n            }\n            if(!vParts.length) propOut.set(dflt);\n            else propOut.set(vParts.join('+'));\n        }\n    },\n    any: {\n        description: 'Any type.',\n        requiredOpts: [],\n        otherOpts: ['dflt', 'values', 'arrayOk'],\n        coerceFunction: function(v, propOut, dflt) {\n            if(v === undefined) {\n                propOut.set(dflt);\n            } else {\n                propOut.set(\n                    isTypedArraySpec(v) ? decodeTypedArraySpec(v) :\n                    v\n                );\n            }\n        }\n    },\n    info_array: {\n        description: [\n            'An {array} of plot information.'\n        ].join(' '),\n        requiredOpts: ['items'],\n        // set `dimensions=2` for a 2D array or '1-2' for either\n        // `items` may be a single object instead of an array, in which case\n        // `freeLength` must be true.\n        // if `dimensions='1-2'` and items is a 1D array, then the value can\n        // either be a matching 1D array or an array of such matching 1D arrays\n        otherOpts: ['dflt', 'freeLength', 'dimensions'],\n        coerceFunction: function(v, propOut, dflt, opts) {\n            // simplified coerce function just for array items\n            function coercePart(v, opts, dflt) {\n                var out;\n                var propPart = {set: function(v) { out = v; }};\n\n                if(dflt === undefined) dflt = opts.dflt;\n\n                exports.valObjectMeta[opts.valType].coerceFunction(v, propPart, dflt, opts);\n\n                return out;\n            }\n\n            if(isTypedArraySpec(v)) v = decodeTypedArraySpec(v);\n\n            if(!isArrayOrTypedArray(v)) {\n                propOut.set(dflt);\n                return;\n            }\n\n            var twoD = opts.dimensions === 2 || (opts.dimensions === '1-2' && Array.isArray(v) && isArrayOrTypedArray(v[0]));\n\n            var items = opts.items;\n            var vOut = [];\n            var arrayItems = Array.isArray(items);\n            var arrayItems2D = arrayItems && twoD && isArrayOrTypedArray(items[0]);\n            var innerItemsOnly = twoD && arrayItems && !arrayItems2D;\n            var len = (arrayItems && !innerItemsOnly) ? items.length : v.length;\n\n            var i, j, row, item, len2, vNew;\n\n            dflt = Array.isArray(dflt) ? dflt : [];\n\n            if(twoD) {\n                for(i = 0; i < len; i++) {\n                    vOut[i] = [];\n                    row = isArrayOrTypedArray(v[i]) ? v[i] : [];\n                    if(innerItemsOnly) len2 = items.length;\n                    else if(arrayItems) len2 = items[i].length;\n                    else len2 = row.length;\n\n                    for(j = 0; j < len2; j++) {\n                        if(innerItemsOnly) item = items[j];\n                        else if(arrayItems) item = items[i][j];\n                        else item = items;\n\n                        vNew = coercePart(row[j], item, (dflt[i] || [])[j]);\n                        if(vNew !== undefined) vOut[i][j] = vNew;\n                    }\n                }\n            } else {\n                for(i = 0; i < len; i++) {\n                    vNew = coercePart(v[i], arrayItems ? items[i] : items, dflt[i]);\n                    if(vNew !== undefined) vOut[i] = vNew;\n                }\n            }\n\n            propOut.set(vOut);\n        },\n        validateFunction: function(v, opts) {\n            if(!isArrayOrTypedArray(v)) return false;\n\n            var items = opts.items;\n            var arrayItems = Array.isArray(items);\n            var twoD = opts.dimensions === 2;\n\n            // when free length is off, input and declared lengths must match\n            if(!opts.freeLength && v.length !== items.length) return false;\n\n            // valid when all input items are valid\n            for(var i = 0; i < v.length; i++) {\n                if(twoD) {\n                    if(!isArrayOrTypedArray(v[i]) || (!opts.freeLength && v[i].length !== items[i].length)) {\n                        return false;\n                    }\n                    for(var j = 0; j < v[i].length; j++) {\n                        if(!validate(v[i][j], arrayItems ? items[i][j] : items)) {\n                            return false;\n                        }\n                    }\n                } else if(!validate(v[i], arrayItems ? items[i] : items)) return false;\n            }\n\n            return true;\n        }\n    }\n};\n\n/**\n * Ensures that container[attribute] has a valid value.\n *\n * attributes[attribute] is an object with possible keys:\n * - valType: data_array, enumerated, boolean, ... as in valObjectMeta\n * - values: (enumerated only) array of allowed vals\n * - min, max: (number, integer only) inclusive bounds on allowed vals\n *      either or both may be omitted\n * - dflt: if attribute is invalid or missing, use this default\n *      if dflt is provided as an argument to lib.coerce it takes precedence\n *      as a convenience, returns the value it finally set\n */\nexports.coerce = function(containerIn, containerOut, attributes, attribute, dflt) {\n    var opts = nestedProperty(attributes, attribute).get();\n    var propIn = nestedProperty(containerIn, attribute);\n    var propOut = nestedProperty(containerOut, attribute);\n    var v = propIn.get();\n\n    var template = containerOut._template;\n    if(v === undefined && template) {\n        v = nestedProperty(template, attribute).get();\n        // already used the template value, so short-circuit the second check\n        template = 0;\n    }\n\n    if(dflt === undefined) dflt = opts.dflt;\n\n    if(opts.arrayOk) {\n        if(isArrayOrTypedArray(v)) {\n            /**\n             * arrayOk: value MAY be an array, then we do no value checking\n             * at this point, because it can be more complicated than the\n             * individual form (eg. some array vals can be numbers, even if the\n             * single values must be color strings)\n             */\n\n            propOut.set(v);\n            return v;\n        } else {\n            if(isTypedArraySpec(v)) {\n                v = decodeTypedArraySpec(v);\n                propOut.set(v);\n                return v;\n            }\n        }\n    }\n\n    var coerceFunction = exports.valObjectMeta[opts.valType].coerceFunction;\n    coerceFunction(v, propOut, dflt, opts);\n\n    var out = propOut.get();\n    // in case v was provided but invalid, try the template again so it still\n    // overrides the regular default\n    if(template && out === dflt && !validate(v, opts)) {\n        v = nestedProperty(template, attribute).get();\n        coerceFunction(v, propOut, dflt, opts);\n        out = propOut.get();\n    }\n    return out;\n};\n\n/**\n * Variation on coerce\n *\n * Uses coerce to get attribute value if user input is valid,\n * returns attribute default if user input it not valid or\n * returns false if there is no user input.\n */\nexports.coerce2 = function(containerIn, containerOut, attributes, attribute, dflt) {\n    var propIn = nestedProperty(containerIn, attribute);\n    var propOut = exports.coerce(containerIn, containerOut, attributes, attribute, dflt);\n    var valIn = propIn.get();\n\n    return (valIn !== undefined && valIn !== null) ? propOut : false;\n};\n\n/*\n * Shortcut to coerce the three font attributes\n *\n * 'coerce' is a lib.coerce wrapper with implied first three arguments\n */\nexports.coerceFont = function(coerce, attr, dfltObj) {\n    var out = {};\n\n    dfltObj = dfltObj || {};\n\n    out.family = coerce(attr + '.family', dfltObj.family);\n    out.size = coerce(attr + '.size', dfltObj.size);\n    out.color = coerce(attr + '.color', dfltObj.color);\n\n    return out;\n};\n\n/*\n * Shortcut to coerce the pattern attributes\n */\nexports.coercePattern = function(coerce, attr, markerColor, hasMarkerColorscale) {\n    var shape = coerce(attr + '.shape');\n    if(shape) {\n        coerce(attr + '.solidity');\n        coerce(attr + '.size');\n        var fillmode = coerce(attr + '.fillmode');\n        var isOverlay = fillmode === 'overlay';\n\n        if(!hasMarkerColorscale) {\n            var bgcolor = coerce(attr + '.bgcolor', isOverlay ?\n                markerColor :\n                undefined\n            );\n\n            coerce(attr + '.fgcolor', isOverlay ?\n                Color.contrast(bgcolor) :\n                markerColor\n            );\n        }\n\n        coerce(attr + '.fgopacity', isOverlay ?\n            0.5 :\n            1\n        );\n    }\n};\n\n/** Coerce shortcut for 'hoverinfo'\n * handling 1-vs-multi-trace dflt logic\n *\n * @param {object} traceIn : user trace object\n * @param {object} traceOut : full trace object (requires _module ref)\n * @param {object} layoutOut : full layout object (require _dataLength ref)\n * @return {any} : the coerced value\n */\nexports.coerceHoverinfo = function(traceIn, traceOut, layoutOut) {\n    var moduleAttrs = traceOut._module.attributes;\n    var attrs = moduleAttrs.hoverinfo ? moduleAttrs : baseTraceAttrs;\n\n    var valObj = attrs.hoverinfo;\n    var dflt;\n\n    if(layoutOut._dataLength === 1) {\n        var flags = valObj.dflt === 'all' ?\n            valObj.flags.slice() :\n            valObj.dflt.split('+');\n\n        flags.splice(flags.indexOf('name'), 1);\n        dflt = flags.join('+');\n    }\n\n    return exports.coerce(traceIn, traceOut, attrs, 'hoverinfo', dflt);\n};\n\n/** Coerce shortcut for [un]selected.marker.opacity,\n *  which has special default logic, to ensure that it corresponds to the\n *  default selection behavior while allowing to be overtaken by any other\n *  [un]selected attribute.\n *\n *  N.B. This must be called *after* coercing all the other [un]selected attrs,\n *  to give the intended result.\n *\n * @param {object} traceOut : fullData item\n * @param {function} coerce : lib.coerce wrapper with implied first three arguments\n */\nexports.coerceSelectionMarkerOpacity = function(traceOut, coerce) {\n    if(!traceOut.marker) return;\n\n    var mo = traceOut.marker.opacity;\n    // you can still have a `marker` container with no markers if there's text\n    if(mo === undefined) return;\n\n    var smoDflt;\n    var usmoDflt;\n\n    // Don't give [un]selected.marker.opacity a default value if\n    // marker.opacity is an array: handle this during style step.\n    //\n    // Only give [un]selected.marker.opacity a default value if you don't\n    // set any other [un]selected attributes.\n    if(!isArrayOrTypedArray(mo) && !traceOut.selected && !traceOut.unselected) {\n        smoDflt = mo;\n        usmoDflt = DESELECTDIM * mo;\n    }\n\n    coerce('selected.marker.opacity', smoDflt);\n    coerce('unselected.marker.opacity', usmoDflt);\n};\n\nfunction validate(value, opts) {\n    var valObjectDef = exports.valObjectMeta[opts.valType];\n\n    if(opts.arrayOk && isArrayOrTypedArray(value)) return true;\n\n    if(valObjectDef.validateFunction) {\n        return valObjectDef.validateFunction(value, opts);\n    }\n\n    var failed = {};\n    var out = failed;\n    var propMock = { set: function(v) { out = v; } };\n\n    // 'failed' just something mutable that won't be === anything else\n\n    valObjectDef.coerceFunction(value, propMock, failed, opts);\n    return out !== failed;\n}\nexports.validate = validate;\n","'use strict';\n\nvar d3 = require('@plotly/d3');\nvar loggers = require('./loggers');\nvar matrix = require('./matrix');\nvar mat4X4 = require('gl-mat4');\n\n/**\n * Allow referencing a graph DOM element either directly\n * or by its id string\n *\n * @param {HTMLDivElement|string} gd: a graph element or its id\n *\n * @returns {HTMLDivElement} the DOM element of the graph\n */\nfunction getGraphDiv(gd) {\n    var gdElement;\n\n    if(typeof gd === 'string') {\n        gdElement = document.getElementById(gd);\n\n        if(gdElement === null) {\n            throw new Error('No DOM element with id \\'' + gd + '\\' exists on the page.');\n        }\n\n        return gdElement;\n    } else if(gd === null || gd === undefined) {\n        throw new Error('DOM element provided is null or undefined');\n    }\n\n    // otherwise assume that gd is a DOM element\n    return gd;\n}\n\nfunction isPlotDiv(el) {\n    var el3 = d3.select(el);\n    return el3.node() instanceof HTMLElement &&\n        el3.size() &&\n        el3.classed('js-plotly-plot');\n}\n\nfunction removeElement(el) {\n    var elParent = el && el.parentNode;\n    if(elParent) elParent.removeChild(el);\n}\n\n/**\n * for dynamically adding style rules\n * makes one stylesheet that contains all rules added\n * by all calls to this function\n */\nfunction addStyleRule(selector, styleString) {\n    addRelatedStyleRule('global', selector, styleString);\n}\n\n/**\n * for dynamically adding style rules\n * to a stylesheet uniquely identified by a uid\n */\nfunction addRelatedStyleRule(uid, selector, styleString) {\n    var id = 'plotly.js-style-' + uid;\n    var style = document.getElementById(id);\n    if(!style) {\n        style = document.createElement('style');\n        style.setAttribute('id', id);\n        // WebKit hack :(\n        style.appendChild(document.createTextNode(''));\n        document.head.appendChild(style);\n    }\n    var styleSheet = style.sheet;\n\n    if(styleSheet.insertRule) {\n        styleSheet.insertRule(selector + '{' + styleString + '}', 0);\n    } else if(styleSheet.addRule) {\n        styleSheet.addRule(selector, styleString, 0);\n    } else loggers.warn('addStyleRule failed');\n}\n\n/**\n * to remove from the page a stylesheet identified by a given uid\n */\nfunction deleteRelatedStyleRule(uid) {\n    var id = 'plotly.js-style-' + uid;\n    var style = document.getElementById(id);\n    if(style) removeElement(style);\n}\n\nfunction getFullTransformMatrix(element) {\n    var allElements = getElementAndAncestors(element);\n    // the identity matrix\n    var out = [\n        1, 0, 0, 0,\n        0, 1, 0, 0,\n        0, 0, 1, 0,\n        0, 0, 0, 1\n    ];\n    allElements.forEach(function(e) {\n        var t = getElementTransformMatrix(e);\n        if(t) {\n            var m = matrix.convertCssMatrix(t);\n            out = mat4X4.multiply(out, out, m);\n        }\n    });\n    return out;\n}\n\n/**\n * extracts and parses the 2d css style transform matrix from some element\n */\nfunction getElementTransformMatrix(element) {\n    var style = window.getComputedStyle(element, null);\n    var transform = (\n      style.getPropertyValue('-webkit-transform') ||\n      style.getPropertyValue('-moz-transform') ||\n      style.getPropertyValue('-ms-transform') ||\n      style.getPropertyValue('-o-transform') ||\n      style.getPropertyValue('transform')\n    );\n\n    if(transform === 'none') return null;\n    // the transform is a string in the form of matrix(a, b, ...) or matrix3d(...)\n    return transform\n        .replace('matrix', '')\n        .replace('3d', '')\n        .slice(1, -1)\n        .split(',')\n        .map(function(n) { return +n; });\n}\n/**\n * retrieve all DOM elements that are ancestors of the specified one (including itself)\n */\nfunction getElementAndAncestors(element) {\n    var allElements = [];\n    while(isTransformableElement(element)) {\n        allElements.push(element);\n        element = element.parentNode;\n    }\n    return allElements;\n}\n\nfunction isTransformableElement(element) {\n    return element && (element instanceof Element || element instanceof HTMLElement);\n}\n\nfunction equalDomRects(a, b) {\n    return (\n        a && b &&\n        a.top === b.top &&\n        a.left === b.left &&\n        a.right === b.right &&\n        a.bottom === b.bottom\n    );\n}\n\nmodule.exports = {\n    getGraphDiv: getGraphDiv,\n    isPlotDiv: isPlotDiv,\n    removeElement: removeElement,\n    addStyleRule: addStyleRule,\n    addRelatedStyleRule: addRelatedStyleRule,\n    deleteRelatedStyleRule: deleteRelatedStyleRule,\n    getFullTransformMatrix: getFullTransformMatrix,\n    getElementTransformMatrix: getElementTransformMatrix,\n    getElementAndAncestors: getElementAndAncestors,\n    equalDomRects: equalDomRects\n};\n","'use strict';\n\nvar isPlainObject = require('./is_plain_object.js');\nvar isArray = Array.isArray;\n\nfunction primitivesLoopSplice(source, target) {\n    var i, value;\n    for(i = 0; i < source.length; i++) {\n        value = source[i];\n        if(value !== null && typeof(value) === 'object') {\n            return false;\n        }\n        if(value !== void(0)) {\n            target[i] = value;\n        }\n    }\n    return true;\n}\n\nexports.extendFlat = function() {\n    return _extend(arguments, false, false, false);\n};\n\nexports.extendDeep = function() {\n    return _extend(arguments, true, false, false);\n};\n\nexports.extendDeepAll = function() {\n    return _extend(arguments, true, true, false);\n};\n\nexports.extendDeepNoArrays = function() {\n    return _extend(arguments, true, false, true);\n};\n\n/*\n * Inspired by https://github.com/justmoon/node-extend/blob/master/index.js\n * All credit to the jQuery authors for perfecting this amazing utility.\n *\n * API difference with jQuery version:\n * - No optional boolean (true -> deep extend) first argument,\n *   use `extendFlat` for first-level only extend and\n *   use `extendDeep` for a deep extend.\n *\n * Other differences with jQuery version:\n * - Uses a modern (and faster) isPlainObject routine.\n * - Expected to work with object {} and array [] arguments only.\n * - Does not check for circular structure.\n *   FYI: jQuery only does a check across one level.\n *   Warning: this might result in infinite loops.\n *\n */\nfunction _extend(inputs, isDeep, keepAllKeys, noArrayCopies) {\n    var target = inputs[0];\n    var length = inputs.length;\n\n    var input, key, src, copy, copyIsArray, clone, allPrimitives;\n\n    // TODO does this do the right thing for typed arrays?\n\n    if(length === 2 && isArray(target) && isArray(inputs[1]) && target.length === 0) {\n        allPrimitives = primitivesLoopSplice(inputs[1], target);\n\n        if(allPrimitives) {\n            return target;\n        } else {\n            target.splice(0, target.length); // reset target and continue to next block\n        }\n    }\n\n    for(var i = 1; i < length; i++) {\n        input = inputs[i];\n\n        for(key in input) {\n            src = target[key];\n            copy = input[key];\n\n            if(noArrayCopies && isArray(copy)) {\n                // Stop early and just transfer the array if array copies are disallowed:\n\n                target[key] = copy;\n            } else if(isDeep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n                // recurse if we're merging plain objects or arrays\n\n                if(copyIsArray) {\n                    copyIsArray = false;\n                    clone = src && isArray(src) ? src : [];\n                } else {\n                    clone = src && isPlainObject(src) ? src : {};\n                }\n\n                // never move original objects, clone them\n                target[key] = _extend([clone, copy], isDeep, keepAllKeys, noArrayCopies);\n            } else if(typeof copy !== 'undefined' || keepAllKeys) {\n                // don't bring in undefined values, except for extendDeepAll\n\n                target[key] = copy;\n            }\n        }\n    }\n\n    return target;\n}\n","'use strict';\n\nvar Registry = require('../registry');\n\n/**\n * localize: translate a string for the current locale\n *\n * @param {object} gd: the graphDiv for context\n *  gd._context.locale determines the language (& optional region/country)\n *  the dictionary for each locale may either be supplied in\n *  gd._context.locales or globally via Plotly.register\n * @param {string} s: the string to translate\n */\nmodule.exports = function localize(gd, s) {\n    var locale = gd._context.locale;\n\n    /*\n     * Priority of lookup:\n     *     contextDicts[locale],\n     *     registeredDicts[locale],\n     *     contextDicts[baseLocale], (if baseLocale is distinct)\n     *     registeredDicts[baseLocale]\n     * Return the first translation we find.\n     * This way if you have a regionalization you are allowed to specify\n     * only what's different from the base locale, everything else will\n     * fall back on the base.\n     */\n    for(var i = 0; i < 2; i++) {\n        var locales = gd._context.locales;\n        for(var j = 0; j < 2; j++) {\n            var dict = (locales[locale] || {}).dictionary;\n            if(dict) {\n                var out = dict[s];\n                if(out) return out;\n            }\n            locales = Registry.localeRegistry;\n        }\n\n        var baseLocale = locale.split('-')[0];\n        if(baseLocale === locale) break;\n        locale = baseLocale;\n    }\n\n    return s;\n};\n","'use strict';\n\nvar mat4X4 = require('gl-mat4');\n\nexports.init2dArray = function(rowLength, colLength) {\n    var array = new Array(rowLength);\n    for(var i = 0; i < rowLength; i++) array[i] = new Array(colLength);\n    return array;\n};\n\n/**\n * transpose a (possibly ragged) 2d array z. inspired by\n * http://stackoverflow.com/questions/17428587/\n * transposing-a-2d-array-in-javascript\n */\nexports.transposeRagged = function(z) {\n    var maxlen = 0;\n    var zlen = z.length;\n    var i, j;\n    // Maximum row length:\n    for(i = 0; i < zlen; i++) maxlen = Math.max(maxlen, z[i].length);\n\n    var t = new Array(maxlen);\n    for(i = 0; i < maxlen; i++) {\n        t[i] = new Array(zlen);\n        for(j = 0; j < zlen; j++) t[i][j] = z[j][i];\n    }\n\n    return t;\n};\n\n// our own dot function so that we don't need to include numeric\nexports.dot = function(x, y) {\n    if(!(x.length && y.length) || x.length !== y.length) return null;\n\n    var len = x.length;\n    var out;\n    var i;\n\n    if(x[0].length) {\n        // mat-vec or mat-mat\n        out = new Array(len);\n        for(i = 0; i < len; i++) out[i] = exports.dot(x[i], y);\n    } else if(y[0].length) {\n        // vec-mat\n        var yTranspose = exports.transposeRagged(y);\n        out = new Array(yTranspose.length);\n        for(i = 0; i < yTranspose.length; i++) out[i] = exports.dot(x, yTranspose[i]);\n    } else {\n        // vec-vec\n        out = 0;\n        for(i = 0; i < len; i++) out += x[i] * y[i];\n    }\n\n    return out;\n};\n\n// translate by (x,y)\nexports.translationMatrix = function(x, y) {\n    return [[1, 0, x], [0, 1, y], [0, 0, 1]];\n};\n\n// rotate by alpha around (0,0)\nexports.rotationMatrix = function(alpha) {\n    var a = alpha * Math.PI / 180;\n    return [[Math.cos(a), -Math.sin(a), 0],\n            [Math.sin(a), Math.cos(a), 0],\n            [0, 0, 1]];\n};\n\n// rotate by alpha around (x,y)\nexports.rotationXYMatrix = function(a, x, y) {\n    return exports.dot(\n        exports.dot(exports.translationMatrix(x, y),\n                    exports.rotationMatrix(a)),\n        exports.translationMatrix(-x, -y));\n};\n\n// applies a 3D transformation matrix to either x, y and z params\n// Note: z is optional\nexports.apply3DTransform = function(transform) {\n    return function() {\n        var args = arguments;\n        var xyz = arguments.length === 1 ? args[0] : [args[0], args[1], args[2] || 0];\n        return exports.dot(transform, [xyz[0], xyz[1], xyz[2], 1]).slice(0, 3);\n    };\n};\n\n// applies a 2D transformation matrix to either x and y params or an [x,y] array\nexports.apply2DTransform = function(transform) {\n    return function() {\n        var args = arguments;\n        if(args.length === 3) {\n            args = args[0];\n        } // from map\n        var xy = arguments.length === 1 ? args[0] : [args[0], args[1]];\n        return exports.dot(transform, [xy[0], xy[1], 1]).slice(0, 2);\n    };\n};\n\n// applies a 2D transformation matrix to an [x1,y1,x2,y2] array (to transform a segment)\nexports.apply2DTransform2 = function(transform) {\n    var at = exports.apply2DTransform(transform);\n    return function(xys) {\n        return at(xys.slice(0, 2)).concat(at(xys.slice(2, 4)));\n    };\n};\n\nexports.convertCssMatrix = function(m) {\n    if(m) {\n        var len = m.length;\n        if(len === 16) return m;\n        if(len === 6) {\n            // converts a 2x3 css transform matrix to a 4x4 matrix see https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix\n            return [\n                m[0], m[1], 0, 0,\n                m[2], m[3], 0, 0,\n                0, 0, 1, 0,\n                m[4], m[5], 0, 1\n            ];\n        }\n    }\n    return [\n        1, 0, 0, 0,\n        0, 1, 0, 0,\n        0, 0, 1, 0,\n        0, 0, 0, 1\n    ];\n};\n\n// find the inverse for a 4x4 affine transform matrix\nexports.inverseTransformMatrix = function(m) {\n    var out = [];\n    mat4X4.invert(out, m);\n    return [\n        [out[0], out[1], out[2], out[3]],\n        [out[4], out[5], out[6], out[7]],\n        [out[8], out[9], out[10], out[11]],\n        [out[12], out[13], out[14], out[15]]\n    ];\n};\n","'use strict';\n\n/**\n * Clear gl frame (if any). This is a common pattern as\n * we usually set `preserveDrawingBuffer: true` during\n * gl context creation (e.g. via `reglUtils.prepare`).\n *\n * @param {DOM node or object} gd : graph div object\n */\nmodule.exports = function clearGlCanvases(gd) {\n    var fullLayout = gd._fullLayout;\n\n    if(fullLayout._glcanvas && fullLayout._glcanvas.size()) {\n        fullLayout._glcanvas.each(function(d) {\n            if(d.regl) d.regl.clear({color: true, depth: true});\n        });\n    }\n};\n","'use strict';\n\n// Simple helper functions\n// none of these need any external deps\n\nmodule.exports = function identity(d) { return d; };\n","'use strict';\n\nvar timeFormat = require('d3-time-format').timeFormat;\nvar isNumeric = require('fast-isnumeric');\n\nvar Loggers = require('./loggers');\nvar mod = require('./mod').mod;\n\nvar constants = require('../constants/numerical');\nvar BADNUM = constants.BADNUM;\nvar ONEDAY = constants.ONEDAY;\nvar ONEHOUR = constants.ONEHOUR;\nvar ONEMIN = constants.ONEMIN;\nvar ONESEC = constants.ONESEC;\nvar EPOCHJD = constants.EPOCHJD;\n\nvar Registry = require('../registry');\n\nvar utcFormat = require('d3-time-format').utcFormat;\n\nvar DATETIME_REGEXP = /^\\s*(-?\\d\\d\\d\\d|\\d\\d)(-(\\d?\\d)(-(\\d?\\d)([ Tt]([01]?\\d|2[0-3])(:([0-5]\\d)(:([0-5]\\d(\\.\\d+)?))?(Z|z|[+\\-]\\d\\d(:?\\d\\d)?)?)?)?)?)?\\s*$/m;\n// special regex for chinese calendars to support yyyy-mmi-dd etc for intercalary months\nvar DATETIME_REGEXP_CN = /^\\s*(-?\\d\\d\\d\\d|\\d\\d)(-(\\d?\\di?)(-(\\d?\\d)([ Tt]([01]?\\d|2[0-3])(:([0-5]\\d)(:([0-5]\\d(\\.\\d+)?))?(Z|z|[+\\-]\\d\\d(:?\\d\\d)?)?)?)?)?)?\\s*$/m;\n\n// for 2-digit years, the first year we map them onto\nvar YFIRST = new Date().getFullYear() - 70;\n\nfunction isWorldCalendar(calendar) {\n    return (\n        calendar &&\n        Registry.componentsRegistry.calendars &&\n        typeof calendar === 'string' && calendar !== 'gregorian'\n    );\n}\n\n/*\n * dateTick0: get the canonical tick for this calendar\n *\n * integer weekdays : Saturday: 0, Sunday: 1, Monday: 2, etc.\n */\nexports.dateTick0 = function(calendar, dayOfWeek) {\n    var tick0 = _dateTick0(calendar, !!dayOfWeek);\n    if(dayOfWeek < 2) return tick0;\n\n    var v = exports.dateTime2ms(tick0, calendar);\n    v += ONEDAY * (dayOfWeek - 1); // shift Sunday to Monday, etc.\n    return exports.ms2DateTime(v, 0, calendar);\n};\n\n/*\n * _dateTick0: get the canonical tick for this calendar\n *\n * bool sunday is for week ticks, shift it to a Sunday.\n */\nfunction _dateTick0(calendar, sunday) {\n    if(isWorldCalendar(calendar)) {\n        return sunday ?\n            Registry.getComponentMethod('calendars', 'CANONICAL_SUNDAY')[calendar] :\n            Registry.getComponentMethod('calendars', 'CANONICAL_TICK')[calendar];\n    } else {\n        return sunday ? '2000-01-02' : '2000-01-01';\n    }\n}\n\n/*\n * dfltRange: for each calendar, give a valid default range\n */\nexports.dfltRange = function(calendar) {\n    if(isWorldCalendar(calendar)) {\n        return Registry.getComponentMethod('calendars', 'DFLTRANGE')[calendar];\n    } else {\n        return ['2000-01-01', '2001-01-01'];\n    }\n};\n\n// is an object a javascript date?\nexports.isJSDate = function(v) {\n    return typeof v === 'object' && v !== null && typeof v.getTime === 'function';\n};\n\n// The absolute limits of our date-time system\n// This is a little weird: we use MIN_MS and MAX_MS in dateTime2ms\n// but we use dateTime2ms to calculate them (after defining it!)\nvar MIN_MS, MAX_MS;\n\n/**\n * dateTime2ms - turn a date object or string s into milliseconds\n * (relative to 1970-01-01, per javascript standard)\n * optional calendar (string) to use a non-gregorian calendar\n *\n * Returns BADNUM if it doesn't find a date\n *\n * strings should have the form:\n *\n *    -?YYYY-mm-dd<sep>HH:MM:SS.sss<tzInfo>?\n *\n * <sep>: space (our normal standard) or T or t (ISO-8601)\n * <tzInfo>: Z, z, [+\\-]HH:?MM or [+\\-]HH and we THROW IT AWAY\n * this format comes from https://tools.ietf.org/html/rfc3339#section-5.6\n * and 4.2.5.1 Difference between local time and UTC of day (ISO-8601)\n * but we allow it even with a space as the separator\n *\n * May truncate after any full field, and sss can be any length\n * even >3 digits, though javascript dates truncate to milliseconds,\n * we keep as much as javascript numeric precision can hold, but we only\n * report back up to 100 microsecond precision, because most dates support\n * this precision (close to 1970 support more, very far away support less)\n *\n * Expanded to support negative years to -9999 but you must always\n * give 4 digits, except for 2-digit positive years which we assume are\n * near the present time.\n * Note that we follow ISO 8601:2004: there *is* a year 0, which\n * is 1BC/BCE, and -1===2BC etc.\n *\n * World calendars: not all of these *have* agreed extensions to this full range,\n * if you have another calendar system but want a date range outside its validity,\n * you can use a gregorian date string prefixed with 'G' or 'g'.\n *\n * Where to cut off 2-digit years between 1900s and 2000s?\n * from https://docs.microsoft.com/en-us/office/troubleshoot/excel/two-digit-year-numbers#the-2029-rule:\n *   1930-2029 (the most retro of all...)\n * but in my mac chrome from eg. d=new Date(Date.parse('8/19/50')):\n *   1950-2049\n * by Java, from http://stackoverflow.com/questions/2024273/:\n *   now-80 - now+19\n * or FileMaker Pro, from\n *      https://fmhelp.filemaker.com/help/18/fmp/en/index.html#page/FMP_Help/dates-with-two-digit-years.html:\n *   now-70 - now+29\n * but python strptime etc, via\n *      http://docs.python.org/py3k/library/time.html:\n *   1969-2068 (super forward-looking, but static, not sliding!)\n *\n * lets go with now-70 to now+29, and if anyone runs into this problem\n * they can learn the hard way not to use 2-digit years, as no choice we\n * make now will cover all possibilities. mostly this will all be taken\n * care of in initial parsing, should only be an issue for hand-entered data\n * currently (2016) this range is:\n *   1946-2045\n */\nexports.dateTime2ms = function(s, calendar) {\n    // first check if s is a date object\n    if(exports.isJSDate(s)) {\n        // Convert to the UTC milliseconds that give the same\n        // hours as this date has in the local timezone\n        var tzOffset = s.getTimezoneOffset() * ONEMIN;\n        var offsetTweak = (s.getUTCMinutes() - s.getMinutes()) * ONEMIN +\n            (s.getUTCSeconds() - s.getSeconds()) * ONESEC +\n            (s.getUTCMilliseconds() - s.getMilliseconds());\n\n        if(offsetTweak) {\n            var comb = 3 * ONEMIN;\n            tzOffset = tzOffset - comb / 2 + mod(offsetTweak - tzOffset + comb / 2, comb);\n        }\n        s = Number(s) - tzOffset;\n        if(s >= MIN_MS && s <= MAX_MS) return s;\n        return BADNUM;\n    }\n    // otherwise only accept strings and numbers\n    if(typeof s !== 'string' && typeof s !== 'number') return BADNUM;\n\n    s = String(s);\n\n    var isWorld = isWorldCalendar(calendar);\n\n    // to handle out-of-range dates in international calendars, accept\n    // 'G' as a prefix to force the built-in gregorian calendar.\n    var s0 = s.charAt(0);\n    if(isWorld && (s0 === 'G' || s0 === 'g')) {\n        s = s.substr(1);\n        calendar = '';\n    }\n\n    var isChinese = isWorld && calendar.substr(0, 7) === 'chinese';\n\n    var match = s.match(isChinese ? DATETIME_REGEXP_CN : DATETIME_REGEXP);\n    if(!match) return BADNUM;\n    var y = match[1];\n    var m = match[3] || '1';\n    var d = Number(match[5] || 1);\n    var H = Number(match[7] || 0);\n    var M = Number(match[9] || 0);\n    var S = Number(match[11] || 0);\n\n    if(isWorld) {\n        // disallow 2-digit years for world calendars\n        if(y.length === 2) return BADNUM;\n        y = Number(y);\n\n        var cDate;\n        try {\n            var calInstance = Registry.getComponentMethod('calendars', 'getCal')(calendar);\n            if(isChinese) {\n                var isIntercalary = m.charAt(m.length - 1) === 'i';\n                m = parseInt(m, 10);\n                cDate = calInstance.newDate(y, calInstance.toMonthIndex(y, m, isIntercalary), d);\n            } else {\n                cDate = calInstance.newDate(y, Number(m), d);\n            }\n        } catch(e) { return BADNUM; } // Invalid ... date\n\n        if(!cDate) return BADNUM;\n\n        return ((cDate.toJD() - EPOCHJD) * ONEDAY) +\n            (H * ONEHOUR) + (M * ONEMIN) + (S * ONESEC);\n    }\n\n    if(y.length === 2) {\n        y = (Number(y) + 2000 - YFIRST) % 100 + YFIRST;\n    } else y = Number(y);\n\n    // new Date uses months from 0; subtract 1 here just so we\n    // don't have to do it again during the validity test below\n    m -= 1;\n\n    // javascript takes new Date(0..99,m,d) to mean 1900-1999, so\n    // to support years 0-99 we need to use setFullYear explicitly\n    // Note that 2000 is a leap year.\n    var date = new Date(Date.UTC(2000, m, d, H, M));\n    date.setUTCFullYear(y);\n\n    if(date.getUTCMonth() !== m) return BADNUM;\n    if(date.getUTCDate() !== d) return BADNUM;\n\n    return date.getTime() + S * ONESEC;\n};\n\nMIN_MS = exports.MIN_MS = exports.dateTime2ms('-9999');\nMAX_MS = exports.MAX_MS = exports.dateTime2ms('9999-12-31 23:59:59.9999');\n\n// is string s a date? (see above)\nexports.isDateTime = function(s, calendar) {\n    return (exports.dateTime2ms(s, calendar) !== BADNUM);\n};\n\n// pad a number with zeroes, to given # of digits before the decimal point\nfunction lpad(val, digits) {\n    return String(val + Math.pow(10, digits)).substr(1);\n}\n\n/**\n * Turn ms into string of the form YYYY-mm-dd HH:MM:SS.ssss\n * Crop any trailing zeros in time, except never stop right after hours\n * (we could choose to crop '-01' from date too but for now we always\n * show the whole date)\n * Optional range r is the data range that applies, also in ms.\n * If rng is big, the later parts of time will be omitted\n */\nvar NINETYDAYS = 90 * ONEDAY;\nvar THREEHOURS = 3 * ONEHOUR;\nvar FIVEMIN = 5 * ONEMIN;\nexports.ms2DateTime = function(ms, r, calendar) {\n    if(typeof ms !== 'number' || !(ms >= MIN_MS && ms <= MAX_MS)) return BADNUM;\n\n    if(!r) r = 0;\n\n    var msecTenths = Math.floor(mod(ms + 0.05, 1) * 10);\n    var msRounded = Math.round(ms - msecTenths / 10);\n    var dateStr, h, m, s, msec10, d;\n\n    if(isWorldCalendar(calendar)) {\n        var dateJD = Math.floor(msRounded / ONEDAY) + EPOCHJD;\n        var timeMs = Math.floor(mod(ms, ONEDAY));\n        try {\n            dateStr = Registry.getComponentMethod('calendars', 'getCal')(calendar)\n                .fromJD(dateJD).formatDate('yyyy-mm-dd');\n        } catch(e) {\n            // invalid date in this calendar - fall back to Gyyyy-mm-dd\n            dateStr = utcFormat('G%Y-%m-%d')(new Date(msRounded));\n        }\n\n        // yyyy does NOT guarantee 4-digit years. YYYY mostly does, but does\n        // other things for a few calendars, so we can't trust it. Just pad\n        // it manually (after the '-' if there is one)\n        if(dateStr.charAt(0) === '-') {\n            while(dateStr.length < 11) dateStr = '-0' + dateStr.substr(1);\n        } else {\n            while(dateStr.length < 10) dateStr = '0' + dateStr;\n        }\n\n        // TODO: if this is faster, we could use this block for extracting\n        // the time components of regular gregorian too\n        h = (r < NINETYDAYS) ? Math.floor(timeMs / ONEHOUR) : 0;\n        m = (r < NINETYDAYS) ? Math.floor((timeMs % ONEHOUR) / ONEMIN) : 0;\n        s = (r < THREEHOURS) ? Math.floor((timeMs % ONEMIN) / ONESEC) : 0;\n        msec10 = (r < FIVEMIN) ? (timeMs % ONESEC) * 10 + msecTenths : 0;\n    } else {\n        d = new Date(msRounded);\n\n        dateStr = utcFormat('%Y-%m-%d')(d);\n\n        // <90 days: add hours and minutes - never *only* add hours\n        h = (r < NINETYDAYS) ? d.getUTCHours() : 0;\n        m = (r < NINETYDAYS) ? d.getUTCMinutes() : 0;\n        // <3 hours: add seconds\n        s = (r < THREEHOURS) ? d.getUTCSeconds() : 0;\n        // <5 minutes: add ms (plus one extra digit, this is msec*10)\n        msec10 = (r < FIVEMIN) ? d.getUTCMilliseconds() * 10 + msecTenths : 0;\n    }\n\n    return includeTime(dateStr, h, m, s, msec10);\n};\n\n// For converting old-style milliseconds to date strings,\n// we use the local timezone rather than UTC like we use\n// everywhere else, both for backward compatibility and\n// because that's how people mostly use javasript date objects.\n// Clip one extra day off our date range though so we can't get\n// thrown beyond the range by the timezone shift.\nexports.ms2DateTimeLocal = function(ms) {\n    if(!(ms >= MIN_MS + ONEDAY && ms <= MAX_MS - ONEDAY)) return BADNUM;\n\n    var msecTenths = Math.floor(mod(ms + 0.05, 1) * 10);\n    var d = new Date(Math.round(ms - msecTenths / 10));\n    var dateStr = timeFormat('%Y-%m-%d')(d);\n    var h = d.getHours();\n    var m = d.getMinutes();\n    var s = d.getSeconds();\n    var msec10 = d.getUTCMilliseconds() * 10 + msecTenths;\n\n    return includeTime(dateStr, h, m, s, msec10);\n};\n\nfunction includeTime(dateStr, h, m, s, msec10) {\n    // include each part that has nonzero data in or after it\n    if(h || m || s || msec10) {\n        dateStr += ' ' + lpad(h, 2) + ':' + lpad(m, 2);\n        if(s || msec10) {\n            dateStr += ':' + lpad(s, 2);\n            if(msec10) {\n                var digits = 4;\n                while(msec10 % 10 === 0) {\n                    digits -= 1;\n                    msec10 /= 10;\n                }\n                dateStr += '.' + lpad(msec10, digits);\n            }\n        }\n    }\n    return dateStr;\n}\n\n// normalize date format to date string, in case it starts as\n// a Date object or milliseconds\n// optional dflt is the return value if cleaning fails\nexports.cleanDate = function(v, dflt, calendar) {\n    // let us use cleanDate to provide a missing default without an error\n    if(v === BADNUM) return dflt;\n    if(exports.isJSDate(v) || (typeof v === 'number' && isFinite(v))) {\n        // do not allow milliseconds (old) or jsdate objects (inherently\n        // described as gregorian dates) with world calendars\n        if(isWorldCalendar(calendar)) {\n            Loggers.error('JS Dates and milliseconds are incompatible with world calendars', v);\n            return dflt;\n        }\n\n        // NOTE: if someone puts in a year as a number rather than a string,\n        // this will mistakenly convert it thinking it's milliseconds from 1970\n        // that is: '2012' -> Jan. 1, 2012, but 2012 -> 2012 epoch milliseconds\n        v = exports.ms2DateTimeLocal(+v);\n        if(!v && dflt !== undefined) return dflt;\n    } else if(!exports.isDateTime(v, calendar)) {\n        Loggers.error('unrecognized date', v);\n        return dflt;\n    }\n    return v;\n};\n\n/*\n *  Date formatting for ticks and hovertext\n */\n\n/*\n * modDateFormat: Support world calendars, and add two items to\n * d3's vocabulary:\n * %{n}f where n is the max number of digits of fractional seconds\n * %h formats: half of the year as a decimal number [1,2]\n */\nvar fracMatch = /%\\d?f/g;\nvar halfYearMatch = /%h/g;\nvar quarterToHalfYear = {\n    1: '1',\n    2: '1',\n    3: '2',\n    4: '2',\n};\nfunction modDateFormat(fmt, x, formatter, calendar) {\n    fmt = fmt.replace(fracMatch, function(match) {\n        var digits = Math.min(+(match.charAt(1)) || 6, 6);\n        var fracSecs = ((x / 1000 % 1) + 2)\n            .toFixed(digits)\n            .substr(2).replace(/0+$/, '') || '0';\n        return fracSecs;\n    });\n\n    var d = new Date(Math.floor(x + 0.05));\n\n    fmt = fmt.replace(halfYearMatch, function() {\n        return quarterToHalfYear[formatter('%q')(d)];\n    });\n\n    if(isWorldCalendar(calendar)) {\n        try {\n            fmt = Registry.getComponentMethod('calendars', 'worldCalFmt')(fmt, x, calendar);\n        } catch(e) {\n            return 'Invalid';\n        }\n    }\n    return formatter(fmt)(d);\n}\n\n/*\n * formatTime: create a time string from:\n *   x: milliseconds\n *   tr: tickround ('M', 'S', or # digits)\n * only supports UTC times (where every day is 24 hours and 0 is at midnight)\n */\nvar MAXSECONDS = [59, 59.9, 59.99, 59.999, 59.9999];\nfunction formatTime(x, tr) {\n    var timePart = mod(x + 0.05, ONEDAY);\n\n    var timeStr = lpad(Math.floor(timePart / ONEHOUR), 2) + ':' +\n        lpad(mod(Math.floor(timePart / ONEMIN), 60), 2);\n\n    if(tr !== 'M') {\n        if(!isNumeric(tr)) tr = 0; // should only be 'S'\n\n        /*\n         * this is a weird one - and shouldn't come up unless people\n         * monkey with tick0 in weird ways, but we need to do something!\n         * IN PARTICULAR we had better not display garbage (see below)\n         * for numbers we always round to the nearest increment of the\n         * precision we're showing, and this seems like the right way to\n         * handle seconds and milliseconds, as they have a decimal point\n         * and people will interpret that to mean rounding like numbers.\n         * but for larger increments we floor the value: it's always\n         * 2013 until the ball drops on the new year. We could argue about\n         * which field it is where we start rounding (should 12:08:59\n         * round to 12:09 if we're stopping at minutes?) but for now I'll\n         * say we round seconds but floor everything else. BUT that means\n         * we need to never round up to 60 seconds, ie 23:59:60\n         */\n        var sec = Math.min(mod(x / ONESEC, 60), MAXSECONDS[tr]);\n\n        var secStr = (100 + sec).toFixed(tr).substr(1);\n        if(tr > 0) {\n            secStr = secStr.replace(/0+$/, '').replace(/[\\.]$/, '');\n        }\n\n        timeStr += ':' + secStr;\n    }\n    return timeStr;\n}\n\n/*\n * formatDate: turn a date into tick or hover label text.\n *\n *   x: milliseconds, the value to convert\n *   fmt: optional, an explicit format string (d3 format, even for world calendars)\n *   tr: tickround ('y', 'm', 'd', 'M', 'S', or # digits)\n *      used if no explicit fmt is provided\n *   formatter: locale-aware d3 date formatter for standard gregorian calendars\n *      should be the result of exports.getD3DateFormat(gd)\n *   calendar: optional string, the world calendar system to use\n *\n * returns the date/time as a string, potentially with the leading portion\n * on a separate line (after '\\n')\n * Note that this means if you provide an explicit format which includes '\\n'\n * the axis may choose to strip things after it when they don't change from\n * one tick to the next (as it does with automatic formatting)\n */\nexports.formatDate = function(x, fmt, tr, formatter, calendar, extraFormat) {\n    calendar = isWorldCalendar(calendar) && calendar;\n\n    if(!fmt) {\n        if(tr === 'y') fmt = extraFormat.year;\n        else if(tr === 'm') fmt = extraFormat.month;\n        else if(tr === 'd') {\n            fmt = extraFormat.dayMonth + '\\n' + extraFormat.year;\n        } else {\n            return formatTime(x, tr) + '\\n' + modDateFormat(extraFormat.dayMonthYear, x, formatter, calendar);\n        }\n    }\n\n    return modDateFormat(fmt, x, formatter, calendar);\n};\n\n/*\n * incrementMonth: make a new milliseconds value from the given one,\n * having changed the month\n *\n * special case for world calendars: multiples of 12 are treated as years,\n * even for calendar systems that don't have (always or ever) 12 months/year\n * TODO: perhaps we need a different code for year increments to support this?\n *\n * ms (number): the initial millisecond value\n * dMonth (int): the (signed) number of months to shift\n * calendar (string): the calendar system to use\n *\n * changing month does not (and CANNOT) always preserve day, since\n * months have different lengths. The worst example of this is:\n *   d = new Date(1970,0,31); d.setMonth(1) -> Feb 31 turns into Mar 3\n *\n * But we want to be able to iterate over the last day of each month,\n * regardless of what its number is.\n * So shift 3 days forward, THEN set the new month, then unshift:\n *   1/31 -> 2/28 (or 29) -> 3/31 -> 4/30 -> ...\n *\n * Note that odd behavior still exists if you start from the 26th-28th:\n *   1/28 -> 2/28 -> 3/31\n * but at least you can't shift any dates into the wrong month,\n * and ticks on these days incrementing by month would be very unusual\n */\nvar THREEDAYS = 3 * ONEDAY;\nexports.incrementMonth = function(ms, dMonth, calendar) {\n    calendar = isWorldCalendar(calendar) && calendar;\n\n    // pull time out and operate on pure dates, then add time back at the end\n    // this gives maximum precision - not that we *normally* care if we're\n    // incrementing by month, but better to be safe!\n    var timeMs = mod(ms, ONEDAY);\n    ms = Math.round(ms - timeMs);\n\n    if(calendar) {\n        try {\n            var dateJD = Math.round(ms / ONEDAY) + EPOCHJD;\n            var calInstance = Registry.getComponentMethod('calendars', 'getCal')(calendar);\n            var cDate = calInstance.fromJD(dateJD);\n\n            if(dMonth % 12) calInstance.add(cDate, dMonth, 'm');\n            else calInstance.add(cDate, dMonth / 12, 'y');\n\n            return (cDate.toJD() - EPOCHJD) * ONEDAY + timeMs;\n        } catch(e) {\n            Loggers.error('invalid ms ' + ms + ' in calendar ' + calendar);\n            // then keep going in gregorian even though the result will be 'Invalid'\n        }\n    }\n\n    var y = new Date(ms + THREEDAYS);\n    return y.setUTCMonth(y.getUTCMonth() + dMonth) + timeMs - THREEDAYS;\n};\n\n/*\n * findExactDates: what fraction of data is exact days, months, or years?\n *\n * data: array of millisecond values\n * calendar (string) the calendar to test against\n */\nexports.findExactDates = function(data, calendar) {\n    var exactYears = 0;\n    var exactMonths = 0;\n    var exactDays = 0;\n    var blankCount = 0;\n    var d;\n    var di;\n\n    var calInstance = (\n        isWorldCalendar(calendar) &&\n        Registry.getComponentMethod('calendars', 'getCal')(calendar)\n    );\n\n    for(var i = 0; i < data.length; i++) {\n        di = data[i];\n\n        // not date data at all\n        if(!isNumeric(di)) {\n            blankCount ++;\n            continue;\n        }\n\n        // not an exact date\n        if(di % ONEDAY) continue;\n\n        if(calInstance) {\n            try {\n                d = calInstance.fromJD(di / ONEDAY + EPOCHJD);\n                if(d.day() === 1) {\n                    if(d.month() === 1) exactYears++;\n                    else exactMonths++;\n                } else exactDays++;\n            } catch(e) {\n                // invalid date in this calendar - ignore it here.\n            }\n        } else {\n            d = new Date(di);\n            if(d.getUTCDate() === 1) {\n                if(d.getUTCMonth() === 0) exactYears++;\n                else exactMonths++;\n            } else exactDays++;\n        }\n    }\n    exactMonths += exactYears;\n    exactDays += exactMonths;\n\n    var dataCount = data.length - blankCount;\n\n    return {\n        exactYears: exactYears / dataCount,\n        exactMonths: exactMonths / dataCount,\n        exactDays: exactDays / dataCount\n    };\n};\n","'use strict';\n\nvar d3 = require('@plotly/d3');\nvar utcFormat = require('d3-time-format').utcFormat;\nvar d3Format = require('d3-format').format;\nvar isNumeric = require('fast-isnumeric');\n\nvar numConstants = require('../constants/numerical');\nvar MAX_SAFE = numConstants.FP_SAFE;\nvar MIN_SAFE = -MAX_SAFE;\nvar BADNUM = numConstants.BADNUM;\n\nvar lib = module.exports = {};\n\nlib.adjustFormat = function adjustFormat(formatStr) {\n    if(\n        !formatStr ||\n        /^\\d[.]\\df/.test(formatStr) ||\n        /[.]\\d%/.test(formatStr)\n    ) return formatStr;\n\n    if(formatStr === '0.f') return '~f';\n    if(/^\\d%/.test(formatStr)) return '~%';\n    if(/^\\ds/.test(formatStr)) return '~s';\n\n    // try adding tilde to the start of format in order to trim\n    if(!(/^[~,.0$]/.test(formatStr)) && /[&fps]/.test(formatStr)) return '~' + formatStr;\n\n    return formatStr;\n};\n\nvar seenBadFormats = {};\nlib.warnBadFormat = function(f) {\n    var key = String(f);\n    if(!seenBadFormats[key]) {\n        seenBadFormats[key] = 1;\n        lib.warn('encountered bad format: \"' + key + '\"');\n    }\n};\n\nlib.noFormat = function(value) {\n    return String(value);\n};\n\nlib.numberFormat = function(formatStr) {\n    var fn;\n    try {\n        fn = d3Format(lib.adjustFormat(formatStr));\n    } catch(e) {\n        lib.warnBadFormat(formatStr);\n        return lib.noFormat;\n    }\n\n    return fn;\n};\n\nlib.nestedProperty = require('./nested_property');\nlib.keyedContainer = require('./keyed_container');\nlib.relativeAttr = require('./relative_attr');\nlib.isPlainObject = require('./is_plain_object');\nlib.toLogRange = require('./to_log_range');\nlib.relinkPrivateKeys = require('./relink_private');\n\nvar arrayModule = require('./array');\nlib.isArrayBuffer = arrayModule.isArrayBuffer;\nlib.isTypedArray = arrayModule.isTypedArray;\nlib.isArrayOrTypedArray = arrayModule.isArrayOrTypedArray;\nlib.isArray1D = arrayModule.isArray1D;\nlib.ensureArray = arrayModule.ensureArray;\nlib.concat = arrayModule.concat;\nlib.maxRowLength = arrayModule.maxRowLength;\nlib.minRowLength = arrayModule.minRowLength;\n\nvar modModule = require('./mod');\nlib.mod = modModule.mod;\nlib.modHalf = modModule.modHalf;\n\nvar coerceModule = require('./coerce');\nlib.valObjectMeta = coerceModule.valObjectMeta;\nlib.coerce = coerceModule.coerce;\nlib.coerce2 = coerceModule.coerce2;\nlib.coerceFont = coerceModule.coerceFont;\nlib.coercePattern = coerceModule.coercePattern;\nlib.coerceHoverinfo = coerceModule.coerceHoverinfo;\nlib.coerceSelectionMarkerOpacity = coerceModule.coerceSelectionMarkerOpacity;\nlib.validate = coerceModule.validate;\n\nvar datesModule = require('./dates');\nlib.dateTime2ms = datesModule.dateTime2ms;\nlib.isDateTime = datesModule.isDateTime;\nlib.ms2DateTime = datesModule.ms2DateTime;\nlib.ms2DateTimeLocal = datesModule.ms2DateTimeLocal;\nlib.cleanDate = datesModule.cleanDate;\nlib.isJSDate = datesModule.isJSDate;\nlib.formatDate = datesModule.formatDate;\nlib.incrementMonth = datesModule.incrementMonth;\nlib.dateTick0 = datesModule.dateTick0;\nlib.dfltRange = datesModule.dfltRange;\nlib.findExactDates = datesModule.findExactDates;\nlib.MIN_MS = datesModule.MIN_MS;\nlib.MAX_MS = datesModule.MAX_MS;\n\nvar searchModule = require('./search');\nlib.findBin = searchModule.findBin;\nlib.sorterAsc = searchModule.sorterAsc;\nlib.sorterDes = searchModule.sorterDes;\nlib.distinctVals = searchModule.distinctVals;\nlib.roundUp = searchModule.roundUp;\nlib.sort = searchModule.sort;\nlib.findIndexOfMin = searchModule.findIndexOfMin;\n\nlib.sortObjectKeys = require('./sort_object_keys');\n\nvar statsModule = require('./stats');\nlib.aggNums = statsModule.aggNums;\nlib.len = statsModule.len;\nlib.mean = statsModule.mean;\nlib.median = statsModule.median;\nlib.midRange = statsModule.midRange;\nlib.variance = statsModule.variance;\nlib.stdev = statsModule.stdev;\nlib.interp = statsModule.interp;\n\nvar matrixModule = require('./matrix');\nlib.init2dArray = matrixModule.init2dArray;\nlib.transposeRagged = matrixModule.transposeRagged;\nlib.dot = matrixModule.dot;\nlib.translationMatrix = matrixModule.translationMatrix;\nlib.rotationMatrix = matrixModule.rotationMatrix;\nlib.rotationXYMatrix = matrixModule.rotationXYMatrix;\nlib.apply3DTransform = matrixModule.apply3DTransform;\nlib.apply2DTransform = matrixModule.apply2DTransform;\nlib.apply2DTransform2 = matrixModule.apply2DTransform2;\nlib.convertCssMatrix = matrixModule.convertCssMatrix;\nlib.inverseTransformMatrix = matrixModule.inverseTransformMatrix;\n\nvar anglesModule = require('./angles');\nlib.deg2rad = anglesModule.deg2rad;\nlib.rad2deg = anglesModule.rad2deg;\nlib.angleDelta = anglesModule.angleDelta;\nlib.angleDist = anglesModule.angleDist;\nlib.isFullCircle = anglesModule.isFullCircle;\nlib.isAngleInsideSector = anglesModule.isAngleInsideSector;\nlib.isPtInsideSector = anglesModule.isPtInsideSector;\nlib.pathArc = anglesModule.pathArc;\nlib.pathSector = anglesModule.pathSector;\nlib.pathAnnulus = anglesModule.pathAnnulus;\n\nvar anchorUtils = require('./anchor_utils');\nlib.isLeftAnchor = anchorUtils.isLeftAnchor;\nlib.isCenterAnchor = anchorUtils.isCenterAnchor;\nlib.isRightAnchor = anchorUtils.isRightAnchor;\nlib.isTopAnchor = anchorUtils.isTopAnchor;\nlib.isMiddleAnchor = anchorUtils.isMiddleAnchor;\nlib.isBottomAnchor = anchorUtils.isBottomAnchor;\n\nvar geom2dModule = require('./geometry2d');\nlib.segmentsIntersect = geom2dModule.segmentsIntersect;\nlib.segmentDistance = geom2dModule.segmentDistance;\nlib.getTextLocation = geom2dModule.getTextLocation;\nlib.clearLocationCache = geom2dModule.clearLocationCache;\nlib.getVisibleSegment = geom2dModule.getVisibleSegment;\nlib.findPointOnPath = geom2dModule.findPointOnPath;\n\nvar extendModule = require('./extend');\nlib.extendFlat = extendModule.extendFlat;\nlib.extendDeep = extendModule.extendDeep;\nlib.extendDeepAll = extendModule.extendDeepAll;\nlib.extendDeepNoArrays = extendModule.extendDeepNoArrays;\n\nvar loggersModule = require('./loggers');\nlib.log = loggersModule.log;\nlib.warn = loggersModule.warn;\nlib.error = loggersModule.error;\n\nvar regexModule = require('./regex');\nlib.counterRegex = regexModule.counter;\n\nvar throttleModule = require('./throttle');\nlib.throttle = throttleModule.throttle;\nlib.throttleDone = throttleModule.done;\nlib.clearThrottle = throttleModule.clear;\n\nvar domModule = require('./dom');\nlib.getGraphDiv = domModule.getGraphDiv;\nlib.isPlotDiv = domModule.isPlotDiv;\nlib.removeElement = domModule.removeElement;\nlib.addStyleRule = domModule.addStyleRule;\nlib.addRelatedStyleRule = domModule.addRelatedStyleRule;\nlib.deleteRelatedStyleRule = domModule.deleteRelatedStyleRule;\nlib.getFullTransformMatrix = domModule.getFullTransformMatrix;\nlib.getElementTransformMatrix = domModule.getElementTransformMatrix;\nlib.getElementAndAncestors = domModule.getElementAndAncestors;\nlib.equalDomRects = domModule.equalDomRects;\n\nlib.clearResponsive = require('./clear_responsive');\nlib.preserveDrawingBuffer = require('./preserve_drawing_buffer');\n\nlib.makeTraceGroups = require('./make_trace_groups');\n\nlib._ = require('./localize');\n\nlib.notifier = require('./notifier');\n\nlib.filterUnique = require('./filter_unique');\nlib.filterVisible = require('./filter_visible');\nlib.pushUnique = require('./push_unique');\n\nlib.increment = require('./increment');\n\nlib.cleanNumber = require('./clean_number');\n\nlib.ensureNumber = function ensureNumber(v) {\n    if(!isNumeric(v)) return BADNUM;\n    v = Number(v);\n    return (v > MAX_SAFE || v < MIN_SAFE) ? BADNUM : v;\n};\n\n/**\n * Is v a valid array index? Accepts numeric strings as well as numbers.\n *\n * @param {any} v: the value to test\n * @param {Optional[integer]} len: the array length we are indexing\n *\n * @return {bool}: v is a valid array index\n */\nlib.isIndex = function(v, len) {\n    if(len !== undefined && v >= len) return false;\n    return isNumeric(v) && (v >= 0) && (v % 1 === 0);\n};\n\nlib.noop = require('./noop');\nlib.identity = require('./identity');\n\n/**\n * create an array of length 'cnt' filled with 'v' at all indices\n *\n * @param {any} v\n * @param {number} cnt\n * @return {array}\n */\nlib.repeat = function(v, cnt) {\n    var out = new Array(cnt);\n    for(var i = 0; i < cnt; i++) {\n        out[i] = v;\n    }\n    return out;\n};\n\n/**\n * swap x and y of the same attribute in container cont\n * specify attr with a ? in place of x/y\n * you can also swap other things than x/y by providing part1 and part2\n */\nlib.swapAttrs = function(cont, attrList, part1, part2) {\n    if(!part1) part1 = 'x';\n    if(!part2) part2 = 'y';\n    for(var i = 0; i < attrList.length; i++) {\n        var attr = attrList[i];\n        var xp = lib.nestedProperty(cont, attr.replace('?', part1));\n        var yp = lib.nestedProperty(cont, attr.replace('?', part2));\n        var temp = xp.get();\n        xp.set(yp.get());\n        yp.set(temp);\n    }\n};\n\n/**\n * SVG painter's algo worked around with reinsertion\n */\nlib.raiseToTop = function raiseToTop(elem) {\n    elem.parentNode.appendChild(elem);\n};\n\n/**\n * cancel a possibly pending transition; returned selection may be used by caller\n */\nlib.cancelTransition = function(selection) {\n    return selection.transition().duration(0);\n};\n\n// constrain - restrict a number v to be between v0 and v1\nlib.constrain = function(v, v0, v1) {\n    if(v0 > v1) return Math.max(v1, Math.min(v0, v));\n    return Math.max(v0, Math.min(v1, v));\n};\n\n/**\n * do two bounding boxes from getBoundingClientRect,\n * ie {left,right,top,bottom,width,height}, overlap?\n * takes optional padding pixels\n */\nlib.bBoxIntersect = function(a, b, pad) {\n    pad = pad || 0;\n    return (a.left <= b.right + pad &&\n            b.left <= a.right + pad &&\n            a.top <= b.bottom + pad &&\n            b.top <= a.bottom + pad);\n};\n\n/*\n * simpleMap: alternative to Array.map that only\n * passes on the element and up to 2 extra args you\n * provide (but not the array index or the whole array)\n *\n * array: the array to map it to\n * func: the function to apply\n * x1, x2: optional extra args\n */\nlib.simpleMap = function(array, func, x1, x2, opts) {\n    var len = array.length;\n    var out = new Array(len);\n    for(var i = 0; i < len; i++) out[i] = func(array[i], x1, x2, opts);\n    return out;\n};\n\n/**\n * Random string generator\n *\n * @param {object} existing\n *     pass in strings to avoid as keys with truthy values\n * @param {int} bits\n *     bits of information in the output string, default 24\n * @param {int} base\n *     base of string representation, default 16. Should be a power of 2.\n */\nlib.randstr = function randstr(existing, bits, base, _recursion) {\n    if(!base) base = 16;\n    if(bits === undefined) bits = 24;\n    if(bits <= 0) return '0';\n\n    var digits = Math.log(Math.pow(2, bits)) / Math.log(base);\n    var res = '';\n    var i, b, x;\n\n    for(i = 2; digits === Infinity; i *= 2) {\n        digits = Math.log(Math.pow(2, bits / i)) / Math.log(base) * i;\n    }\n\n    var rem = digits - Math.floor(digits);\n\n    for(i = 0; i < Math.floor(digits); i++) {\n        x = Math.floor(Math.random() * base).toString(base);\n        res = x + res;\n    }\n\n    if(rem) {\n        b = Math.pow(base, rem);\n        x = Math.floor(Math.random() * b).toString(base);\n        res = x + res;\n    }\n\n    var parsed = parseInt(res, base);\n    if((existing && existing[res]) ||\n         (parsed !== Infinity && parsed >= Math.pow(2, bits))) {\n        if(_recursion > 10) {\n            lib.warn('randstr failed uniqueness');\n            return res;\n        }\n        return randstr(existing, bits, base, (_recursion || 0) + 1);\n    } else return res;\n};\n\nlib.OptionControl = function(opt, optname) {\n    /*\n     * An environment to contain all option setters and\n     * getters that collectively modify opts.\n     *\n     * You can call up opts from any function in new object\n     * as this.optname || this.opt\n     *\n     * See FitOpts for example of usage\n     */\n    if(!opt) opt = {};\n    if(!optname) optname = 'opt';\n\n    var self = {};\n    self.optionList = [];\n\n    self._newoption = function(optObj) {\n        optObj[optname] = opt;\n        self[optObj.name] = optObj;\n        self.optionList.push(optObj);\n    };\n\n    self['_' + optname] = opt;\n    return self;\n};\n\n/**\n * lib.smooth: smooth arrayIn by convolving with\n * a hann window with given full width at half max\n * bounce the ends in, so the output has the same length as the input\n */\nlib.smooth = function(arrayIn, FWHM) {\n    FWHM = Math.round(FWHM) || 0; // only makes sense for integers\n    if(FWHM < 2) return arrayIn;\n\n    var alen = arrayIn.length;\n    var alen2 = 2 * alen;\n    var wlen = 2 * FWHM - 1;\n    var w = new Array(wlen);\n    var arrayOut = new Array(alen);\n    var i;\n    var j;\n    var k;\n    var v;\n\n    // first make the window array\n    for(i = 0; i < wlen; i++) {\n        w[i] = (1 - Math.cos(Math.PI * (i + 1) / FWHM)) / (2 * FWHM);\n    }\n\n    // now do the convolution\n    for(i = 0; i < alen; i++) {\n        v = 0;\n        for(j = 0; j < wlen; j++) {\n            k = i + j + 1 - FWHM;\n\n            // multibounce\n            if(k < -alen) k -= alen2 * Math.round(k / alen2);\n            else if(k >= alen2) k -= alen2 * Math.floor(k / alen2);\n\n            // single bounce\n            if(k < 0) k = - 1 - k;\n            else if(k >= alen) k = alen2 - 1 - k;\n\n            v += arrayIn[k] * w[j];\n        }\n        arrayOut[i] = v;\n    }\n\n    return arrayOut;\n};\n\n/**\n * syncOrAsync: run a sequence of functions synchronously\n * as long as its returns are not promises (ie have no .then)\n * includes one argument arg to send to all functions...\n * this is mainly just to prevent us having to make wrapper functions\n * when the only purpose of the wrapper is to reference gd\n * and a final step to be executed at the end\n * TODO: if there's an error and everything is sync,\n * this doesn't happen yet because we want to make sure\n * that it gets reported\n */\nlib.syncOrAsync = function(sequence, arg, finalStep) {\n    var ret, fni;\n\n    function continueAsync() {\n        return lib.syncOrAsync(sequence, arg, finalStep);\n    }\n\n    while(sequence.length) {\n        fni = sequence.splice(0, 1)[0];\n        ret = fni(arg);\n\n        if(ret && ret.then) {\n            return ret.then(continueAsync);\n        }\n    }\n\n    return finalStep && finalStep(arg);\n};\n\n\n/**\n * Helper to strip trailing slash, from\n * http://stackoverflow.com/questions/6680825/return-string-without-trailing-slash\n */\nlib.stripTrailingSlash = function(str) {\n    if(str.substr(-1) === '/') return str.substr(0, str.length - 1);\n    return str;\n};\n\nlib.noneOrAll = function(containerIn, containerOut, attrList) {\n    /**\n     * some attributes come together, so if you have one of them\n     * in the input, you should copy the default values of the others\n     * to the input as well.\n     */\n    if(!containerIn) return;\n\n    var hasAny = false;\n    var hasAll = true;\n    var i;\n    var val;\n\n    for(i = 0; i < attrList.length; i++) {\n        val = containerIn[attrList[i]];\n        if(val !== undefined && val !== null) hasAny = true;\n        else hasAll = false;\n    }\n\n    if(hasAny && !hasAll) {\n        for(i = 0; i < attrList.length; i++) {\n            containerIn[attrList[i]] = containerOut[attrList[i]];\n        }\n    }\n};\n\n/** merges calcdata field (given by cdAttr) with traceAttr values\n *\n * N.B. Loop over minimum of cd.length and traceAttr.length\n * i.e. it does not try to fill in beyond traceAttr.length-1\n *\n * @param {array} traceAttr : trace attribute\n * @param {object} cd : calcdata trace\n * @param {string} cdAttr : calcdata key\n */\nlib.mergeArray = function(traceAttr, cd, cdAttr, fn) {\n    var hasFn = typeof fn === 'function';\n    if(lib.isArrayOrTypedArray(traceAttr)) {\n        var imax = Math.min(traceAttr.length, cd.length);\n        for(var i = 0; i < imax; i++) {\n            var v = traceAttr[i];\n            cd[i][cdAttr] = hasFn ? fn(v) : v;\n        }\n    }\n};\n\n// cast numbers to positive numbers, returns 0 if not greater than 0\nlib.mergeArrayCastPositive = function(traceAttr, cd, cdAttr) {\n    return lib.mergeArray(traceAttr, cd, cdAttr, function(v) {\n        var w = +v;\n        return !isFinite(w) ? 0 : w > 0 ? w : 0;\n    });\n};\n\n/** fills calcdata field (given by cdAttr) with traceAttr values\n *  or function of traceAttr values (e.g. some fallback)\n *\n * N.B. Loops over all cd items.\n *\n * @param {array} traceAttr : trace attribute\n * @param {object} cd : calcdata trace\n * @param {string} cdAttr : calcdata key\n * @param {function} [fn] : optional function to apply to each array item\n */\nlib.fillArray = function(traceAttr, cd, cdAttr, fn) {\n    fn = fn || lib.identity;\n\n    if(lib.isArrayOrTypedArray(traceAttr)) {\n        for(var i = 0; i < cd.length; i++) {\n            cd[i][cdAttr] = fn(traceAttr[i]);\n        }\n    }\n};\n\n/** Handler for trace-wide vs per-point options\n *\n * @param {object} trace : (full) trace object\n * @param {number} ptNumber : index of the point in question\n * @param {string} astr : attribute string\n * @param {function} [fn] : optional function to apply to each array item\n *\n * @return {any}\n */\nlib.castOption = function(trace, ptNumber, astr, fn) {\n    fn = fn || lib.identity;\n\n    var val = lib.nestedProperty(trace, astr).get();\n\n    if(lib.isArrayOrTypedArray(val)) {\n        if(Array.isArray(ptNumber) && lib.isArrayOrTypedArray(val[ptNumber[0]])) {\n            return fn(val[ptNumber[0]][ptNumber[1]]);\n        } else {\n            return fn(val[ptNumber]);\n        }\n    } else {\n        return val;\n    }\n};\n\n/** Extract option from calcdata item, correctly falling back to\n *  trace value if not found.\n *\n *  @param {object} calcPt : calcdata[i][j] item\n *  @param {object} trace : (full) trace object\n *  @param {string} calcKey : calcdata key\n *  @param {string} traceKey : aka trace attribute string\n *  @return {any}\n */\nlib.extractOption = function(calcPt, trace, calcKey, traceKey) {\n    if(calcKey in calcPt) return calcPt[calcKey];\n\n    // fallback to trace value,\n    //   must check if value isn't itself an array\n    //   which means the trace attribute has a corresponding\n    //   calcdata key, but its value is falsy\n    var traceVal = lib.nestedProperty(trace, traceKey).get();\n    if(!Array.isArray(traceVal)) return traceVal;\n};\n\nfunction makePtIndex2PtNumber(indexToPoints) {\n    var ptIndex2ptNumber = {};\n    for(var k in indexToPoints) {\n        var pts = indexToPoints[k];\n        for(var j = 0; j < pts.length; j++) {\n            ptIndex2ptNumber[pts[j]] = +k;\n        }\n    }\n    return ptIndex2ptNumber;\n}\n\n/** Tag selected calcdata items\n *\n * N.B. note that point 'index' corresponds to input data array index\n *  whereas 'number' is its post-transform version.\n *\n * @param {array} calcTrace\n * @param {object} trace\n *  - selectedpoints {array}\n *  - _indexToPoints {object}\n * @param {ptNumber2cdIndex} ptNumber2cdIndex (optional)\n *  optional map object for trace types that do not have 1-to-1 point number to\n *  calcdata item index correspondence (e.g. histogram)\n */\nlib.tagSelected = function(calcTrace, trace, ptNumber2cdIndex) {\n    var selectedpoints = trace.selectedpoints;\n    var indexToPoints = trace._indexToPoints;\n    var ptIndex2ptNumber;\n\n    // make pt index-to-number map object, which takes care of transformed traces\n    if(indexToPoints) {\n        ptIndex2ptNumber = makePtIndex2PtNumber(indexToPoints);\n    }\n\n    function isCdIndexValid(v) {\n        return v !== undefined && v < calcTrace.length;\n    }\n\n    for(var i = 0; i < selectedpoints.length; i++) {\n        var ptIndex = selectedpoints[i];\n\n        if(lib.isIndex(ptIndex) ||\n           (lib.isArrayOrTypedArray(ptIndex) && lib.isIndex(ptIndex[0]) && lib.isIndex(ptIndex[1]))\n        ) {\n            var ptNumber = ptIndex2ptNumber ? ptIndex2ptNumber[ptIndex] : ptIndex;\n            var cdIndex = ptNumber2cdIndex ? ptNumber2cdIndex[ptNumber] : ptNumber;\n\n            if(isCdIndexValid(cdIndex)) {\n                calcTrace[cdIndex].selected = 1;\n            }\n        }\n    }\n};\n\nlib.selIndices2selPoints = function(trace) {\n    var selectedpoints = trace.selectedpoints;\n    var indexToPoints = trace._indexToPoints;\n\n    if(indexToPoints) {\n        var ptIndex2ptNumber = makePtIndex2PtNumber(indexToPoints);\n        var out = [];\n\n        for(var i = 0; i < selectedpoints.length; i++) {\n            var ptIndex = selectedpoints[i];\n            if(lib.isIndex(ptIndex)) {\n                var ptNumber = ptIndex2ptNumber[ptIndex];\n                if(lib.isIndex(ptNumber)) {\n                    out.push(ptNumber);\n                }\n            }\n        }\n\n        return out;\n    } else {\n        return selectedpoints;\n    }\n};\n\n/** Returns target as set by 'target' transform attribute\n *\n * @param {object} trace : full trace object\n * @param {object} transformOpts : transform option object\n *  - target (string} :\n *      either an attribute string referencing an array in the trace object, or\n *      a set array.\n *\n * @return {array or false} : the target array (NOT a copy!!) or false if invalid\n */\nlib.getTargetArray = function(trace, transformOpts) {\n    var target = transformOpts.target;\n\n    if(typeof target === 'string' && target) {\n        var array = lib.nestedProperty(trace, target).get();\n        return lib.isArrayOrTypedArray(array) ? array : false;\n    } else if(lib.isArrayOrTypedArray(target)) {\n        return target;\n    }\n\n    return false;\n};\n\n/**\n * modified version of jQuery's extend to strip out private objs and functions,\n * and cut arrays down to first <arraylen> or 1 elements\n * because extend-like algorithms are hella slow\n * obj2 is assumed to already be clean of these things (including no arrays)\n */\nfunction minExtend(obj1, obj2, opt) {\n    var objOut = {};\n    if(typeof obj2 !== 'object') obj2 = {};\n\n    var arrayLen = opt === 'pieLike' ? -1 : 3;\n\n    var keys = Object.keys(obj1);\n    var i, k, v;\n\n    for(i = 0; i < keys.length; i++) {\n        k = keys[i];\n        v = obj1[k];\n        if(k.charAt(0) === '_' || typeof v === 'function') continue;\n        else if(k === 'module') objOut[k] = v;\n        else if(Array.isArray(v)) {\n            if(k === 'colorscale' || arrayLen === -1) {\n                objOut[k] = v.slice();\n            } else {\n                objOut[k] = v.slice(0, arrayLen);\n            }\n        } else if(lib.isTypedArray(v)) {\n            if(arrayLen === -1) {\n                objOut[k] = v.subarray();\n            } else {\n                objOut[k] = v.subarray(0, arrayLen);\n            }\n        } else if(v && (typeof v === 'object')) objOut[k] = minExtend(obj1[k], obj2[k], opt);\n        else objOut[k] = v;\n    }\n\n    keys = Object.keys(obj2);\n    for(i = 0; i < keys.length; i++) {\n        k = keys[i];\n        v = obj2[k];\n        if(typeof v !== 'object' || !(k in objOut) || typeof objOut[k] !== 'object') {\n            objOut[k] = v;\n        }\n    }\n\n    return objOut;\n}\nlib.minExtend = minExtend;\n\nlib.titleCase = function(s) {\n    return s.charAt(0).toUpperCase() + s.substr(1);\n};\n\nlib.containsAny = function(s, fragments) {\n    for(var i = 0; i < fragments.length; i++) {\n        if(s.indexOf(fragments[i]) !== -1) return true;\n    }\n    return false;\n};\n\nlib.isIE = function() {\n    return typeof window.navigator.msSaveBlob !== 'undefined';\n};\n\nvar IS_SAFARI_REGEX = /Version\\/[\\d\\.]+.*Safari/;\nlib.isSafari = function() {\n    return IS_SAFARI_REGEX.test(window.navigator.userAgent);\n};\n\nvar IS_IOS_REGEX = /iPad|iPhone|iPod/;\nlib.isIOS = function() {\n    return IS_IOS_REGEX.test(window.navigator.userAgent);\n};\n\nvar FIREFOX_VERSION_REGEX = /Firefox\\/(\\d+)\\.\\d+/;\nlib.getFirefoxVersion = function() {\n    var match = FIREFOX_VERSION_REGEX.exec(window.navigator.userAgent);\n    if(match && match.length === 2) {\n        var versionInt = parseInt(match[1]);\n        if(!isNaN(versionInt)) {\n            return versionInt;\n        }\n    }\n    return null;\n};\n\nlib.isD3Selection = function(obj) {\n    return obj instanceof d3.selection;\n};\n\n/**\n * Append element to DOM only if not present.\n *\n * @param {d3 selection} parent : parent selection of the element in question\n * @param {string} nodeType : node type of element to append\n * @param {string} className (optional) : class name of element in question\n * @param {fn} enterFn (optional) : optional fn applied to entering elements only\n * @return {d3 selection} selection of new layer\n *\n * Previously, we were using the following pattern:\n *\n * ```\n * var sel = parent.selectAll('.' + className)\n *     .data([0]);\n *\n * sel.enter().append(nodeType)\n *     .classed(className, true);\n *\n * return sel;\n * ```\n *\n * in numerous places in our codebase to achieve the same behavior.\n *\n * The logic below performs much better, mostly as we are using\n * `.select` instead `.selectAll` that is `querySelector` instead of\n * `querySelectorAll`.\n *\n */\nlib.ensureSingle = function(parent, nodeType, className, enterFn) {\n    var sel = parent.select(nodeType + (className ? '.' + className : ''));\n    if(sel.size()) return sel;\n\n    var layer = parent.append(nodeType);\n    if(className) layer.classed(className, true);\n    if(enterFn) layer.call(enterFn);\n\n    return layer;\n};\n\n/**\n * Same as Lib.ensureSingle, but using id as selector.\n * This version is mostly used for clipPath nodes.\n *\n * @param {d3 selection} parent : parent selection of the element in question\n * @param {string} nodeType : node type of element to append\n * @param {string} id : id of element in question\n * @param {fn} enterFn (optional) : optional fn applied to entering elements only\n * @return {d3 selection} selection of new layer\n */\nlib.ensureSingleById = function(parent, nodeType, id, enterFn) {\n    var sel = parent.select(nodeType + '#' + id);\n    if(sel.size()) return sel;\n\n    var layer = parent.append(nodeType).attr('id', id);\n    if(enterFn) layer.call(enterFn);\n\n    return layer;\n};\n\n/**\n * Converts a string path to an object.\n *\n * When given a string containing an array element, it will create a `null`\n * filled array of the given size.\n *\n * @example\n * lib.objectFromPath('nested.test[2].path', 'value');\n * // returns { nested: { test: [null, null, { path: 'value' }]}\n *\n * @param   {string}    path to nested value\n * @param   {*}         any value to be set\n *\n * @return {Object} the constructed object with a full nested path\n */\nlib.objectFromPath = function(path, value) {\n    var keys = path.split('.');\n    var tmpObj;\n    var obj = tmpObj = {};\n\n    for(var i = 0; i < keys.length; i++) {\n        var key = keys[i];\n        var el = null;\n\n        var parts = keys[i].match(/(.*)\\[([0-9]+)\\]/);\n\n        if(parts) {\n            key = parts[1];\n            el = parts[2];\n\n            tmpObj = tmpObj[key] = [];\n\n            if(i === keys.length - 1) {\n                tmpObj[el] = value;\n            } else {\n                tmpObj[el] = {};\n            }\n\n            tmpObj = tmpObj[el];\n        } else {\n            if(i === keys.length - 1) {\n                tmpObj[key] = value;\n            } else {\n                tmpObj[key] = {};\n            }\n\n            tmpObj = tmpObj[key];\n        }\n    }\n\n    return obj;\n};\n\n/**\n * Iterate through an object in-place, converting dotted properties to objects.\n *\n * Examples:\n *\n *   lib.expandObjectPaths({'nested.test.path': 'value'});\n *     => { nested: { test: {path: 'value'}}}\n *\n * It also handles array notation, e.g.:\n *\n *   lib.expandObjectPaths({'foo[1].bar': 'value'});\n *     => { foo: [null, {bar: value}] }\n *\n * It handles merges the results when two properties are specified in parallel:\n *\n *   lib.expandObjectPaths({'foo[1].bar': 10, 'foo[0].bar': 20});\n *     => { foo: [{bar: 10}, {bar: 20}] }\n *\n * It does NOT, however, merge multiple multiply-nested arrays::\n *\n *   lib.expandObjectPaths({'marker[1].range[1]': 5, 'marker[1].range[0]': 4})\n *     => { marker: [null, {range: 4}] }\n */\n\n// Store this to avoid recompiling regex on *every* prop since this may happen many\n// many times for animations. Could maybe be inside the function. Not sure about\n// scoping vs. recompilation tradeoff, but at least it's not just inlining it into\n// the inner loop.\nvar dottedPropertyRegex = /^([^\\[\\.]+)\\.(.+)?/;\nvar indexedPropertyRegex = /^([^\\.]+)\\[([0-9]+)\\](\\.)?(.+)?/;\n\nfunction notValid(prop) {\n    // guard against polluting __proto__ and other internals getters and setters\n    return prop.slice(0, 2) === '__';\n}\n\nlib.expandObjectPaths = function(data) {\n    var match, key, prop, datum, idx, dest, trailingPath;\n    if(typeof data === 'object' && !Array.isArray(data)) {\n        for(key in data) {\n            if(data.hasOwnProperty(key)) {\n                if((match = key.match(dottedPropertyRegex))) {\n                    datum = data[key];\n                    prop = match[1];\n                    if(notValid(prop)) continue;\n\n                    delete data[key];\n\n                    data[prop] = lib.extendDeepNoArrays(data[prop] || {}, lib.objectFromPath(key, lib.expandObjectPaths(datum))[prop]);\n                } else if((match = key.match(indexedPropertyRegex))) {\n                    datum = data[key];\n\n                    prop = match[1];\n                    if(notValid(prop)) continue;\n\n                    idx = parseInt(match[2]);\n\n                    delete data[key];\n\n                    data[prop] = data[prop] || [];\n\n                    if(match[3] === '.') {\n                        // This is the case where theere are subsequent properties into which\n                        // we must recurse, e.g. transforms[0].value\n                        trailingPath = match[4];\n                        dest = data[prop][idx] = data[prop][idx] || {};\n\n                        // NB: Extend deep no arrays prevents this from working on multiple\n                        // nested properties in the same object, e.g.\n                        //\n                        // {\n                        //   foo[0].bar[1].range\n                        //   foo[0].bar[0].range\n                        // }\n                        //\n                        // In this case, the extendDeepNoArrays will overwrite one array with\n                        // the other, so that both properties *will not* be present in the\n                        // result. Fixing this would require a more intelligent tracking\n                        // of changes and merging than extendDeepNoArrays currently accomplishes.\n                        lib.extendDeepNoArrays(dest, lib.objectFromPath(trailingPath, lib.expandObjectPaths(datum)));\n                    } else {\n                        // This is the case where this property is the end of the line,\n                        // e.g. xaxis.range[0]\n\n                        if(notValid(prop)) continue;\n                        data[prop][idx] = lib.expandObjectPaths(datum);\n                    }\n                } else {\n                    if(notValid(key)) continue;\n                    data[key] = lib.expandObjectPaths(data[key]);\n                }\n            }\n        }\n    }\n\n    return data;\n};\n\n/**\n * Converts value to string separated by the provided separators.\n *\n * @example\n * lib.numSeparate(2016, '.,');\n * // returns '2016'\n *\n * @example\n * lib.numSeparate(3000, '.,', true);\n * // returns '3,000'\n *\n * @example\n * lib.numSeparate(1234.56, '|,')\n * // returns '1,234|56'\n *\n * @param   {string|number} value       the value to be converted\n * @param   {string}    separators  string of decimal, then thousands separators\n * @param   {boolean}    separatethousands  boolean, 4-digit integers are separated if true\n *\n * @return  {string}    the value that has been separated\n */\nlib.numSeparate = function(value, separators, separatethousands) {\n    if(!separatethousands) separatethousands = false;\n\n    if(typeof separators !== 'string' || separators.length === 0) {\n        throw new Error('Separator string required for formatting!');\n    }\n\n    if(typeof value === 'number') {\n        value = String(value);\n    }\n\n    var thousandsRe = /(\\d+)(\\d{3})/;\n    var decimalSep = separators.charAt(0);\n    var thouSep = separators.charAt(1);\n\n    var x = value.split('.');\n    var x1 = x[0];\n    var x2 = x.length > 1 ? decimalSep + x[1] : '';\n\n    // Years are ignored for thousands separators\n    if(thouSep && (x.length > 1 || x1.length > 4 || separatethousands)) {\n        while(thousandsRe.test(x1)) {\n            x1 = x1.replace(thousandsRe, '$1' + thouSep + '$2');\n        }\n    }\n\n    return x1 + x2;\n};\n\nlib.TEMPLATE_STRING_REGEX = /%{([^\\s%{}:]*)([:|\\|][^}]*)?}/g;\nvar SIMPLE_PROPERTY_REGEX = /^\\w*$/;\n\n/**\n * Substitute values from an object into a string\n *\n * Examples:\n *  Lib.templateString('name: %{trace}', {trace: 'asdf'}) --> 'name: asdf'\n *  Lib.templateString('name: %{trace[0].name}', {trace: [{name: 'asdf'}]}) --> 'name: asdf'\n *\n * @param {string}  input string containing %{...} template strings\n * @param {obj}     data object containing substitution values\n *\n * @return {string} templated string\n */\nlib.templateString = function(string, obj) {\n    // Not all that useful, but cache nestedProperty instantiation\n    // just in case it speeds things up *slightly*:\n    var getterCache = {};\n\n    return string.replace(lib.TEMPLATE_STRING_REGEX, function(dummy, key) {\n        var v;\n        if(SIMPLE_PROPERTY_REGEX.test(key)) {\n            v = obj[key];\n        } else {\n            getterCache[key] = getterCache[key] || lib.nestedProperty(obj, key).get;\n            v = getterCache[key]();\n        }\n        return lib.isValidTextValue(v) ? v : '';\n    });\n};\n\nvar hovertemplateWarnings = {\n    max: 10,\n    count: 0,\n    name: 'hovertemplate'\n};\nlib.hovertemplateString = function() {\n    return templateFormatString.apply(hovertemplateWarnings, arguments);\n};\n\nvar texttemplateWarnings = {\n    max: 10,\n    count: 0,\n    name: 'texttemplate'\n};\nlib.texttemplateString = function() {\n    return templateFormatString.apply(texttemplateWarnings, arguments);\n};\n\n// Regex for parsing multiplication and division operations applied to a template key\n// Used for shape.label.texttemplate\n// Matches a key name (non-whitespace characters), followed by a * or / character, followed by a number\n// For example, the following strings are matched: `x0*2`, `slope/1.60934`, `y1*2.54`\nvar MULT_DIV_REGEX = /^(\\S+)([\\*\\/])(-?\\d+(\\.\\d+)?)$/;\nfunction multDivParser(inputStr) {\n    var match = inputStr.match(MULT_DIV_REGEX);\n    if(match) return { key: match[1], op: match[2], number: Number(match[3]) };\n    return { key: inputStr, op: null, number: null };\n}\nvar texttemplateWarningsForShapes = {\n    max: 10,\n    count: 0,\n    name: 'texttemplate',\n    parseMultDiv: true,\n};\nlib.texttemplateStringForShapes = function() {\n    return templateFormatString.apply(texttemplateWarningsForShapes, arguments);\n};\n\nvar TEMPLATE_STRING_FORMAT_SEPARATOR = /^[:|\\|]/;\n/**\n * Substitute values from an object into a string and optionally formats them using d3-format,\n * or fallback to associated labels.\n *\n * Examples:\n *  Lib.hovertemplateString('name: %{trace}', {trace: 'asdf'}) --> 'name: asdf'\n *  Lib.hovertemplateString('name: %{trace[0].name}', {trace: [{name: 'asdf'}]}) --> 'name: asdf'\n *  Lib.hovertemplateString('price: %{y:$.2f}', {y: 1}) --> 'price: $1.00'\n *\n * @param {string}  input string containing %{...:...} template strings\n * @param {obj}     data object containing fallback text when no formatting is specified, ex.: {yLabel: 'formattedYValue'}\n * @param {obj}     d3 locale\n * @param {obj}     data objects containing substitution values\n *\n * @return {string} templated string\n */\nfunction templateFormatString(string, labels, d3locale) {\n    var opts = this;\n    var args = arguments;\n    if(!labels) labels = {};\n    // Not all that useful, but cache nestedProperty instantiation\n    // just in case it speeds things up *slightly*:\n    var getterCache = {};\n\n    return string.replace(lib.TEMPLATE_STRING_REGEX, function(match, rawKey, format) {\n        var isOther =\n            rawKey === 'xother' ||\n            rawKey === 'yother';\n\n        var isSpaceOther =\n            rawKey === '_xother' ||\n            rawKey === '_yother';\n\n        var isSpaceOtherSpace =\n            rawKey === '_xother_' ||\n            rawKey === '_yother_';\n\n        var isOtherSpace =\n            rawKey === 'xother_' ||\n            rawKey === 'yother_';\n\n        var hasOther = isOther || isSpaceOther || isOtherSpace || isSpaceOtherSpace;\n\n        var key = rawKey;\n        if(isSpaceOther || isSpaceOtherSpace) key = key.substring(1);\n        if(isOtherSpace || isSpaceOtherSpace) key = key.substring(0, key.length - 1);\n\n        // Shape labels support * and / operators in template string\n        // Parse these if the parseMultDiv param is set to true\n        var parsedOp = null;\n        var parsedNumber = null;\n        if(opts.parseMultDiv) {\n            var _match = multDivParser(key);\n            key = _match.key;\n            parsedOp = _match.op;\n            parsedNumber = _match.number;\n        }\n\n        var value;\n        if(hasOther) {\n            value = labels[key];\n            if(value === undefined) return '';\n        } else {\n            var obj, i;\n            for(i = 3; i < args.length; i++) {\n                obj = args[i];\n                if(!obj) continue;\n                if(obj.hasOwnProperty(key)) {\n                    value = obj[key];\n                    break;\n                }\n\n                if(!SIMPLE_PROPERTY_REGEX.test(key)) {\n                    value = lib.nestedProperty(obj, key).get();\n                    value = getterCache[key] || lib.nestedProperty(obj, key).get();\n                    if(value) getterCache[key] = value;\n                }\n                if(value !== undefined) break;\n            }\n        }\n\n        // Apply mult/div operation (if applicable)\n        if(value !== undefined) {\n            if(parsedOp === '*') value *= parsedNumber;\n            if(parsedOp === '/') value /= parsedNumber;\n        }\n\n        if(value === undefined && opts) {\n            if(opts.count < opts.max) {\n                lib.warn('Variable \\'' + key + '\\' in ' + opts.name + ' could not be found!');\n                value = match;\n            }\n\n            if(opts.count === opts.max) {\n                lib.warn('Too many ' + opts.name + ' warnings - additional warnings will be suppressed');\n            }\n            opts.count++;\n\n            return match;\n        }\n\n        if(format) {\n            var fmt;\n            if(format[0] === ':') {\n                fmt = d3locale ? d3locale.numberFormat : lib.numberFormat;\n                value = fmt(format.replace(TEMPLATE_STRING_FORMAT_SEPARATOR, ''))(value);\n            }\n\n            if(format[0] === '|') {\n                fmt = d3locale ? d3locale.timeFormat : utcFormat;\n                var ms = lib.dateTime2ms(value);\n                value = lib.formatDate(ms, format.replace(TEMPLATE_STRING_FORMAT_SEPARATOR, ''), false, fmt);\n            }\n        } else {\n            var keyLabel = key + 'Label';\n            if(labels.hasOwnProperty(keyLabel)) value = labels[keyLabel];\n        }\n\n        if(hasOther) {\n            value = '(' + value + ')';\n            if(isSpaceOther || isSpaceOtherSpace) value = ' ' + value;\n            if(isOtherSpace || isSpaceOtherSpace) value = value + ' ';\n        }\n\n        return value;\n    });\n}\n\n/*\n * alphanumeric string sort, tailored for subplot IDs like scene2, scene10, x10y13 etc\n */\nvar char0 = 48;\nvar char9 = 57;\nlib.subplotSort = function(a, b) {\n    var l = Math.min(a.length, b.length) + 1;\n    var numA = 0;\n    var numB = 0;\n    for(var i = 0; i < l; i++) {\n        var charA = a.charCodeAt(i) || 0;\n        var charB = b.charCodeAt(i) || 0;\n        var isNumA = charA >= char0 && charA <= char9;\n        var isNumB = charB >= char0 && charB <= char9;\n\n        if(isNumA) numA = 10 * numA + charA - char0;\n        if(isNumB) numB = 10 * numB + charB - char0;\n\n        if(!isNumA || !isNumB) {\n            if(numA !== numB) return numA - numB;\n            if(charA !== charB) return charA - charB;\n        }\n    }\n    return numB - numA;\n};\n\n// repeatable pseudorandom generator\nvar randSeed = 2000000000;\n\nlib.seedPseudoRandom = function() {\n    randSeed = 2000000000;\n};\n\nlib.pseudoRandom = function() {\n    var lastVal = randSeed;\n    randSeed = (69069 * randSeed + 1) % 4294967296;\n    // don't let consecutive vals be too close together\n    // gets away from really trying to be random, in favor of better local uniformity\n    if(Math.abs(randSeed - lastVal) < 429496729) return lib.pseudoRandom();\n    return randSeed / 4294967296;\n};\n\n\n/** Fill hover 'pointData' container with 'correct' hover text value\n *\n * - If trace hoverinfo contains a 'text' flag and hovertext is not set,\n *   the text elements will be seen in the hover labels.\n *\n * - If trace hoverinfo contains a 'text' flag and hovertext is set,\n *   hovertext takes precedence over text\n *   i.e. the hoverinfo elements will be seen in the hover labels\n *\n *  @param {object} calcPt\n *  @param {object} trace\n *  @param {object || array} contOut (mutated here)\n */\nlib.fillText = function(calcPt, trace, contOut) {\n    var fill = Array.isArray(contOut) ?\n        function(v) { contOut.push(v); } :\n        function(v) { contOut.text = v; };\n\n    var htx = lib.extractOption(calcPt, trace, 'htx', 'hovertext');\n    if(lib.isValidTextValue(htx)) return fill(htx);\n\n    var tx = lib.extractOption(calcPt, trace, 'tx', 'text');\n    if(lib.isValidTextValue(tx)) return fill(tx);\n};\n\n// accept all truthy values and 0 (which gets cast to '0' in the hover labels)\nlib.isValidTextValue = function(v) {\n    return v || v === 0;\n};\n\n/**\n * @param {number} ratio\n * @param {number} n (number of decimal places)\n */\nlib.formatPercent = function(ratio, n) {\n    n = n || 0;\n    var str = (Math.round(100 * ratio * Math.pow(10, n)) * Math.pow(0.1, n)).toFixed(n) + '%';\n    for(var i = 0; i < n; i++) {\n        if(str.indexOf('.') !== -1) {\n            str = str.replace('0%', '%');\n            str = str.replace('.%', '%');\n        }\n    }\n    return str;\n};\n\nlib.isHidden = function(gd) {\n    var display = window.getComputedStyle(gd).display;\n    return !display || display === 'none';\n};\n\nlib.strTranslate = function(x, y) {\n    return (x || y) ? 'translate(' + x + ',' + y + ')' : '';\n};\n\nlib.strRotate = function(a) {\n    return a ? 'rotate(' + a + ')' : '';\n};\n\nlib.strScale = function(s) {\n    return s !== 1 ? 'scale(' + s + ')' : '';\n};\n\n/** Return transform text for bar bar-like rectangles and pie-like slices\n *  @param {object} transform\n *  - targetX: desired position on the x-axis\n *  - targetY: desired position on the y-axis\n *  - textX: text middle position on the x-axis\n *  - textY: text middle position on the y-axis\n *  - anchorX: (optional) text anchor position on the x-axis (computed from textX), zero for middle anchor\n *  - anchorY: (optional) text anchor position on the y-axis (computed from textY), zero for middle anchor\n *  - scale: (optional) scale applied after translate\n *  - rotate: (optional) rotation applied after scale\n *  - noCenter: when defined no extra arguments needed in rotation\n */\nlib.getTextTransform = function(transform) {\n    var noCenter = transform.noCenter;\n    var textX = transform.textX;\n    var textY = transform.textY;\n    var targetX = transform.targetX;\n    var targetY = transform.targetY;\n    var anchorX = transform.anchorX || 0;\n    var anchorY = transform.anchorY || 0;\n    var rotate = transform.rotate;\n    var scale = transform.scale;\n    if(!scale) scale = 0;\n    else if(scale > 1) scale = 1;\n\n    return (\n        lib.strTranslate(\n            targetX - scale * (textX + anchorX),\n            targetY - scale * (textY + anchorY)\n        ) +\n        lib.strScale(scale) +\n        (rotate ?\n            'rotate(' + rotate +\n                (noCenter ? '' : ' ' + textX + ' ' + textY) +\n            ')' : ''\n        )\n    );\n};\n\nlib.setTransormAndDisplay = function(s, transform) {\n    s.attr('transform', lib.getTextTransform(transform));\n    s.style('display', transform.scale ? null : 'none');\n};\n\nlib.ensureUniformFontSize = function(gd, baseFont) {\n    var out = lib.extendFlat({}, baseFont);\n    out.size = Math.max(\n        baseFont.size,\n        gd._fullLayout.uniformtext.minsize || 0\n    );\n    return out;\n};\n\n/**\n * provide a human-readable list e.g. \"A, B, C and D\" with an ending separator\n *\n * @param {array} arr : the array to join\n * @param {string} mainSeparator : main separator\n * @param {string} lastSeparator : last separator\n *\n * @return {string} : joined list\n */\nlib.join2 = function(arr, mainSeparator, lastSeparator) {\n    var len = arr.length;\n    if(len > 1) {\n        return arr.slice(0, -1).join(mainSeparator) + lastSeparator + arr[len - 1];\n    }\n    return arr.join(mainSeparator);\n};\n\nlib.bigFont = function(size) {\n    return Math.round(1.2 * size);\n};\n\nvar firefoxVersion = lib.getFirefoxVersion();\n// see https://bugzilla.mozilla.org/show_bug.cgi?id=1684973\nvar isProblematicFirefox = firefoxVersion !== null && firefoxVersion < 86;\n\n/**\n * Return the mouse position from the last event registered by D3.\n * @returns An array with two numbers, representing the x and y coordinates of the mouse pointer\n *   at the event relative to the targeted node.\n */\nlib.getPositionFromD3Event = function() {\n    if(isProblematicFirefox) {\n        // layerX and layerY are non-standard, so we only fallback to them when we have to:\n        return [\n            d3.event.layerX,\n            d3.event.layerY\n        ];\n    } else {\n        return [\n            d3.event.offsetX,\n            d3.event.offsetY\n        ];\n    }\n};\n","'use strict';\n\n/**\n * sanitized modulus function that always returns in the range [0, d)\n * rather than (-d, 0] if v is negative\n */\nfunction mod(v, d) {\n    var out = v % d;\n    return out < 0 ? out + d : out;\n}\n\n/**\n * sanitized modulus function that always returns in the range [-d/2, d/2]\n * rather than (-d, 0] if v is negative\n */\nfunction modHalf(v, d) {\n    return Math.abs(v) > (d / 2) ?\n        v - Math.round(v / d) * d :\n        v;\n}\n\nmodule.exports = {\n    mod: mod,\n    modHalf: modHalf\n};\n","'use strict';\n\n/* eslint-disable no-console */\n\nvar dfltConfig = require('../plot_api/plot_config').dfltConfig;\n\nvar notifier = require('./notifier');\n\nvar loggers = module.exports = {};\n\n/**\n * ------------------------------------------\n * debugging tools\n * ------------------------------------------\n */\n\nloggers.log = function() {\n    var i;\n\n    if(dfltConfig.logging > 1) {\n        var messages = ['LOG:'];\n        for(i = 0; i < arguments.length; i++) {\n            messages.push(arguments[i]);\n        }\n        console.trace.apply(console, messages);\n    }\n\n    if(dfltConfig.notifyOnLogging > 1) {\n        var lines = [];\n        for(i = 0; i < arguments.length; i++) {\n            lines.push(arguments[i]);\n        }\n        notifier(lines.join('<br>'), 'long');\n    }\n};\n\nloggers.warn = function() {\n    var i;\n\n    if(dfltConfig.logging > 0) {\n        var messages = ['WARN:'];\n        for(i = 0; i < arguments.length; i++) {\n            messages.push(arguments[i]);\n        }\n        console.trace.apply(console, messages);\n    }\n\n    if(dfltConfig.notifyOnLogging > 0) {\n        var lines = [];\n        for(i = 0; i < arguments.length; i++) {\n            lines.push(arguments[i]);\n        }\n        notifier(lines.join('<br>'), 'stick');\n    }\n};\n\nloggers.error = function() {\n    var i;\n\n    if(dfltConfig.logging > 0) {\n        var messages = ['ERROR:'];\n        for(i = 0; i < arguments.length; i++) {\n            messages.push(arguments[i]);\n        }\n        console.error.apply(console, messages);\n    }\n\n    if(dfltConfig.notifyOnLogging > 0) {\n        var lines = [];\n        for(i = 0; i < arguments.length; i++) {\n            lines.push(arguments[i]);\n        }\n        notifier(lines.join('<br>'), 'stick');\n    }\n};\n"],"names":["module","exports","undo","width","height","path","transform","home","zoombox","pan","zoom_plus","zoom_minus","autoscale","tooltip_basic","tooltip_compare","plotlylogo","camera","movie","question","disk","drawopenpath","drawclosedpath","lasso","selectbox","drawline","drawrect","drawcircle","eraseshape","spikeline","pencil","newplotlylogo","name","svg","join","isNumeric","require","BADNUM","JUNK","v","replace","Number","d3","traceLayer","cdModule","cls","traces","selectAll","data","cd","trace","uid","exit","remove","enter","append","attr","order","k","classed","each","select","this","EventEmitter","Events","init","plotObj","_ev","ev","internalEv","_internalEv","on","bind","once","removeListener","removeAllListeners","_internalOn","_internalOnce","_removeInternalListener","_removeAllInternalListeners","emit","event","jQuery","trigger","triggerHandler","jQueryHandlerValue","nodeEventHandlerValue","i","handlers","_events","apply","handler","listener","fired","Array","isArray","length","undefined","purge","locationCache","workingPath","workingTextWidth","mod","segmentsIntersect","x1","y1","x2","y2","x3","y3","x4","y4","a","b","c","d","e","f","det","t","u","x","y","perpDistance2","xab","yab","llab","xac","yac","fcAB","xbc","ybc","crossProduct","segmentDistance","x12","y12","x34","y34","ll12","ll34","dist2","Math","min","sqrt","getTextLocation","totalPathLen","positionOnPath","textWidth","p0","getPointAtLength","p1","theta","atan","pCenter","out","clearLocationCache","getVisibleSegment","bounds","buffer","pt0","ptTotal","left","right","top","bottom","pMin","pTotal","getTotalLength","pMax","getDistToPlot","len","pt","dx","dy","distToPlot","max","total","isClosed","abs","findPointOnPath","val","coord","opts","mid","diff","pathLength","tolerance","iterationLimit","mul","b0","b1","version","Registry","register","plotApi","methodNames","Object","keys","charAt","moduleType","fn","window","PlotlyLocales","Icons","Fx","Plots","resize","graphJson","sendDataToCloud","hover","unhover","loneHover","loneUnhover","Snapshot","PlotSchema","b64decode","isPlainObject","ab","ArrayBuffer","dv","DataView","isTypedArray","isView","isArrayOrTypedArray","isArray1D","ensureArray","n","typedArrays","u1c","Uint8ClampedArray","i1","Int8Array","u1","Uint8Array","i2","Int16Array","u2","Uint16Array","i4","Int32Array","u4","Uint32Array","f4","Float32Array","f8","Float64Array","isArrayBuffer","constructor","_rowLength","z","len0","uint8c","uint8","int8","uint16","int16","uint32","int32","float32","float64","decodeTypedArraySpec","vIn","bdata","dtype","shape","coerceTypedArraySpec","T","Error","BYTES_PER_ELEMENT","byteLength","split","reverse","nj","j","ndim","ni","rowBytes","pos","nk","_inputArray","isTypedArraySpec","hasOwnProperty","concat","_constructor","arg0","argi","posi","leni","args","allArray","totalLen","arguments","push","set","maxRowLength","minRowLength","Infinity","nestedProperty","SIMPLE_PROPERTY_REGEX","baseObj","keyName","valueName","arr","baseProp","changeTypes","get","indexLookup","isSimpleValueProp","test","obj","value","changeType","idx","newValue","rename","newName","object","splice","constructUpdate","astr","update","changed","process","versions","prototype","toString","call","getPrototypeOf","array","seen","item","modModule","modHalf","PI","twoPI","isFullCircle","aBnds","angleDelta","isAngleInsideSector","s0","s1","a0","a1","_path","r0","r1","cx","cy","aStart","aMid","aEnd","rStart","rEnd","isCircle","r","cos","sin","p","largeArc","arc","cw","deg2rad","deg","rad2deg","rad","angleDist","isPtInsideSector","rBnds","pathArc","pathSector","pathAnnulus","gd","_responsiveChartHandler","removeEventListener","delta","scale","newX","lenX1","String","lenDt","s","parseFloat","toPrecision","indexOf","baseFilter","visible","calcDataFilter","_length","container","cont","filterFn","isLeftAnchor","xanchor","isCenterAnchor","isRightAnchor","isTopAnchor","yanchor","isMiddleAnchor","isBottomAnchor","tinycolor","baseTraceAttrs","colorscales","Color","DESELECTDIM","counterRegex","validate","valObjectDef","valObjectMeta","valType","arrayOk","validateFunction","failed","propMock","coerceFunction","data_array","description","requiredOpts","otherOpts","propOut","dflt","enumerated","coerceNumber","values","RegExp","substr","boolean","number","integer","string","okToCoerce","strict","noBlank","color","isValid","colorlist","every","colorscale","scales","angle","subplotid","regex","flaglist","extras","vParts","vi","flags","any","info_array","coercePart","propPart","row","len2","vNew","twoD","dimensions","items","vOut","arrayItems","arrayItems2D","innerItemsOnly","freeLength","coerce","containerIn","containerOut","attributes","attribute","propIn","template","_template","coerce2","valIn","coerceFont","dfltObj","family","size","coercePattern","markerColor","hasMarkerColorscale","isOverlay","bgcolor","contrast","coerceHoverinfo","traceIn","traceOut","layoutOut","moduleAttrs","_module","attrs","hoverinfo","valObj","_dataLength","slice","coerceSelectionMarkerOpacity","marker","smoDflt","usmoDflt","mo","opacity","selected","unselected","loggers","matrix","mat4X4","removeElement","el","elParent","parentNode","removeChild","addRelatedStyleRule","selector","styleString","id","style","document","getElementById","createElement","setAttribute","appendChild","createTextNode","head","styleSheet","sheet","insertRule","addRule","warn","getElementTransformMatrix","element","getComputedStyle","getPropertyValue","map","getElementAndAncestors","allElements","isTransformableElement","Element","HTMLElement","getGraphDiv","gdElement","isPlotDiv","el3","node","addStyleRule","deleteRelatedStyleRule","getFullTransformMatrix","forEach","m","convertCssMatrix","multiply","equalDomRects","_extend","inputs","isDeep","keepAllKeys","noArrayCopies","input","key","src","copy","copyIsArray","clone","allPrimitives","target","source","primitivesLoopSplice","extendFlat","extendDeep","extendDeepAll","extendDeepNoArrays","locale","_context","locales","dict","dictionary","localeRegistry","baseLocale","init2dArray","rowLength","colLength","transposeRagged","maxlen","zlen","dot","yTranspose","translationMatrix","rotationMatrix","alpha","rotationXYMatrix","apply3DTransform","xyz","apply2DTransform","xy","apply2DTransform2","at","xys","inverseTransformMatrix","invert","fullLayout","_fullLayout","_glcanvas","regl","clear","depth","MIN_MS","MAX_MS","timeFormat","Loggers","constants","ONEDAY","ONEHOUR","ONEMIN","ONESEC","EPOCHJD","utcFormat","DATETIME_REGEXP","DATETIME_REGEXP_CN","YFIRST","Date","getFullYear","isWorldCalendar","calendar","componentsRegistry","calendars","lpad","digits","pow","dateTick0","dayOfWeek","tick0","sunday","getComponentMethod","_dateTick0","dateTime2ms","ms2DateTime","dfltRange","isJSDate","getTime","tzOffset","getTimezoneOffset","offsetTweak","getUTCMinutes","getMinutes","getUTCSeconds","getSeconds","getUTCMilliseconds","getMilliseconds","comb","isWorld","isChinese","match","H","M","S","cDate","calInstance","isIntercalary","parseInt","newDate","toMonthIndex","toJD","date","UTC","setUTCFullYear","getUTCMonth","getUTCDate","isDateTime","NINETYDAYS","THREEHOURS","FIVEMIN","includeTime","dateStr","h","msec10","ms","msecTenths","floor","msRounded","round","dateJD","timeMs","fromJD","formatDate","getUTCHours","ms2DateTimeLocal","getHours","cleanDate","isFinite","error","fracMatch","halfYearMatch","quarterToHalfYear","modDateFormat","fmt","formatter","toFixed","MAXSECONDS","tr","extraFormat","year","month","timePart","timeStr","secStr","formatTime","dayMonthYear","dayMonth","THREEDAYS","incrementMonth","dMonth","add","setUTCMonth","findExactDates","di","exactYears","exactMonths","exactDays","blankCount","day","dataCount","d3Format","numConstants","MAX_SAFE","FP_SAFE","MIN_SAFE","lib","adjustFormat","formatStr","seenBadFormats","warnBadFormat","noFormat","numberFormat","keyedContainer","relativeAttr","toLogRange","relinkPrivateKeys","arrayModule","coerceModule","datesModule","searchModule","findBin","sorterAsc","sorterDes","distinctVals","roundUp","sort","findIndexOfMin","sortObjectKeys","statsModule","aggNums","mean","median","midRange","variance","stdev","interp","matrixModule","anglesModule","anchorUtils","geom2dModule","extendModule","loggersModule","log","regexModule","counter","throttleModule","throttle","throttleDone","done","clearThrottle","domModule","makePtIndex2PtNumber","indexToPoints","ptIndex2ptNumber","pts","clearResponsive","preserveDrawingBuffer","makeTraceGroups","_","notifier","filterUnique","filterVisible","pushUnique","increment","cleanNumber","ensureNumber","isIndex","noop","identity","repeat","cnt","swapAttrs","attrList","part1","part2","xp","yp","temp","raiseToTop","elem","cancelTransition","selection","transition","duration","constrain","v0","v1","bBoxIntersect","pad","simpleMap","func","randstr","existing","bits","base","_recursion","res","rem","random","parsed","OptionControl","opt","optname","self","optObj","optionList","smooth","arrayIn","FWHM","alen","alen2","wlen","w","arrayOut","syncOrAsync","sequence","arg","finalStep","ret","continueAsync","fni","then","stripTrailingSlash","str","noneOrAll","hasAny","hasAll","mergeArray","traceAttr","cdAttr","hasFn","imax","mergeArrayCastPositive","fillArray","castOption","ptNumber","extractOption","calcPt","calcKey","traceKey","traceVal","tagSelected","calcTrace","ptNumber2cdIndex","selectedpoints","_indexToPoints","ptIndex","cdIndex","selIndices2selPoints","getTargetArray","transformOpts","minExtend","obj1","obj2","objOut","arrayLen","subarray","titleCase","toUpperCase","containsAny","fragments","isIE","navigator","msSaveBlob","IS_SAFARI_REGEX","isSafari","userAgent","IS_IOS_REGEX","isIOS","FIREFOX_VERSION_REGEX","getFirefoxVersion","exec","versionInt","isNaN","isD3Selection","ensureSingle","parent","nodeType","className","enterFn","sel","layer","ensureSingleById","objectFromPath","tmpObj","parts","dottedPropertyRegex","indexedPropertyRegex","notValid","prop","expandObjectPaths","datum","dest","trailingPath","numSeparate","separators","separatethousands","thousandsRe","decimalSep","thouSep","TEMPLATE_STRING_REGEX","templateString","getterCache","dummy","isValidTextValue","hovertemplateWarnings","count","hovertemplateString","templateFormatString","texttemplateWarnings","texttemplateString","MULT_DIV_REGEX","texttemplateWarningsForShapes","parseMultDiv","texttemplateStringForShapes","TEMPLATE_STRING_FORMAT_SEPARATOR","labels","d3locale","rawKey","format","isSpaceOther","isSpaceOtherSpace","isOtherSpace","hasOther","substring","parsedOp","parsedNumber","_match","inputStr","op","multDivParser","keyLabel","subplotSort","l","numA","numB","charA","charCodeAt","charB","isNumA","isNumB","randSeed","seedPseudoRandom","pseudoRandom","lastVal","fillText","contOut","fill","text","htx","tx","formatPercent","ratio","isHidden","display","strTranslate","strRotate","strScale","getTextTransform","noCenter","textX","textY","targetX","targetY","anchorX","anchorY","rotate","setTransormAndDisplay","ensureUniformFontSize","baseFont","uniformtext","minsize","join2","mainSeparator","lastSeparator","bigFont","firefoxVersion","isProblematicFirefox","getPositionFromD3Event","layerX","layerY","offsetX","offsetY","dfltConfig","logging","messages","console","notifyOnLogging","lines"],"sourceRoot":""}