{"version":3,"sources":["webpack:///./node_modules/react-draggable/build/cjs/utils/shims.js","webpack:///./node_modules/react-draggable/build/cjs/utils/domFns.js","webpack:///./node_modules/react-draggable/build/cjs/utils/positionFns.js","webpack:///./node_modules/react-draggable/build/cjs/utils/log.js","webpack:///./node_modules/react-draggable/build/cjs/Draggable.js","webpack:///./node_modules/clsx/dist/clsx.m.js","webpack:///./node_modules/react-draggable/build/cjs/utils/getPrefix.js","webpack:///./node_modules/react-draggable/build/cjs/DraggableCore.js","webpack:///./node_modules/react-draggable/build/cjs/cjs.js"],"names":["Object","defineProperty","exports","value","findInArray","array","callback","i","length","apply","isFunction","func","prototype","toString","call","isNum","num","isNaN","int","a","parseInt","dontSetMe","props","propName","componentName","Error","concat","_typeof","obj","Symbol","iterator","constructor","matchesSelector","matchesSelectorAndParentsTo","el","selector","baseNode","node","parentNode","addEvent","event","handler","inputOptions","options","_objectSpread","capture","addEventListener","attachEvent","removeEvent","removeEventListener","detachEvent","outerHeight","height","clientHeight","computedStyle","ownerDocument","defaultView","getComputedStyle","_shims","borderTopWidth","borderBottomWidth","outerWidth","width","clientWidth","borderLeftWidth","borderRightWidth","innerHeight","paddingTop","paddingBottom","innerWidth","paddingLeft","paddingRight","offsetXYFromParent","evt","offsetParent","scale","offsetParentRect","body","left","top","getBoundingClientRect","x","clientX","scrollLeft","y","clientY","scrollTop","createCSSTransform","controlPos","positionOffset","translation","getTranslation","_defineProperty","_getPrefix","browserPrefixToKey","default","createSVGTransform","getTouch","e","identifier","targetTouches","t","changedTouches","getTouchIdentifier","addUserSelectStyles","doc","styleEl","getElementById","createElement","type","id","innerHTML","getElementsByTagName","appendChild","addClassName","removeUserSelectStyles","removeClassName","selection","empty","window","getSelection","removeAllRanges","nodeInterop","__esModule","cache","_getRequireWildcardCache","has","get","newObj","hasPropertyDescriptor","getOwnPropertyDescriptor","key","hasOwnProperty","desc","set","_interopRequireWildcard","WeakMap","cacheBabelInterop","cacheNodeInterop","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","enumerable","push","target","arguments","source","forEach","getOwnPropertyDescriptors","defineProperties","configurable","writable","matchesSelectorFunc","method","_ref2","unitSuffix","defaultX","defaultY","className","classList","add","match","RegExp","remove","replace","getBoundPosition","draggable","bounds","right","bottom","cloneBounds","findDOMNode","boundNode","ownerWindow","querySelector","HTMLElement","boundNodeEl","nodeStyle","boundNodeStyle","offsetLeft","marginLeft","offsetTop","marginTop","_domFns","marginRight","marginBottom","Math","min","max","snapToGrid","grid","pendingX","pendingY","round","canDragX","axis","canDragY","getControlPosition","touchIdentifier","draggableCore","touchObj","createCoreData","state","isStart","lastX","deltaX","deltaY","lastY","createDraggableData","coreData","undefined","_DraggableCore","React","_propTypes","_interopRequireDefault","_reactDom","_clsx2","_positionFns","_log","_excluded","_extends","assign","this","_objectWithoutProperties","excluded","sourceKeys","indexOf","_objectWithoutPropertiesLoose","sourceSymbolKeys","propertyIsEnumerable","_slicedToArray","arr","Array","isArray","_arrayWithHoles","_i","_s","_e","_arr","_n","_d","next","done","err","_iterableToArrayLimit","o","minLen","_arrayLikeToArray","n","slice","name","from","test","_unsupportedIterableToArray","TypeError","_nonIterableRest","len","arr2","_defineProperties","descriptor","_setPrototypeOf","p","setPrototypeOf","__proto__","_createSuper","Derived","hasNativeReflectConstruct","Reflect","construct","sham","Proxy","Boolean","valueOf","_isNativeReflectConstruct","result","Super","_getPrototypeOf","NewTarget","_possibleConstructorReturn","self","_assertThisInitialized","ReferenceError","getPrototypeOf","Draggable","_React$Component","subClass","superClass","create","_inherits","Constructor","protoProps","staticProps","_super","_this","instance","_classCallCheck","onStart","setState","dragging","dragged","uiData","newState","slackX","slackY","_getBoundPosition2","newStateX","newStateY","onDrag","onStop","position","_this$props$position","defaultPosition","prevPropsPosition","isElementSVG","_ref","SVGElement","_this$props$nodeRef$c","_this$props","_this$props$nodeRef","nodeRef","current","_clsx","_this$props2","children","defaultClassName","defaultClassNameDragging","defaultClassNameDragged","draggableCoreProps","style","svgTransform","validPosition","transformOpts","onDragStart","onDragStop","cloneElement","Children","only","transform","Component","propTypes","oneOf","oneOfType","shape","number","string","defaultProps","toVal","mix","k","str","tmp","getPrefix","browserPrefixToStyle","prop","prefix","toLowerCase","prefixes","_window$document","_window$document$docu","document","documentElement","out","shouldCapitalize","toUpperCase","kebabToTitleCase","_default","eventsFor","start","move","stop","dragEventFor","DraggableCore","_len","args","_key","NaN","onMouseDown","allowAnyClick","button","thisNode","disabled","Node","handle","cancel","preventDefault","coreEvent","mounted","enableUserSelectHack","handleDrag","handleDragStop","_snapToGrid2","MouseEvent","createEvent","initMouseEvent","handleDragStart","onTouchStart","passive","onMouseUp","onTouchEnd","bool","nodeType","arrayOf","_require","module"],"mappings":"2FAEAA,OAAOC,eAAeC,EAAS,aAAc,CAC3CC,OAAO,IAETD,EAAQE,YAOR,SAAqBC,EAEnBC,GAKA,IAAK,IAAIC,EAAI,EAAGC,EAASH,EAAMG,OAAQD,EAAIC,EAAQD,IACjD,GAAID,EAASG,MAAMH,EAAU,CAACD,EAAME,GAAIA,EAAGF,IAAS,OAAOA,EAAME,IAdrEL,EAAQQ,WAkBR,SAAoBC,GAMlB,MAAuB,oBAATA,GAAgE,sBAAzCX,OAAOY,UAAUC,SAASC,KAAKH,IAvBtET,EAAQa,MA0BR,SAAeC,GAKb,MAAsB,kBAARA,IAAqBC,MAAMD,IA9B3Cd,EAAQgB,IAiCR,SAAaC,GAKX,OAAOC,SAASD,EAAG,KArCrBjB,EAAQmB,UAwCR,SAAmBC,EAEjBC,EAEAC,GAKA,GAAIF,EAAMC,GACR,OAAO,IAAIE,MAAM,gBAAgBC,OAAOH,EAAU,eAAeG,OAAOF,EAAe,+C,kCCzD3F,SAASG,EAAQC,GAAmV,OAAtOD,EAArD,oBAAXE,QAAoD,kBAApBA,OAAOC,SAAmC,SAAiBF,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,oBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAOjB,UAAY,gBAAkBgB,IAAyBA,GAEnX5B,OAAOC,eAAeC,EAAS,aAAc,CAC3CC,OAAO,IAETD,EAAQ8B,gBAAkBA,EAC1B9B,EAAQ+B,4BAwDR,SAAqCC,EAEnCC,EAEAC,GAKA,IAAIC,EAAOH,EAEX,EAAG,CACD,GAAIF,EAAgBK,EAAMF,GAAW,OAAO,EAC5C,GAAIE,IAASD,EAAU,OAAO,EAC9BC,EAAOA,EAAKC,iBACLD,GAET,OAAO,GAxETnC,EAAQqC,SA2ER,SAAkBL,EAEhBM,EAEAC,EAEAC,GAKA,IAAKR,EAAI,OAET,IAAIS,EAAUC,EAAc,CAC1BC,SAAS,GACRH,GAGCR,EAAGY,iBACLZ,EAAGY,iBAAiBN,EAAOC,EAASE,GAC3BT,EAAGa,YACZb,EAAGa,YAAY,KAAOP,EAAOC,GAG7BP,EAAG,KAAOM,GAASC,GAlGvBvC,EAAQ8C,YAsGR,SAAqBd,EAEnBM,EAEAC,EAEAC,GAKA,IAAKR,EAAI,OAET,IAAIS,EAAUC,EAAc,CAC1BC,SAAS,GACRH,GAGCR,EAAGe,oBACLf,EAAGe,oBAAoBT,EAAOC,EAASE,GAC9BT,EAAGgB,YACZhB,EAAGgB,YAAY,KAAOV,EAAOC,GAG7BP,EAAG,KAAOM,GAAS,MA7HvBtC,EAAQiD,YAiIR,SAAqBd,GAOnB,IAAIe,EAASf,EAAKgB,aACdC,EAAgBjB,EAAKkB,cAAcC,YAAYC,iBAAiBpB,GAGpE,OAFAe,IAAU,EAAIM,EAAOxC,KAAKoC,EAAcK,gBACxCP,IAAU,EAAIM,EAAOxC,KAAKoC,EAAcM,oBA1I1C1D,EAAQ2D,WA8IR,SAAoBxB,GAOlB,IAAIyB,EAAQzB,EAAK0B,YACbT,EAAgBjB,EAAKkB,cAAcC,YAAYC,iBAAiBpB,GAGpE,OAFAyB,IAAS,EAAIJ,EAAOxC,KAAKoC,EAAcU,iBACvCF,IAAS,EAAIJ,EAAOxC,KAAKoC,EAAcW,mBAvJzC/D,EAAQgE,YA2JR,SAAqB7B,GAKnB,IAAIe,EAASf,EAAKgB,aACdC,EAAgBjB,EAAKkB,cAAcC,YAAYC,iBAAiBpB,GAGpE,OAFAe,IAAU,EAAIM,EAAOxC,KAAKoC,EAAca,YACxCf,IAAU,EAAIM,EAAOxC,KAAKoC,EAAcc,gBAlK1ClE,EAAQmE,WAsKR,SAAoBhC,GAKlB,IAAIyB,EAAQzB,EAAK0B,YACbT,EAAgBjB,EAAKkB,cAAcC,YAAYC,iBAAiBpB,GAGpE,OAFAyB,IAAS,EAAIJ,EAAOxC,KAAKoC,EAAcgB,aACvCR,IAAS,EAAIJ,EAAOxC,KAAKoC,EAAciB,eA7KzCrE,EAAQsE,mBAsLR,SAA4BC,EAE1BC,EAEAC,GAKA,IACIC,EADSF,IAAiBA,EAAanB,cAAcsB,KACzB,CAC9BC,KAAM,EACNC,IAAK,GACHL,EAAaM,wBACbC,GAAKR,EAAIS,QAAUR,EAAaS,WAAaP,EAAiBE,MAAQH,EACtES,GAAKX,EAAIY,QAAUX,EAAaY,UAAYV,EAAiBG,KAAOJ,EACxE,MAAO,CACLM,EAAGA,EACHG,EAAGA,IAvMPlF,EAAQqF,mBA2MR,SAA4BC,EAE1BC,GAKA,IAAIC,EAAcC,EAAeH,EAAYC,EAAgB,MAC7D,OAAOG,EAAgB,IAAI,EAAIC,EAAWC,oBAAoB,YAAaD,EAAWE,SAAUL,IAlNlGxF,EAAQ8F,mBAqNR,SAA4BR,EAE1BC,GAMA,OADkBE,EAAeH,EAAYC,EAAgB,KA3N/DvF,EAAQyF,eAAiBA,EACzBzF,EAAQ+F,SAkPR,SAAkBC,EAEhBC,GAKA,OAAOD,EAAEE,gBAAiB,EAAI1C,EAAOtD,aAAa8F,EAAEE,eAAe,SAAUC,GAC3E,OAAOF,IAAeE,EAAEF,eACpBD,EAAEI,iBAAkB,EAAI5C,EAAOtD,aAAa8F,EAAEI,gBAAgB,SAAUD,GAC5E,OAAOF,IAAeE,EAAEF,eA3P5BjG,EAAQqG,mBA+PR,SAA4BL,GAK1B,GAAIA,EAAEE,eAAiBF,EAAEE,cAAc,GAAI,OAAOF,EAAEE,cAAc,GAAGD,WACrE,GAAID,EAAEI,gBAAkBJ,EAAEI,eAAe,GAAI,OAAOJ,EAAEI,eAAe,GAAGH,YApQ1EjG,EAAQsG,oBA2QR,SAA6BC,GAG3B,IAAKA,EAAK,OACV,IAAIC,EAAUD,EAAIE,eAAe,4BAE5BD,KACHA,EAAUD,EAAIG,cAAc,UACpBC,KAAO,WACfH,EAAQI,GAAK,2BACbJ,EAAQK,UAAY,6EACpBL,EAAQK,WAAa,wEACrBN,EAAIO,qBAAqB,QAAQ,GAAGC,YAAYP,IAG9CD,EAAI5B,MAAMqC,EAAaT,EAAI5B,KAAM,0CAzRvC3E,EAAQiH,uBA4RR,SAAgCV,GAG9B,IAAKA,EAAK,OAEV,IAGE,GAFIA,EAAI5B,MAAMuC,EAAgBX,EAAI5B,KAAM,yCAEpC4B,EAAIY,UAENZ,EAAIY,UAAUC,YACT,CAGL,IAAID,GAAaZ,EAAIjD,aAAe+D,QAAQC,eAExCH,GAAgC,UAAnBA,EAAUR,MACzBQ,EAAUI,mBAGd,MAAOvB,MA/SXhG,EAAQgH,aAAeA,EACvBhH,EAAQkH,gBAAkBA,EAE1B,IAAI1D,EAAS,EAAQ,MAEjBmC,EAIJ,SAAiCjE,EAAK8F,GAAe,IAAKA,GAAe9F,GAAOA,EAAI+F,WAAc,OAAO/F,EAAO,GAAY,OAARA,GAAiC,WAAjBD,EAAQC,IAAoC,oBAARA,EAAsB,MAAO,CAAEmE,QAASnE,GAAS,IAAIgG,EAAQC,EAAyBH,GAAc,GAAIE,GAASA,EAAME,IAAIlG,GAAQ,OAAOgG,EAAMG,IAAInG,GAAQ,IAAIoG,EAAS,GAAQC,EAAwBjI,OAAOC,gBAAkBD,OAAOkI,yBAA0B,IAAK,IAAIC,KAAOvG,EAAO,GAAY,YAARuG,GAAqBnI,OAAOY,UAAUwH,eAAetH,KAAKc,EAAKuG,GAAM,CAAE,IAAIE,EAAOJ,EAAwBjI,OAAOkI,yBAAyBtG,EAAKuG,GAAO,KAAUE,IAASA,EAAKN,KAAOM,EAAKC,KAAQtI,OAAOC,eAAe+H,EAAQG,EAAKE,GAAgBL,EAAOG,GAAOvG,EAAIuG,GAAYH,EAAOjC,QAAUnE,EAASgG,GAASA,EAAMU,IAAI1G,EAAKoG,GAAW,OAAOA,EAJ5wBO,CAAwB,EAAQ,OAEjD,SAASV,EAAyBH,GAAe,GAAuB,oBAAZc,QAAwB,OAAO,KAAM,IAAIC,EAAoB,IAAID,QAAeE,EAAmB,IAAIF,QAAW,OAAQX,EAA2B,SAAkCH,GAAe,OAAOA,EAAcgB,EAAmBD,IAAsBf,GAIhU,SAASiB,EAAQC,EAAQC,GAAkB,IAAIC,EAAO9I,OAAO8I,KAAKF,GAAS,GAAI5I,OAAO+I,sBAAuB,CAAE,IAAIC,EAAUhJ,OAAO+I,sBAAsBH,GAAaC,IAAkBG,EAAUA,EAAQC,QAAO,SAAUC,GAAO,OAAOlJ,OAAOkI,yBAAyBU,EAAQM,GAAKC,eAAkBL,EAAKM,KAAK3I,MAAMqI,EAAME,GAAY,OAAOF,EAElV,SAASlG,EAAcyG,GAAU,IAAK,IAAI9I,EAAI,EAAGA,EAAI+I,UAAU9I,OAAQD,IAAK,CAAE,IAAIgJ,EAAyB,MAAhBD,UAAU/I,GAAa+I,UAAU/I,GAAK,GAAQA,EAAI,EAAKoI,EAAQ3I,OAAOuJ,IAAS,GAAMC,SAAQ,SAAUrB,GAAOvC,EAAgByD,EAAQlB,EAAKoB,EAAOpB,OAAsBnI,OAAOyJ,0BAA6BzJ,OAAO0J,iBAAiBL,EAAQrJ,OAAOyJ,0BAA0BF,IAAmBZ,EAAQ3I,OAAOuJ,IAASC,SAAQ,SAAUrB,GAAOnI,OAAOC,eAAeoJ,EAAQlB,EAAKnI,OAAOkI,yBAAyBqB,EAAQpB,OAAe,OAAOkB,EAE7gB,SAASzD,EAAgBhE,EAAKuG,EAAKhI,GAAiK,OAApJgI,KAAOvG,EAAO5B,OAAOC,eAAe2B,EAAKuG,EAAK,CAAEhI,MAAOA,EAAOgJ,YAAY,EAAMQ,cAAc,EAAMC,UAAU,IAAkBhI,EAAIuG,GAAOhI,EAAgByB,EAE3M,IAAIiI,EAAsB,GAE1B,SAAS7H,EAAgBE,EAEvBC,GAcA,OATK0H,IACHA,GAAsB,EAAInG,EAAOtD,aAAa,CAAC,UAAW,wBAAyB,qBAAsB,oBAAqB,qBAAqB,SAAU0J,GAE3J,OAAO,EAAIpG,EAAOhD,YAAYwB,EAAG4H,WAMhC,EAAIpG,EAAOhD,YAAYwB,EAAG2H,KAExB3H,EAAG2H,GAAqB1H,GAqLjC,SAASwD,EAAeoE,EAAOtE,EAE7BuE,GAKA,IAAI/E,EAAI8E,EAAM9E,EACVG,EAAI2E,EAAM3E,EACVM,EAAc,aAAahE,OAAOuD,GAAGvD,OAAOsI,EAAY,KAAKtI,OAAO0D,GAAG1D,OAAOsI,EAAY,KAE9F,GAAIvE,EAAgB,CAClB,IAAIwE,EAAW,GAAGvI,OAAmC,kBAArB+D,EAAeR,EAAiBQ,EAAeR,EAAIQ,EAAeR,EAAI+E,GAClGE,EAAW,GAAGxI,OAAmC,kBAArB+D,EAAeL,EAAiBK,EAAeL,EAAIK,EAAeL,EAAI4E,GACtGtE,EAAc,aAAahE,OAAOuI,EAAU,MAAMvI,OAAOwI,EAAU,KAAOxE,EAG5E,OAAOA,EAwET,SAASwB,EAAahF,EAEpBiI,GAGIjI,EAAGkI,UACLlI,EAAGkI,UAAUC,IAAIF,GAEZjI,EAAGiI,UAAUG,MAAM,IAAIC,OAAO,YAAY7I,OAAOyI,EAAW,eAC/DjI,EAAGiI,WAAa,IAAIzI,OAAOyI,IAKjC,SAAS/C,EAAgBlF,EAEvBiI,GAGIjI,EAAGkI,UACLlI,EAAGkI,UAAUI,OAAOL,GAEpBjI,EAAGiI,UAAYjI,EAAGiI,UAAUM,QAAQ,IAAIF,OAAO,YAAY7I,OAAOyI,EAAW,WAAY,KAAM,M,kCC9VnGnK,OAAOC,eAAeC,EAAS,aAAc,CAC3CC,OAAO,IAETD,EAAQwK,iBAYR,SAA0BC,EAExB1F,EAEAG,GAMA,IAAKuF,EAAUrJ,MAAMsJ,OAAQ,MAAO,CAAC3F,EAAGG,GAExC,IAAIwF,EAASD,EAAUrJ,MAAMsJ,OAC7BA,EAA2B,kBAAXA,EAAsBA,EAuJxC,SAAqBA,GAKnB,MAAO,CACL9F,KAAM8F,EAAO9F,KACbC,IAAK6F,EAAO7F,IACZ8F,MAAOD,EAAOC,MACdC,OAAQF,EAAOE,QAhK8BC,CAAYH,GAC3D,IAAIvI,EAAO2I,EAAYL,GAEvB,GAAsB,kBAAXC,EAAqB,CAC9B,IAEIK,EAFA1H,EAAgBlB,EAAKkB,cACrB2H,EAAc3H,EAAcC,YAShC,MALEyH,EADa,WAAXL,EACUvI,EAAKC,WAELiB,EAAc4H,cAAcP,cAGfM,EAAYE,aACrC,MAAM,IAAI3J,MAAM,oBAAsBmJ,EAAS,gCAGjD,IAAIS,EAEFJ,EAEEK,EAAYJ,EAAYzH,iBAAiBpB,GACzCkJ,EAAiBL,EAAYzH,iBAAiB4H,GAElDT,EAAS,CACP9F,MAAOzC,EAAKmJ,YAAa,EAAI9H,EAAOxC,KAAKqK,EAAejH,cAAe,EAAIZ,EAAOxC,KAAKoK,EAAUG,YACjG1G,KAAM1C,EAAKqJ,WAAY,EAAIhI,EAAOxC,KAAKqK,EAAepH,aAAc,EAAIT,EAAOxC,KAAKoK,EAAUK,WAC9Fd,OAAO,EAAIe,EAAQvH,YAAYgH,IAAe,EAAIO,EAAQ/H,YAAYxB,GAAQA,EAAKmJ,YAAa,EAAI9H,EAAOxC,KAAKqK,EAAehH,eAAgB,EAAIb,EAAOxC,KAAKoK,EAAUO,aACzKf,QAAQ,EAAIc,EAAQ1H,aAAamH,IAAe,EAAIO,EAAQzI,aAAad,GAAQA,EAAKqJ,WAAY,EAAIhI,EAAOxC,KAAKqK,EAAenH,gBAAiB,EAAIV,EAAOxC,KAAKoK,EAAUQ,gBAK5K,EAAIpI,EAAO3C,OAAO6J,EAAOC,SAAQ5F,EAAI8G,KAAKC,IAAI/G,EAAG2F,EAAOC,SACxD,EAAInH,EAAO3C,OAAO6J,EAAOE,UAAS1F,EAAI2G,KAAKC,IAAI5G,EAAGwF,EAAOE,UAEzD,EAAIpH,EAAO3C,OAAO6J,EAAO9F,QAAOG,EAAI8G,KAAKE,IAAIhH,EAAG2F,EAAO9F,QACvD,EAAIpB,EAAO3C,OAAO6J,EAAO7F,OAAMK,EAAI2G,KAAKE,IAAI7G,EAAGwF,EAAO7F,MAC1D,MAAO,CAACE,EAAGG,IA/DblF,EAAQgM,WAkER,SAAoBC,EAElBC,EAEAC,GAKA,IAAIpH,EAAI8G,KAAKO,MAAMF,EAAWD,EAAK,IAAMA,EAAK,GAC1C/G,EAAI2G,KAAKO,MAAMD,EAAWF,EAAK,IAAMA,EAAK,GAC9C,MAAO,CAAClH,EAAGG,IA5EblF,EAAQqM,SA+ER,SAAkB5B,GAKhB,MAAgC,SAAzBA,EAAUrJ,MAAMkL,MAA4C,MAAzB7B,EAAUrJ,MAAMkL,MAnF5DtM,EAAQuM,SAsFR,SAAkB9B,GAKhB,MAAgC,SAAzBA,EAAUrJ,MAAMkL,MAA4C,MAAzB7B,EAAUrJ,MAAMkL,MA1F5DtM,EAAQwM,mBA8FR,SAA4BxG,EAE1ByG,EAEAC,GAKA,IAAIC,EAAsC,kBAApBF,GAA+B,EAAIf,EAAQ3F,UAAUC,EAAGyG,GAAmB,KACjG,GAA+B,kBAApBA,IAAiCE,EAAU,OAAO,KAE7D,IAAIxK,EAAO2I,EAAY4B,GAEnBlI,EAAekI,EAActL,MAAMoD,cAAgBrC,EAAKqC,cAAgBrC,EAAKkB,cAAcsB,KAC/F,OAAO,EAAI+G,EAAQpH,oBAAoBqI,GAAY3G,EAAGxB,EAAckI,EAActL,MAAMqD,QA5G1FzE,EAAQ4M,eAgHR,SAAwBnC,EAEtB1F,EAEAG,GAKA,IAAI2H,EAAQpC,EAAUoC,MAClBC,IAAW,EAAItJ,EAAO3C,OAAOgM,EAAME,OACnC5K,EAAO2I,EAAYL,GAEvB,OAAIqC,EAEK,CACL3K,KAAMA,EACN6K,OAAQ,EACRC,OAAQ,EACRF,MAAOhI,EACPmI,MAAOhI,EACPH,EAAGA,EACHG,EAAGA,GAIE,CACL/C,KAAMA,EACN6K,OAAQjI,EAAI8H,EAAME,MAClBE,OAAQ/H,EAAI2H,EAAMK,MAClBH,MAAOF,EAAME,MACbG,MAAOL,EAAMK,MACbnI,EAAGA,EACHG,EAAGA,IAhJTlF,EAAQmN,oBAsJR,SAA6B1C,EAE3B2C,GAKA,IAAI3I,EAAQgG,EAAUrJ,MAAMqD,MAC5B,MAAO,CACLtC,KAAMiL,EAASjL,KACf4C,EAAG0F,EAAUoC,MAAM9H,EAAIqI,EAASJ,OAASvI,EACzCS,EAAGuF,EAAUoC,MAAM3H,EAAIkI,EAASH,OAASxI,EACzCuI,OAAQI,EAASJ,OAASvI,EAC1BwI,OAAQG,EAASH,OAASxI,EAC1BsI,MAAOtC,EAAUoC,MAAM9H,EACvBmI,MAAOzC,EAAUoC,MAAM3H,IAnK3B,IAAI1B,EAAS,EAAQ,MAEjBkI,EAAU,EAAQ,MAmLtB,SAASZ,EAAYL,GAKnB,IAAItI,EAAOsI,EAAUK,cAErB,IAAK3I,EACH,MAAM,IAAIZ,MAAM,4CAIlB,OAAOY,I,kCC5MTrC,OAAOC,eAAeC,EAAS,aAAc,CAC3CC,OAAO,IAETD,EAAQ6F,QAGR,gBAGMwH,I,kCCTN,SAAS5L,EAAQC,GAAmV,OAAtOD,EAArD,oBAAXE,QAAoD,kBAApBA,OAAOC,SAAmC,SAAiBF,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,oBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAOjB,UAAY,gBAAkBgB,IAAyBA,GAEnX5B,OAAOC,eAAeC,EAAS,aAAc,CAC3CC,OAAO,IAETH,OAAOC,eAAeC,EAAS,gBAAiB,CAC9CiJ,YAAY,EACZpB,IAAK,WACH,OAAOyF,EAAezH,WAG1B7F,EAAQ6F,aAAU,EAElB,IAAI0H,EAwBJ,SAAiC7L,EAAK8F,GAAe,IAAKA,GAAe9F,GAAOA,EAAI+F,WAAc,OAAO/F,EAAO,GAAY,OAARA,GAAiC,WAAjBD,EAAQC,IAAoC,oBAARA,EAAsB,MAAO,CAAEmE,QAASnE,GAAS,IAAIgG,EAAQC,EAAyBH,GAAc,GAAIE,GAASA,EAAME,IAAIlG,GAAQ,OAAOgG,EAAMG,IAAInG,GAAQ,IAAIoG,EAAS,GAAQC,EAAwBjI,OAAOC,gBAAkBD,OAAOkI,yBAA0B,IAAK,IAAIC,KAAOvG,EAAO,GAAY,YAARuG,GAAqBnI,OAAOY,UAAUwH,eAAetH,KAAKc,EAAKuG,GAAM,CAAE,IAAIE,EAAOJ,EAAwBjI,OAAOkI,yBAAyBtG,EAAKuG,GAAO,KAAUE,IAASA,EAAKN,KAAOM,EAAKC,KAAQtI,OAAOC,eAAe+H,EAAQG,EAAKE,GAAgBL,EAAOG,GAAOvG,EAAIuG,GAAYH,EAAOjC,QAAUnE,EAASgG,GAASA,EAAMU,IAAI1G,EAAKoG,GAAW,OAAOA,EAxBjxBO,CAAwB,EAAQ,IAExCmF,EAAaC,EAAuB,EAAQ,IAE5CC,EAAYD,EAAuB,EAAQ,MAE3CE,EAASF,EAAuB,EAAQ,OAExC/B,EAAU,EAAQ,MAElBkC,EAAe,EAAQ,MAEvBpK,EAAS,EAAQ,MAEjB8J,EAAiBG,EAAuB,EAAQ,OAEhDI,EAAOJ,EAAuB,EAAQ,OAEtCK,EAAY,CAAC,OAAQ,SAAU,WAAY,kBAAmB,mBAAoB,2BAA4B,0BAA2B,WAAY,iBAAkB,SAE3K,SAASL,EAAuB/L,GAAO,OAAOA,GAAOA,EAAI+F,WAAa/F,EAAM,CAAEmE,QAASnE,GAEvF,SAASiG,EAAyBH,GAAe,GAAuB,oBAAZc,QAAwB,OAAO,KAAM,IAAIC,EAAoB,IAAID,QAAeE,EAAmB,IAAIF,QAAW,OAAQX,EAA2B,SAAkCH,GAAe,OAAOA,EAAcgB,EAAmBD,IAAsBf,GAIhU,SAASuG,IAA2Q,OAA9PA,EAAWjO,OAAOkO,QAAU,SAAU7E,GAAU,IAAK,IAAI9I,EAAI,EAAGA,EAAI+I,UAAU9I,OAAQD,IAAK,CAAE,IAAIgJ,EAASD,UAAU/I,GAAI,IAAK,IAAI4H,KAAOoB,EAAcvJ,OAAOY,UAAUwH,eAAetH,KAAKyI,EAAQpB,KAAQkB,EAAOlB,GAAOoB,EAAOpB,IAAY,OAAOkB,IAA2B5I,MAAM0N,KAAM7E,WAEhT,SAAS8E,EAAyB7E,EAAQ8E,GAAY,GAAc,MAAV9E,EAAgB,MAAO,GAAI,IAAkEpB,EAAK5H,EAAnE8I,EAEzF,SAAuCE,EAAQ8E,GAAY,GAAc,MAAV9E,EAAgB,MAAO,GAAI,IAA2DpB,EAAK5H,EAA5D8I,EAAS,GAAQiF,EAAatO,OAAO8I,KAAKS,GAAqB,IAAKhJ,EAAI,EAAGA,EAAI+N,EAAW9N,OAAQD,IAAO4H,EAAMmG,EAAW/N,GAAQ8N,EAASE,QAAQpG,IAAQ,IAAakB,EAAOlB,GAAOoB,EAAOpB,IAAQ,OAAOkB,EAFxMmF,CAA8BjF,EAAQ8E,GAAuB,GAAIrO,OAAO+I,sBAAuB,CAAE,IAAI0F,EAAmBzO,OAAO+I,sBAAsBQ,GAAS,IAAKhJ,EAAI,EAAGA,EAAIkO,EAAiBjO,OAAQD,IAAO4H,EAAMsG,EAAiBlO,GAAQ8N,EAASE,QAAQpG,IAAQ,GAAkBnI,OAAOY,UAAU8N,qBAAqB5N,KAAKyI,EAAQpB,KAAgBkB,EAAOlB,GAAOoB,EAAOpB,IAAU,OAAOkB,EAIne,SAASV,EAAQC,EAAQC,GAAkB,IAAIC,EAAO9I,OAAO8I,KAAKF,GAAS,GAAI5I,OAAO+I,sBAAuB,CAAE,IAAIC,EAAUhJ,OAAO+I,sBAAsBH,GAAaC,IAAkBG,EAAUA,EAAQC,QAAO,SAAUC,GAAO,OAAOlJ,OAAOkI,yBAAyBU,EAAQM,GAAKC,eAAkBL,EAAKM,KAAK3I,MAAMqI,EAAME,GAAY,OAAOF,EAElV,SAASlG,EAAcyG,GAAU,IAAK,IAAI9I,EAAI,EAAGA,EAAI+I,UAAU9I,OAAQD,IAAK,CAAE,IAAIgJ,EAAyB,MAAhBD,UAAU/I,GAAa+I,UAAU/I,GAAK,GAAQA,EAAI,EAAKoI,EAAQ3I,OAAOuJ,IAAS,GAAMC,SAAQ,SAAUrB,GAAOvC,EAAgByD,EAAQlB,EAAKoB,EAAOpB,OAAsBnI,OAAOyJ,0BAA6BzJ,OAAO0J,iBAAiBL,EAAQrJ,OAAOyJ,0BAA0BF,IAAmBZ,EAAQ3I,OAAOuJ,IAASC,SAAQ,SAAUrB,GAAOnI,OAAOC,eAAeoJ,EAAQlB,EAAKnI,OAAOkI,yBAAyBqB,EAAQpB,OAAe,OAAOkB,EAE7gB,SAASsF,EAAeC,EAAKrO,GAAK,OAUlC,SAAyBqO,GAAO,GAAIC,MAAMC,QAAQF,GAAM,OAAOA,EAVtBG,CAAgBH,IAQzD,SAA+BA,EAAKrO,GAAK,IAAIyO,EAAY,MAAPJ,EAAc,KAAyB,qBAAX/M,QAA0B+M,EAAI/M,OAAOC,WAAa8M,EAAI,cAAe,GAAU,MAANI,EAAY,OAAQ,IAAkDC,EAAIC,EAAlDC,EAAO,GAAQC,GAAK,EAAUC,GAAK,EAAmB,IAAM,IAAKL,EAAKA,EAAGlO,KAAK8N,KAAQQ,GAAMH,EAAKD,EAAGM,QAAQC,QAAoBJ,EAAK/F,KAAK6F,EAAG9O,QAAYI,GAAK4O,EAAK3O,SAAWD,GAA3D6O,GAAK,IAAoE,MAAOI,GAAOH,GAAK,EAAMH,EAAKM,EAAO,QAAU,IAAWJ,GAAsB,MAAhBJ,EAAW,QAAWA,EAAW,SAAO,QAAU,GAAIK,EAAI,MAAMH,GAAQ,OAAOC,EARzbM,CAAsBb,EAAKrO,IAI5F,SAAqCmP,EAAGC,GAAU,IAAKD,EAAG,OAAQ,GAAiB,kBAANA,EAAgB,OAAOE,EAAkBF,EAAGC,GAAS,IAAIE,EAAI7P,OAAOY,UAAUC,SAASC,KAAK4O,GAAGI,MAAM,GAAI,GAAc,WAAND,GAAkBH,EAAE3N,cAAa8N,EAAIH,EAAE3N,YAAYgO,MAAM,GAAU,QAANF,GAAqB,QAANA,EAAa,OAAOhB,MAAMmB,KAAKN,GAAI,GAAU,cAANG,GAAqB,2CAA2CI,KAAKJ,GAAI,OAAOD,EAAkBF,EAAGC,GAJpTO,CAA4BtB,EAAKrO,IAEnI,WAA8B,MAAM,IAAI4P,UAAU,6IAFuFC,GAMzI,SAASR,EAAkBhB,EAAKyB,IAAkB,MAAPA,GAAeA,EAAMzB,EAAIpO,UAAQ6P,EAAMzB,EAAIpO,QAAQ,IAAK,IAAID,EAAI,EAAG+P,EAAO,IAAIzB,MAAMwB,GAAM9P,EAAI8P,EAAK9P,IAAO+P,EAAK/P,GAAKqO,EAAIrO,GAAM,OAAO+P,EAQhL,SAASC,EAAkBlH,EAAQ/H,GAAS,IAAK,IAAIf,EAAI,EAAGA,EAAIe,EAAMd,OAAQD,IAAK,CAAE,IAAIiQ,EAAalP,EAAMf,GAAIiQ,EAAWrH,WAAaqH,EAAWrH,aAAc,EAAOqH,EAAW7G,cAAe,EAAU,UAAW6G,IAAYA,EAAW5G,UAAW,GAAM5J,OAAOC,eAAeoJ,EAAQmH,EAAWrI,IAAKqI,IAM7S,SAASC,EAAgBf,EAAGgB,GAA+G,OAA1GD,EAAkBzQ,OAAO2Q,gBAAkB,SAAyBjB,EAAGgB,GAAsB,OAAjBhB,EAAEkB,UAAYF,EAAUhB,IAA6BA,EAAGgB,GAErK,SAASG,EAAaC,GAAW,IAAIC,EAMrC,WAAuC,GAAuB,qBAAZC,UAA4BA,QAAQC,UAAW,OAAO,EAAO,GAAID,QAAQC,UAAUC,KAAM,OAAO,EAAO,GAAqB,oBAAVC,MAAsB,OAAO,EAAM,IAAsF,OAAhFC,QAAQxQ,UAAUyQ,QAAQvQ,KAAKkQ,QAAQC,UAAUG,QAAS,IAAI,iBAAyB,EAAQ,MAAOlL,GAAK,OAAO,GAN9PoL,GAA6B,OAAO,WAAkC,IAAsCC,EAAlCC,EAAQC,EAAgBX,GAAkB,GAAIC,EAA2B,CAAE,IAAIW,EAAYD,EAAgBtD,MAAMpM,YAAawP,EAASP,QAAQC,UAAUO,EAAOlI,UAAWoI,QAAqBH,EAASC,EAAM/Q,MAAM0N,KAAM7E,WAAc,OAAOqI,EAA2BxD,KAAMoD,IAE5Z,SAASI,EAA2BC,EAAM9Q,GAAQ,GAAIA,IAA2B,WAAlBa,EAAQb,IAAsC,oBAATA,GAAwB,OAAOA,EAAa,QAAa,IAATA,EAAmB,MAAM,IAAIqP,UAAU,4DAA+D,OAAO0B,EAAuBD,GAExR,SAASC,EAAuBD,GAAQ,QAAa,IAATA,EAAmB,MAAM,IAAIE,eAAe,6DAAgE,OAAOF,EAI/J,SAASH,EAAgB/B,GAAwJ,OAAnJ+B,EAAkBzR,OAAO2Q,eAAiB3Q,OAAO+R,eAAiB,SAAyBrC,GAAK,OAAOA,EAAEkB,WAAa5Q,OAAO+R,eAAerC,KAA8BA,GAExM,SAAS9J,EAAgBhE,EAAKuG,EAAKhI,GAAiK,OAApJgI,KAAOvG,EAAO5B,OAAOC,eAAe2B,EAAKuG,EAAK,CAAEhI,MAAOA,EAAOgJ,YAAY,EAAMQ,cAAc,EAAMC,UAAU,IAAkBhI,EAAIuG,GAAOhI,EAAgByB,EAK3M,IAAIoQ,EAAyB,SAAUC,IAnBvC,SAAmBC,EAAUC,GAAc,GAA0B,oBAAfA,GAA4C,OAAfA,EAAuB,MAAM,IAAIhC,UAAU,sDAAyD+B,EAAStR,UAAYZ,OAAOoS,OAAOD,GAAcA,EAAWvR,UAAW,CAAEmB,YAAa,CAAE5B,MAAO+R,EAAUtI,UAAU,EAAMD,cAAc,KAAewI,GAAY1B,EAAgByB,EAAUC,GAoBjXE,CAAUL,EAAWC,GAErB,IAxBoBK,EAAaC,EAAYC,EAwBzCC,EAAS5B,EAAamB,GAE1B,SAASA,EAAU1Q,GAGjB,IAAIoR,EAoHJ,OArJJ,SAAyBC,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInC,UAAU,qCAmC5GyC,CAAgBzE,KAAM6D,GAItBpM,EAAgBiM,EAFhBa,EAAQD,EAAO3R,KAAKqN,KAAM7M,IAEqB,eAAe,SAAU4E,EAAGoH,GAMzE,IALA,EAAIS,EAAKhI,SAAS,6BAA8BuH,IAK5B,IAHFoF,EAAMpR,MAAMuR,QAAQ3M,GAAG,EAAI4H,EAAaT,qBAAqBwE,EAAuBa,GAAQpF,IAGnF,OAAO,EAElCoF,EAAMI,SAAS,CACbC,UAAU,EACVC,SAAS,OAIbpN,EAAgBiM,EAAuBa,GAAQ,UAAU,SAAUxM,EAAGoH,GACpE,IAAKoF,EAAM3F,MAAMgG,SAAU,OAAO,GAClC,EAAIhF,EAAKhI,SAAS,wBAAyBuH,GAC3C,IAAI2F,GAAS,EAAInF,EAAaT,qBAAqBwE,EAAuBa,GAAQpF,GAC9E4F,EAEF,CACAjO,EAAGgO,EAAOhO,EACVG,EAAG6N,EAAO7N,GAGZ,GAAIsN,EAAMpR,MAAMsJ,OAAQ,CAEtB,IAAI3F,EAAIiO,EAASjO,EACbG,EAAI8N,EAAS9N,EAIjB8N,EAASjO,GAAKyN,EAAM3F,MAAMoG,OAC1BD,EAAS9N,GAAKsN,EAAM3F,MAAMqG,OAE1B,IACIC,EAAqB1E,GADD,EAAIb,EAAapD,kBAAkBmH,EAAuBa,GAAQQ,EAASjO,EAAGiO,EAAS9N,GACpD,GACvDkO,EAAYD,EAAmB,GAC/BE,EAAYF,EAAmB,GAEnCH,EAASjO,EAAIqO,EACbJ,EAAS9N,EAAImO,EAEbL,EAASC,OAAST,EAAM3F,MAAMoG,QAAUlO,EAAIiO,EAASjO,GACrDiO,EAASE,OAASV,EAAM3F,MAAMqG,QAAUhO,EAAI8N,EAAS9N,GAErD6N,EAAOhO,EAAIiO,EAASjO,EACpBgO,EAAO7N,EAAI8N,EAAS9N,EACpB6N,EAAO/F,OAASgG,EAASjO,EAAIyN,EAAM3F,MAAM9H,EACzCgO,EAAO9F,OAAS+F,EAAS9N,EAAIsN,EAAM3F,MAAM3H,EAM3C,IAAqB,IAFFsN,EAAMpR,MAAMkS,OAAOtN,EAAG+M,GAEb,OAAO,EAEnCP,EAAMI,SAASI,MAGjBtN,EAAgBiM,EAAuBa,GAAQ,cAAc,SAAUxM,EAAGoH,GACxE,IAAKoF,EAAM3F,MAAMgG,SAAU,OAAO,EAIlC,IAAuB,IAFFL,EAAMpR,MAAMmS,OAAOvN,GAAG,EAAI4H,EAAaT,qBAAqBwE,EAAuBa,GAAQpF,IAElF,OAAO,GACrC,EAAIS,EAAKhI,SAAS,4BAA6BuH,GAC/C,IAAI4F,EAEF,CACAH,UAAU,EACVI,OAAQ,EACRC,OAAQ,GAMV,GAFiBhC,QAAQsB,EAAMpR,MAAMoS,UAErB,CACd,IAAIC,EAAuBjB,EAAMpR,MAAMoS,SACnCzO,EAAI0O,EAAqB1O,EACzBG,EAAIuO,EAAqBvO,EAC7B8N,EAASjO,EAAIA,EACbiO,EAAS9N,EAAIA,EAGfsN,EAAMI,SAASI,MAGjBR,EAAM3F,MAAQ,CAEZgG,UAAU,EAEVC,SAAS,EAET/N,EAAG3D,EAAMoS,SAAWpS,EAAMoS,SAASzO,EAAI3D,EAAMsS,gBAAgB3O,EAC7DG,EAAG9D,EAAMoS,SAAWpS,EAAMoS,SAAStO,EAAI9D,EAAMsS,gBAAgBxO,EAC7DyO,kBAAmBjR,EAAc,GAAItB,EAAMoS,UAE3CP,OAAQ,EACRC,OAAQ,EAERU,cAAc,GAGZxS,EAAMoS,WAAcpS,EAAMkS,QAAUlS,EAAMmS,OAKvCf,EAmHT,OApQoBJ,EAoJPN,EApJgCQ,EAyOzC,CAAC,CACHrK,IAAK,2BACLhI,MAEA,SAAkC4T,EAAMhK,GAGtC,IAAI2J,EAAWK,EAAKL,SAChBG,EAAoB9J,EAAM8J,kBAG9B,OAAIH,GAAcG,GAAqBH,EAASzO,IAAM4O,EAAkB5O,GAAKyO,EAAStO,IAAMyO,EAAkBzO,EAYvG,OAXL,EAAI2I,EAAKhI,SAAS,yCAA0C,CAC1D2N,SAAUA,EACVG,kBAAmBA,IAEd,CACL5O,EAAGyO,EAASzO,EACZG,EAAGsO,EAAStO,EACZyO,kBAAmBjR,EAAc,GAAI8Q,SA5PZnB,EAoJT,CAAC,CACvBpK,IAAK,oBACLhI,MAAO,WAE4B,qBAAtBoH,OAAOyM,YAA8B7F,KAAKnD,wBAAyBzD,OAAOyM,YACnF7F,KAAK2E,SAAS,CACZgB,cAAc,MAInB,CACD3L,IAAK,uBACLhI,MAAO,WACLgO,KAAK2E,SAAS,CACZC,UAAU,MAKb,CACD5K,IAAK,cACLhI,MAAO,WAGL,IAAI8T,EAAuBC,EAAaC,EAExC,OAA4O,QAApOF,EAAuD,QAA9BC,EAAc/F,KAAK7M,aAAmC,IAAhB4S,GAAkF,QAA/CC,EAAsBD,EAAYE,eAA6C,IAAxBD,OAAjE,EAA2GA,EAAoBE,eAA+C,IAA1BJ,EAAmCA,EAAwBrG,EAAU7H,QAAQiF,YAAYmD,QAE9U,CACDhG,IAAK,SACLhI,MAAO,WAGL,IAAImU,EAEAC,EAAepG,KAAK7M,MAGpBkT,GAFOD,EAAa/H,KACX+H,EAAa3J,OACX2J,EAAaC,UACxBZ,EAAkBW,EAAaX,gBAC/Ba,EAAmBF,EAAaE,iBAChCC,EAA2BH,EAAaG,yBACxCC,EAA0BJ,EAAaI,wBACvCjB,EAAWa,EAAab,SACxBjO,EAAiB8O,EAAa9O,eAE9BmP,GADQL,EAAa5P,MACAyJ,EAAyBmG,EAAcvG,IAE5D6G,EAAQ,GACRC,EAAe,KAGfnK,GADayG,QAAQsC,IACMvF,KAAKpB,MAAMgG,SACtCgC,EAAgBrB,GAAYE,EAC5BoB,EAAgB,CAElB/P,GAAG,EAAI6I,EAAavB,UAAU4B,OAASxD,EAAYwD,KAAKpB,MAAM9H,EAAI8P,EAAc9P,EAEhFG,GAAG,EAAI0I,EAAarB,UAAU0B,OAASxD,EAAYwD,KAAKpB,MAAM3H,EAAI2P,EAAc3P,GAG9E+I,KAAKpB,MAAM+G,aACbgB,GAAe,EAAIlJ,EAAQ5F,oBAAoBgP,EAAevP,GAM9DoP,GAAQ,EAAIjJ,EAAQrG,oBAAoByP,EAAevP,GAIzD,IAAI0E,GAAY,EAAI0D,EAAO9H,SAASyO,EAASlT,MAAM6I,WAAa,GAAIsK,GAA+B7O,EAAZ0O,EAAQ,GAA2BI,EAA0BvG,KAAKpB,MAAMgG,UAAWnN,EAAgB0O,EAAOK,EAAyBxG,KAAKpB,MAAMiG,SAAUsB,IAG/O,OAAoB7G,EAAM7G,cAAc4G,EAAezH,QAASkI,EAAS,GAAI2G,EAAoB,CAC/F/B,QAAS1E,KAAK8G,YACdzB,OAAQrF,KAAKqF,OACbC,OAAQtF,KAAK+G,aACEzH,EAAM0H,aAAa1H,EAAM2H,SAASC,KAAKb,GAAW,CACjErK,UAAWA,EACX0K,MAAOjS,EAAcA,EAAc,GAAI4R,EAASlT,MAAMuT,OAAQA,GAC9DS,UAAWR,UAtO2DvE,EAAkB+B,EAAY1R,UAAW2R,GAAiBC,GAAajC,EAAkB+B,EAAaE,GAoQ3KR,EA/OoB,CAgP3BvE,EAAM8H,WAERrV,EAAQ6F,QAAUiM,EAElBpM,EAAgBoM,EAAW,cAAe,aAE1CpM,EAAgBoM,EAAW,YAAapP,EAAcA,EAAc,GAAI4K,EAAezH,QAAQyP,WAAY,GAAI,CAc7GhJ,KAAMkB,EAAW3H,QAAQ0P,MAAM,CAAC,OAAQ,IAAK,IAAK,SA4BlD7K,OAAQ8C,EAAW3H,QAAQ2P,UAAU,CAAChI,EAAW3H,QAAQ4P,MAAM,CAC7D7Q,KAAM4I,EAAW3H,QAAQ6P,OACzB/K,MAAO6C,EAAW3H,QAAQ6P,OAC1B7Q,IAAK2I,EAAW3H,QAAQ6P,OACxB9K,OAAQ4C,EAAW3H,QAAQ6P,SACzBlI,EAAW3H,QAAQ8P,OAAQnI,EAAW3H,QAAQ0P,MAAM,EAAC,MACzDhB,iBAAkB/G,EAAW3H,QAAQ8P,OACrCnB,yBAA0BhH,EAAW3H,QAAQ8P,OAC7ClB,wBAAyBjH,EAAW3H,QAAQ8P,OAmB5CjC,gBAAiBlG,EAAW3H,QAAQ4P,MAAM,CACxC1Q,EAAGyI,EAAW3H,QAAQ6P,OACtBxQ,EAAGsI,EAAW3H,QAAQ6P,SAExBnQ,eAAgBiI,EAAW3H,QAAQ4P,MAAM,CACvC1Q,EAAGyI,EAAW3H,QAAQ2P,UAAU,CAAChI,EAAW3H,QAAQ6P,OAAQlI,EAAW3H,QAAQ8P,SAC/EzQ,EAAGsI,EAAW3H,QAAQ2P,UAAU,CAAChI,EAAW3H,QAAQ6P,OAAQlI,EAAW3H,QAAQ8P,WAuBjFnC,SAAUhG,EAAW3H,QAAQ4P,MAAM,CACjC1Q,EAAGyI,EAAW3H,QAAQ6P,OACtBxQ,EAAGsI,EAAW3H,QAAQ6P,SAMxBzL,UAAWzG,EAAOrC,UAClBwT,MAAOnR,EAAOrC,UACdiU,UAAW5R,EAAOrC,aAGpBuE,EAAgBoM,EAAW,eAAgBpP,EAAcA,EAAc,GAAI4K,EAAezH,QAAQ+P,cAAe,GAAI,CACnHtJ,KAAM,OACN5B,QAAQ,EACR6J,iBAAkB,kBAClBC,yBAA0B,2BAC1BC,wBAAyB,0BACzBf,gBAAiB,CACf3O,EAAG,EACHG,EAAG,GAELT,MAAO,M,kCCvcT,SAASoR,EAAMC,GACd,IAAIC,EAAG7Q,EAAG8Q,EAAI,GAEd,GAAmB,kBAARF,GAAmC,kBAARA,EACrCE,GAAOF,OACD,GAAmB,kBAARA,EACjB,GAAInH,MAAMC,QAAQkH,GACjB,IAAKC,EAAE,EAAGA,EAAID,EAAIxV,OAAQyV,IACrBD,EAAIC,KACH7Q,EAAI2Q,EAAMC,EAAIC,OACjBC,IAAQA,GAAO,KACfA,GAAO9Q,QAKV,IAAK6Q,KAAKD,EACLA,EAAIC,KACPC,IAAQA,GAAO,KACfA,GAAOD,GAMX,OAAOC,EAzBR,OA4Be,qBAEd,IADA,IAASC,EAAKlR,EAAV1E,EAAE,EAAW2V,EAAI,GACd3V,EAAI+I,UAAU9I,SAChB2V,EAAM7M,UAAU/I,QACf0E,EAAI8Q,EAAMI,MACbD,IAAQA,GAAO,KACfA,GAAOjR,GAIV,OAAOiR,I,kCCpCRlW,OAAOC,eAAeC,EAAS,aAAc,CAC3CC,OAAO,IAETD,EAAQkW,UAAYA,EACpBlW,EAAQ4F,mBAAqBA,EAC7B5F,EAAQmW,qBAsCR,SAA8BC,EAE5BC,GAKA,OAAOA,EAAS,IAAI7U,OAAO6U,EAAOC,cAAe,KAAK9U,OAAO4U,GAAQA,GA5CvEpW,EAAQ6F,aAAU,EAClB,IAAI0Q,EAAW,CAAC,MAAO,SAAU,IAAK,MAEtC,SAASL,IAGP,IAAIM,EAAkBC,EAElBL,EAEFhN,UAAU9I,OAAS,QAAsB+M,IAAjBjE,UAAU,GAAmBA,UAAU,GAAK,YAGtE,GAAsB,qBAAX/B,OAAwB,MAAO,GAG1C,IAAIsN,EAAiD,QAAxC6B,EAAmBnP,OAAOqP,gBAA2C,IAArBF,GAAsG,QAA9DC,EAAwBD,EAAiBG,uBAAuD,IAA1BF,OAAhF,EAA4HA,EAAsB9B,MAC7O,IAAKA,EAAO,MAAO,GACnB,GAAIyB,KAAQzB,EAAO,MAAO,GAE1B,IAAK,IAAItU,EAAI,EAAGA,EAAIkW,EAASjW,OAAQD,IACnC,GAAIuF,EAAmBwQ,EAAMG,EAASlW,MAAOsU,EAAO,OAAO4B,EAASlW,GAGtE,MAAO,GAGT,SAASuF,EAAmBwQ,EAE1BC,GAKA,OAAOA,EAAS,GAAG7U,OAAO6U,GAAQ7U,OAapC,SAA0BwU,GAQxB,IAHA,IAAIY,EAAM,GACNC,GAAmB,EAEdxW,EAAI,EAAGA,EAAI2V,EAAI1V,OAAQD,IAC1BwW,GACFD,GAAOZ,EAAI3V,GAAGyW,cACdD,GAAmB,GACC,MAAXb,EAAI3V,GACbwW,GAAmB,EAEnBD,GAAOZ,EAAI3V,GAIf,OAAOuW,EAhCkCG,CAAiBX,IAASA,EAsCrE,IAAIY,EAAYd,IAIhBlW,EAAQ6F,QAAUmR,G,kCClFlB,SAASvV,EAAQC,GAAmV,OAAtOD,EAArD,oBAAXE,QAAoD,kBAApBA,OAAOC,SAAmC,SAAiBF,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,oBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAOjB,UAAY,gBAAkBgB,IAAyBA,GAEnX5B,OAAOC,eAAeC,EAAS,aAAc,CAC3CC,OAAO,IAETD,EAAQ6F,aAAU,EAElB,IAAI0H,EAkBJ,SAAiC7L,EAAK8F,GAAe,IAAKA,GAAe9F,GAAOA,EAAI+F,WAAc,OAAO/F,EAAO,GAAY,OAARA,GAAiC,WAAjBD,EAAQC,IAAoC,oBAARA,EAAsB,MAAO,CAAEmE,QAASnE,GAAS,IAAIgG,EAAQC,EAAyBH,GAAc,GAAIE,GAASA,EAAME,IAAIlG,GAAQ,OAAOgG,EAAMG,IAAInG,GAAQ,IAAIoG,EAAS,GAAQC,EAAwBjI,OAAOC,gBAAkBD,OAAOkI,yBAA0B,IAAK,IAAIC,KAAOvG,EAAO,GAAY,YAARuG,GAAqBnI,OAAOY,UAAUwH,eAAetH,KAAKc,EAAKuG,GAAM,CAAE,IAAIE,EAAOJ,EAAwBjI,OAAOkI,yBAAyBtG,EAAKuG,GAAO,KAAUE,IAASA,EAAKN,KAAOM,EAAKC,KAAQtI,OAAOC,eAAe+H,EAAQG,EAAKE,GAAgBL,EAAOG,GAAOvG,EAAIuG,GAAYH,EAAOjC,QAAUnE,EAASgG,GAASA,EAAMU,IAAI1G,EAAKoG,GAAW,OAAOA,EAlBjxBO,CAAwB,EAAQ,IAExCmF,EAAaC,EAAuB,EAAQ,IAE5CC,EAAYD,EAAuB,EAAQ,MAE3C/B,EAAU,EAAQ,MAElBkC,EAAe,EAAQ,MAEvBpK,EAAS,EAAQ,MAEjBqK,EAAOJ,EAAuB,EAAQ,OAE1C,SAASA,EAAuB/L,GAAO,OAAOA,GAAOA,EAAI+F,WAAa/F,EAAM,CAAEmE,QAASnE,GAEvF,SAASiG,EAAyBH,GAAe,GAAuB,oBAAZc,QAAwB,OAAO,KAAM,IAAIC,EAAoB,IAAID,QAAeE,EAAmB,IAAIF,QAAW,OAAQX,EAA2B,SAAkCH,GAAe,OAAOA,EAAcgB,EAAmBD,IAAsBf,GAIhU,SAASiH,EAAeC,EAAKrO,GAAK,OAUlC,SAAyBqO,GAAO,GAAIC,MAAMC,QAAQF,GAAM,OAAOA,EAVtBG,CAAgBH,IAQzD,SAA+BA,EAAKrO,GAAK,IAAIyO,EAAY,MAAPJ,EAAc,KAAyB,qBAAX/M,QAA0B+M,EAAI/M,OAAOC,WAAa8M,EAAI,cAAe,GAAU,MAANI,EAAY,OAAQ,IAAkDC,EAAIC,EAAlDC,EAAO,GAAQC,GAAK,EAAUC,GAAK,EAAmB,IAAM,IAAKL,EAAKA,EAAGlO,KAAK8N,KAAQQ,GAAMH,EAAKD,EAAGM,QAAQC,QAAoBJ,EAAK/F,KAAK6F,EAAG9O,QAAYI,GAAK4O,EAAK3O,SAAWD,GAA3D6O,GAAK,IAAoE,MAAOI,GAAOH,GAAK,EAAMH,EAAKM,EAAO,QAAU,IAAWJ,GAAsB,MAAhBJ,EAAW,QAAWA,EAAW,SAAO,QAAU,GAAIK,EAAI,MAAMH,GAAQ,OAAOC,EARzbM,CAAsBb,EAAKrO,IAI5F,SAAqCmP,EAAGC,GAAU,IAAKD,EAAG,OAAQ,GAAiB,kBAANA,EAAgB,OAAOE,EAAkBF,EAAGC,GAAS,IAAIE,EAAI7P,OAAOY,UAAUC,SAASC,KAAK4O,GAAGI,MAAM,GAAI,GAAc,WAAND,GAAkBH,EAAE3N,cAAa8N,EAAIH,EAAE3N,YAAYgO,MAAM,GAAU,QAANF,GAAqB,QAANA,EAAa,OAAOhB,MAAMmB,KAAKN,GAAI,GAAU,cAANG,GAAqB,2CAA2CI,KAAKJ,GAAI,OAAOD,EAAkBF,EAAGC,GAJpTO,CAA4BtB,EAAKrO,IAEnI,WAA8B,MAAM,IAAI4P,UAAU,6IAFuFC,GAMzI,SAASR,EAAkBhB,EAAKyB,IAAkB,MAAPA,GAAeA,EAAMzB,EAAIpO,UAAQ6P,EAAMzB,EAAIpO,QAAQ,IAAK,IAAID,EAAI,EAAG+P,EAAO,IAAIzB,MAAMwB,GAAM9P,EAAI8P,EAAK9P,IAAO+P,EAAK/P,GAAKqO,EAAIrO,GAAM,OAAO+P,EAMhL,SAASsC,EAAgBD,EAAUL,GAAe,KAAMK,aAAoBL,GAAgB,MAAM,IAAInC,UAAU,qCAEhH,SAASI,EAAkBlH,EAAQ/H,GAAS,IAAK,IAAIf,EAAI,EAAGA,EAAIe,EAAMd,OAAQD,IAAK,CAAE,IAAIiQ,EAAalP,EAAMf,GAAIiQ,EAAWrH,WAAaqH,EAAWrH,aAAc,EAAOqH,EAAW7G,cAAe,EAAU,UAAW6G,IAAYA,EAAW5G,UAAW,GAAM5J,OAAOC,eAAeoJ,EAAQmH,EAAWrI,IAAKqI,IAM7S,SAASC,EAAgBf,EAAGgB,GAA+G,OAA1GD,EAAkBzQ,OAAO2Q,gBAAkB,SAAyBjB,EAAGgB,GAAsB,OAAjBhB,EAAEkB,UAAYF,EAAUhB,IAA6BA,EAAGgB,GAErK,SAASG,EAAaC,GAAW,IAAIC,EAMrC,WAAuC,GAAuB,qBAAZC,UAA4BA,QAAQC,UAAW,OAAO,EAAO,GAAID,QAAQC,UAAUC,KAAM,OAAO,EAAO,GAAqB,oBAAVC,MAAsB,OAAO,EAAM,IAAsF,OAAhFC,QAAQxQ,UAAUyQ,QAAQvQ,KAAKkQ,QAAQC,UAAUG,QAAS,IAAI,iBAAyB,EAAQ,MAAOlL,GAAK,OAAO,GAN9PoL,GAA6B,OAAO,WAAkC,IAAsCC,EAAlCC,EAAQC,EAAgBX,GAAkB,GAAIC,EAA2B,CAAE,IAAIW,EAAYD,EAAgBtD,MAAMpM,YAAawP,EAASP,QAAQC,UAAUO,EAAOlI,UAAWoI,QAAqBH,EAASC,EAAM/Q,MAAM0N,KAAM7E,WAAc,OAAOqI,EAA2BxD,KAAMoD,IAE5Z,SAASI,EAA2BC,EAAM9Q,GAAQ,GAAIA,IAA2B,WAAlBa,EAAQb,IAAsC,oBAATA,GAAwB,OAAOA,EAAa,QAAa,IAATA,EAAmB,MAAM,IAAIqP,UAAU,4DAA+D,OAAO0B,EAAuBD,GAExR,SAASC,EAAuBD,GAAQ,QAAa,IAATA,EAAmB,MAAM,IAAIE,eAAe,6DAAgE,OAAOF,EAI/J,SAASH,EAAgB/B,GAAwJ,OAAnJ+B,EAAkBzR,OAAO2Q,eAAiB3Q,OAAO+R,eAAiB,SAAyBrC,GAAK,OAAOA,EAAEkB,WAAa5Q,OAAO+R,eAAerC,KAA8BA,GAExM,SAAS9J,EAAgBhE,EAAKuG,EAAKhI,GAAiK,OAApJgI,KAAOvG,EAAO5B,OAAOC,eAAe2B,EAAKuG,EAAK,CAAEhI,MAAOA,EAAOgJ,YAAY,EAAMQ,cAAc,EAAMC,UAAU,IAAkBhI,EAAIuG,GAAOhI,EAAgByB,EAG3M,IAAIuV,EACK,CACLC,MAAO,aACPC,KAAM,YACNC,KAAM,YAJNH,EAMK,CACLC,MAAO,YACPC,KAAM,YACNC,KAAM,WAINC,EAAeJ,EAgDfK,EAA6B,SAAUvF,IA9E3C,SAAmBC,EAAUC,GAAc,GAA0B,oBAAfA,GAA4C,OAAfA,EAAuB,MAAM,IAAIhC,UAAU,sDAAyD+B,EAAStR,UAAYZ,OAAOoS,OAAOD,GAAcA,EAAWvR,UAAW,CAAEmB,YAAa,CAAE5B,MAAO+R,EAAUtI,UAAU,EAAMD,cAAc,KAAewI,GAAY1B,EAAgByB,EAAUC,GA+EjXE,CAAUmF,EAAevF,GAEzB,IAnFoBK,EAAaC,EAAYC,EAmFzCC,EAAS5B,EAAa2G,GAE1B,SAASA,IACP,IAAI9E,EAEJE,EAAgBzE,KAAMqJ,GAEtB,IAAK,IAAIC,EAAOnO,UAAU9I,OAAQkX,EAAO,IAAI7I,MAAM4I,GAAOE,EAAO,EAAGA,EAAOF,EAAME,IAC/ED,EAAKC,GAAQrO,UAAUqO,GAgMzB,OA3LA/R,EAAgBiM,EAFhBa,EAAQD,EAAO3R,KAAKL,MAAMgS,EAAQ,CAACtE,MAAMzM,OAAOgW,KAED,QAAS,CACtD3E,UAAU,EAEV9F,MAAO2K,IACPxK,MAAOwK,IACPjL,gBAAiB,OAGnB/G,EAAgBiM,EAAuBa,GAAQ,WAAW,GAE1D9M,EAAgBiM,EAAuBa,GAAQ,mBAAmB,SAAUxM,GAK1E,GAHAwM,EAAMpR,MAAMuW,YAAY3R,IAGnBwM,EAAMpR,MAAMwW,eAAqC,kBAAb5R,EAAE6R,QAAoC,IAAb7R,EAAE6R,OAAc,OAAO,EAEzF,IAAIC,EAAWtF,EAAM1H,cAErB,IAAKgN,IAAaA,EAASzU,gBAAkByU,EAASzU,cAAcsB,KAClE,MAAM,IAAIpD,MAAM,6CAGlB,IAAI8B,EAAgByU,EAASzU,cAE7B,KAAImP,EAAMpR,MAAM2W,YAAc/R,EAAEmD,kBAAkB9F,EAAcC,YAAY0U,OAASxF,EAAMpR,MAAM6W,UAAW,EAAIvM,EAAQ3J,6BAA6BiE,EAAEmD,OAAQqJ,EAAMpR,MAAM6W,OAAQH,IAAatF,EAAMpR,MAAM8W,SAAU,EAAIxM,EAAQ3J,6BAA6BiE,EAAEmD,OAAQqJ,EAAMpR,MAAM8W,OAAQJ,IAA7R,CAMe,eAAX9R,EAAEW,MAAuBX,EAAEmS,iBAI/B,IAAI1L,GAAkB,EAAIf,EAAQrF,oBAAoBL,GAEtDwM,EAAMI,SAAS,CACbnG,gBAAiBA,IAInB,IAAI+G,GAAW,EAAI5F,EAAapB,oBAAoBxG,EAAGyG,EAAiBkF,EAAuBa,IAC/F,GAAgB,MAAZgB,EAAJ,CAEA,IAAIzO,EAAIyO,EAASzO,EACbG,EAAIsO,EAAStO,EAEbkT,GAAY,EAAIxK,EAAahB,gBAAgB+E,EAAuBa,GAAQzN,EAAGG,IACnF,EAAI2I,EAAKhI,SAAS,qCAAsCuS,IAExD,EAAIvK,EAAKhI,SAAS,UAAW2M,EAAMpR,MAAMuR,UAIpB,IAFFH,EAAMpR,MAAMuR,QAAQ3M,EAAGoS,KAEM,IAAlB5F,EAAM6F,UAGhC7F,EAAMpR,MAAMkX,uBAAsB,EAAI5M,EAAQpF,qBAAqBjD,GAIvEmP,EAAMI,SAAS,CACbC,UAAU,EACV9F,MAAOhI,EACPmI,MAAOhI,KAMT,EAAIwG,EAAQrJ,UAAUgB,EAAegU,EAAaF,KAAM3E,EAAM+F,aAC9D,EAAI7M,EAAQrJ,UAAUgB,EAAegU,EAAaD,KAAM5E,EAAMgG,sBAGhE9S,EAAgBiM,EAAuBa,GAAQ,cAAc,SAAUxM,GAErE,IAAIwN,GAAW,EAAI5F,EAAapB,oBAAoBxG,EAAGwM,EAAM3F,MAAMJ,gBAAiBkF,EAAuBa,IAC3G,GAAgB,MAAZgB,EAAJ,CACA,IAAIzO,EAAIyO,EAASzO,EACbG,EAAIsO,EAAStO,EAEjB,GAAIyJ,MAAMC,QAAQ4D,EAAMpR,MAAM6K,MAAO,CACnC,IAAIe,EAASjI,EAAIyN,EAAM3F,MAAME,MACzBE,EAAS/H,EAAIsN,EAAM3F,MAAMK,MAIzBuL,EAAehK,GAFD,EAAIb,EAAa5B,YAAYwG,EAAMpR,MAAM6K,KAAMe,EAAQC,GAE1B,GAI/C,GAFAD,EAASyL,EAAa,GACtBxL,EAASwL,EAAa,IACjBzL,IAAWC,EAAQ,OAExBlI,EAAIyN,EAAM3F,MAAME,MAAQC,EAAQ9H,EAAIsN,EAAM3F,MAAMK,MAAQD,EAG1D,IAAImL,GAAY,EAAIxK,EAAahB,gBAAgB+E,EAAuBa,GAAQzN,EAAGG,GAKnF,IAJA,EAAI2I,EAAKhI,SAAS,gCAAiCuS,IAI9B,IAFF5F,EAAMpR,MAAMkS,OAAOtN,EAAGoS,KAEO,IAAlB5F,EAAM6F,QAqBpC7F,EAAMI,SAAS,CACb7F,MAAOhI,EACPmI,MAAOhI,SAtBP,IAEEsN,EAAMgG,eAAe,IAAIE,WAAW,YACpC,MAAOpJ,GAEP,IAAIhN,EAAUoU,SAASiC,YAAY,eAOnCrW,EAAMsW,eAAe,WAAW,GAAM,EAAMvR,OAAQ,EAAG,EAAG,EAAG,EAAG,GAAG,GAAO,GAAO,GAAO,EAAO,EAAG,MAElGmL,EAAMgG,eAAelW,QAY3BoD,EAAgBiM,EAAuBa,GAAQ,kBAAkB,SAAUxM,GACzE,GAAKwM,EAAM3F,MAAMgG,SAAjB,CACA,IAAIW,GAAW,EAAI5F,EAAapB,oBAAoBxG,EAAGwM,EAAM3F,MAAMJ,gBAAiBkF,EAAuBa,IAC3G,GAAgB,MAAZgB,EAAJ,CACA,IAAIzO,EAAIyO,EAASzO,EACbG,EAAIsO,EAAStO,EACbkT,GAAY,EAAIxK,EAAahB,gBAAgB+E,EAAuBa,GAAQzN,EAAGG,GAInF,IAAuB,IAFFsN,EAAMpR,MAAMmS,OAAOvN,EAAGoS,KAEO,IAAlB5F,EAAM6F,QAAmB,OAAO,EAEhE,IAAIP,EAAWtF,EAAM1H,cAEjBgN,GAEEtF,EAAMpR,MAAMkX,uBAAsB,EAAI5M,EAAQzE,wBAAwB6Q,EAASzU,gBAGrF,EAAIwK,EAAKhI,SAAS,oCAAqCuS,GAEvD5F,EAAMI,SAAS,CACbC,UAAU,EACV9F,MAAO2K,IACPxK,MAAOwK,MAGLI,KAEF,EAAIjK,EAAKhI,SAAS,qCAClB,EAAI6F,EAAQ5I,aAAagV,EAASzU,cAAegU,EAAaF,KAAM3E,EAAM+F,aAC1E,EAAI7M,EAAQ5I,aAAagV,EAASzU,cAAegU,EAAaD,KAAM5E,EAAMgG,sBAI9E9S,EAAgBiM,EAAuBa,GAAQ,eAAe,SAAUxM,GAGtE,OAFAqR,EAAeJ,EAERzE,EAAMqG,gBAAgB7S,MAG/BN,EAAgBiM,EAAuBa,GAAQ,aAAa,SAAUxM,GAEpE,OADAqR,EAAeJ,EACRzE,EAAMgG,eAAexS,MAG9BN,EAAgBiM,EAAuBa,GAAQ,gBAAgB,SAAUxM,GAGvE,OADAqR,EAAeJ,EACRzE,EAAMqG,gBAAgB7S,MAG/BN,EAAgBiM,EAAuBa,GAAQ,cAAc,SAAUxM,GAGrE,OADAqR,EAAeJ,EACRzE,EAAMgG,eAAexS,MAGvBwM,EAoET,OA/VoBJ,EA8RPkF,GA9RoBjF,EA8RL,CAAC,CAC3BpK,IAAK,oBACLhI,MAAO,WACLgO,KAAKoK,SAAU,EAGf,IAAIP,EAAW7J,KAAKnD,cAEhBgN,IACF,EAAIpM,EAAQrJ,UAAUyV,EAAUb,EAAgBC,MAAOjJ,KAAK6K,aAAc,CACxEC,SAAS,MAId,CACD9Q,IAAK,uBACLhI,MAAO,WACLgO,KAAKoK,SAAU,EAGf,IAAIP,EAAW7J,KAAKnD,cAEpB,GAAIgN,EAAU,CACZ,IAAIzU,EAAgByU,EAASzU,eAC7B,EAAIqI,EAAQ5I,aAAaO,EAAe4T,EAAgBE,KAAMlJ,KAAKsK,aACnE,EAAI7M,EAAQ5I,aAAaO,EAAe4T,EAAgBE,KAAMlJ,KAAKsK,aACnE,EAAI7M,EAAQ5I,aAAaO,EAAe4T,EAAgBG,KAAMnJ,KAAKuK,iBACnE,EAAI9M,EAAQ5I,aAAaO,EAAe4T,EAAgBG,KAAMnJ,KAAKuK,iBACnE,EAAI9M,EAAQ5I,aAAagV,EAAUb,EAAgBC,MAAOjJ,KAAK6K,aAAc,CAC3EC,SAAS,IAEP9K,KAAK7M,MAAMkX,uBAAsB,EAAI5M,EAAQzE,wBAAwB5D,MAK5E,CACD4E,IAAK,cACLhI,MAAO,WAGL,IAAI8T,EAAuBC,EAAaC,EAExC,OAA4O,QAApOF,EAAuD,QAA9BC,EAAc/F,KAAK7M,aAAmC,IAAhB4S,GAAkF,QAA/CC,EAAsBD,EAAYE,eAA6C,IAAxBD,OAAjE,EAA2GA,EAAoBE,eAA+C,IAA1BJ,EAAmCA,EAAwBrG,EAAU7H,QAAQiF,YAAYmD,QAE9U,CACDhG,IAAK,SACLhI,MAAO,WAKL,OAAoBsN,EAAM0H,aAAa1H,EAAM2H,SAASC,KAAKlH,KAAK7M,MAAMkT,UAAW,CAG/EqD,YAAa1J,KAAK0J,YAClBqB,UAAW/K,KAAK+K,UAIhBC,WAAYhL,KAAKgL,kBA1VqD5I,EAAkB+B,EAAY1R,UAAW2R,GAAiBC,GAAajC,EAAkB+B,EAAaE,GA+V3KgF,EA/QwB,CAgR/B/J,EAAM8H,WAERrV,EAAQ6F,QAAUyR,EAElB5R,EAAgB4R,EAAe,cAAe,iBAE9C5R,EAAgB4R,EAAe,YAAa,CAO1CM,cAAepK,EAAW3H,QAAQqT,KAMlCnB,SAAUvK,EAAW3H,QAAQqT,KAO7BZ,qBAAsB9K,EAAW3H,QAAQqT,KAMzC1U,aAAc,SAAsBpD,EAElCC,GAGA,GAAID,EAAMC,IAA0C,IAA7BD,EAAMC,GAAU8X,SACrC,MAAM,IAAI5X,MAAM,iDAOpB0K,KAAMuB,EAAW3H,QAAQuT,QAAQ5L,EAAW3H,QAAQ6P,QAsBpDuC,OAAQzK,EAAW3H,QAAQ8P,OAsB3BuC,OAAQ1K,EAAW3H,QAAQ8P,OAmB3BzB,QAAS1G,EAAW3H,QAAQ6C,OAM5BiK,QAASnF,EAAW3H,QAAQpF,KAM5B6S,OAAQ9F,EAAW3H,QAAQpF,KAM3B8S,OAAQ/F,EAAW3H,QAAQpF,KAM3BkX,YAAanK,EAAW3H,QAAQpF,KAKhCgE,MAAO+I,EAAW3H,QAAQ6P,OAK1BzL,UAAWzG,EAAOrC,UAClBwT,MAAOnR,EAAOrC,UACdiU,UAAW5R,EAAOrC,YAGpBuE,EAAgB4R,EAAe,eAAgB,CAC7CM,eAAe,EAEfG,UAAU,EACVO,sBAAsB,EACtB3F,QAAS,aACTW,OAAQ,aACRC,OAAQ,aACRoE,YAAa,aACblT,MAAO,K,kCCviBT,IAAI4U,EAAW,EAAQ,MACnBvH,EAAYuH,EAASxT,QACrByR,EAAgB+B,EAAS/B,cAK7BgC,EAAOtZ,QAAU8R,EACjBwH,EAAOtZ,QAAQ6F,QAAUiM,EACzBwH,EAAOtZ,QAAQsX,cAAgBA","file":"2.bundle.js?cb=1734556040556","sourcesContent":["\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.findInArray = findInArray;\nexports.isFunction = isFunction;\nexports.isNum = isNum;\nexports.int = int;\nexports.dontSetMe = dontSetMe;\n\n// @credits https://gist.github.com/rogozhnikoff/a43cfed27c41e4e68cdc\nfunction findInArray(array\n/*: Array<any> | TouchList*/\n, callback\n/*: Function*/\n)\n/*: any*/\n{\n  for (var i = 0, length = array.length; i < length; i++) {\n    if (callback.apply(callback, [array[i], i, array])) return array[i];\n  }\n}\n\nfunction isFunction(func\n/*: any*/\n)\n/*: boolean %checks*/\n{\n  // $FlowIgnore[method-unbinding]\n  return typeof func === 'function' || Object.prototype.toString.call(func) === '[object Function]';\n}\n\nfunction isNum(num\n/*: any*/\n)\n/*: boolean %checks*/\n{\n  return typeof num === 'number' && !isNaN(num);\n}\n\nfunction int(a\n/*: string*/\n)\n/*: number*/\n{\n  return parseInt(a, 10);\n}\n\nfunction dontSetMe(props\n/*: Object*/\n, propName\n/*: string*/\n, componentName\n/*: string*/\n)\n/*: ?Error*/\n{\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}","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.matchesSelector = matchesSelector;\nexports.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;\nexports.addEvent = addEvent;\nexports.removeEvent = removeEvent;\nexports.outerHeight = outerHeight;\nexports.outerWidth = outerWidth;\nexports.innerHeight = innerHeight;\nexports.innerWidth = innerWidth;\nexports.offsetXYFromParent = offsetXYFromParent;\nexports.createCSSTransform = createCSSTransform;\nexports.createSVGTransform = createSVGTransform;\nexports.getTranslation = getTranslation;\nexports.getTouch = getTouch;\nexports.getTouchIdentifier = getTouchIdentifier;\nexports.addUserSelectStyles = addUserSelectStyles;\nexports.removeUserSelectStyles = removeUserSelectStyles;\nexports.addClassName = addClassName;\nexports.removeClassName = removeClassName;\n\nvar _shims = require(\"./shims\");\n\nvar _getPrefix = _interopRequireWildcard(require(\"./getPrefix\"));\n\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\n\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\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar matchesSelectorFunc = '';\n\nfunction matchesSelector(el\n/*: Node*/\n, selector\n/*: string*/\n)\n/*: boolean*/\n{\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  } // Might not be found entirely (not an Element?) - in that case, bail\n  // $FlowIgnore: Doesn't think elements are indexable\n\n\n  if (!(0, _shims.isFunction)(el[matchesSelectorFunc])) return false; // $FlowIgnore: Doesn't think elements are indexable\n\n  return el[matchesSelectorFunc](selector);\n} // Works up the tree to the draggable itself attempting to match selector.\n\n\nfunction matchesSelectorAndParentsTo(el\n/*: Node*/\n, selector\n/*: string*/\n, baseNode\n/*: Node*/\n)\n/*: boolean*/\n{\n  var node = el;\n\n  do {\n    if (matchesSelector(node, selector)) return true;\n    if (node === baseNode) return false;\n    node = node.parentNode;\n  } while (node);\n\n  return false;\n}\n\nfunction addEvent(el\n/*: ?Node*/\n, event\n/*: string*/\n, handler\n/*: Function*/\n, inputOptions\n/*: Object*/\n)\n/*: void*/\n{\n  if (!el) return;\n\n  var options = _objectSpread({\n    capture: true\n  }, inputOptions); // $FlowIgnore[method-unbinding]\n\n\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}\n\nfunction removeEvent(el\n/*: ?Node*/\n, event\n/*: string*/\n, handler\n/*: Function*/\n, inputOptions\n/*: Object*/\n)\n/*: void*/\n{\n  if (!el) return;\n\n  var options = _objectSpread({\n    capture: true\n  }, inputOptions); // $FlowIgnore[method-unbinding]\n\n\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}\n\nfunction outerHeight(node\n/*: HTMLElement*/\n)\n/*: number*/\n{\n  // This is deliberately excluding margin for our calculations, since we are using\n  // offsetTop which is including margin. See getBoundPosition\n  var height = node.clientHeight;\n  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  height += (0, _shims.int)(computedStyle.borderTopWidth);\n  height += (0, _shims.int)(computedStyle.borderBottomWidth);\n  return height;\n}\n\nfunction outerWidth(node\n/*: HTMLElement*/\n)\n/*: number*/\n{\n  // This is deliberately excluding margin for our calculations, since we are using\n  // offsetLeft which is including margin. See getBoundPosition\n  var width = node.clientWidth;\n  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  width += (0, _shims.int)(computedStyle.borderLeftWidth);\n  width += (0, _shims.int)(computedStyle.borderRightWidth);\n  return width;\n}\n\nfunction innerHeight(node\n/*: HTMLElement*/\n)\n/*: number*/\n{\n  var height = node.clientHeight;\n  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);\n  height -= (0, _shims.int)(computedStyle.paddingTop);\n  height -= (0, _shims.int)(computedStyle.paddingBottom);\n  return height;\n}\n\nfunction innerWidth(node\n/*: HTMLElement*/\n)\n/*: number*/\n{\n  var width = node.clientWidth;\n  var 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\n\n// Get from offsetParent\nfunction offsetXYFromParent(evt\n/*: EventWithOffset*/\n, offsetParent\n/*: HTMLElement*/\n, scale\n/*: number*/\n)\n/*: ControlPosition*/\n{\n  var isBody = offsetParent === offsetParent.ownerDocument.body;\n  var offsetParentRect = isBody ? {\n    left: 0,\n    top: 0\n  } : offsetParent.getBoundingClientRect();\n  var x = (evt.clientX + offsetParent.scrollLeft - offsetParentRect.left) / scale;\n  var y = (evt.clientY + offsetParent.scrollTop - offsetParentRect.top) / scale;\n  return {\n    x: x,\n    y: y\n  };\n}\n\nfunction createCSSTransform(controlPos\n/*: ControlPosition*/\n, positionOffset\n/*: PositionOffsetControlPosition*/\n)\n/*: Object*/\n{\n  var translation = getTranslation(controlPos, positionOffset, 'px');\n  return _defineProperty({}, (0, _getPrefix.browserPrefixToKey)('transform', _getPrefix.default), translation);\n}\n\nfunction createSVGTransform(controlPos\n/*: ControlPosition*/\n, positionOffset\n/*: PositionOffsetControlPosition*/\n)\n/*: string*/\n{\n  var translation = getTranslation(controlPos, positionOffset, '');\n  return translation;\n}\n\nfunction getTranslation(_ref2, positionOffset\n/*: PositionOffsetControlPosition*/\n, unitSuffix\n/*: string*/\n)\n/*: string*/\n{\n  var x = _ref2.x,\n      y = _ref2.y;\n  var translation = \"translate(\".concat(x).concat(unitSuffix, \",\").concat(y).concat(unitSuffix, \")\");\n\n  if (positionOffset) {\n    var defaultX = \"\".concat(typeof positionOffset.x === 'string' ? positionOffset.x : positionOffset.x + unitSuffix);\n    var defaultY = \"\".concat(typeof positionOffset.y === 'string' ? positionOffset.y : positionOffset.y + unitSuffix);\n    translation = \"translate(\".concat(defaultX, \", \").concat(defaultY, \")\") + translation;\n  }\n\n  return translation;\n}\n\nfunction getTouch(e\n/*: MouseTouchEvent*/\n, identifier\n/*: number*/\n)\n/*: ?{clientX: number, clientY: number}*/\n{\n  return e.targetTouches && (0, _shims.findInArray)(e.targetTouches, function (t) {\n    return identifier === t.identifier;\n  }) || e.changedTouches && (0, _shims.findInArray)(e.changedTouches, function (t) {\n    return identifier === t.identifier;\n  });\n}\n\nfunction getTouchIdentifier(e\n/*: MouseTouchEvent*/\n)\n/*: ?number*/\n{\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} // User-select Hacks:\n//\n// Useful for preventing blue highlights all over everything when dragging.\n// Note we're passing `document` b/c we could be iframed\n\n\nfunction addUserSelectStyles(doc\n/*: ?Document*/\n) {\n  if (!doc) return;\n  var styleEl = doc.getElementById('react-draggable-style-el');\n\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\n  if (doc.body) addClassName(doc.body, 'react-draggable-transparent-selection');\n}\n\nfunction removeUserSelectStyles(doc\n/*: ?Document*/\n) {\n  if (!doc) return;\n\n  try {\n    if (doc.body) removeClassName(doc.body, 'react-draggable-transparent-selection'); // $FlowIgnore: IE\n\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      var selection = (doc.defaultView || window).getSelection();\n\n      if (selection && selection.type !== 'Caret') {\n        selection.removeAllRanges();\n      }\n    }\n  } catch (e) {// probably IE\n  }\n}\n\nfunction addClassName(el\n/*: HTMLElement*/\n, className\n/*: string*/\n) {\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}\n\nfunction removeClassName(el\n/*: HTMLElement*/\n, className\n/*: string*/\n) {\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.getBoundPosition = getBoundPosition;\nexports.snapToGrid = snapToGrid;\nexports.canDragX = canDragX;\nexports.canDragY = canDragY;\nexports.getControlPosition = getControlPosition;\nexports.createCoreData = createCoreData;\nexports.createDraggableData = createDraggableData;\n\nvar _shims = require(\"./shims\");\n\nvar _domFns = require(\"./domFns\");\n\nfunction getBoundPosition(draggable\n/*: Draggable*/\n, x\n/*: number*/\n, y\n/*: number*/\n)\n/*: [number, number]*/\n{\n  // If no bounds, short-circuit and move on\n  if (!draggable.props.bounds) return [x, y]; // Clone new bounds\n\n  var bounds = draggable.props.bounds;\n  bounds = typeof bounds === 'string' ? bounds : cloneBounds(bounds);\n  var node = findDOMNode(draggable);\n\n  if (typeof bounds === 'string') {\n    var ownerDocument = node.ownerDocument;\n    var ownerWindow = ownerDocument.defaultView;\n    var boundNode;\n\n    if (bounds === 'parent') {\n      boundNode = node.parentNode;\n    } else {\n      boundNode = ownerDocument.querySelector(bounds);\n    }\n\n    if (!(boundNode instanceof ownerWindow.HTMLElement)) {\n      throw new Error('Bounds selector \"' + bounds + '\" could not find an element.');\n    }\n\n    var boundNodeEl\n    /*: HTMLElement*/\n    = boundNode; // for Flow, can't seem to refine correctly\n\n    var nodeStyle = ownerWindow.getComputedStyle(node);\n    var boundNodeStyle = ownerWindow.getComputedStyle(boundNodeEl); // Compute bounds. This is a pain with padding and offsets but this gets it exactly right.\n\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  } // Keep x and y below right and bottom limits...\n\n\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); // But above left and top limits.\n\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}\n\nfunction snapToGrid(grid\n/*: [number, number]*/\n, pendingX\n/*: number*/\n, pendingY\n/*: number*/\n)\n/*: [number, number]*/\n{\n  var x = Math.round(pendingX / grid[0]) * grid[0];\n  var y = Math.round(pendingY / grid[1]) * grid[1];\n  return [x, y];\n}\n\nfunction canDragX(draggable\n/*: Draggable*/\n)\n/*: boolean*/\n{\n  return draggable.props.axis === 'both' || draggable.props.axis === 'x';\n}\n\nfunction canDragY(draggable\n/*: Draggable*/\n)\n/*: boolean*/\n{\n  return draggable.props.axis === 'both' || draggable.props.axis === 'y';\n} // Get {x, y} positions from event.\n\n\nfunction getControlPosition(e\n/*: MouseTouchEvent*/\n, touchIdentifier\n/*: ?number*/\n, draggableCore\n/*: DraggableCore*/\n)\n/*: ?ControlPosition*/\n{\n  var touchObj = typeof touchIdentifier === 'number' ? (0, _domFns.getTouch)(e, touchIdentifier) : null;\n  if (typeof touchIdentifier === 'number' && !touchObj) return null; // not the right touch\n\n  var node = findDOMNode(draggableCore); // User can provide an offsetParent if desired.\n\n  var offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;\n  return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent, draggableCore.props.scale);\n} // Create an data object exposed by <DraggableCore>'s events\n\n\nfunction createCoreData(draggable\n/*: DraggableCore*/\n, x\n/*: number*/\n, y\n/*: number*/\n)\n/*: DraggableData*/\n{\n  var state = draggable.state;\n  var isStart = !(0, _shims.isNum)(state.lastX);\n  var node = findDOMNode(draggable);\n\n  if (isStart) {\n    // If this is our first move, use the x and y as last coords.\n    return {\n      node: node,\n      deltaX: 0,\n      deltaY: 0,\n      lastX: x,\n      lastY: y,\n      x: x,\n      y: y\n    };\n  } else {\n    // Otherwise calculate proper values.\n    return {\n      node: node,\n      deltaX: x - state.lastX,\n      deltaY: y - state.lastY,\n      lastX: state.lastX,\n      lastY: state.lastY,\n      x: x,\n      y: y\n    };\n  }\n} // Create an data exposed by <Draggable>'s events\n\n\nfunction createDraggableData(draggable\n/*: Draggable*/\n, coreData\n/*: DraggableData*/\n)\n/*: DraggableData*/\n{\n  var 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} // A lot faster than stringify/parse\n\n\nfunction cloneBounds(bounds\n/*: Bounds*/\n)\n/*: Bounds*/\n{\n  return {\n    left: bounds.left,\n    top: bounds.top,\n    right: bounds.right,\n    bottom: bounds.bottom\n  };\n}\n\nfunction findDOMNode(draggable\n/*: Draggable | DraggableCore*/\n)\n/*: HTMLElement*/\n{\n  var node = draggable.findDOMNode();\n\n  if (!node) {\n    throw new Error('<DraggableCore>: Unmounted during event!');\n  } // $FlowIgnore we can't assert on HTMLElement due to tests... FIXME\n\n\n  return node;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = log;\n\n/*eslint no-console:0*/\nfunction log() {\n  var _console;\n\n  if (undefined) (_console = console).log.apply(_console, arguments);\n}","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nObject.defineProperty(exports, \"DraggableCore\", {\n  enumerable: true,\n  get: function get() {\n    return _DraggableCore.default;\n  }\n});\nexports.default = void 0;\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _reactDom = _interopRequireDefault(require(\"react-dom\"));\n\nvar _clsx2 = _interopRequireDefault(require(\"clsx\"));\n\nvar _domFns = require(\"./utils/domFns\");\n\nvar _positionFns = require(\"./utils/positionFns\");\n\nvar _shims = require(\"./utils/shims\");\n\nvar _DraggableCore = _interopRequireDefault(require(\"./DraggableCore\"));\n\nvar _log = _interopRequireDefault(require(\"./utils/log\"));\n\nvar _excluded = [\"axis\", \"bounds\", \"children\", \"defaultPosition\", \"defaultClassName\", \"defaultClassNameDragging\", \"defaultClassNameDragged\", \"position\", \"positionOffset\", \"scale\"];\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\n\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\nfunction _extends() { _extends = Object.assign || 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); }\n\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\n\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n//\n// Define <Draggable>\n//\nvar Draggable = /*#__PURE__*/function (_React$Component) {\n  _inherits(Draggable, _React$Component);\n\n  var _super = _createSuper(Draggable);\n\n  function Draggable(props\n  /*: DraggableProps*/\n  ) {\n    var _this;\n\n    _classCallCheck(this, Draggable);\n\n    _this = _super.call(this, props);\n\n    _defineProperty(_assertThisInitialized(_this), \"onDragStart\", function (e, coreData) {\n      (0, _log.default)('Draggable: onDragStart: %j', coreData); // Short-circuit if user's callback killed it.\n\n      var shouldStart = _this.props.onStart(e, (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData)); // Kills start event on core as well, so move handlers are never bound.\n\n\n      if (shouldStart === false) return false;\n\n      _this.setState({\n        dragging: true,\n        dragged: true\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onDrag\", function (e, coreData) {\n      if (!_this.state.dragging) return false;\n      (0, _log.default)('Draggable: onDrag: %j', coreData);\n      var uiData = (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData);\n      var newState\n      /*: $Shape<DraggableState>*/\n      = {\n        x: uiData.x,\n        y: uiData.y\n      }; // Keep within bounds.\n\n      if (_this.props.bounds) {\n        // Save original x and y.\n        var x = newState.x,\n            y = newState.y; // 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\n        newState.x += _this.state.slackX;\n        newState.y += _this.state.slackY; // Get bound position. This will ceil/floor the x and y within the boundaries.\n\n        var _getBoundPosition = (0, _positionFns.getBoundPosition)(_assertThisInitialized(_this), newState.x, newState.y),\n            _getBoundPosition2 = _slicedToArray(_getBoundPosition, 2),\n            newStateX = _getBoundPosition2[0],\n            newStateY = _getBoundPosition2[1];\n\n        newState.x = newStateX;\n        newState.y = newStateY; // Recalculate slack by noting how much was shaved by the boundPosition handler.\n\n        newState.slackX = _this.state.slackX + (x - newState.x);\n        newState.slackY = _this.state.slackY + (y - newState.y); // Update the event we fire to reflect what really happened after bounds took effect.\n\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      } // Short-circuit if user's callback killed it.\n\n\n      var shouldUpdate = _this.props.onDrag(e, uiData);\n\n      if (shouldUpdate === false) return false;\n\n      _this.setState(newState);\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onDragStop\", function (e, coreData) {\n      if (!_this.state.dragging) return false; // Short-circuit if user's callback killed it.\n\n      var shouldContinue = _this.props.onStop(e, (0, _positionFns.createDraggableData)(_assertThisInitialized(_this), coreData));\n\n      if (shouldContinue === false) return false;\n      (0, _log.default)('Draggable: onDragStop: %j', coreData);\n      var newState\n      /*: $Shape<DraggableState>*/\n      = {\n        dragging: false,\n        slackX: 0,\n        slackY: 0\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\n      var controlled = Boolean(_this.props.position);\n\n      if (controlled) {\n        var _this$props$position = _this.props.position,\n            x = _this$props$position.x,\n            y = _this$props$position.y;\n        newState.x = x;\n        newState.y = y;\n      }\n\n      _this.setState(newState);\n    });\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: _objectSpread({}, props.position),\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\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    return _this;\n  }\n\n  _createClass(Draggable, [{\n    key: \"componentDidMount\",\n    value: function 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  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      this.setState({\n        dragging: false\n      }); // prevents invariant if unmounted while dragging\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\n  }, {\n    key: \"findDOMNode\",\n    value: function findDOMNode()\n    /*: ?HTMLElement*/\n    {\n      var _this$props$nodeRef$c, _this$props, _this$props$nodeRef;\n\n      return (_this$props$nodeRef$c = (_this$props = this.props) === null || _this$props === void 0 ? void 0 : (_this$props$nodeRef = _this$props.nodeRef) === null || _this$props$nodeRef === void 0 ? void 0 : _this$props$nodeRef.current) !== null && _this$props$nodeRef$c !== void 0 ? _this$props$nodeRef$c : _reactDom.default.findDOMNode(this);\n    }\n  }, {\n    key: \"render\",\n    value: function render()\n    /*: ReactElement<any>*/\n    {\n      var _clsx;\n\n      var _this$props2 = this.props,\n          axis = _this$props2.axis,\n          bounds = _this$props2.bounds,\n          children = _this$props2.children,\n          defaultPosition = _this$props2.defaultPosition,\n          defaultClassName = _this$props2.defaultClassName,\n          defaultClassNameDragging = _this$props2.defaultClassNameDragging,\n          defaultClassNameDragged = _this$props2.defaultClassNameDragged,\n          position = _this$props2.position,\n          positionOffset = _this$props2.positionOffset,\n          scale = _this$props2.scale,\n          draggableCoreProps = _objectWithoutProperties(_this$props2, _excluded);\n\n      var style = {};\n      var svgTransform = null; // If this is controlled, we don't want to move it - unless it's dragging.\n\n      var controlled = Boolean(position);\n      var draggable = !controlled || this.state.dragging;\n      var validPosition = position || defaultPosition;\n      var 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      }; // If this element was SVG, we use the `transform` attribute.\n\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      } // Mark with class while dragging\n\n\n      var className = (0, _clsx2.default)(children.props.className || '', defaultClassName, (_clsx = {}, _defineProperty(_clsx, defaultClassNameDragging, this.state.dragging), _defineProperty(_clsx, defaultClassNameDragged, this.state.dragged), _clsx)); // Reuse the child provided\n      // This makes it flexible to use whatever element is wanted (div, ul, etc)\n\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: _objectSpread(_objectSpread({}, children.props.style), style),\n        transform: svgTransform\n      }));\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: // React 16.3+\n    // Arity (props, state)\n    function getDerivedStateFromProps(_ref, _ref2)\n    /*: ?$Shape<DraggableState>*/\n    {\n      var position = _ref.position;\n      var prevPropsPosition = _ref2.prevPropsPosition;\n\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: position,\n          prevPropsPosition: prevPropsPosition\n        });\n        return {\n          x: position.x,\n          y: position.y,\n          prevPropsPosition: _objectSpread({}, position)\n        };\n      }\n\n      return null;\n    }\n  }]);\n\n  return Draggable;\n}(React.Component);\n\nexports.default = Draggable;\n\n_defineProperty(Draggable, \"displayName\", 'Draggable');\n\n_defineProperty(Draggable, \"propTypes\", _objectSpread(_objectSpread({}, _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  /**\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  /**\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  /**\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  /**\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\n_defineProperty(Draggable, \"defaultProps\", _objectSpread(_objectSpread({}, _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}));","function toVal(mix) {\n\tvar k, y, str='';\n\n\tif (typeof mix === 'string' || typeof mix === 'number') {\n\t\tstr += mix;\n\t} else if (typeof mix === 'object') {\n\t\tif (Array.isArray(mix)) {\n\t\t\tfor (k=0; k < mix.length; k++) {\n\t\t\t\tif (mix[k]) {\n\t\t\t\t\tif (y = toVal(mix[k])) {\n\t\t\t\t\t\tstr && (str += ' ');\n\t\t\t\t\t\tstr += y;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor (k in mix) {\n\t\t\t\tif (mix[k]) {\n\t\t\t\t\tstr && (str += ' ');\n\t\t\t\t\tstr += k;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn str;\n}\n\nexport default function () {\n\tvar i=0, tmp, x, str='';\n\twhile (i < arguments.length) {\n\t\tif (tmp = arguments[i++]) {\n\t\t\tif (x = toVal(tmp)) {\n\t\t\t\tstr && (str += ' ');\n\t\t\t\tstr += x\n\t\t\t}\n\t\t}\n\t}\n\treturn str;\n}\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getPrefix = getPrefix;\nexports.browserPrefixToKey = browserPrefixToKey;\nexports.browserPrefixToStyle = browserPrefixToStyle;\nexports.default = void 0;\nvar prefixes = ['Moz', 'Webkit', 'O', 'ms'];\n\nfunction getPrefix()\n/*: string*/\n{\n  var _window$document, _window$document$docu;\n\n  var prop\n  /*: string*/\n  = 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 ''; // 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\n  var style = (_window$document = window.document) === null || _window$document === void 0 ? void 0 : (_window$document$docu = _window$document.documentElement) === null || _window$document$docu === void 0 ? void 0 : _window$document$docu.style;\n  if (!style) return '';\n  if (prop in style) return '';\n\n  for (var i = 0; i < prefixes.length; i++) {\n    if (browserPrefixToKey(prop, prefixes[i]) in style) return prefixes[i];\n  }\n\n  return '';\n}\n\nfunction browserPrefixToKey(prop\n/*: string*/\n, prefix\n/*: string*/\n)\n/*: string*/\n{\n  return prefix ? \"\".concat(prefix).concat(kebabToTitleCase(prop)) : prop;\n}\n\nfunction browserPrefixToStyle(prop\n/*: string*/\n, prefix\n/*: string*/\n)\n/*: string*/\n{\n  return prefix ? \"-\".concat(prefix.toLowerCase(), \"-\").concat(prop) : prop;\n}\n\nfunction kebabToTitleCase(str\n/*: string*/\n)\n/*: string*/\n{\n  var out = '';\n  var shouldCapitalize = true;\n\n  for (var 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\n  return out;\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`\n\n\nvar _default = (getPrefix()\n/*: string*/\n);\n\nexports.default = _default;","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _reactDom = _interopRequireDefault(require(\"react-dom\"));\n\nvar _domFns = require(\"./utils/domFns\");\n\nvar _positionFns = require(\"./utils/positionFns\");\n\nvar _shims = require(\"./utils/shims\");\n\nvar _log = _interopRequireDefault(require(\"./utils/log\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\n\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\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n// Simple abstraction for dragging events names.\nvar 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}; // Default to mouse events.\n\nvar dragEventFor = eventsFor.mouse;\n/*:: type DraggableCoreState = {\n  dragging: boolean,\n  lastX: number,\n  lastY: number,\n  touchIdentifier: ?number\n};*/\n\n/*:: export type DraggableData = {\n  node: HTMLElement,\n  x: number, y: number,\n  deltaX: number, deltaY: number,\n  lastX: number, lastY: number,\n};*/\n\n/*:: export type DraggableEventHandler = (e: MouseEvent, data: DraggableData) => void | false;*/\n\n/*:: export type ControlPosition = {x: number, y: number};*/\n\n/*:: export type PositionOffsetControlPosition = {x: number|string, y: number|string};*/\n\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\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//\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//\nvar DraggableCore = /*#__PURE__*/function (_React$Component) {\n  _inherits(DraggableCore, _React$Component);\n\n  var _super = _createSuper(DraggableCore);\n\n  function DraggableCore() {\n    var _this;\n\n    _classCallCheck(this, DraggableCore);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _super.call.apply(_super, [this].concat(args));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      dragging: false,\n      // Used while dragging to determine deltas.\n      lastX: NaN,\n      lastY: NaN,\n      touchIdentifier: null\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"mounted\", false);\n\n    _defineProperty(_assertThisInitialized(_this), \"handleDragStart\", function (e) {\n      // Make it possible to attach event handlers on top of this one.\n      _this.props.onMouseDown(e); // Only accept left-clicks.\n\n\n      if (!_this.props.allowAnyClick && typeof e.button === 'number' && e.button !== 0) return false; // Get nodes. Be sure to grab relative document (could be iframed)\n\n      var thisNode = _this.findDOMNode();\n\n      if (!thisNode || !thisNode.ownerDocument || !thisNode.ownerDocument.body) {\n        throw new Error('<DraggableCore> not mounted on DragStart!');\n      }\n\n      var ownerDocument = thisNode.ownerDocument; // Short circuit if handle or cancel prop was provided and selector doesn't match.\n\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      } // Prevent scrolling on mobile devices, like ipad/iphone.\n      // Important that this is after handle/cancel.\n\n\n      if (e.type === 'touchstart') e.preventDefault(); // 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\n      var touchIdentifier = (0, _domFns.getTouchIdentifier)(e);\n\n      _this.setState({\n        touchIdentifier: touchIdentifier\n      }); // Get the current drag point from the event. This is used as the offset.\n\n\n      var position = (0, _positionFns.getControlPosition)(e, touchIdentifier, _assertThisInitialized(_this));\n      if (position == null) return; // not possible but satisfies flow\n\n      var x = position.x,\n          y = position.y; // Create an event object with all the data parents need to make a decision here.\n\n      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y);\n      (0, _log.default)('DraggableCore: handleDragStart: %j', coreEvent); // Call event handler. If it returns explicit false, cancel.\n\n      (0, _log.default)('calling', _this.props.onStart);\n\n      var shouldUpdate = _this.props.onStart(e, coreEvent);\n\n      if (shouldUpdate === false || _this.mounted === false) return; // Add a style to the body to disable user-select. This prevents text from\n      // being selected all over the page.\n\n      if (_this.props.enableUserSelectHack) (0, _domFns.addUserSelectStyles)(ownerDocument); // 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\n      _this.setState({\n        dragging: true,\n        lastX: x,\n        lastY: y\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\n\n      (0, _domFns.addEvent)(ownerDocument, dragEventFor.move, _this.handleDrag);\n      (0, _domFns.addEvent)(ownerDocument, dragEventFor.stop, _this.handleDragStop);\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"handleDrag\", function (e) {\n      // Get the current drag point from the event. This is used as the offset.\n      var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _assertThisInitialized(_this));\n      if (position == null) return;\n      var x = position.x,\n          y = position.y; // Snap to grid if prop has been provided\n\n      if (Array.isArray(_this.props.grid)) {\n        var deltaX = x - _this.state.lastX,\n            deltaY = y - _this.state.lastY;\n\n        var _snapToGrid = (0, _positionFns.snapToGrid)(_this.props.grid, deltaX, deltaY);\n\n        var _snapToGrid2 = _slicedToArray(_snapToGrid, 2);\n\n        deltaX = _snapToGrid2[0];\n        deltaY = _snapToGrid2[1];\n        if (!deltaX && !deltaY) return; // skip useless drag\n\n        x = _this.state.lastX + deltaX, y = _this.state.lastY + deltaY;\n      }\n\n      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y);\n      (0, _log.default)('DraggableCore: handleDrag: %j', coreEvent); // Call event handler. If it returns explicit false, trigger end.\n\n      var shouldUpdate = _this.props.onDrag(e, coreEvent);\n\n      if (shouldUpdate === false || _this.mounted === false) {\n        try {\n          // $FlowIgnore\n          _this.handleDragStop(new MouseEvent('mouseup'));\n        } catch (err) {\n          // Old browsers\n          var event = ((document.createEvent('MouseEvents')\n          /*: any*/\n          )\n          /*: MouseTouchEvent*/\n          ); // I see why this insanity was deprecated\n          // $FlowIgnore\n\n          event.initMouseEvent('mouseup', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);\n\n          _this.handleDragStop(event);\n        }\n\n        return;\n      }\n\n      _this.setState({\n        lastX: x,\n        lastY: y\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"handleDragStop\", function (e) {\n      if (!_this.state.dragging) return;\n      var position = (0, _positionFns.getControlPosition)(e, _this.state.touchIdentifier, _assertThisInitialized(_this));\n      if (position == null) return;\n      var x = position.x,\n          y = position.y;\n      var coreEvent = (0, _positionFns.createCoreData)(_assertThisInitialized(_this), x, y); // Call event handler\n\n      var shouldContinue = _this.props.onStop(e, coreEvent);\n\n      if (shouldContinue === false || _this.mounted === false) return false;\n\n      var thisNode = _this.findDOMNode();\n\n      if (thisNode) {\n        // Remove user-select hack\n        if (_this.props.enableUserSelectHack) (0, _domFns.removeUserSelectStyles)(thisNode.ownerDocument);\n      }\n\n      (0, _log.default)('DraggableCore: handleDragStop: %j', coreEvent); // Reset the el.\n\n      _this.setState({\n        dragging: false,\n        lastX: NaN,\n        lastY: NaN\n      });\n\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\n    _defineProperty(_assertThisInitialized(_this), \"onMouseDown\", function (e) {\n      dragEventFor = eventsFor.mouse; // on touchscreen laptops we could switch back to mouse\n\n      return _this.handleDragStart(e);\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onMouseUp\", function (e) {\n      dragEventFor = eventsFor.mouse;\n      return _this.handleDragStop(e);\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"onTouchStart\", function (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\n    _defineProperty(_assertThisInitialized(_this), \"onTouchEnd\", function (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    return _this;\n  }\n\n  _createClass(DraggableCore, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this.mounted = true; // Touch handlers must be added with {passive: false} to be cancelable.\n      // https://developers.google.com/web/updates/2017/01/scrolling-intervention\n\n      var thisNode = this.findDOMNode();\n\n      if (thisNode) {\n        (0, _domFns.addEvent)(thisNode, eventsFor.touch.start, this.onTouchStart, {\n          passive: false\n        });\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      this.mounted = false; // 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\n      var thisNode = this.findDOMNode();\n\n      if (thisNode) {\n        var ownerDocument = thisNode.ownerDocument;\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    } // 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\n  }, {\n    key: \"findDOMNode\",\n    value: function findDOMNode()\n    /*: ?HTMLElement*/\n    {\n      var _this$props$nodeRef$c, _this$props, _this$props$nodeRef;\n\n      return (_this$props$nodeRef$c = (_this$props = this.props) === null || _this$props === void 0 ? void 0 : (_this$props$nodeRef = _this$props.nodeRef) === null || _this$props$nodeRef === void 0 ? void 0 : _this$props$nodeRef.current) !== null && _this$props$nodeRef$c !== void 0 ? _this$props$nodeRef$c : _reactDom.default.findDOMNode(this);\n    }\n  }, {\n    key: \"render\",\n    value: function render()\n    /*: React.Element<any>*/\n    {\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  }]);\n\n  return DraggableCore;\n}(React.Component);\n\nexports.default = DraggableCore;\n\n_defineProperty(DraggableCore, \"displayName\", 'DraggableCore');\n\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\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  /**\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  /**\n   * `offsetParent`, if set, uses the passed DOM node to compute drag offsets\n   * instead of using the parent node.\n   */\n  offsetParent: function offsetParent(props\n  /*: DraggableCoreProps*/\n  , propName\n  /*: $Keys<DraggableCoreProps>*/\n  ) {\n    if (props[propName] && props[propName].nodeType !== 1) {\n      throw new Error('Draggable\\'s offsetParent must be a DOM Node.');\n    }\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  /**\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  /**\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\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  /**\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  /**\n   * Called while dragging.\n   * If this function returns the boolean false, dragging will be canceled.\n   */\n  onDrag: _propTypes.default.func,\n\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  /**\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  /**\n   * `scale`, if set, applies scaling while dragging an element\n   */\n  scale: _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\n_defineProperty(DraggableCore, \"defaultProps\", {\n  allowAnyClick: false,\n  // by default only accept left click\n  disabled: false,\n  enableUserSelectHack: true,\n  onStart: function onStart() {},\n  onDrag: function onDrag() {},\n  onStop: function onStop() {},\n  onMouseDown: function onMouseDown() {},\n  scale: 1\n});","\"use strict\";\n\nvar _require = require('./Draggable'),\n    Draggable = _require.default,\n    DraggableCore = _require.DraggableCore; // 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\n\n\nmodule.exports = Draggable;\nmodule.exports.default = Draggable;\nmodule.exports.DraggableCore = DraggableCore;"],"sourceRoot":""}