{"version":3,"file":"static/js/npm.react-draggable.0bfa5023.js","mappings":"6FAEAA,OAAOC,eAAeC,EAAS,aAAc,CAC3CC,OAAO,IAETH,OAAOC,eAAeC,EAAS,gBAAiB,CAC9CE,YAAY,EACZC,IAAK,WACH,OAAOC,EAAeC,OACxB,IAEFL,EAAA,aAAkB,EAClB,IAAIM,EAWJ,SAAiCC,EAAKC,GAAe,IAAKA,GAAeD,GAAOA,EAAIE,WAAc,OAAOF,EAAO,GAAY,OAARA,GAA+B,iBAARA,GAAmC,mBAARA,EAAsB,MAAO,CAAEF,QAASE,GAAS,IAAIG,EAAQC,EAAyBH,GAAc,GAAIE,GAASA,EAAME,IAAIL,GAAQ,OAAOG,EAAMP,IAAII,GAAQ,IAAIM,EAAS,CAAC,EAAOC,EAAwBhB,OAAOC,gBAAkBD,OAAOiB,yBAA0B,IAAK,IAAIC,KAAOT,EAAO,GAAY,YAARS,GAAqBlB,OAAOmB,UAAUC,eAAeC,KAAKZ,EAAKS,GAAM,CAAE,IAAII,EAAON,EAAwBhB,OAAOiB,yBAAyBR,EAAKS,GAAO,KAAUI,IAASA,EAAKjB,KAAOiB,EAAKC,KAAQvB,OAAOC,eAAec,EAAQG,EAAKI,GAAgBP,EAAOG,GAAOT,EAAIS,EAAQ,CAAIH,EAAOR,QAAUE,EAASG,GAASA,EAAMW,IAAId,EAAKM,GAAW,OAAOA,CAAQ,CAXvxBS,CAAwB,EAAQ,SACxCC,EAAaC,EAAuB,EAAQ,SAC5CC,EAAYD,EAAuB,EAAQ,SAC3CE,EAAQF,EAAuB,EAAQ,SACvCG,EAAU,EAAQ,QAClBC,EAAe,EAAQ,QACvBC,EAAS,EAAQ,QACjBzB,EAAiBoB,EAAuB,EAAQ,SAChDM,EAAON,EAAuB,EAAQ,SAC1C,SAASA,EAAuBjB,GAAO,OAAOA,GAAOA,EAAIE,WAAaF,EAAM,CAAEF,QAASE,EAAO,CAC9F,SAASI,EAAyBH,GAAe,GAAuB,mBAAZuB,QAAwB,OAAO,KAAM,IAAIC,EAAoB,IAAID,QAAeE,EAAmB,IAAIF,QAAW,OAAQpB,EAA2B,SAAUH,GAAe,OAAOA,EAAcyB,EAAmBD,CAAmB,GAAGxB,EAAc,CAEtT,SAAS0B,IAAiS,OAApRA,EAAWpC,OAAOqC,OAASrC,OAAOqC,OAAOC,OAAS,SAAUC,GAAU,IAAK,IAAIC,EAAI,EAAGA,EAAIC,UAAUC,OAAQF,IAAK,CAAE,IAAIG,EAASF,UAAUD,GAAI,IAAK,IAAItB,KAAOyB,EAAc3C,OAAOmB,UAAUC,eAAeC,KAAKsB,EAAQzB,KAAQqB,EAAOrB,GAAOyB,EAAOzB,GAAU,CAAE,OAAOqB,CAAQ,EAAUH,EAASQ,MAAMC,KAAMJ,UAAY,CAClV,SAASK,EAAgBrC,EAAKS,EAAKf,GAA4L,OAAnLe,EAC5C,SAAwB6B,GAAO,IAAI7B,EACnC,SAAsB8B,EAAOC,GAAQ,GAAqB,iBAAVD,GAAgC,OAAVA,EAAgB,OAAOA,EAAO,IAAIE,EAAOF,EAAMG,OAAOC,aAAc,QAAaC,IAATH,EAAoB,CAAE,IAAII,EAAMJ,EAAK7B,KAAK2B,EAAOC,GAAQ,WAAY,GAAmB,iBAARK,EAAkB,OAAOA,EAAK,MAAM,IAAIC,UAAU,+CAAiD,CAAE,OAAiB,WAATN,EAAoBO,OAASC,QAAQT,EAAQ,CAD/UU,CAAaX,EAAK,UAAW,MAAsB,iBAAR7B,EAAmBA,EAAMsC,OAAOtC,EAAM,CADxEyC,CAAezC,MAAiBT,EAAOT,OAAOC,eAAeQ,EAAKS,EAAK,CAAEf,MAAOA,EAAOC,YAAY,EAAMwD,cAAc,EAAMC,UAAU,IAAkBpD,EAAIS,GAAOf,EAAgBM,CAAK,CAgC3O,MAAMqD,UAAkBtD,EAAMuD,UAG5B,+BAAOC,CAAyBC,EAAcC,GAC5C,IAAI,SACFC,GACuBF,GACrB,kBACFG,GACuBF,EAEzB,OAAIC,GAAcC,GAAqBD,EAASE,IAAMD,EAAkBC,GAAKF,EAASG,IAAMF,EAAkBE,EAavG,OAZL,EAAItC,EAAKzB,SAAS,yCAA0C,CAC1D4D,WACAC,sBAEK,CACLC,EAAGF,EAASE,EACZC,EAAGH,EAASG,EACZF,kBAAmB,IACdD,IAKX,CACA,WAAAI,CAAYC,GACVC,MAAMD,GACN1B,EAAgBD,KAAM,eAAe,CAAC6B,EAAGC,MACvC,EAAI3C,EAAKzB,SAAS,6BAA8BoE,GAKhD,IAAoB,IAFA9B,KAAK2B,MAAMI,QAAQF,GAAG,EAAI5C,EAAa+C,qBAAqBhC,KAAM8B,IAE3D,OAAO,EAClC9B,KAAKiC,SAAS,CACZC,UAAU,EACVC,SAAS,GACT,IAEJlC,EAAgBD,KAAM,UAAU,CAAC6B,EAAGC,KAClC,IAAK9B,KAAKoC,MAAMF,SAAU,OAAO,GACjC,EAAI/C,EAAKzB,SAAS,wBAAyBoE,GAC3C,MAAMO,GAAS,EAAIpD,EAAa+C,qBAAqBhC,KAAM8B,GACrDQ,EAAW,CACfd,EAAGa,EAAOb,EACVC,EAAGY,EAAOZ,EACVc,OAAQ,EACRC,OAAQ,GAIV,GAAIxC,KAAK2B,MAAMc,OAAQ,CAErB,MAAM,EACJjB,EAAC,EACDC,GACEa,EAKJA,EAASd,GAAKxB,KAAKoC,MAAMG,OACzBD,EAASb,GAAKzB,KAAKoC,MAAMI,OAGzB,MAAOE,EAAWC,IAAa,EAAI1D,EAAa2D,kBAAkB5C,KAAMsC,EAASd,EAAGc,EAASb,GAC7Fa,EAASd,EAAIkB,EACbJ,EAASb,EAAIkB,EAGbL,EAASC,OAASvC,KAAKoC,MAAMG,QAAUf,EAAIc,EAASd,GACpDc,EAASE,OAASxC,KAAKoC,MAAMI,QAAUf,EAAIa,EAASb,GAGpDY,EAAOb,EAAIc,EAASd,EACpBa,EAAOZ,EAAIa,EAASb,EACpBY,EAAOQ,OAASP,EAASd,EAAIxB,KAAKoC,MAAMZ,EACxCa,EAAOS,OAASR,EAASb,EAAIzB,KAAKoC,MAAMX,CAC1C,CAIA,IAAqB,IADAzB,KAAK2B,MAAMoB,OAAOlB,EAAGQ,GACd,OAAO,EACnCrC,KAAKiC,SAASK,EAAS,IAEzBrC,EAAgBD,KAAM,cAAc,CAAC6B,EAAGC,KACtC,IAAK9B,KAAKoC,MAAMF,SAAU,OAAO,EAIjC,IAAuB,IADAlC,KAAK2B,MAAMqB,OAAOnB,GAAG,EAAI5C,EAAa+C,qBAAqBhC,KAAM8B,IAC1D,OAAO,GACrC,EAAI3C,EAAKzB,SAAS,4BAA6BoE,GAC/C,MAAMQ,EAAyC,CAC7CJ,UAAU,EACVK,OAAQ,EACRC,OAAQ,GAMV,GADmBS,QAAQjD,KAAK2B,MAAML,UACtB,CACd,MAAM,EACJE,EAAC,EACDC,GACEzB,KAAK2B,MAAML,SACfgB,EAASd,EAAIA,EACbc,EAASb,EAAIA,CACf,CACAzB,KAAKiC,SAASK,EAAS,IAEzBtC,KAAKoC,MAAQ,CAEXF,UAAU,EAEVC,SAAS,EAETX,EAAGG,EAAML,SAAWK,EAAML,SAASE,EAAIG,EAAMuB,gBAAgB1B,EAC7DC,EAAGE,EAAML,SAAWK,EAAML,SAASG,EAAIE,EAAMuB,gBAAgBzB,EAC7DF,kBAAmB,IACdI,EAAML,UAGXiB,OAAQ,EACRC,OAAQ,EAERW,cAAc,IAEZxB,EAAML,UAAcK,EAAMoB,QAAUpB,EAAMqB,QAE5CI,QAAQC,KAAK,4NAEjB,CACA,iBAAAC,QAEmC,IAAtBC,OAAOC,YAA8BxD,KAAKyD,wBAAyBF,OAAOC,YACnFxD,KAAKiC,SAAS,CACZkB,cAAc,GAGpB,CACA,oBAAAO,GACE1D,KAAKiC,SAAS,CACZC,UAAU,GAEd,CAIA,WAAAuB,GACE,IAAIE,EAAuBC,EAC3B,OAA4M,QAApMD,EAAuD,QAA9BC,EAAc5D,KAAK2B,aAAmC,IAAhBiC,GAAkE,QAAvCA,EAAcA,EAAYC,eAAqC,IAAhBD,OAAyB,EAASA,EAAYE,eAA+C,IAA1BH,EAAmCA,EAAwB7E,EAAUpB,QAAQ+F,YAAYzD,KAC/S,CACA,MAAA+D,GACE,MAAM,KACJC,EAAI,OACJvB,EAAM,SACNwB,EAAQ,gBACRf,EAAe,iBACfgB,EAAgB,yBAChBC,EAAwB,wBACxBC,EAAuB,SACvB9C,EAAQ,eACR+C,EAAc,MACdC,KACGC,GACDvE,KAAK2B,MACT,IAAI6C,EAAQ,CAAC,EACTC,EAAe,KAGnB,MACMC,GADazB,QAAQ3B,IACMtB,KAAKoC,MAAMF,SACtCyC,EAAgBrD,GAAY4B,EAC5B0B,EAAgB,CAEpBpD,GAAG,EAAIvC,EAAa4F,UAAU7E,OAAS0E,EAAY1E,KAAKoC,MAAMZ,EAAImD,EAAcnD,EAEhFC,GAAG,EAAIxC,EAAa6F,UAAU9E,OAAS0E,EAAY1E,KAAKoC,MAAMX,EAAIkD,EAAclD,GAI9EzB,KAAKoC,MAAMe,aACbsB,GAAe,EAAIzF,EAAQ+F,oBAAoBH,EAAeP,GAM9DG,GAAQ,EAAIxF,EAAQgG,oBAAoBJ,EAAeP,GAIzD,MAAMY,GAAY,EAAIlG,EAAMrB,SAASuG,EAAStC,MAAMsD,WAAa,GAAIf,EAAkB,CACrF,CAACC,GAA2BnE,KAAKoC,MAAMF,SACvC,CAACkC,GAA0BpE,KAAKoC,MAAMD,UAKxC,OAAoBxE,EAAMuH,cAAczH,EAAeC,QAAS6B,EAAS,CAAC,EAAGgF,EAAoB,CAC/FxC,QAAS/B,KAAKmF,YACdpC,OAAQ/C,KAAK+C,OACbC,OAAQhD,KAAKoF,aACEzH,EAAM0H,aAAa1H,EAAM2H,SAASC,KAAKtB,GAAW,CACjEgB,UAAWA,EACXT,MAAO,IACFP,EAAStC,MAAM6C,SACfA,GAELgB,UAAWf,IAEf,EAEFpH,EAAA,QAAkB4D,EAClBhB,EAAgBgB,EAAW,cAAe,aAC1ChB,EAAgBgB,EAAW,YAAa,IAEnCxD,EAAeC,QAAQ+H,UAc1BzB,KAAMpF,EAAWlB,QAAQgI,MAAM,CAAC,OAAQ,IAAK,IAAK,SA2BlDjD,OAAQ7D,EAAWlB,QAAQiI,UAAU,CAAC/G,EAAWlB,QAAQkI,MAAM,CAC7DC,KAAMjH,EAAWlB,QAAQoI,OACzBC,MAAOnH,EAAWlB,QAAQoI,OAC1BE,IAAKpH,EAAWlB,QAAQoI,OACxBG,OAAQrH,EAAWlB,QAAQoI,SACzBlH,EAAWlB,QAAQwI,OAAQtH,EAAWlB,QAAQgI,MAAM,EAAC,MACzDxB,iBAAkBtF,EAAWlB,QAAQwI,OACrC/B,yBAA0BvF,EAAWlB,QAAQwI,OAC7C9B,wBAAyBxF,EAAWlB,QAAQwI,OAkB5ChD,gBAAiBtE,EAAWlB,QAAQkI,MAAM,CACxCpE,EAAG5C,EAAWlB,QAAQoI,OACtBrE,EAAG7C,EAAWlB,QAAQoI,SAExBzB,eAAgBzF,EAAWlB,QAAQkI,MAAM,CACvCpE,EAAG5C,EAAWlB,QAAQiI,UAAU,CAAC/G,EAAWlB,QAAQoI,OAAQlH,EAAWlB,QAAQwI,SAC/EzE,EAAG7C,EAAWlB,QAAQiI,UAAU,CAAC/G,EAAWlB,QAAQoI,OAAQlH,EAAWlB,QAAQwI,WAsBjF5E,SAAU1C,EAAWlB,QAAQkI,MAAM,CACjCpE,EAAG5C,EAAWlB,QAAQoI,OACtBrE,EAAG7C,EAAWlB,QAAQoI,SAKxBb,UAAW/F,EAAOiH,UAClB3B,MAAOtF,EAAOiH,UACdX,UAAWtG,EAAOiH,YAEpBlG,EAAgBgB,EAAW,eAAgB,IACtCxD,EAAeC,QAAQ0I,aAC1BpC,KAAM,OACNvB,QAAQ,EACRyB,iBAAkB,kBAClBC,yBAA0B,2BAC1BC,wBAAyB,0BACzBlB,gBAAiB,CACf1B,EAAG,EACHC,EAAG,GAEL6C,MAAO,G,iBCvYTnH,OAAOC,eAAeC,EAAS,aAAc,CAC3CC,OAAO,IAETD,EAAA,aAAkB,EAClB,IAAIM,EASJ,SAAiCC,EAAKC,GAAe,IAAKA,GAAeD,GAAOA,EAAIE,WAAc,OAAOF,EAAO,GAAY,OAARA,GAA+B,iBAARA,GAAmC,mBAARA,EAAsB,MAAO,CAAEF,QAASE,GAAS,IAAIG,EAAQC,EAAyBH,GAAc,GAAIE,GAASA,EAAME,IAAIL,GAAQ,OAAOG,EAAMP,IAAII,GAAQ,IAAIM,EAAS,CAAC,EAAOC,EAAwBhB,OAAOC,gBAAkBD,OAAOiB,yBAA0B,IAAK,IAAIC,KAAOT,EAAO,GAAY,YAARS,GAAqBlB,OAAOmB,UAAUC,eAAeC,KAAKZ,EAAKS,GAAM,CAAE,IAAII,EAAON,EAAwBhB,OAAOiB,yBAAyBR,EAAKS,GAAO,KAAUI,IAASA,EAAKjB,KAAOiB,EAAKC,KAAQvB,OAAOC,eAAec,EAAQG,EAAKI,GAAgBP,EAAOG,GAAOT,EAAIS,EAAQ,CAAIH,EAAOR,QAAUE,EAASG,GAASA,EAAMW,IAAId,EAAKM,GAAW,OAAOA,CAAQ,CATvxBS,CAAwB,EAAQ,SACxCC,EAAaC,EAAuB,EAAQ,SAC5CC,EAAYD,EAAuB,EAAQ,SAC3CG,EAAU,EAAQ,QAClBC,EAAe,EAAQ,QACvBC,EAAS,EAAQ,QACjBC,EAAON,EAAuB,EAAQ,SAC1C,SAASA,EAAuBjB,GAAO,OAAOA,GAAOA,EAAIE,WAAaF,EAAM,CAAEF,QAASE,EAAO,CAC9F,SAASI,EAAyBH,GAAe,GAAuB,mBAAZuB,QAAwB,OAAO,KAAM,IAAIC,EAAoB,IAAID,QAAeE,EAAmB,IAAIF,QAAW,OAAQpB,EAA2B,SAAUH,GAAe,OAAOA,EAAcyB,EAAmBD,CAAmB,GAAGxB,EAAc,CAEtT,SAASoC,EAAgBrC,EAAKS,EAAKf,GAA4L,OAAnLe,EAC5C,SAAwB6B,GAAO,IAAI7B,EACnC,SAAsB8B,EAAOC,GAAQ,GAAqB,iBAAVD,GAAgC,OAAVA,EAAgB,OAAOA,EAAO,IAAIE,EAAOF,EAAMG,OAAOC,aAAc,QAAaC,IAATH,EAAoB,CAAE,IAAII,EAAMJ,EAAK7B,KAAK2B,EAAOC,GAAQ,WAAY,GAAmB,iBAARK,EAAkB,OAAOA,EAAK,MAAM,IAAIC,UAAU,+CAAiD,CAAE,OAAiB,WAATN,EAAoBO,OAASC,QAAQT,EAAQ,CAD/UU,CAAaX,EAAK,UAAW,MAAsB,iBAAR7B,EAAmBA,EAAMsC,OAAOtC,EAAM,CADxEyC,CAAezC,MAAiBT,EAAOT,OAAOC,eAAeQ,EAAKS,EAAK,CAAEf,MAAOA,EAAOC,YAAY,EAAMwD,cAAc,EAAMC,UAAU,IAAkBpD,EAAIS,GAAOf,EAAgBM,CAAK,CAM3O,MAAMyI,EACG,CACLC,MAAO,aACPC,KAAM,YACNC,KAAM,YAJJH,EAMG,CACLC,MAAO,YACPC,KAAM,YACNC,KAAM,WAKV,IAAIC,EAAeJ,EAoCnB,MAAMK,UAAsB/I,EAAMuD,UAChC,WAAAQ,GACEE,SAAShC,WACTK,EAAgBD,KAAM,YAAY,GAElCC,EAAgBD,KAAM,QAAS2G,KAC/B1G,EAAgBD,KAAM,QAAS2G,KAC/B1G,EAAgBD,KAAM,kBAAmB,MACzCC,EAAgBD,KAAM,WAAW,GACjCC,EAAgBD,KAAM,mBAAmB6B,IAKvC,GAHA7B,KAAK2B,MAAMiF,YAAY/E,IAGlB7B,KAAK2B,MAAMkF,eAAqC,iBAAbhF,EAAEiF,QAAoC,IAAbjF,EAAEiF,OAAc,OAAO,EAGxF,MAAMC,EAAW/G,KAAKyD,cACtB,IAAKsD,IAAaA,EAASC,gBAAkBD,EAASC,cAAcC,KAClE,MAAM,IAAIC,MAAM,6CAElB,MAAM,cACJF,GACED,EAGJ,GAAI/G,KAAK2B,MAAMwF,YAActF,EAAEnC,kBAAkBsH,EAAcI,YAAYC,OAASrH,KAAK2B,MAAM2F,UAAW,EAAItI,EAAQuI,6BAA6B1F,EAAEnC,OAAQM,KAAK2B,MAAM2F,OAAQP,IAAa/G,KAAK2B,MAAM6F,SAAU,EAAIxI,EAAQuI,6BAA6B1F,EAAEnC,OAAQM,KAAK2B,MAAM6F,OAAQT,GACtR,OAKa,eAAXlF,EAAE4F,MAAuB5F,EAAE6F,iBAK/B,MAAMC,GAAkB,EAAI3I,EAAQ4I,oBAAoB/F,GACxD7B,KAAK2H,gBAAkBA,EAGvB,MAAMrG,GAAW,EAAIrC,EAAa4I,oBAAoBhG,EAAG8F,EAAiB3H,MAC1E,GAAgB,MAAZsB,EAAkB,OACtB,MAAM,EACJE,EAAC,EACDC,GACEH,EAGEwG,GAAY,EAAI7I,EAAa8I,gBAAgB/H,KAAMwB,EAAGC,IAC5D,EAAItC,EAAKzB,SAAS,qCAAsCoK,IAGxD,EAAI3I,EAAKzB,SAAS,UAAWsC,KAAK2B,MAAMI,UAEnB,IADA/B,KAAK2B,MAAMI,QAAQF,EAAGiG,KACI,IAAjB9H,KAAKgI,UAI/BhI,KAAK2B,MAAMsG,uBAAsB,EAAIjJ,EAAQkJ,qBAAqBlB,GAKtEhH,KAAKkC,UAAW,EAChBlC,KAAKmI,MAAQ3G,EACbxB,KAAKoI,MAAQ3G,GAKb,EAAIzC,EAAQqJ,UAAUrB,EAAeP,EAAaF,KAAMvG,KAAKsI,aAC7D,EAAItJ,EAAQqJ,UAAUrB,EAAeP,EAAaD,KAAMxG,KAAKuI,gBAAe,IAE9EtI,EAAgBD,KAAM,cAAc6B,IAElC,MAAMP,GAAW,EAAIrC,EAAa4I,oBAAoBhG,EAAG7B,KAAK2H,gBAAiB3H,MAC/E,GAAgB,MAAZsB,EAAkB,OACtB,IAAI,EACFE,EAAC,EACDC,GACEH,EAGJ,GAAIkH,MAAMC,QAAQzI,KAAK2B,MAAM+G,MAAO,CAClC,IAAI7F,EAASrB,EAAIxB,KAAKmI,MACpBrF,EAASrB,EAAIzB,KAAKoI,MAEpB,IADCvF,EAAQC,IAAU,EAAI7D,EAAa0J,YAAY3I,KAAK2B,MAAM+G,KAAM7F,EAAQC,IACpED,IAAWC,EAAQ,OACxBtB,EAAIxB,KAAKmI,MAAQtF,EAAQpB,EAAIzB,KAAKoI,MAAQtF,CAC5C,CACA,MAAMgF,GAAY,EAAI7I,EAAa8I,gBAAgB/H,KAAMwB,EAAGC,IAC5D,EAAItC,EAAKzB,SAAS,gCAAiCoK,GAInD,IAAqB,IADA9H,KAAK2B,MAAMoB,OAAOlB,EAAGiG,KACK,IAAjB9H,KAAKgI,QAcnChI,KAAKmI,MAAQ3G,EACbxB,KAAKoI,MAAQ3G,OAdX,IAEEzB,KAAKuI,eAAe,IAAIK,WAAW,WACrC,CAAE,MAAOC,GAEP,MAAMC,EAAUC,SAASC,YAAY,eAGrCF,EAAMG,eAAe,WAAW,GAAM,EAAM1F,OAAQ,EAAG,EAAG,EAAG,EAAG,GAAG,GAAO,GAAO,GAAO,EAAO,EAAG,MAClGvD,KAAKuI,eAAeO,EACtB,CAIY,IAEhB7I,EAAgBD,KAAM,kBAAkB6B,IACtC,IAAK7B,KAAKkC,SAAU,OACpB,MAAMZ,GAAW,EAAIrC,EAAa4I,oBAAoBhG,EAAG7B,KAAK2H,gBAAiB3H,MAC/E,GAAgB,MAAZsB,EAAkB,OACtB,IAAI,EACFE,EAAC,EACDC,GACEH,EAGJ,GAAIkH,MAAMC,QAAQzI,KAAK2B,MAAM+G,MAAO,CAClC,IAAI7F,EAASrB,EAAIxB,KAAKmI,OAAS,EAC3BrF,EAASrB,EAAIzB,KAAKoI,OAAS,GAC9BvF,EAAQC,IAAU,EAAI7D,EAAa0J,YAAY3I,KAAK2B,MAAM+G,KAAM7F,EAAQC,GACzEtB,EAAIxB,KAAKmI,MAAQtF,EAAQpB,EAAIzB,KAAKoI,MAAQtF,CAC5C,CACA,MAAMgF,GAAY,EAAI7I,EAAa8I,gBAAgB/H,KAAMwB,EAAGC,GAI5D,IAAuB,IADAzB,KAAK2B,MAAMqB,OAAOnB,EAAGiG,KACK,IAAjB9H,KAAKgI,QAAmB,OAAO,EAC/D,MAAMjB,EAAW/G,KAAKyD,cAClBsD,GAEE/G,KAAK2B,MAAMsG,uBAAsB,EAAIjJ,EAAQkK,wBAAwBnC,EAASC,gBAEpF,EAAI7H,EAAKzB,SAAS,oCAAqCoK,GAGvD9H,KAAKkC,UAAW,EAChBlC,KAAKmI,MAAQxB,IACb3G,KAAKoI,MAAQzB,IACTI,KAEF,EAAI5H,EAAKzB,SAAS,qCAClB,EAAIsB,EAAQmK,aAAapC,EAASC,cAAeP,EAAaF,KAAMvG,KAAKsI,aACzE,EAAItJ,EAAQmK,aAAapC,EAASC,cAAeP,EAAaD,KAAMxG,KAAKuI,gBAC3E,IAEFtI,EAAgBD,KAAM,eAAe6B,IACnC4E,EAAeJ,EAERrG,KAAKoJ,gBAAgBvH,MAE9B5B,EAAgBD,KAAM,aAAa6B,IACjC4E,EAAeJ,EACRrG,KAAKuI,eAAe1G,MAG7B5B,EAAgBD,KAAM,gBAAgB6B,IAEpC4E,EAAeJ,EACRrG,KAAKoJ,gBAAgBvH,MAE9B5B,EAAgBD,KAAM,cAAc6B,IAElC4E,EAAeJ,EACRrG,KAAKuI,eAAe1G,KAE/B,CACA,iBAAAyB,GACEtD,KAAKgI,SAAU,EAGf,MAAMjB,EAAW/G,KAAKyD,cAClBsD,IACF,EAAI/H,EAAQqJ,UAAUtB,EAAUV,EAAgBC,MAAOtG,KAAKqJ,aAAc,CACxEC,SAAS,GAGf,CACA,oBAAA5F,GACE1D,KAAKgI,SAAU,EAGf,MAAMjB,EAAW/G,KAAKyD,cACtB,GAAIsD,EAAU,CACZ,MAAM,cACJC,GACED,GACJ,EAAI/H,EAAQmK,aAAanC,EAAeX,EAAgBE,KAAMvG,KAAKsI,aACnE,EAAItJ,EAAQmK,aAAanC,EAAeX,EAAgBE,KAAMvG,KAAKsI,aACnE,EAAItJ,EAAQmK,aAAanC,EAAeX,EAAgBG,KAAMxG,KAAKuI,iBACnE,EAAIvJ,EAAQmK,aAAanC,EAAeX,EAAgBG,KAAMxG,KAAKuI,iBACnE,EAAIvJ,EAAQmK,aAAapC,EAAUV,EAAgBC,MAAOtG,KAAKqJ,aAAc,CAC3EC,SAAS,IAEPtJ,KAAK2B,MAAMsG,uBAAsB,EAAIjJ,EAAQkK,wBAAwBlC,EAC3E,CACF,CAIA,WAAAvD,GACE,IAAIG,EAAa2F,EACjB,OAAsC,QAA9B3F,EAAc5D,KAAK2B,aAAmC,IAAhBiC,GAA0BA,EAAYC,QAA0C,QAA/B0F,EAAevJ,KAAK2B,aAAoC,IAAjB4H,GAAqE,QAAzCA,EAAeA,EAAa1F,eAAsC,IAAjB0F,OAA0B,EAASA,EAAazF,QAAUhF,EAAUpB,QAAQ+F,YAAYzD,KAC7S,CACA,MAAA+D,GAGE,OAAoBpG,EAAM0H,aAAa1H,EAAM2H,SAASC,KAAKvF,KAAK2B,MAAMsC,UAAW,CAG/E2C,YAAa5G,KAAK4G,YAClB4C,UAAWxJ,KAAKwJ,UAIhBC,WAAYzJ,KAAKyJ,YAErB,EAEFpM,EAAA,QAAkBqJ,EAClBzG,EAAgByG,EAAe,cAAe,iBAC9CzG,EAAgByG,EAAe,YAAa,CAO1CG,cAAejI,EAAWlB,QAAQgM,KAClCzF,SAAUrF,EAAWlB,QAAQiM,KAAKC,WAKlCzC,SAAUvI,EAAWlB,QAAQgM,KAM7BzB,qBAAsBrJ,EAAWlB,QAAQgM,KAKzCG,aAAc,SAAUlI,EAAgCmI,GACtD,GAAInI,EAAMmI,IAA0C,IAA7BnI,EAAMmI,GAAUC,SACrC,MAAM,IAAI7C,MAAM,+CAEpB,EAIAwB,KAAM9J,EAAWlB,QAAQsM,QAAQpL,EAAWlB,QAAQoI,QAqBpDwB,OAAQ1I,EAAWlB,QAAQwI,OAqB3BsB,OAAQ5I,EAAWlB,QAAQwI,OAkB3BrC,QAASjF,EAAWlB,QAAQuM,OAK5BlI,QAASnD,EAAWlB,QAAQwM,KAK5BnH,OAAQnE,EAAWlB,QAAQwM,KAK3BlH,OAAQpE,EAAWlB,QAAQwM,KAK3BtD,YAAahI,EAAWlB,QAAQwM,KAIhC5F,MAAO1F,EAAWlB,QAAQoI,OAI1Bb,UAAW/F,EAAOiH,UAClB3B,MAAOtF,EAAOiH,UACdX,UAAWtG,EAAOiH,YAEpBlG,EAAgByG,EAAe,eAAgB,CAC7CG,eAAe,EAEfM,UAAU,EACVc,sBAAsB,EACtBlG,QAAS,WAAa,EACtBgB,OAAQ,WAAa,EACrBC,OAAQ,WAAa,EACrB4D,YAAa,WAAa,EAC1BtC,MAAO,G,iBC9aT,MACE5G,QAASuD,EAAS,cAClByF,GACE,EAAQ,QAKZyD,EAAO9M,QAAU4D,EACjBkJ,EAAO9M,QAAP,QAAyB4D,EACzBkJ,EAAO9M,QAAQqJ,cAAgBA,C,mBCV/BvJ,OAAOC,eAAeC,EAAS,aAAc,CAC3CC,OAAO,IAETD,EAAQ+M,aAAeA,EACvB/M,EAAQgL,SAkDR,SAAkBgC,EAAgBvB,EAAoBwB,EAAwBC,GAC5E,IAAKF,EAAI,OACT,MAAMG,EAAU,CACdC,SAAS,KACNF,GAGDF,EAAGK,iBACLL,EAAGK,iBAAiB5B,EAAOwB,EAASE,GAC3BH,EAAGM,YACZN,EAAGM,YAAY,KAAO7B,EAAOwB,GAG7BD,EAAG,KAAOvB,GAASwB,CAEvB,EAhEAjN,EAAQ6K,oBAsKR,SAA6B0C,GAC3B,IAAKA,EAAK,OACV,IAAIC,EAAUD,EAAIE,eAAe,4BAC5BD,IACHA,EAAUD,EAAI1F,cAAc,SAC5B2F,EAAQpD,KAAO,WACfoD,EAAQE,GAAK,2BACbF,EAAQG,UAAY,6EACpBH,EAAQG,WAAa,wEACrBJ,EAAIK,qBAAqB,QAAQ,GAAGC,YAAYL,IAE9CD,EAAI3D,MAAMmD,EAAaQ,EAAI3D,KAAM,wCACvC,EAjLA5J,EAAQ2H,mBAiIR,SAA4BmG,EAAkC9G,GAC5D,MAAM+G,EAAcC,EAAeF,EAAY9G,EAAgB,MAC/D,MAAO,CACL,EAAC,EAAIiH,EAAWC,oBAAoB,YAAaD,EAAW5N,UAAW0N,EAE3E,EArIA/N,EAAQ0H,mBAsIR,SAA4BoG,EAAkC9G,GAE5D,OADoBgH,EAAeF,EAAY9G,EAAgB,GAEjE,EAxIAhH,EAAQmO,SAsJR,SAAkB3J,EAAyB4J,GACzC,OAAO5J,EAAE6J,gBAAiB,EAAIxM,EAAOyM,aAAa9J,EAAE6J,eAAeE,GAAKH,IAAeG,EAAEH,cAAe5J,EAAEgK,iBAAkB,EAAI3M,EAAOyM,aAAa9J,EAAEgK,gBAAgBD,GAAKH,IAAeG,EAAEH,YAC9L,EAvJApO,EAAQuK,mBAwJR,SAA4B/F,GAC1B,GAAIA,EAAE6J,eAAiB7J,EAAE6J,cAAc,GAAI,OAAO7J,EAAE6J,cAAc,GAAGD,WACrE,GAAI5J,EAAEgK,gBAAkBhK,EAAEgK,eAAe,GAAI,OAAOhK,EAAEgK,eAAe,GAAGJ,UAC1E,EA1JApO,EAAQgO,eAAiBA,EACzBhO,EAAQyO,YA6FR,SAAqBnC,GACnB,IAAIoC,EAASpC,EAAKqC,aAClB,MAAMC,EAAgBtC,EAAK3C,cAAcI,YAAY8E,iBAAiBvC,GAGtE,OAFAoC,IAAU,EAAI7M,EAAOiN,KAAKF,EAAcG,YACxCL,IAAU,EAAI7M,EAAOiN,KAAKF,EAAcI,eACjCN,CACT,EAlGA1O,EAAQiP,WAmGR,SAAoB3C,GAClB,IAAI4C,EAAQ5C,EAAK6C,YACjB,MAAMP,EAAgBtC,EAAK3C,cAAcI,YAAY8E,iBAAiBvC,GAGtE,OAFA4C,IAAS,EAAIrN,EAAOiN,KAAKF,EAAcQ,aACvCF,IAAS,EAAIrN,EAAOiN,KAAKF,EAAcS,cAChCH,CACT,EAxGAlP,EAAQsP,gBAAkBA,EAC1BtP,EAAQkK,4BA8BR,SAAqC8C,EAAeuC,EAAuBC,GACzE,IAAIlD,EAAOU,EACX,EAAG,CACD,GAAIsC,EAAgBhD,EAAMiD,GAAW,OAAO,EAC5C,GAAIjD,IAASkD,EAAU,OAAO,EAE9BlD,EAAOA,EAAKmD,UACd,OAASnD,GACT,OAAO,CACT,EAtCAtM,EAAQ0P,mBA2GR,SAA4BC,EAA2BnD,EAAgCvF,GACrF,MACM2I,EADSpD,IAAiBA,EAAa7C,cAAcC,KACzB,CAChCpB,KAAM,EACNG,IAAK,GACH6D,EAAaqD,wBACX1L,GAAKwL,EAAIG,QAAUtD,EAAauD,WAAaH,EAAiBpH,MAAQvB,EACtE7C,GAAKuL,EAAIK,QAAUxD,EAAayD,UAAYL,EAAiBjH,KAAO1B,EAC1E,MAAO,CACL9C,IACAC,IAEJ,EAtHApE,EAAQkQ,YAsER,SAAqB5D,GAGnB,IAAIoC,EAASpC,EAAKqC,aAClB,MAAMC,EAAgBtC,EAAK3C,cAAcI,YAAY8E,iBAAiBvC,GAGtE,OAFAoC,IAAU,EAAI7M,EAAOiN,KAAKF,EAAcuB,gBACxCzB,IAAU,EAAI7M,EAAOiN,KAAKF,EAAcwB,mBACjC1B,CACT,EA7EA1O,EAAQqQ,WA8ER,SAAoB/D,GAGlB,IAAI4C,EAAQ5C,EAAK6C,YACjB,MAAMP,EAAgBtC,EAAK3C,cAAcI,YAAY8E,iBAAiBvC,GAGtE,OAFA4C,IAAS,EAAIrN,EAAOiN,KAAKF,EAAc0B,iBACvCpB,IAAS,EAAIrN,EAAOiN,KAAKF,EAAc2B,kBAChCrB,CACT,EArFAlP,EAAQwQ,gBAAkBA,EAC1BxQ,EAAQ8L,YAmDR,SAAqBkB,EAAgBvB,EAAoBwB,EAAwBC,GAC/E,IAAKF,EAAI,OACT,MAAMG,EAAU,CACdC,SAAS,KACNF,GAGDF,EAAGyD,oBACLzD,EAAGyD,oBAAoBhF,EAAOwB,EAASE,GAC9BH,EAAG0D,YACZ1D,EAAG0D,YAAY,KAAOjF,EAAOwB,GAG7BD,EAAG,KAAOvB,GAAS,IAEvB,EAjEAzL,EAAQ6L,uBAoKR,SAAgC0B,GAC9B,IAAKA,EAAK,OACV,IAGE,GAFIA,EAAI3D,MAAM4G,EAAgBjD,EAAI3D,KAAM,yCAEpC2D,EAAIoD,UAENpD,EAAIoD,UAAUC,YACT,CAGL,MAAMD,GAAapD,EAAIxD,aAAe7D,QAAQ2K,eAC1CF,GAAgC,UAAnBA,EAAUvG,MACzBuG,EAAUG,iBAEd,CACF,CAAE,MAAOtM,GAET,CACF,EAtLA,IAAI3C,EAAS,EAAQ,QACjBoM,EAEJ,SAAiC1N,EAAKC,GAAe,IAAKA,GAAeD,GAAOA,EAAIE,WAAc,OAAOF,EAAO,GAAY,OAARA,GAA+B,iBAARA,GAAmC,mBAARA,EAAsB,MAAO,CAAEF,QAASE,GAAS,IAAIG,EAAQC,EAAyBH,GAAc,GAAIE,GAASA,EAAME,IAAIL,GAAQ,OAAOG,EAAMP,IAAII,GAAQ,IAAIM,EAAS,CAAC,EAAOC,EAAwBhB,OAAOC,gBAAkBD,OAAOiB,yBAA0B,IAAK,IAAIC,KAAOT,EAAO,GAAY,YAARS,GAAqBlB,OAAOmB,UAAUC,eAAeC,KAAKZ,EAAKS,GAAM,CAAE,IAAII,EAAON,EAAwBhB,OAAOiB,yBAAyBR,EAAKS,GAAO,KAAUI,IAASA,EAAKjB,KAAOiB,EAAKC,KAAQvB,OAAOC,eAAec,EAAQG,EAAKI,GAAgBP,EAAOG,GAAOT,EAAIS,EAAQ,CAAIH,EAAOR,QAAUE,EAASG,GAASA,EAAMW,IAAId,EAAKM,GAAW,OAAOA,CAAQ,CAFlxBS,CAAwB,EAAQ,SACjD,SAASX,EAAyBH,GAAe,GAAuB,mBAAZuB,QAAwB,OAAO,KAAM,IAAIC,EAAoB,IAAID,QAAeE,EAAmB,IAAIF,QAAW,OAAQpB,EAA2B,SAAUH,GAAe,OAAOA,EAAcyB,EAAmBD,CAAmB,GAAGxB,EAAc,CAGtT,IAAIuQ,EAAsB,GAC1B,SAASzB,EAAgBtC,EAAeuC,GAUtC,OATKwB,IACHA,GAAsB,EAAIlP,EAAOyM,aAAa,CAAC,UAAW,wBAAyB,qBAAsB,oBAAqB,qBAAqB,SAAU0C,GAE3J,OAAO,EAAInP,EAAOoP,YAAYjE,EAAGgE,GACnC,QAKG,EAAInP,EAAOoP,YAAYjE,EAAG+D,KAGxB/D,EAAG+D,GAAqBxB,EACjC,CAwGA,SAASvB,EAAejK,EAAciD,EAAoDkK,GACxF,IAAI,EACF/M,EAAC,EACDC,GACwBL,EACtBgK,EAAc,aAAaoD,OAAOhN,GAAGgN,OAAOD,EAAY,KAAKC,OAAO/M,GAAG+M,OAAOD,EAAY,KAC9F,GAAIlK,EAAgB,CAClB,MAAMoK,EAAW,GAAGD,OAAmC,iBAArBnK,EAAe7C,EAAiB6C,EAAe7C,EAAI6C,EAAe7C,EAAI+M,GAClGG,EAAW,GAAGF,OAAmC,iBAArBnK,EAAe5C,EAAiB4C,EAAe5C,EAAI4C,EAAe5C,EAAI8M,GACxGnD,EAAc,aAAaoD,OAAOC,EAAU,MAAMD,OAAOE,EAAU,KAAOtD,CAC5E,CACA,OAAOA,CACT,CA+CA,SAAShB,EAAaC,EAAsBpF,GACtCoF,EAAGsE,UACLtE,EAAGsE,UAAUC,IAAI3J,GAEZoF,EAAGpF,UAAU4J,MAAM,IAAIC,OAAO,YAAYN,OAAOvJ,EAAW,eAC/DoF,EAAGpF,WAAa,IAAIuJ,OAAOvJ,GAGjC,CACA,SAAS4I,EAAgBxD,EAAsBpF,GACzCoF,EAAGsE,UACLtE,EAAGsE,UAAUI,OAAO9J,GAEpBoF,EAAGpF,UAAYoF,EAAGpF,UAAU+J,QAAQ,IAAIF,OAAO,YAAYN,OAAOvJ,EAAW,WAAY,KAAM,GAEnG,C,eC3NA9H,OAAOC,eAAeC,EAAS,aAAc,CAC3CC,OAAO,IAETD,EAAQkO,mBAAqBA,EAC7BlO,EAAQ4R,qBAwBR,SAA8BC,EAAmBC,GAC/C,OAAOA,EAAS,IAAIX,OAAOW,EAAOC,cAAe,KAAKZ,OAAOU,GAAQA,CACvE,EAzBA7R,EAAA,aAAkB,EAClBA,EAAQgS,UAAYA,EACpB,MAAMC,EAAW,CAAC,MAAO,SAAU,IAAK,MACxC,SAASD,IACP,IAAIE,EACJ,IAAIL,EAAoBtP,UAAUC,OAAS,QAAsBW,IAAjBZ,UAAU,GAAmBA,UAAU,GAAK,YAG5F,GAAsB,oBAAX2D,OAAwB,MAAO,GAI1C,MAAMiB,EAAiD,QAAxC+K,EAAmBhM,OAAOwF,gBAA2C,IAArBwG,GAAyF,QAAzDA,EAAmBA,EAAiBC,uBAAkD,IAArBD,OAA8B,EAASA,EAAiB/K,MACxN,IAAKA,EAAO,MAAO,GACnB,GAAI0K,KAAQ1K,EAAO,MAAO,GAC1B,IAAK,IAAI7E,EAAI,EAAGA,EAAI2P,EAASzP,OAAQF,IACnC,GAAI4L,EAAmB2D,EAAMI,EAAS3P,MAAO6E,EAAO,OAAO8K,EAAS3P,GAEtE,MAAO,EACT,CACA,SAAS4L,EAAmB2D,EAAmBC,GAC7C,OAAOA,EAAS,GAAGX,OAAOW,GAAQX,OAKpC,SAA0BiB,GACxB,IAAIC,EAAM,GACNC,GAAmB,EACvB,IAAK,IAAIhQ,EAAI,EAAGA,EAAI8P,EAAI5P,OAAQF,IAC1BgQ,GACFD,GAAOD,EAAI9P,GAAGiQ,cACdD,GAAmB,GACC,MAAXF,EAAI9P,GACbgQ,GAAmB,EAEnBD,GAAOD,EAAI9P,GAGf,OAAO+P,CACT,CAnB2CG,CAAiBX,IAASA,CACrE,CAuBe7R,EAAA,QAAmBgS,G,eClDlClS,OAAOC,eAAeC,EAAS,aAAc,CAC3CC,OAAO,IAETD,EAAA,QAEA,WACM,CACN,C,iBCPAF,OAAOC,eAAeC,EAAS,aAAc,CAC3CC,OAAO,IAETD,EAAQwH,SA8DR,SAAkBH,GAChB,MAAgC,SAAzBA,EAAU/C,MAAMqC,MAA4C,MAAzBU,EAAU/C,MAAMqC,IAC5D,EA/DA3G,EAAQyH,SAgER,SAAkBJ,GAChB,MAAgC,SAAzBA,EAAU/C,MAAMqC,MAA4C,MAAzBU,EAAU/C,MAAMqC,IAC5D,EAjEA3G,EAAQ0K,eA8ER,SAAwBrD,EAA+BlD,EAAgBC,GACrE,MAAMqO,IAAW,EAAI5Q,EAAO6Q,OAAOrL,EAAUyD,OACvCwB,EAAOlG,EAAYiB,GACzB,OAAIoL,EAEK,CACLnG,OACA9G,OAAQ,EACRC,OAAQ,EACRqF,MAAO3G,EACP4G,MAAO3G,EACPD,IACAC,KAIK,CACLkI,OACA9G,OAAQrB,EAAIkD,EAAUyD,MACtBrF,OAAQrB,EAAIiD,EAAU0D,MACtBD,MAAOzD,EAAUyD,MACjBC,MAAO1D,EAAU0D,MACjB5G,IACAC,IAGN,EAvGApE,EAAQ2E,oBA0GR,SAA6B0C,EAA2B5C,GACtD,MAAMwC,EAAQI,EAAU/C,MAAM2C,MAC9B,MAAO,CACLqF,KAAM7H,EAAS6H,KACfnI,EAAGkD,EAAUtC,MAAMZ,EAAIM,EAASe,OAASyB,EACzC7C,EAAGiD,EAAUtC,MAAMX,EAAIK,EAASgB,OAASwB,EACzCzB,OAAQf,EAASe,OAASyB,EAC1BxB,OAAQhB,EAASgB,OAASwB,EAC1B6D,MAAOzD,EAAUtC,MAAMZ,EACvB4G,MAAO1D,EAAUtC,MAAMX,EAE3B,EApHApE,EAAQuF,iBAQR,SAA0B8B,EAA2BlD,EAAgBC,GAEnE,IAAKiD,EAAU/C,MAAMc,OAAQ,MAAO,CAACjB,EAAGC,GAGxC,IAAI,OACFgB,GACEiC,EAAU/C,MACdc,EAA2B,iBAAXA,EAAsBA,EAuGxC,SAAqBA,GACnB,MAAO,CACLoD,KAAMpD,EAAOoD,KACbG,IAAKvD,EAAOuD,IACZD,MAAOtD,EAAOsD,MACdE,OAAQxD,EAAOwD,OAEnB,CA9GiD+J,CAAYvN,GAC3D,MAAMkH,EAAOlG,EAAYiB,GACzB,GAAsB,iBAAXjC,EAAqB,CAC9B,MAAM,cACJuE,GACE2C,EACEsG,EAAcjJ,EAAcI,YAClC,IAAI8I,EAMJ,GAJEA,EADa,WAAXzN,EACUkH,EAAKmD,WAEL9F,EAAcmJ,cAAc1N,KAEpCyN,aAAqBD,EAAYG,aACrC,MAAM,IAAIlJ,MAAM,oBAAsBzE,EAAS,gCAEjD,MAAM4N,EAAgCH,EAChCI,EAAYL,EAAY/D,iBAAiBvC,GACzC4G,EAAiBN,EAAY/D,iBAAiBmE,GAEpD5N,EAAS,CACPoD,MAAO8D,EAAK6G,YAAa,EAAItR,EAAOiN,KAAKoE,EAAe9D,cAAe,EAAIvN,EAAOiN,KAAKmE,EAAUG,YACjGzK,KAAM2D,EAAK+G,WAAY,EAAIxR,EAAOiN,KAAKoE,EAAenE,aAAc,EAAIlN,EAAOiN,KAAKmE,EAAUK,WAC9F5K,OAAO,EAAI/G,EAAQsN,YAAY+D,IAAe,EAAIrR,EAAQ0O,YAAY/D,GAAQA,EAAK6G,YAAa,EAAItR,EAAOiN,KAAKoE,EAAe7D,eAAgB,EAAIxN,EAAOiN,KAAKmE,EAAUM,aACzK3K,QAAQ,EAAIjH,EAAQ8M,aAAauE,IAAe,EAAIrR,EAAQuO,aAAa5D,GAAQA,EAAK+G,WAAY,EAAIxR,EAAOiN,KAAKoE,EAAelE,gBAAiB,EAAInN,EAAOiN,KAAKmE,EAAUO,cAEhL,EAGI,EAAI3R,EAAO6Q,OAAOtN,EAAOsD,SAAQvE,EAAIsP,KAAKC,IAAIvP,EAAGiB,EAAOsD,SACxD,EAAI7G,EAAO6Q,OAAOtN,EAAOwD,UAASxE,EAAIqP,KAAKC,IAAItP,EAAGgB,EAAOwD,UAGzD,EAAI/G,EAAO6Q,OAAOtN,EAAOoD,QAAOrE,EAAIsP,KAAKE,IAAIxP,EAAGiB,EAAOoD,QACvD,EAAI3G,EAAO6Q,OAAOtN,EAAOuD,OAAMvE,EAAIqP,KAAKE,IAAIvP,EAAGgB,EAAOuD,MAC1D,MAAO,CAACxE,EAAGC,EACb,EAnDApE,EAAQwK,mBAiER,SAA4BhG,EAAyB8F,EAA+BsJ,GAClF,MAAMC,EAAsC,iBAApBvJ,GAA+B,EAAI3I,EAAQwM,UAAU3J,EAAG8F,GAAmB,KACnG,GAA+B,iBAApBA,IAAiCuJ,EAAU,OAAO,KAC7D,MAAMvH,EAAOlG,EAAYwN,GAEnBpH,EAAeoH,EAActP,MAAMkI,cAAgBF,EAAKE,cAAgBF,EAAK3C,cAAcC,KACjG,OAAO,EAAIjI,EAAQ+N,oBAAoBmE,GAAYrP,EAAGgI,EAAcoH,EAActP,MAAM2C,MAC1F,EAvEAjH,EAAQsL,WAmDR,SAAoBD,EAA6ByI,EAAuBC,GACtE,MAAM5P,EAAIsP,KAAKO,MAAMF,EAAWzI,EAAK,IAAMA,EAAK,GAC1CjH,EAAIqP,KAAKO,MAAMD,EAAW1I,EAAK,IAAMA,EAAK,GAChD,MAAO,CAAClH,EAAGC,EACb,EAtDA,IAAIvC,EAAS,EAAQ,QACjBF,EAAU,EAAQ,QA2HtB,SAASyE,EAAYiB,GACnB,MAAMiF,EAAOjF,EAAUjB,cACvB,IAAKkG,EACH,MAAM,IAAIzC,MAAM,4CAGlB,OAAOyC,CACT,C,eC7IAxM,OAAOC,eAAeC,EAAS,aAAc,CAC3CC,OAAO,IAETD,EAAQ8I,UAqBR,SAAmBxE,EAAoBmI,EAAuBwH,GAC5D,GAAI3P,EAAMmI,GACR,OAAO,IAAI5C,MAAM,gBAAgBsH,OAAO1E,EAAU,eAAe0E,OAAO8C,EAAe,4CAE3F,EAxBAjU,EAAQsO,YAKR,SAAqB4F,EAAoCC,GACvD,IAAK,IAAI7R,EAAI,EAAGE,EAAS0R,EAAM1R,OAAQF,EAAIE,EAAQF,IACjD,GAAI6R,EAASzR,MAAMyR,EAAU,CAACD,EAAM5R,GAAIA,EAAG4R,IAAS,OAAOA,EAAM5R,EAErE,EARAtC,EAAQ8O,IAgBR,SAAasF,GACX,OAAOC,SAASD,EAAG,GACrB,EAjBApU,EAAQiR,WAQR,SAAoBpE,GAElB,MAAuB,mBAATA,GAAgE,sBAAzC/M,OAAOmB,UAAUqT,SAASnT,KAAK0L,EACtE,EAVA7M,EAAQ0S,MAWR,SAAe6B,GACb,MAAsB,iBAARA,IAAqBC,MAAMD,EAC3C,C","sources":["webpack://acura/./node_modules/react-draggable/build/cjs/Draggable.js","webpack://acura/./node_modules/react-draggable/build/cjs/DraggableCore.js","webpack://acura/./node_modules/react-draggable/build/cjs/cjs.js","webpack://acura/./node_modules/react-draggable/build/cjs/utils/domFns.js","webpack://acura/./node_modules/react-draggable/build/cjs/utils/getPrefix.js","webpack://acura/./node_modules/react-draggable/build/cjs/utils/log.js","webpack://acura/./node_modules/react-draggable/build/cjs/utils/positionFns.js","webpack://acura/./node_modules/react-draggable/build/cjs/utils/shims.js"],"sourcesContent":["\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nObject.defineProperty(exports, \"DraggableCore\", {\n  enumerable: true,\n  get: function () {\n    return _DraggableCore.default;\n  }\n});\nexports.default = void 0;\nvar React = _interopRequireWildcard(require(\"react\"));\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\nvar _reactDom = _interopRequireDefault(require(\"react-dom\"));\nvar _clsx = _interopRequireDefault(require(\"clsx\"));\nvar _domFns = require(\"./utils/domFns\");\nvar _positionFns = require(\"./utils/positionFns\");\nvar _shims = require(\"./utils/shims\");\nvar _DraggableCore = _interopRequireDefault(require(\"./DraggableCore\"));\nvar _log = _interopRequireDefault(require(\"./utils/log\"));\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\nfunction _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== \"object\" && typeof obj !== \"function\") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\nfunction _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return typeof key === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (typeof input !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (typeof res !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); } /*:: import type {ControlPosition, PositionOffsetControlPosition, DraggableCoreProps, DraggableCoreDefaultProps} from './DraggableCore';*/\n/*:: import type {Bounds, DraggableEventHandler} from './utils/types';*/\n/*:: import type {Element as ReactElement} from 'react';*/\n/*:: type DraggableState = {\n  dragging: boolean,\n  dragged: boolean,\n  x: number, y: number,\n  slackX: number, slackY: number,\n  isElementSVG: boolean,\n  prevPropsPosition: ?ControlPosition,\n};*/\n/*:: export type DraggableDefaultProps = {\n  ...DraggableCoreDefaultProps,\n  axis: 'both' | 'x' | 'y' | 'none',\n  bounds: Bounds | string | false,\n  defaultClassName: string,\n  defaultClassNameDragging: string,\n  defaultClassNameDragged: string,\n  defaultPosition: ControlPosition,\n  scale: number,\n};*/\n/*:: export type DraggableProps = {\n  ...DraggableCoreProps,\n  ...DraggableDefaultProps,\n  positionOffset: PositionOffsetControlPosition,\n  position: ControlPosition,\n};*/\n//\n// Define <Draggable>\n//\nclass Draggable extends React.Component /*:: <DraggableProps, DraggableState>*/{\n  // React 16.3+\n  // Arity (props, state)\n  static getDerivedStateFromProps(_ref /*:: */, _ref2 /*:: */) /*: ?Partial<DraggableState>*/{\n    let {\n      position\n    } /*: DraggableProps*/ = _ref /*: DraggableProps*/;\n    let {\n      prevPropsPosition\n    } /*: DraggableState*/ = _ref2 /*: DraggableState*/;\n    // Set x/y if a new position is provided in props that is different than the previous.\n    if (position && (!prevPropsPosition || position.x !== prevPropsPosition.x || position.y !== prevPropsPosition.y)) {\n      (0, _log.default)('Draggable: getDerivedStateFromProps %j', {\n        position,\n        prevPropsPosition\n      });\n      return {\n        x: position.x,\n        y: position.y,\n        prevPropsPosition: {\n          ...position\n        }\n      };\n    }\n    return null;\n  }\n  constructor(props /*: DraggableProps*/) {\n    super(props);\n    _defineProperty(this, \"onDragStart\", (e, coreData) => {\n      (0, _log.default)('Draggable: onDragStart: %j', coreData);\n\n      // Short-circuit if user's callback killed it.\n      const shouldStart = this.props.onStart(e, (0, _positionFns.createDraggableData)(this, coreData));\n      // Kills start event on core as well, so move handlers are never bound.\n      if (shouldStart === false) return false;\n      this.setState({\n        dragging: true,\n        dragged: true\n      });\n    });\n    _defineProperty(this, \"onDrag\", (e, coreData) => {\n      if (!this.state.dragging) return false;\n      (0, _log.default)('Draggable: onDrag: %j', coreData);\n      const uiData = (0, _positionFns.createDraggableData)(this, coreData);\n      const newState = {\n        x: uiData.x,\n        y: uiData.y,\n        slackX: 0,\n        slackY: 0\n      };\n\n      // Keep within bounds.\n      if (this.props.bounds) {\n        // Save original x and y.\n        const {\n          x,\n          y\n        } = newState;\n\n        // Add slack to the values used to calculate bound position. This will ensure that if\n        // we start removing slack, the element won't react to it right away until it's been\n        // completely removed.\n        newState.x += this.state.slackX;\n        newState.y += this.state.slackY;\n\n        // Get bound position. This will ceil/floor the x and y within the boundaries.\n        const [newStateX, newStateY] = (0, _positionFns.getBoundPosition)(this, newState.x, newState.y);\n        newState.x = newStateX;\n        newState.y = newStateY;\n\n        // Recalculate slack by noting how much was shaved by the boundPosition handler.\n        newState.slackX = this.state.slackX + (x - newState.x);\n        newState.slackY = this.state.slackY + (y - newState.y);\n\n        // Update the event we fire to reflect what really happened after bounds took effect.\n        uiData.x = newState.x;\n        uiData.y = newState.y;\n        uiData.deltaX = newState.x - this.state.x;\n        uiData.deltaY = newState.y - this.state.y;\n      }\n\n      // Short-circuit if user's callback killed it.\n      const shouldUpdate = this.props.onDrag(e, uiData);\n      if (shouldUpdate === false) return false;\n      this.setState(newState);\n    });\n    _defineProperty(this, \"onDragStop\", (e, coreData) => {\n      if (!this.state.dragging) return false;\n\n      // Short-circuit if user's callback killed it.\n      const shouldContinue = this.props.onStop(e, (0, _positionFns.createDraggableData)(this, coreData));\n      if (shouldContinue === false) return false;\n      (0, _log.default)('Draggable: onDragStop: %j', coreData);\n      const newState /*: Partial<DraggableState>*/ = {\n        dragging: false,\n        slackX: 0,\n        slackY: 0\n      };\n\n      // If this is a controlled component, the result of this operation will be to\n      // revert back to the old position. We expect a handler on `onDragStop`, at the least.\n      const controlled = Boolean(this.props.position);\n      if (controlled) {\n        const {\n          x,\n          y\n        } = this.props.position;\n        newState.x = x;\n        newState.y = y;\n      }\n      this.setState(newState);\n    });\n    this.state = {\n      // Whether or not we are currently dragging.\n      dragging: false,\n      // Whether or not we have been dragged before.\n      dragged: false,\n      // Current transform x and y.\n      x: props.position ? props.position.x : props.defaultPosition.x,\n      y: props.position ? props.position.y : props.defaultPosition.y,\n      prevPropsPosition: {\n        ...props.position\n      },\n      // Used for compensating for out-of-bounds drags\n      slackX: 0,\n      slackY: 0,\n      // Can only determine if SVG after mounting\n      isElementSVG: false\n    };\n    if (props.position && !(props.onDrag || props.onStop)) {\n      // eslint-disable-next-line no-console\n      console.warn('A `position` was applied to this <Draggable>, without drag handlers. This will make this ' + 'component effectively undraggable. Please attach `onDrag` or `onStop` handlers so you can adjust the ' + '`position` of this element.');\n    }\n  }\n  componentDidMount() {\n    // Check to see if the element passed is an instanceof SVGElement\n    if (typeof window.SVGElement !== 'undefined' && this.findDOMNode() instanceof window.SVGElement) {\n      this.setState({\n        isElementSVG: true\n      });\n    }\n  }\n  componentWillUnmount() {\n    this.setState({\n      dragging: false\n    }); // prevents invariant if unmounted while dragging\n  }\n\n  // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find\n  // the underlying DOM node ourselves. See the README for more information.\n  findDOMNode() /*: ?HTMLElement*/{\n    var _this$props$nodeRef$c, _this$props;\n    return (_this$props$nodeRef$c = (_this$props = this.props) === null || _this$props === void 0 || (_this$props = _this$props.nodeRef) === null || _this$props === void 0 ? void 0 : _this$props.current) !== null && _this$props$nodeRef$c !== void 0 ? _this$props$nodeRef$c : _reactDom.default.findDOMNode(this);\n  }\n  render() /*: ReactElement<any>*/{\n    const {\n      axis,\n      bounds,\n      children,\n      defaultPosition,\n      defaultClassName,\n      defaultClassNameDragging,\n      defaultClassNameDragged,\n      position,\n      positionOffset,\n      scale,\n      ...draggableCoreProps\n    } = this.props;\n    let style = {};\n    let svgTransform = null;\n\n    // If this is controlled, we don't want to move it - unless it's dragging.\n    const controlled = Boolean(position);\n    const draggable = !controlled || this.state.dragging;\n    const validPosition = position || defaultPosition;\n    const transformOpts = {\n      // Set left if horizontal drag is enabled\n      x: (0, _positionFns.canDragX)(this) && draggable ? this.state.x : validPosition.x,\n      // Set top if vertical drag is enabled\n      y: (0, _positionFns.canDragY)(this) && draggable ? this.state.y : validPosition.y\n    };\n\n    // If this element was SVG, we use the `transform` attribute.\n    if (this.state.isElementSVG) {\n      svgTransform = (0, _domFns.createSVGTransform)(transformOpts, positionOffset);\n    } else {\n      // Add a CSS transform to move the element around. This allows us to move the element around\n      // without worrying about whether or not it is relatively or absolutely positioned.\n      // If the item you are dragging already has a transform set, wrap it in a <span> so <Draggable>\n      // has a clean slate.\n      style = (0, _domFns.createCSSTransform)(transformOpts, positionOffset);\n    }\n\n    // Mark with class while dragging\n    const className = (0, _clsx.default)(children.props.className || '', defaultClassName, {\n      [defaultClassNameDragging]: this.state.dragging,\n      [defaultClassNameDragged]: this.state.dragged\n    });\n\n    // Reuse the child provided\n    // This makes it flexible to use whatever element is wanted (div, ul, etc)\n    return /*#__PURE__*/React.createElement(_DraggableCore.default, _extends({}, draggableCoreProps, {\n      onStart: this.onDragStart,\n      onDrag: this.onDrag,\n      onStop: this.onDragStop\n    }), /*#__PURE__*/React.cloneElement(React.Children.only(children), {\n      className: className,\n      style: {\n        ...children.props.style,\n        ...style\n      },\n      transform: svgTransform\n    }));\n  }\n}\nexports.default = Draggable;\n_defineProperty(Draggable, \"displayName\", 'Draggable');\n_defineProperty(Draggable, \"propTypes\", {\n  // Accepts all props <DraggableCore> accepts.\n  ..._DraggableCore.default.propTypes,\n  /**\n   * `axis` determines which axis the draggable can move.\n   *\n   *  Note that all callbacks will still return data as normal. This only\n   *  controls flushing to the DOM.\n   *\n   * 'both' allows movement horizontally and vertically.\n   * 'x' limits movement to horizontal axis.\n   * 'y' limits movement to vertical axis.\n   * 'none' limits all movement.\n   *\n   * Defaults to 'both'.\n   */\n  axis: _propTypes.default.oneOf(['both', 'x', 'y', 'none']),\n  /**\n   * `bounds` determines the range of movement available to the element.\n   * Available values are:\n   *\n   * 'parent' restricts movement within the Draggable's parent node.\n   *\n   * Alternatively, pass an object with the following properties, all of which are optional:\n   *\n   * {left: LEFT_BOUND, right: RIGHT_BOUND, bottom: BOTTOM_BOUND, top: TOP_BOUND}\n   *\n   * All values are in px.\n   *\n   * Example:\n   *\n   * ```jsx\n   *   let App = React.createClass({\n   *       render: function () {\n   *         return (\n   *            <Draggable bounds={{right: 300, bottom: 300}}>\n   *              <div>Content</div>\n   *           </Draggable>\n   *         );\n   *       }\n   *   });\n   * ```\n   */\n  bounds: _propTypes.default.oneOfType([_propTypes.default.shape({\n    left: _propTypes.default.number,\n    right: _propTypes.default.number,\n    top: _propTypes.default.number,\n    bottom: _propTypes.default.number\n  }), _propTypes.default.string, _propTypes.default.oneOf([false])]),\n  defaultClassName: _propTypes.default.string,\n  defaultClassNameDragging: _propTypes.default.string,\n  defaultClassNameDragged: _propTypes.default.string,\n  /**\n   * `defaultPosition` specifies the x and y that the dragged item should start at\n   *\n   * Example:\n   *\n   * ```jsx\n   *      let App = React.createClass({\n   *          render: function () {\n   *              return (\n   *                  <Draggable defaultPosition={{x: 25, y: 25}}>\n   *                      <div>I start with transformX: 25px and transformY: 25px;</div>\n   *                  </Draggable>\n   *              );\n   *          }\n   *      });\n   * ```\n   */\n  defaultPosition: _propTypes.default.shape({\n    x: _propTypes.default.number,\n    y: _propTypes.default.number\n  }),\n  positionOffset: _propTypes.default.shape({\n    x: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]),\n    y: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string])\n  }),\n  /**\n   * `position`, if present, defines the current position of the element.\n   *\n   *  This is similar to how form elements in React work - if no `position` is supplied, the component\n   *  is uncontrolled.\n   *\n   * Example:\n   *\n   * ```jsx\n   *      let App = React.createClass({\n   *          render: function () {\n   *              return (\n   *                  <Draggable position={{x: 25, y: 25}}>\n   *                      <div>I start with transformX: 25px and transformY: 25px;</div>\n   *                  </Draggable>\n   *              );\n   *          }\n   *      });\n   * ```\n   */\n  position: _propTypes.default.shape({\n    x: _propTypes.default.number,\n    y: _propTypes.default.number\n  }),\n  /**\n   * These properties should be defined on the child, not here.\n   */\n  className: _shims.dontSetMe,\n  style: _shims.dontSetMe,\n  transform: _shims.dontSetMe\n});\n_defineProperty(Draggable, \"defaultProps\", {\n  ..._DraggableCore.default.defaultProps,\n  axis: 'both',\n  bounds: false,\n  defaultClassName: 'react-draggable',\n  defaultClassNameDragging: 'react-draggable-dragging',\n  defaultClassNameDragged: 'react-draggable-dragged',\n  defaultPosition: {\n    x: 0,\n    y: 0\n  },\n  scale: 1\n});","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nvar React = _interopRequireWildcard(require(\"react\"));\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\nvar _reactDom = _interopRequireDefault(require(\"react-dom\"));\nvar _domFns = require(\"./utils/domFns\");\nvar _positionFns = require(\"./utils/positionFns\");\nvar _shims = require(\"./utils/shims\");\nvar _log = _interopRequireDefault(require(\"./utils/log\"));\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\nfunction _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== \"object\" && typeof obj !== \"function\") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return typeof key === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (typeof input !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (typeof res !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\n/*:: import type {EventHandler, MouseTouchEvent} from './utils/types';*/\n/*:: import type {Element as ReactElement} from 'react';*/\n// Simple abstraction for dragging events names.\nconst eventsFor = {\n  touch: {\n    start: 'touchstart',\n    move: 'touchmove',\n    stop: 'touchend'\n  },\n  mouse: {\n    start: 'mousedown',\n    move: 'mousemove',\n    stop: 'mouseup'\n  }\n};\n\n// Default to mouse events.\nlet dragEventFor = eventsFor.mouse;\n/*:: export type DraggableData = {\n  node: HTMLElement,\n  x: number, y: number,\n  deltaX: number, deltaY: number,\n  lastX: number, lastY: number,\n};*/\n/*:: export type DraggableEventHandler = (e: MouseEvent, data: DraggableData) => void | false;*/\n/*:: export type ControlPosition = {x: number, y: number};*/\n/*:: export type PositionOffsetControlPosition = {x: number|string, y: number|string};*/\n/*:: export type DraggableCoreDefaultProps = {\n  allowAnyClick: boolean,\n  disabled: boolean,\n  enableUserSelectHack: boolean,\n  onStart: DraggableEventHandler,\n  onDrag: DraggableEventHandler,\n  onStop: DraggableEventHandler,\n  onMouseDown: (e: MouseEvent) => void,\n  scale: number,\n};*/\n/*:: export type DraggableCoreProps = {\n  ...DraggableCoreDefaultProps,\n  cancel: string,\n  children: ReactElement<any>,\n  offsetParent: HTMLElement,\n  grid: [number, number],\n  handle: string,\n  nodeRef?: ?React.ElementRef<any>,\n};*/\n//\n// Define <DraggableCore>.\n//\n// <DraggableCore> is for advanced usage of <Draggable>. It maintains minimal internal state so it can\n// work well with libraries that require more control over the element.\n//\n\nclass DraggableCore extends React.Component /*:: <DraggableCoreProps>*/{\n  constructor() {\n    super(...arguments);\n    _defineProperty(this, \"dragging\", false);\n    // Used while dragging to determine deltas.\n    _defineProperty(this, \"lastX\", NaN);\n    _defineProperty(this, \"lastY\", NaN);\n    _defineProperty(this, \"touchIdentifier\", null);\n    _defineProperty(this, \"mounted\", false);\n    _defineProperty(this, \"handleDragStart\", e => {\n      // Make it possible to attach event handlers on top of this one.\n      this.props.onMouseDown(e);\n\n      // Only accept left-clicks.\n      if (!this.props.allowAnyClick && typeof e.button === 'number' && e.button !== 0) return false;\n\n      // Get nodes. Be sure to grab relative document (could be iframed)\n      const thisNode = this.findDOMNode();\n      if (!thisNode || !thisNode.ownerDocument || !thisNode.ownerDocument.body) {\n        throw new Error('<DraggableCore> not mounted on DragStart!');\n      }\n      const {\n        ownerDocument\n      } = thisNode;\n\n      // Short circuit if handle or cancel prop was provided and selector doesn't match.\n      if (this.props.disabled || !(e.target instanceof ownerDocument.defaultView.Node) || this.props.handle && !(0, _domFns.matchesSelectorAndParentsTo)(e.target, this.props.handle, thisNode) || this.props.cancel && (0, _domFns.matchesSelectorAndParentsTo)(e.target, this.props.cancel, thisNode)) {\n        return;\n      }\n\n      // Prevent scrolling on mobile devices, like ipad/iphone.\n      // Important that this is after handle/cancel.\n      if (e.type === 'touchstart') e.preventDefault();\n\n      // Set touch identifier in component state if this is a touch event. This allows us to\n      // distinguish between individual touches on multitouch screens by identifying which\n      // touchpoint was set to this element.\n      const touchIdentifier = (0, _domFns.getTouchIdentifier)(e);\n      this.touchIdentifier = touchIdentifier;\n\n      // Get the current drag point from the event. This is used as the offset.\n      const position = (0, _positionFns.getControlPosition)(e, touchIdentifier, this);\n      if (position == null) return; // not possible but satisfies flow\n      const {\n        x,\n        y\n      } = position;\n\n      // Create an event object with all the data parents need to make a decision here.\n      const coreEvent = (0, _positionFns.createCoreData)(this, x, y);\n      (0, _log.default)('DraggableCore: handleDragStart: %j', coreEvent);\n\n      // Call event handler. If it returns explicit false, cancel.\n      (0, _log.default)('calling', this.props.onStart);\n      const shouldUpdate = this.props.onStart(e, coreEvent);\n      if (shouldUpdate === false || this.mounted === false) return;\n\n      // Add a style to the body to disable user-select. This prevents text from\n      // being selected all over the page.\n      if (this.props.enableUserSelectHack) (0, _domFns.addUserSelectStyles)(ownerDocument);\n\n      // Initiate dragging. Set the current x and y as offsets\n      // so we know how much we've moved during the drag. This allows us\n      // to drag elements around even if they have been moved, without issue.\n      this.dragging = true;\n      this.lastX = x;\n      this.lastY = y;\n\n      // Add events to the document directly so we catch when the user's mouse/touch moves outside of\n      // this element. We use different events depending on whether or not we have detected that this\n      // is a touch-capable device.\n      (0, _domFns.addEvent)(ownerDocument, dragEventFor.move, this.handleDrag);\n      (0, _domFns.addEvent)(ownerDocument, dragEventFor.stop, this.handleDragStop);\n    });\n    _defineProperty(this, \"handleDrag\", e => {\n      // Get the current drag point from the event. This is used as the offset.\n      const position = (0, _positionFns.getControlPosition)(e, this.touchIdentifier, this);\n      if (position == null) return;\n      let {\n        x,\n        y\n      } = position;\n\n      // Snap to grid if prop has been provided\n      if (Array.isArray(this.props.grid)) {\n        let deltaX = x - this.lastX,\n          deltaY = y - this.lastY;\n        [deltaX, deltaY] = (0, _positionFns.snapToGrid)(this.props.grid, deltaX, deltaY);\n        if (!deltaX && !deltaY) return; // skip useless drag\n        x = this.lastX + deltaX, y = this.lastY + deltaY;\n      }\n      const coreEvent = (0, _positionFns.createCoreData)(this, x, y);\n      (0, _log.default)('DraggableCore: handleDrag: %j', coreEvent);\n\n      // Call event handler. If it returns explicit false, trigger end.\n      const shouldUpdate = this.props.onDrag(e, coreEvent);\n      if (shouldUpdate === false || this.mounted === false) {\n        try {\n          // $FlowIgnore\n          this.handleDragStop(new MouseEvent('mouseup'));\n        } catch (err) {\n          // Old browsers\n          const event = ((document.createEvent('MouseEvents') /*: any*/) /*: MouseTouchEvent*/);\n          // I see why this insanity was deprecated\n          // $FlowIgnore\n          event.initMouseEvent('mouseup', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);\n          this.handleDragStop(event);\n        }\n        return;\n      }\n      this.lastX = x;\n      this.lastY = y;\n    });\n    _defineProperty(this, \"handleDragStop\", e => {\n      if (!this.dragging) return;\n      const position = (0, _positionFns.getControlPosition)(e, this.touchIdentifier, this);\n      if (position == null) return;\n      let {\n        x,\n        y\n      } = position;\n\n      // Snap to grid if prop has been provided\n      if (Array.isArray(this.props.grid)) {\n        let deltaX = x - this.lastX || 0;\n        let deltaY = y - this.lastY || 0;\n        [deltaX, deltaY] = (0, _positionFns.snapToGrid)(this.props.grid, deltaX, deltaY);\n        x = this.lastX + deltaX, y = this.lastY + deltaY;\n      }\n      const coreEvent = (0, _positionFns.createCoreData)(this, x, y);\n\n      // Call event handler\n      const shouldContinue = this.props.onStop(e, coreEvent);\n      if (shouldContinue === false || this.mounted === false) return false;\n      const thisNode = this.findDOMNode();\n      if (thisNode) {\n        // Remove user-select hack\n        if (this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(thisNode.ownerDocument);\n      }\n      (0, _log.default)('DraggableCore: handleDragStop: %j', coreEvent);\n\n      // Reset the el.\n      this.dragging = false;\n      this.lastX = NaN;\n      this.lastY = NaN;\n      if (thisNode) {\n        // Remove event handlers\n        (0, _log.default)('DraggableCore: Removing handlers');\n        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.move, this.handleDrag);\n        (0, _domFns.removeEvent)(thisNode.ownerDocument, dragEventFor.stop, this.handleDragStop);\n      }\n    });\n    _defineProperty(this, \"onMouseDown\", e => {\n      dragEventFor = eventsFor.mouse; // on touchscreen laptops we could switch back to mouse\n\n      return this.handleDragStart(e);\n    });\n    _defineProperty(this, \"onMouseUp\", e => {\n      dragEventFor = eventsFor.mouse;\n      return this.handleDragStop(e);\n    });\n    // Same as onMouseDown (start drag), but now consider this a touch device.\n    _defineProperty(this, \"onTouchStart\", e => {\n      // We're on a touch device now, so change the event handlers\n      dragEventFor = eventsFor.touch;\n      return this.handleDragStart(e);\n    });\n    _defineProperty(this, \"onTouchEnd\", e => {\n      // We're on a touch device now, so change the event handlers\n      dragEventFor = eventsFor.touch;\n      return this.handleDragStop(e);\n    });\n  }\n  componentDidMount() {\n    this.mounted = true;\n    // Touch handlers must be added with {passive: false} to be cancelable.\n    // https://developers.google.com/web/updates/2017/01/scrolling-intervention\n    const thisNode = this.findDOMNode();\n    if (thisNode) {\n      (0, _domFns.addEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {\n        passive: false\n      });\n    }\n  }\n  componentWillUnmount() {\n    this.mounted = false;\n    // Remove any leftover event handlers. Remove both touch and mouse handlers in case\n    // some browser quirk caused a touch event to fire during a mouse move, or vice versa.\n    const thisNode = this.findDOMNode();\n    if (thisNode) {\n      const {\n        ownerDocument\n      } = thisNode;\n      (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.move, this.handleDrag);\n      (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.move, this.handleDrag);\n      (0, _domFns.removeEvent)(ownerDocument, eventsFor.mouse.stop, this.handleDragStop);\n      (0, _domFns.removeEvent)(ownerDocument, eventsFor.touch.stop, this.handleDragStop);\n      (0, _domFns.removeEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {\n        passive: false\n      });\n      if (this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(ownerDocument);\n    }\n  }\n\n  // React Strict Mode compatibility: if `nodeRef` is passed, we will use it instead of trying to find\n  // the underlying DOM node ourselves. See the README for more information.\n  findDOMNode() /*: ?HTMLElement*/{\n    var _this$props, _this$props2;\n    return (_this$props = this.props) !== null && _this$props !== void 0 && _this$props.nodeRef ? (_this$props2 = this.props) === null || _this$props2 === void 0 || (_this$props2 = _this$props2.nodeRef) === null || _this$props2 === void 0 ? void 0 : _this$props2.current : _reactDom.default.findDOMNode(this);\n  }\n  render() /*: React.Element<any>*/{\n    // Reuse the child provided\n    // This makes it flexible to use whatever element is wanted (div, ul, etc)\n    return /*#__PURE__*/React.cloneElement(React.Children.only(this.props.children), {\n      // Note: mouseMove handler is attached to document so it will still function\n      // when the user drags quickly and leaves the bounds of the element.\n      onMouseDown: this.onMouseDown,\n      onMouseUp: this.onMouseUp,\n      // onTouchStart is added on `componentDidMount` so they can be added with\n      // {passive: false}, which allows it to cancel. See\n      // https://developers.google.com/web/updates/2017/01/scrolling-intervention\n      onTouchEnd: this.onTouchEnd\n    });\n  }\n}\nexports.default = DraggableCore;\n_defineProperty(DraggableCore, \"displayName\", 'DraggableCore');\n_defineProperty(DraggableCore, \"propTypes\", {\n  /**\n   * `allowAnyClick` allows dragging using any mouse button.\n   * By default, we only accept the left button.\n   *\n   * Defaults to `false`.\n   */\n  allowAnyClick: _propTypes.default.bool,\n  children: _propTypes.default.node.isRequired,\n  /**\n   * `disabled`, if true, stops the <Draggable> from dragging. All handlers,\n   * with the exception of `onMouseDown`, will not fire.\n   */\n  disabled: _propTypes.default.bool,\n  /**\n   * By default, we add 'user-select:none' attributes to the document body\n   * to prevent ugly text selection during drag. If this is causing problems\n   * for your app, set this to `false`.\n   */\n  enableUserSelectHack: _propTypes.default.bool,\n  /**\n   * `offsetParent`, if set, uses the passed DOM node to compute drag offsets\n   * instead of using the parent node.\n   */\n  offsetParent: function (props /*: DraggableCoreProps*/, propName /*: $Keys<DraggableCoreProps>*/) {\n    if (props[propName] && props[propName].nodeType !== 1) {\n      throw new Error('Draggable\\'s offsetParent must be a DOM Node.');\n    }\n  },\n  /**\n   * `grid` specifies the x and y that dragging should snap to.\n   */\n  grid: _propTypes.default.arrayOf(_propTypes.default.number),\n  /**\n   * `handle` specifies a selector to be used as the handle that initiates drag.\n   *\n   * Example:\n   *\n   * ```jsx\n   *   let App = React.createClass({\n   *       render: function () {\n   *         return (\n   *            <Draggable handle=\".handle\">\n   *              <div>\n   *                  <div className=\"handle\">Click me to drag</div>\n   *                  <div>This is some other content</div>\n   *              </div>\n   *           </Draggable>\n   *         );\n   *       }\n   *   });\n   * ```\n   */\n  handle: _propTypes.default.string,\n  /**\n   * `cancel` specifies a selector to be used to prevent drag initialization.\n   *\n   * Example:\n   *\n   * ```jsx\n   *   let App = React.createClass({\n   *       render: function () {\n   *           return(\n   *               <Draggable cancel=\".cancel\">\n   *                   <div>\n   *                     <div className=\"cancel\">You can't drag from here</div>\n   *                     <div>Dragging here works fine</div>\n   *                   </div>\n   *               </Draggable>\n   *           );\n   *       }\n   *   });\n   * ```\n   */\n  cancel: _propTypes.default.string,\n  /* If running in React Strict mode, ReactDOM.findDOMNode() is deprecated.\n   * Unfortunately, in order for <Draggable> to work properly, we need raw access\n   * to the underlying DOM node. If you want to avoid the warning, pass a `nodeRef`\n   * as in this example:\n   *\n   * function MyComponent() {\n   *   const nodeRef = React.useRef(null);\n   *   return (\n   *     <Draggable nodeRef={nodeRef}>\n   *       <div ref={nodeRef}>Example Target</div>\n   *     </Draggable>\n   *   );\n   * }\n   *\n   * This can be used for arbitrarily nested components, so long as the ref ends up\n   * pointing to the actual child DOM node and not a custom component.\n   */\n  nodeRef: _propTypes.default.object,\n  /**\n   * Called when dragging starts.\n   * If this function returns the boolean false, dragging will be canceled.\n   */\n  onStart: _propTypes.default.func,\n  /**\n   * Called while dragging.\n   * If this function returns the boolean false, dragging will be canceled.\n   */\n  onDrag: _propTypes.default.func,\n  /**\n   * Called when dragging stops.\n   * If this function returns the boolean false, the drag will remain active.\n   */\n  onStop: _propTypes.default.func,\n  /**\n   * A workaround option which can be passed if onMouseDown needs to be accessed,\n   * since it'll always be blocked (as there is internal use of onMouseDown)\n   */\n  onMouseDown: _propTypes.default.func,\n  /**\n   * `scale`, if set, applies scaling while dragging an element\n   */\n  scale: _propTypes.default.number,\n  /**\n   * These properties should be defined on the child, not here.\n   */\n  className: _shims.dontSetMe,\n  style: _shims.dontSetMe,\n  transform: _shims.dontSetMe\n});\n_defineProperty(DraggableCore, \"defaultProps\", {\n  allowAnyClick: false,\n  // by default only accept left click\n  disabled: false,\n  enableUserSelectHack: true,\n  onStart: function () {},\n  onDrag: function () {},\n  onStop: function () {},\n  onMouseDown: function () {},\n  scale: 1\n});","\"use strict\";\n\nconst {\n  default: Draggable,\n  DraggableCore\n} = require('./Draggable');\n\n// Previous versions of this lib exported <Draggable> as the root export. As to no-// them, or TypeScript, we export *both* as the root and as 'default'.\n// See https://github.com/mzabriskie/react-draggable/pull/254\n// and https://github.com/mzabriskie/react-draggable/issues/266\nmodule.exports = Draggable;\nmodule.exports.default = Draggable;\nmodule.exports.DraggableCore = DraggableCore;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.addClassName = addClassName;\nexports.addEvent = addEvent;\nexports.addUserSelectStyles = addUserSelectStyles;\nexports.createCSSTransform = createCSSTransform;\nexports.createSVGTransform = createSVGTransform;\nexports.getTouch = getTouch;\nexports.getTouchIdentifier = getTouchIdentifier;\nexports.getTranslation = getTranslation;\nexports.innerHeight = innerHeight;\nexports.innerWidth = innerWidth;\nexports.matchesSelector = matchesSelector;\nexports.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;\nexports.offsetXYFromParent = offsetXYFromParent;\nexports.outerHeight = outerHeight;\nexports.outerWidth = outerWidth;\nexports.removeClassName = removeClassName;\nexports.removeEvent = removeEvent;\nexports.removeUserSelectStyles = removeUserSelectStyles;\nvar _shims = require(\"./shims\");\nvar _getPrefix = _interopRequireWildcard(require(\"./getPrefix\"));\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\nfunction _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== \"object\" && typeof obj !== \"function\") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\n/*:: import type {ControlPosition, PositionOffsetControlPosition, MouseTouchEvent} from './types';*/\nlet matchesSelectorFunc = '';\nfunction matchesSelector(el /*: Node*/, selector /*: string*/) /*: boolean*/{\n  if (!matchesSelectorFunc) {\n    matchesSelectorFunc = (0, _shims.findInArray)(['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector'], function (method) {\n      // $FlowIgnore: Doesn't think elements are indexable\n      return (0, _shims.isFunction)(el[method]);\n    });\n  }\n\n  // Might not be found entirely (not an Element?) - in that case, bail\n  // $FlowIgnore: Doesn't think elements are indexable\n  if (!(0, _shims.isFunction)(el[matchesSelectorFunc])) return false;\n\n  // $FlowIgnore: Doesn't think elements are indexable\n  return el[matchesSelectorFunc](selector);\n}\n\n// Works up the tree to the draggable itself attempting to match selector.\nfunction matchesSelectorAndParentsTo(el /*: Node*/, selector /*: string*/, baseNode /*: Node*/) /*: boolean*/{\n  let node = el;\n  do {\n    if (matchesSelector(node, selector)) return true;\n    if (node === baseNode) return false;\n    // $FlowIgnore[incompatible-type]\n    node = node.parentNode;\n  } while (node);\n  return false;\n}\nfunction addEvent(el /*: ?Node*/, event /*: string*/, handler /*: Function*/, inputOptions /*: Object*/) /*: void*/{\n  if (!el) return;\n  const options = {\n    capture: true,\n    ...inputOptions\n  };\n  // $FlowIgnore[method-unbinding]\n  if (el.addEventListener) {\n    el.addEventListener(event, handler, options);\n  } else if (el.attachEvent) {\n    el.attachEvent('on' + event, handler);\n  } else {\n    // $FlowIgnore: Doesn't think elements are indexable\n    el['on' + event] = handler;\n  }\n}\nfunction removeEvent(el /*: ?Node*/, event /*: string*/, handler /*: Function*/, inputOptions /*: Object*/) /*: void*/{\n  if (!el) return;\n  const options = {\n    capture: true,\n    ...inputOptions\n  };\n  // $FlowIgnore[method-unbinding]\n  if (el.removeEventListener) {\n    el.removeEventListener(event, handler, options);\n  } else if (el.detachEvent) {\n    el.detachEvent('on' + event, handler);\n  } else {\n    // $FlowIgnore: Doesn't think elements are indexable\n    el['on' + event] = null;\n  }\n}\nfunction outerHeight(node /*: HTMLElement*/) /*: number*/{\n  // This is deliberately excluding margin for our calculations, since we are using\n  // offsetTop which is including margin. See getBoundPosition\n  let height = node.clientHeight;\n  const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  height += (0, _shims.int)(computedStyle.borderTopWidth);\n  height += (0, _shims.int)(computedStyle.borderBottomWidth);\n  return height;\n}\nfunction outerWidth(node /*: HTMLElement*/) /*: number*/{\n  // This is deliberately excluding margin for our calculations, since we are using\n  // offsetLeft which is including margin. See getBoundPosition\n  let width = node.clientWidth;\n  const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  width += (0, _shims.int)(computedStyle.borderLeftWidth);\n  width += (0, _shims.int)(computedStyle.borderRightWidth);\n  return width;\n}\nfunction innerHeight(node /*: HTMLElement*/) /*: number*/{\n  let height = node.clientHeight;\n  const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  height -= (0, _shims.int)(computedStyle.paddingTop);\n  height -= (0, _shims.int)(computedStyle.paddingBottom);\n  return height;\n}\nfunction innerWidth(node /*: HTMLElement*/) /*: number*/{\n  let width = node.clientWidth;\n  const computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  width -= (0, _shims.int)(computedStyle.paddingLeft);\n  width -= (0, _shims.int)(computedStyle.paddingRight);\n  return width;\n}\n/*:: interface EventWithOffset {\n  clientX: number, clientY: number\n}*/\n// Get from offsetParent\nfunction offsetXYFromParent(evt /*: EventWithOffset*/, offsetParent /*: HTMLElement*/, scale /*: number*/) /*: ControlPosition*/{\n  const isBody = offsetParent === offsetParent.ownerDocument.body;\n  const offsetParentRect = isBody ? {\n    left: 0,\n    top: 0\n  } : offsetParent.getBoundingClientRect();\n  const x = (evt.clientX + offsetParent.scrollLeft - offsetParentRect.left) / scale;\n  const y = (evt.clientY + offsetParent.scrollTop - offsetParentRect.top) / scale;\n  return {\n    x,\n    y\n  };\n}\nfunction createCSSTransform(controlPos /*: ControlPosition*/, positionOffset /*: PositionOffsetControlPosition*/) /*: Object*/{\n  const translation = getTranslation(controlPos, positionOffset, 'px');\n  return {\n    [(0, _getPrefix.browserPrefixToKey)('transform', _getPrefix.default)]: translation\n  };\n}\nfunction createSVGTransform(controlPos /*: ControlPosition*/, positionOffset /*: PositionOffsetControlPosition*/) /*: string*/{\n  const translation = getTranslation(controlPos, positionOffset, '');\n  return translation;\n}\nfunction getTranslation(_ref /*:: */, positionOffset /*: PositionOffsetControlPosition*/, unitSuffix /*: string*/) /*: string*/{\n  let {\n    x,\n    y\n  } /*: ControlPosition*/ = _ref /*: ControlPosition*/;\n  let translation = \"translate(\".concat(x).concat(unitSuffix, \",\").concat(y).concat(unitSuffix, \")\");\n  if (positionOffset) {\n    const defaultX = \"\".concat(typeof positionOffset.x === 'string' ? positionOffset.x : positionOffset.x + unitSuffix);\n    const defaultY = \"\".concat(typeof positionOffset.y === 'string' ? positionOffset.y : positionOffset.y + unitSuffix);\n    translation = \"translate(\".concat(defaultX, \", \").concat(defaultY, \")\") + translation;\n  }\n  return translation;\n}\nfunction getTouch(e /*: MouseTouchEvent*/, identifier /*: number*/) /*: ?{clientX: number, clientY: number}*/{\n  return e.targetTouches && (0, _shims.findInArray)(e.targetTouches, t => identifier === t.identifier) || e.changedTouches && (0, _shims.findInArray)(e.changedTouches, t => identifier === t.identifier);\n}\nfunction getTouchIdentifier(e /*: MouseTouchEvent*/) /*: ?number*/{\n  if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;\n  if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;\n}\n\n// User-select Hacks:\n//\n// Useful for preventing blue highlights all over everything when dragging.\n\n// Note we're passing `document` b/c we could be iframed\nfunction addUserSelectStyles(doc /*: ?Document*/) {\n  if (!doc) return;\n  let styleEl = doc.getElementById('react-draggable-style-el');\n  if (!styleEl) {\n    styleEl = doc.createElement('style');\n    styleEl.type = 'text/css';\n    styleEl.id = 'react-draggable-style-el';\n    styleEl.innerHTML = '.react-draggable-transparent-selection *::-moz-selection {all: inherit;}\\n';\n    styleEl.innerHTML += '.react-draggable-transparent-selection *::selection {all: inherit;}\\n';\n    doc.getElementsByTagName('head')[0].appendChild(styleEl);\n  }\n  if (doc.body) addClassName(doc.body, 'react-draggable-transparent-selection');\n}\nfunction removeUserSelectStyles(doc /*: ?Document*/) {\n  if (!doc) return;\n  try {\n    if (doc.body) removeClassName(doc.body, 'react-draggable-transparent-selection');\n    // $FlowIgnore: IE\n    if (doc.selection) {\n      // $FlowIgnore: IE\n      doc.selection.empty();\n    } else {\n      // Remove selection caused by scroll, unless it's a focused input\n      // (we use doc.defaultView in case we're in an iframe)\n      const selection = (doc.defaultView || window).getSelection();\n      if (selection && selection.type !== 'Caret') {\n        selection.removeAllRanges();\n      }\n    }\n  } catch (e) {\n    // probably IE\n  }\n}\nfunction addClassName(el /*: HTMLElement*/, className /*: string*/) {\n  if (el.classList) {\n    el.classList.add(className);\n  } else {\n    if (!el.className.match(new RegExp(\"(?:^|\\\\s)\".concat(className, \"(?!\\\\S)\")))) {\n      el.className += \" \".concat(className);\n    }\n  }\n}\nfunction removeClassName(el /*: HTMLElement*/, className /*: string*/) {\n  if (el.classList) {\n    el.classList.remove(className);\n  } else {\n    el.className = el.className.replace(new RegExp(\"(?:^|\\\\s)\".concat(className, \"(?!\\\\S)\"), 'g'), '');\n  }\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.browserPrefixToKey = browserPrefixToKey;\nexports.browserPrefixToStyle = browserPrefixToStyle;\nexports.default = void 0;\nexports.getPrefix = getPrefix;\nconst prefixes = ['Moz', 'Webkit', 'O', 'ms'];\nfunction getPrefix() /*: string*/{\n  var _window$document;\n  let prop /*: string*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';\n  // Ensure we're running in an environment where there is actually a global\n  // `window` obj\n  if (typeof window === 'undefined') return '';\n\n  // If we're in a pseudo-browser server-side environment, this access\n  // path may not exist, so bail out if it doesn't.\n  const style = (_window$document = window.document) === null || _window$document === void 0 || (_window$document = _window$document.documentElement) === null || _window$document === void 0 ? void 0 : _window$document.style;\n  if (!style) return '';\n  if (prop in style) return '';\n  for (let i = 0; i < prefixes.length; i++) {\n    if (browserPrefixToKey(prop, prefixes[i]) in style) return prefixes[i];\n  }\n  return '';\n}\nfunction browserPrefixToKey(prop /*: string*/, prefix /*: string*/) /*: string*/{\n  return prefix ? \"\".concat(prefix).concat(kebabToTitleCase(prop)) : prop;\n}\nfunction browserPrefixToStyle(prop /*: string*/, prefix /*: string*/) /*: string*/{\n  return prefix ? \"-\".concat(prefix.toLowerCase(), \"-\").concat(prop) : prop;\n}\nfunction kebabToTitleCase(str /*: string*/) /*: string*/{\n  let out = '';\n  let shouldCapitalize = true;\n  for (let i = 0; i < str.length; i++) {\n    if (shouldCapitalize) {\n      out += str[i].toUpperCase();\n      shouldCapitalize = false;\n    } else if (str[i] === '-') {\n      shouldCapitalize = true;\n    } else {\n      out += str[i];\n    }\n  }\n  return out;\n}\n\n// Default export is the prefix itself, like 'Moz', 'Webkit', etc\n// Note that you may have to re-test for certain things; for instance, Chrome 50\n// can handle unprefixed `transform`, but not unprefixed `user-select`\nvar _default = exports.default = (getPrefix() /*: string*/);","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = log;\n/*eslint no-console:0*/\nfunction log() {\n  if (undefined) console.log(...arguments);\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.canDragX = canDragX;\nexports.canDragY = canDragY;\nexports.createCoreData = createCoreData;\nexports.createDraggableData = createDraggableData;\nexports.getBoundPosition = getBoundPosition;\nexports.getControlPosition = getControlPosition;\nexports.snapToGrid = snapToGrid;\nvar _shims = require(\"./shims\");\nvar _domFns = require(\"./domFns\");\n/*:: import type Draggable from '../Draggable';*/\n/*:: import type {Bounds, ControlPosition, DraggableData, MouseTouchEvent} from './types';*/\n/*:: import type DraggableCore from '../DraggableCore';*/\nfunction getBoundPosition(draggable /*: Draggable*/, x /*: number*/, y /*: number*/) /*: [number, number]*/{\n  // If no bounds, short-circuit and move on\n  if (!draggable.props.bounds) return [x, y];\n\n  // Clone new bounds\n  let {\n    bounds\n  } = draggable.props;\n  bounds = typeof bounds === 'string' ? bounds : cloneBounds(bounds);\n  const node = findDOMNode(draggable);\n  if (typeof bounds === 'string') {\n    const {\n      ownerDocument\n    } = node;\n    const ownerWindow = ownerDocument.defaultView;\n    let boundNode;\n    if (bounds === 'parent') {\n      boundNode = node.parentNode;\n    } else {\n      boundNode = ownerDocument.querySelector(bounds);\n    }\n    if (!(boundNode instanceof ownerWindow.HTMLElement)) {\n      throw new Error('Bounds selector \"' + bounds + '\" could not find an element.');\n    }\n    const boundNodeEl /*: HTMLElement*/ = boundNode; // for Flow, can't seem to refine correctly\n    const nodeStyle = ownerWindow.getComputedStyle(node);\n    const boundNodeStyle = ownerWindow.getComputedStyle(boundNodeEl);\n    // Compute bounds. This is a pain with padding and offsets but this gets it exactly right.\n    bounds = {\n      left: -node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingLeft) + (0, _shims.int)(nodeStyle.marginLeft),\n      top: -node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingTop) + (0, _shims.int)(nodeStyle.marginTop),\n      right: (0, _domFns.innerWidth)(boundNodeEl) - (0, _domFns.outerWidth)(node) - node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingRight) - (0, _shims.int)(nodeStyle.marginRight),\n      bottom: (0, _domFns.innerHeight)(boundNodeEl) - (0, _domFns.outerHeight)(node) - node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingBottom) - (0, _shims.int)(nodeStyle.marginBottom)\n    };\n  }\n\n  // Keep x and y below right and bottom limits...\n  if ((0, _shims.isNum)(bounds.right)) x = Math.min(x, bounds.right);\n  if ((0, _shims.isNum)(bounds.bottom)) y = Math.min(y, bounds.bottom);\n\n  // But above left and top limits.\n  if ((0, _shims.isNum)(bounds.left)) x = Math.max(x, bounds.left);\n  if ((0, _shims.isNum)(bounds.top)) y = Math.max(y, bounds.top);\n  return [x, y];\n}\nfunction snapToGrid(grid /*: [number, number]*/, pendingX /*: number*/, pendingY /*: number*/) /*: [number, number]*/{\n  const x = Math.round(pendingX / grid[0]) * grid[0];\n  const y = Math.round(pendingY / grid[1]) * grid[1];\n  return [x, y];\n}\nfunction canDragX(draggable /*: Draggable*/) /*: boolean*/{\n  return draggable.props.axis === 'both' || draggable.props.axis === 'x';\n}\nfunction canDragY(draggable /*: Draggable*/) /*: boolean*/{\n  return draggable.props.axis === 'both' || draggable.props.axis === 'y';\n}\n\n// Get {x, y} positions from event.\nfunction getControlPosition(e /*: MouseTouchEvent*/, touchIdentifier /*: ?number*/, draggableCore /*: DraggableCore*/) /*: ?ControlPosition*/{\n  const touchObj = typeof touchIdentifier === 'number' ? (0, _domFns.getTouch)(e, touchIdentifier) : null;\n  if (typeof touchIdentifier === 'number' && !touchObj) return null; // not the right touch\n  const node = findDOMNode(draggableCore);\n  // User can provide an offsetParent if desired.\n  const offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;\n  return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent, draggableCore.props.scale);\n}\n\n// Create an data object exposed by <DraggableCore>'s events\nfunction createCoreData(draggable /*: DraggableCore*/, x /*: number*/, y /*: number*/) /*: DraggableData*/{\n  const isStart = !(0, _shims.isNum)(draggable.lastX);\n  const node = findDOMNode(draggable);\n  if (isStart) {\n    // If this is our first move, use the x and y as last coords.\n    return {\n      node,\n      deltaX: 0,\n      deltaY: 0,\n      lastX: x,\n      lastY: y,\n      x,\n      y\n    };\n  } else {\n    // Otherwise calculate proper values.\n    return {\n      node,\n      deltaX: x - draggable.lastX,\n      deltaY: y - draggable.lastY,\n      lastX: draggable.lastX,\n      lastY: draggable.lastY,\n      x,\n      y\n    };\n  }\n}\n\n// Create an data exposed by <Draggable>'s events\nfunction createDraggableData(draggable /*: Draggable*/, coreData /*: DraggableData*/) /*: DraggableData*/{\n  const scale = draggable.props.scale;\n  return {\n    node: coreData.node,\n    x: draggable.state.x + coreData.deltaX / scale,\n    y: draggable.state.y + coreData.deltaY / scale,\n    deltaX: coreData.deltaX / scale,\n    deltaY: coreData.deltaY / scale,\n    lastX: draggable.state.x,\n    lastY: draggable.state.y\n  };\n}\n\n// A lot faster than stringify/parse\nfunction cloneBounds(bounds /*: Bounds*/) /*: Bounds*/{\n  return {\n    left: bounds.left,\n    top: bounds.top,\n    right: bounds.right,\n    bottom: bounds.bottom\n  };\n}\nfunction findDOMNode(draggable /*: Draggable | DraggableCore*/) /*: HTMLElement*/{\n  const node = draggable.findDOMNode();\n  if (!node) {\n    throw new Error('<DraggableCore>: Unmounted during event!');\n  }\n  // $FlowIgnore we can't assert on HTMLElement due to tests... FIXME\n  return node;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.dontSetMe = dontSetMe;\nexports.findInArray = findInArray;\nexports.int = int;\nexports.isFunction = isFunction;\nexports.isNum = isNum;\n// @credits https://gist.github.com/rogozhnikoff/a43cfed27c41e4e68cdc\nfunction findInArray(array /*: Array<any> | TouchList*/, callback /*: Function*/) /*: any*/{\n  for (let i = 0, length = array.length; i < length; i++) {\n    if (callback.apply(callback, [array[i], i, array])) return array[i];\n  }\n}\nfunction isFunction(func /*: any*/) /*: boolean %checks*/{\n  // $FlowIgnore[method-unbinding]\n  return typeof func === 'function' || Object.prototype.toString.call(func) === '[object Function]';\n}\nfunction isNum(num /*: any*/) /*: boolean %checks*/{\n  return typeof num === 'number' && !isNaN(num);\n}\nfunction int(a /*: string*/) /*: number*/{\n  return parseInt(a, 10);\n}\nfunction dontSetMe(props /*: Object*/, propName /*: string*/, componentName /*: string*/) /*: ?Error*/{\n  if (props[propName]) {\n    return new Error(\"Invalid prop \".concat(propName, \" passed to \").concat(componentName, \" - do not set this, set it on the child.\"));\n  }\n}"],"names":["Object","defineProperty","exports","value","enumerable","get","_DraggableCore","default","React","obj","nodeInterop","__esModule","cache","_getRequireWildcardCache","has","newObj","hasPropertyDescriptor","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","_interopRequireWildcard","_propTypes","_interopRequireDefault","_reactDom","_clsx","_domFns","_positionFns","_shims","_log","WeakMap","cacheBabelInterop","cacheNodeInterop","_extends","assign","bind","target","i","arguments","length","source","apply","this","_defineProperty","arg","input","hint","prim","Symbol","toPrimitive","undefined","res","TypeError","String","Number","_toPrimitive","_toPropertyKey","configurable","writable","Draggable","Component","getDerivedStateFromProps","_ref","_ref2","position","prevPropsPosition","x","y","constructor","props","super","e","coreData","onStart","createDraggableData","setState","dragging","dragged","state","uiData","newState","slackX","slackY","bounds","newStateX","newStateY","getBoundPosition","deltaX","deltaY","onDrag","onStop","Boolean","defaultPosition","isElementSVG","console","warn","componentDidMount","window","SVGElement","findDOMNode","componentWillUnmount","_this$props$nodeRef$c","_this$props","nodeRef","current","render","axis","children","defaultClassName","defaultClassNameDragging","defaultClassNameDragged","positionOffset","scale","draggableCoreProps","style","svgTransform","draggable","validPosition","transformOpts","canDragX","canDragY","createSVGTransform","createCSSTransform","className","createElement","onDragStart","onDragStop","cloneElement","Children","only","transform","propTypes","oneOf","oneOfType","shape","left","number","right","top","bottom","string","dontSetMe","defaultProps","eventsFor","start","move","stop","dragEventFor","DraggableCore","NaN","onMouseDown","allowAnyClick","button","thisNode","ownerDocument","body","Error","disabled","defaultView","Node","handle","matchesSelectorAndParentsTo","cancel","type","preventDefault","touchIdentifier","getTouchIdentifier","getControlPosition","coreEvent","createCoreData","mounted","enableUserSelectHack","addUserSelectStyles","lastX","lastY","addEvent","handleDrag","handleDragStop","Array","isArray","grid","snapToGrid","MouseEvent","err","event","document","createEvent","initMouseEvent","removeUserSelectStyles","removeEvent","handleDragStart","onTouchStart","passive","_this$props2","onMouseUp","onTouchEnd","bool","node","isRequired","offsetParent","propName","nodeType","arrayOf","object","func","module","addClassName","el","handler","inputOptions","options","capture","addEventListener","attachEvent","doc","styleEl","getElementById","id","innerHTML","getElementsByTagName","appendChild","controlPos","translation","getTranslation","_getPrefix","browserPrefixToKey","getTouch","identifier","targetTouches","findInArray","t","changedTouches","innerHeight","height","clientHeight","computedStyle","getComputedStyle","int","paddingTop","paddingBottom","innerWidth","width","clientWidth","paddingLeft","paddingRight","matchesSelector","selector","baseNode","parentNode","offsetXYFromParent","evt","offsetParentRect","getBoundingClientRect","clientX","scrollLeft","clientY","scrollTop","outerHeight","borderTopWidth","borderBottomWidth","outerWidth","borderLeftWidth","borderRightWidth","removeClassName","removeEventListener","detachEvent","selection","empty","getSelection","removeAllRanges","matchesSelectorFunc","method","isFunction","unitSuffix","concat","defaultX","defaultY","classList","add","match","RegExp","remove","replace","browserPrefixToStyle","prop","prefix","toLowerCase","getPrefix","prefixes","_window$document","documentElement","str","out","shouldCapitalize","toUpperCase","kebabToTitleCase","isStart","isNum","cloneBounds","ownerWindow","boundNode","querySelector","HTMLElement","boundNodeEl","nodeStyle","boundNodeStyle","offsetLeft","marginLeft","offsetTop","marginTop","marginRight","marginBottom","Math","min","max","draggableCore","touchObj","pendingX","pendingY","round","componentName","array","callback","a","parseInt","toString","num","isNaN"],"sourceRoot":""}