{"version":3,"file":"vendor.split.js.e44825be5bd9c0a4.bundle.js","mappings":"0HAIA,IAAIA,EAA2B,oBAAXC,OAAyBA,OAAS,KAClDC,EAAiB,OAAXF,EACNG,EAAYD,OAAwBE,EAAlBJ,EAAOG,SAIzBE,EAAmB,mBACnBC,EAAsB,sBACtBC,EAAwB,wBACxBC,EAAsB,KACtBC,EAAc,KACdC,EAAc,KACdC,EAAa,aACbC,EAAO,WAAc,OAAO,CAAO,EAOnCC,EAAOX,EACL,OACE,CAAC,GAAI,WAAY,QAAS,OACvBY,QAAO,SAAUC,GACd,IAAIC,EAAKb,EAASc,cAAc,OAGhC,OAFAD,EAAGE,MAAMC,QAAU,SAAWJ,EAAS,cAE9BC,EAAGE,MAAME,MACtB,IACCC,QAAW,OAGlBC,EAAW,SAAUC,GAAK,MAAoB,iBAANA,GAAkBA,aAAaC,MAAQ,EAK/EC,EAAoB,SAAUT,GAC9B,GAAIM,EAASN,GAAK,CACd,IAAIU,EAAMvB,EAASwB,cAAcX,GACjC,IAAKU,EACD,MAAM,IAAIE,MAAO,YAAcZ,EAAK,gCAExC,OAAOU,CACX,CAEA,OAAOV,CACX,EAGIa,EAAY,SAAUC,EAASC,EAAUC,GACzC,IAAIC,EAAQH,EAAQC,GACpB,YAAc3B,IAAV6B,EACOA,EAEJD,CACX,EAEIE,EAAgB,SAAUC,EAAYC,EAASC,EAAQC,GACvD,GAAIF,EAAS,CACT,GAAoB,QAAhBE,EACA,OAAO,EAEX,GAAoB,WAAhBA,EACA,OAAOH,EAAa,CAE5B,MAAO,GAAIE,EAAQ,CACf,GAAoB,UAAhBC,EACA,OAAO,EAEX,GAAoB,WAAhBA,EACA,OAAOH,EAAa,CAE5B,CAEA,OAAOA,CACX,EAGII,EAAkB,SAAUC,EAAGC,GAC/B,IAAIC,EAAMvC,EAASc,cAAc,OAEjC,OADAyB,EAAIC,UAAY,iBAAmBF,EAC5BC,CACX,EAEIE,EAAwB,SAAUC,EAAKC,EAAMC,GAC7C,IAAI7B,EAAQ,CAAC,EAQb,OANKI,EAASwB,GAGV5B,EAAM2B,GAAOC,EAFb5B,EAAM2B,GAAOhC,EAAO,IAAMiC,EAAO,OAASC,EAAU,MAKjD7B,CACX,EAEI8B,EAAuB,SAAUH,EAAKE,GACtC,IAAIE,EAEJ,OAAUA,EAAM,CAAC,GAAOJ,GAAQE,EAAU,KAAOE,CACrD,EA2pBA,QA9nBY,SAAUC,EAAWpB,GAG7B,QAFiB,IAAZA,IAAqBA,EAAU,CAAC,GAEjC5B,EAAO,MAAO,CAAC,EAEnB,IACIiD,EACAC,EACAC,EACAC,EACAC,EACAC,EANAC,EAAMP,EASNQ,MAAMC,OACNF,EAAMC,MAAMC,KAAKF,IAMrB,IACIG,EADenC,EAAkBgC,EAAI,IACfI,WACtBC,EAAcC,iBAAmBA,iBAAiBH,GAAU,KAC5DI,EAAsBF,EAAcA,EAAYG,cAAgB,KAGhEC,EAAQrC,EAAUC,EAAS,UAAY2B,EAAIU,KAAI,WAAc,OAAO,IAAMV,EAAIrC,MAAQ,IAItFgD,EAAUvC,EAAUC,EAAS,UAAW,KACxCuC,EAAWX,MAAMY,QAAQF,GAAWA,EAAUX,EAAIU,KAAI,WAAc,OAAOC,CAAS,IACpFG,EAAU1C,EAAUC,EAAS,UAAW0C,KACxCC,EAAWf,MAAMY,QAAQC,GAAWA,EAAUd,EAAIU,KAAI,WAAc,OAAOI,CAAS,IAGpFG,EAAc7C,EAAUC,EAAS,eAAe,GAChDK,EAAaN,EAAUC,EAAS,aAAc,IAC9CQ,EAAcT,EAAUC,EAAS,cAAe,UAChD6C,EAAa9C,EAAUC,EAAS,aAAc,IAC9C8C,EAAclB,MAAMY,QAAQK,GAAcA,EAAalB,EAAIU,KAAI,WAAc,OAAOQ,CAAY,IAChGE,EAAehD,EAAUC,EAAS,eAAgB,GAClDgD,EAAYjD,EAAUC,EAAS,YAAanB,GAC5CoE,EAASlD,EACTC,EACA,SACAgD,IAAcnE,EAAa,aAAe,cAE1CqE,EAASnD,EAAUC,EAAS,SAAUS,GACtC0C,EAAepD,EACfC,EACA,eACAc,GAEAsC,EAAcrD,EAAUC,EAAS,cAAekB,GA8BpD,SAASmC,EAAenE,EAAI8B,EAAMC,EAASP,GAKvC,IAAItB,EAAQ+D,EAAa9B,EAAWL,EAAMC,EAASP,GAEnD4C,OAAOC,KAAKnE,GAAOoE,SAAQ,SAAUC,GAEjCvE,EAAGE,MAAMqE,GAAQrE,EAAMqE,EAC3B,GACJ,CAWA,SAASC,IACL,OAAOhC,EAASW,KAAI,SAAUsB,GAAW,OAAOA,EAAQ3C,IAAM,GAClE,CAIA,SAAS4C,EAAiBC,GACtB,MAAI,YAAaA,EAAYA,EAAEC,QAAQ,GAAGxC,GACnCuC,EAAEvC,EACb,CAQA,SAASyC,EAAOC,GACZ,IAAIC,EAAIvC,EAASwC,KAAKD,GAClBE,EAAIzC,EAASwC,KAAKC,GAClBC,EAAaH,EAAEjD,KAAOmD,EAAEnD,KAE5BiD,EAAEjD,KAAQgD,EAASE,KAAKlD,KAAQoD,EAChCD,EAAEnD,KAAOoD,EAAcJ,EAASE,KAAKlD,KAAQoD,EAE7Cf,EAAeY,EAAEN,QAASM,EAAEjD,KAAMkD,KAAKvF,GAAcsF,EAAEvD,GACvD2C,EAAec,EAAER,QAASQ,EAAEnD,KAAMkD,KAAKtF,GAAcuF,EAAEzD,EAC3D,CAgBA,SAAS2D,EAAKR,GACV,IAAIG,EACAC,EAAIvC,EAASwC,KAAKD,GAClBE,EAAIzC,EAASwC,KAAKC,GAEjBD,KAAKI,WAKVN,EACIJ,EAAiBC,GACjBK,KAAKK,OACJL,KAAKvF,GAAeuF,KAAKM,YAE1BzB,EAAe,IACfiB,EAASS,KAAKC,MAAMV,EAASjB,GAAgBA,GAM7CiB,GAAUC,EAAE3B,QAAU2B,EAAEpB,WAAaqB,KAAKvF,GAC1CqF,EAASC,EAAE3B,QAAU4B,KAAKvF,GAE1BqF,GACAE,KAAKlD,MAAQmD,EAAE7B,QAAU6B,EAAEtB,WAAaqB,KAAKtF,MAE7CoF,EAASE,KAAKlD,MAAQmD,EAAE7B,QAAU4B,KAAKtF,KAGvCoF,GAAUC,EAAExB,QAAUwB,EAAEpB,WAAaqB,KAAKvF,GAC1CqF,EAASC,EAAExB,QAAUyB,KAAKvF,GAE1BqF,GACAE,KAAKlD,MAAQmD,EAAE1B,QAAU0B,EAAEtB,WAAaqB,KAAKtF,MAE7CoF,EAASE,KAAKlD,MAAQmD,EAAE1B,QAAUyB,KAAKtF,KAI3CmF,EAAOY,KAAKT,KAAMF,GAIlBjE,EAAUC,EAAS,SAAUlB,EAA7BiB,CAAmC2D,KACvC,CAeA,SAASkB,IAEL,IAAIX,EAAIvC,EAASwC,KAAKD,GAAGN,QACrBQ,EAAIzC,EAASwC,KAAKC,GAAGR,QAErBkB,EAAUZ,EAAExF,KACZqG,EAAUX,EAAE1F,KAEhByF,KAAKlD,KACD6D,EAAQxD,GACRyD,EAAQzD,GACR6C,KAAKvF,GACLuF,KAAKtF,GACTsF,KAAKK,MAAQM,EAAQtD,GACrB2C,KAAKa,IAAMF,EAAQrD,EACvB,CAgCA,SAASwD,EAAUC,GAGf,IAAIC,EAjCR,SAAmBvB,GAGf,IAAK1B,iBAAoB,OAAO,KAEhC,IAAIkD,EAAgBlD,iBAAiB0B,GAErC,IAAKwB,EAAiB,OAAO,KAE7B,IAAInE,EAAO2C,EAAQlC,GAEnB,OAAa,IAATT,EAAqB,KAGrBA,GADAgC,IAAcnE,EAEVuG,WAAWD,EAAcE,aACzBD,WAAWD,EAAcG,cAGzBF,WAAWD,EAAcI,YACzBH,WAAWD,EAAcK,cAIrC,CASqBC,CAAU3D,GAC3B,GAAmB,OAAfoD,EACA,OAAOD,EAGX,GAAI1C,EAASmD,QAAO,SAAUzB,EAAGE,GAAK,OAAOF,EAAIE,CAAG,GAAG,GAAKe,EACxD,OAAOD,EAKX,IAAIU,EAAe,EACfC,EAAU,GAEVC,EAAaZ,EAAY5C,KAAI,SAAUrB,EAAMN,GAE7C,IAAIoF,EAAaZ,EAAalE,EAAQ,IAClC+E,EAAoB3F,EACpBC,EACM,IAANK,EACAA,IAAMuE,EAAY3F,OAAS,EAC3BkB,GAEAwF,EAAiBzD,EAAS7B,GAAKqF,EAInC,OAAID,EAAYE,GACZL,GAAgBK,EAAiBF,EACjCF,EAAQK,KAAK,GACND,IAIXJ,EAAQK,KAAKH,EAAYE,GAClBF,EACX,IAGA,OAAqB,IAAjBH,EACOV,EAGJY,EAAWxD,KAAI,SAAUyD,EAAWpF,GACvC,IAAIwF,EAAeJ,EAInB,GAAIH,EAAe,GAAKC,EAAQlF,GAAKiF,EAAe,EAAG,CACnD,IAAIQ,EAAc1B,KAAK2B,IACnBT,EACAC,EAAQlF,GAAKiF,GAIjBA,GAAgBQ,EAChBD,EAAeJ,EAAYK,CAC/B,CAGA,OAAQD,EAAehB,EAAc,GACzC,GACJ,CAGA,SAASmB,IACL,IAAIC,EAAOpC,KACPD,EAAIvC,EAAS4E,EAAKrC,GAAGN,QACrBQ,EAAIzC,EAAS4E,EAAKnC,GAAGR,QAErB2C,EAAKhC,UACLvE,EAAUC,EAAS,YAAalB,EAAhCiB,CAAsC2D,KAG1C4C,EAAKhC,UAAW,EAGhBpG,EAAOM,GAAqB,UAAW8H,EAAKC,MAC5CrI,EAAOM,GAAqB,WAAY8H,EAAKC,MAC7CrI,EAAOM,GAAqB,cAAe8H,EAAKC,MAChDrI,EAAOM,GAAqB,YAAa8H,EAAKE,MAC9CtI,EAAOM,GAAqB,YAAa8H,EAAKE,MAG9CF,EAAKC,KAAO,KACZD,EAAKE,KAAO,KAEZvC,EAAEzF,GAAqB,cAAeM,GACtCmF,EAAEzF,GAAqB,YAAaM,GACpCqF,EAAE3F,GAAqB,cAAeM,GACtCqF,EAAE3F,GAAqB,YAAaM,GAEpCmF,EAAE7E,MAAMqH,WAAa,GACrBxC,EAAE7E,MAAMsH,iBAAmB,GAC3BzC,EAAE7E,MAAMuH,cAAgB,GACxB1C,EAAE7E,MAAMwH,cAAgB,GAExBzC,EAAE/E,MAAMqH,WAAa,GACrBtC,EAAE/E,MAAMsH,iBAAmB,GAC3BvC,EAAE/E,MAAMuH,cAAgB,GACxBxC,EAAE/E,MAAMwH,cAAgB,GAExBN,EAAKpD,OAAO9D,MAAM6D,OAAS,GAC3BqD,EAAKxE,OAAO1C,MAAM6D,OAAS,GAC3B5E,EAASwI,KAAKzH,MAAM6D,OAAS,EACjC,CAKA,SAAS6D,EAAcjD,GAEnB,KAAI,WAAYA,IAAkB,IAAbA,EAAEkD,OAAvB,CAKA,IAAIT,EAAOpC,KACPD,EAAIvC,EAAS4E,EAAKrC,GAAGN,QACrBQ,EAAIzC,EAAS4E,EAAKnC,GAAGR,QAGpB2C,EAAKhC,UACNvE,EAAUC,EAAS,cAAelB,EAAlCiB,CAAwC2D,KAI5CG,EAAEmD,iBAGFV,EAAKhC,UAAW,EAIhBgC,EAAKE,KAAOnC,EAAK4C,KAAKX,GACtBA,EAAKC,KAAOF,EAAaY,KAAKX,GAG9BpI,EAAOK,GAAkB,UAAW+H,EAAKC,MACzCrI,EAAOK,GAAkB,WAAY+H,EAAKC,MAC1CrI,EAAOK,GAAkB,cAAe+H,EAAKC,MAC7CrI,EAAOK,GAAkB,YAAa+H,EAAKE,MAC3CtI,EAAOK,GAAkB,YAAa+H,EAAKE,MAG3CvC,EAAE1F,GAAkB,cAAeO,GACnCmF,EAAE1F,GAAkB,YAAaO,GACjCqF,EAAE5F,GAAkB,cAAeO,GACnCqF,EAAE5F,GAAkB,YAAaO,GAEjCmF,EAAE7E,MAAMqH,WAAa,OACrBxC,EAAE7E,MAAMsH,iBAAmB,OAC3BzC,EAAE7E,MAAMuH,cAAgB,OACxB1C,EAAE7E,MAAMwH,cAAgB,OAExBzC,EAAE/E,MAAMqH,WAAa,OACrBtC,EAAE/E,MAAMsH,iBAAmB,OAC3BvC,EAAE/E,MAAMuH,cAAgB,OACxBxC,EAAE/E,MAAMwH,cAAgB,OAGxBN,EAAKpD,OAAO9D,MAAM6D,OAASA,EAC3BqD,EAAKxE,OAAO1C,MAAM6D,OAASA,EAC3B5E,EAASwI,KAAKzH,MAAM6D,OAASA,EAG7B2B,EAAeD,KAAK2B,GAGpBA,EAAK9B,WAAaZ,EAAiBC,GAAKyC,EAAKvB,GAvD7C,CAwDJ,CAnXI/B,IAAcnE,GACdwC,EAAY,QACZC,EAAa,UACbC,EAAW,OACXC,EAAc,QACdC,EAAa,eACQ,aAAduB,IACP3B,EAAY,SACZC,EAAa,UACbC,EAAW,MACXC,EAAc,SACdC,EAAa,gBA2WjBW,EAAQ4C,EAAU5C,GAsBlB,IAAI8E,GAAQ,GAgGZ,SAASC,GAAYxD,GACjB,IAAIpD,EAASoD,EAAQjD,IAAMwG,GAAM5H,OAC7B8H,EAAO7G,EAAS2G,GAAMvD,EAAQjD,EAAI,GAAKwG,GAAMvD,EAAQjD,GAEzDkE,EAAeD,KAAKyC,GAEpB,IAAIpG,EAAOT,EACL6G,EAAKpG,KAAO2C,EAAQrB,QAAU8E,EAAKxI,GACnC+E,EAAQrB,QAAU8E,EAAKzI,GAE7BoF,EAAOY,KAAKyC,EAAMpG,EACtB,CA+DA,OAzKAU,EAAWC,EAAIU,KAAI,SAAUgF,EAAI3G,GAE7B,IASI0G,EATAzD,EAAU,CACVA,QAAShE,EAAkB0H,GAC3BrG,KAAMoB,EAAM1B,GACZ4B,QAASC,EAAS7B,GAClB+B,QAASE,EAASjC,GAClBmC,WAAYC,EAAYpC,GACxBA,EAAGA,GAKP,GAAIA,EAAI,KAEJ0G,EAAO,CACHnD,EAAGvD,EAAI,EACPyD,EAAGzD,EACH4D,UAAU,EACVtB,UAAWA,EACXlB,OAAQA,IAGPnD,GAAeyB,EAChBC,EACAK,EAAI,GAAM,GACV,EACAF,GAEJ4G,EAAKxI,GAAewB,EAChBC,GACA,EACAK,IAAMiB,EAAIrC,OAAS,EACnBkB,GAKwB,gBAAxB0B,GACwB,mBAAxBA,GACF,CACE,IAAIoF,EAAOF,EAAKnD,EAChBmD,EAAKnD,EAAImD,EAAKjD,EACdiD,EAAKjD,EAAImD,CACb,CAQJ,GAAI5G,EAAI,EAAG,CACP,IAAI6G,EAAgBrE,EAAOxC,EAAGsC,EAAWW,EAAQA,UA5ZzD,SAAuB4D,EAAetG,EAASP,GAC3C,IAAItB,EAAQgE,EAAY/B,EAAWJ,EAASP,GAE5C4C,OAAOC,KAAKnE,GAAOoE,SAAQ,SAAUC,GAEjC8D,EAAcnI,MAAMqE,GAAQrE,EAAMqE,EACtC,GACJ,CAsZQ+D,CAAcD,EAAelH,EAAYK,GAGzC0G,EAAK1I,GAAuBoI,EAAcG,KAAKG,GAG/CG,EAAchJ,GACV,YACA6I,EAAK1I,IAET6I,EAAchJ,GACV,aACA6I,EAAK1I,IAGToD,EAAO2F,aAAaF,EAAe5D,EAAQA,SAE3CyD,EAAKlE,OAASqE,CAClB,CAoBA,OAlBAlE,EACIM,EAAQA,QACRA,EAAQ3C,KACRZ,EACIC,EACM,IAANK,EACAA,IAAMiB,EAAIrC,OAAS,EACnBkB,GAEJE,GAKAA,EAAI,GACJwG,GAAMjB,KAAKmB,GAGRzD,CACX,KAeSH,SAAQ,SAAUG,GACvB,IAAI+D,EAAe/D,EAAQA,QAAQlF,KAAyB4C,GAExDqG,EAAe/D,EAAQrB,UACnBM,EACAuE,GAAYxD,GAGZA,EAAQrB,QAAUoF,EAG9B,IAkDO,CACHC,SAjDJ,SAAkBC,GACd,IAAIC,EAAU7C,EAAU4C,GACxBC,EAAQrE,SAAQ,SAAUsE,EAASpH,GAC/B,GAAIA,EAAI,EAAG,CACP,IAAI0G,EAAOF,GAAMxG,EAAI,GAEjBuD,EAAIvC,EAAS0F,EAAKnD,GAClBE,EAAIzC,EAAS0F,EAAKjD,GAEtBF,EAAEjD,KAAO6G,EAAQnH,EAAI,GACrByD,EAAEnD,KAAO8G,EAETzE,EAAeY,EAAEN,QAASM,EAAEjD,KAAMoG,EAAKzI,GAAcsF,EAAEvD,GACvD2C,EAAec,EAAER,QAASQ,EAAEnD,KAAMoG,EAAKxI,GAAcuF,EAAEzD,EAC3D,CACJ,GACJ,EAkCIgD,SAAUA,EACVqE,SAAU,SAAkBrH,GACxByG,GAAYzF,EAAShB,GACzB,EACAsH,QApCJ,SAAiBC,EAAgBC,GAC7BhB,GAAM1D,SAAQ,SAAU4D,GAcpB,IAbuB,IAAnBc,EACAd,EAAKtF,OAAOqG,YAAYf,EAAKlE,SAE7BkE,EAAKlE,OAAO1E,GACR,YACA4I,EAAK1I,IAET0I,EAAKlE,OAAO1E,GACR,aACA4I,EAAK1I,MAIU,IAAnBuJ,EAAyB,CACzB,IAAI7I,EAAQ+D,EACR9B,EACA+F,EAAKnD,EAAEjD,KACPoG,EAAKzI,IAGT2E,OAAOC,KAAKnE,GAAOoE,SAAQ,SAAUC,GACjC/B,EAAS0F,EAAKnD,GAAGN,QAAQvE,MAAMqE,GAAQ,GACvC/B,EAAS0F,EAAKjD,GAAGR,QAAQvE,MAAMqE,GAAQ,EAC3C,GACJ,CACJ,GACJ,EASI3B,OAAQA,EACRoF,MAAOA,GAEf,C","sources":["webpack://client-app/./node_modules/split.js/dist/split.es.js"],"sourcesContent":["// The programming goals of Split.js are to deliver readable, understandable and\n// maintainable code, while at the same time manually optimizing for tiny minified file size,\n// browser compatibility without additional requirements\n// and very few assumptions about the user's page layout.\nvar global = typeof window !== 'undefined' ? window : null;\nvar ssr = global === null;\nvar document = !ssr ? global.document : undefined;\n\n// Save a couple long function names that are used frequently.\n// This optimization saves around 400 bytes.\nvar addEventListener = 'addEventListener';\nvar removeEventListener = 'removeEventListener';\nvar getBoundingClientRect = 'getBoundingClientRect';\nvar gutterStartDragging = '_a';\nvar aGutterSize = '_b';\nvar bGutterSize = '_c';\nvar HORIZONTAL = 'horizontal';\nvar NOOP = function () { return false; };\n\n// Helper function determines which prefixes of CSS calc we need.\n// We only need to do this once on startup, when this anonymous function is called.\n//\n// Tests -webkit, -moz and -o prefixes. Modified from StackOverflow:\n// http://stackoverflow.com/questions/16625140/js-feature-detection-to-detect-the-usage-of-webkit-calc-over-calc/16625167#16625167\nvar calc = ssr\n    ? 'calc'\n    : ((['', '-webkit-', '-moz-', '-o-']\n          .filter(function (prefix) {\n              var el = document.createElement('div');\n              el.style.cssText = \"width:\" + prefix + \"calc(9px)\";\n\n              return !!el.style.length\n          })\n          .shift()) + \"calc\");\n\n// Helper function checks if its argument is a string-like type\nvar isString = function (v) { return typeof v === 'string' || v instanceof String; };\n\n// Helper function allows elements and string selectors to be used\n// interchangeably. In either case an element is returned. This allows us to\n// do `Split([elem1, elem2])` as well as `Split(['#id1', '#id2'])`.\nvar elementOrSelector = function (el) {\n    if (isString(el)) {\n        var ele = document.querySelector(el);\n        if (!ele) {\n            throw new Error((\"Selector \" + el + \" did not match a DOM element\"))\n        }\n        return ele\n    }\n\n    return el\n};\n\n// Helper function gets a property from the properties object, with a default fallback\nvar getOption = function (options, propName, def) {\n    var value = options[propName];\n    if (value !== undefined) {\n        return value\n    }\n    return def\n};\n\nvar getGutterSize = function (gutterSize, isFirst, isLast, gutterAlign) {\n    if (isFirst) {\n        if (gutterAlign === 'end') {\n            return 0\n        }\n        if (gutterAlign === 'center') {\n            return gutterSize / 2\n        }\n    } else if (isLast) {\n        if (gutterAlign === 'start') {\n            return 0\n        }\n        if (gutterAlign === 'center') {\n            return gutterSize / 2\n        }\n    }\n\n    return gutterSize\n};\n\n// Default options\nvar defaultGutterFn = function (i, gutterDirection) {\n    var gut = document.createElement('div');\n    gut.className = \"gutter gutter-\" + gutterDirection;\n    return gut\n};\n\nvar defaultElementStyleFn = function (dim, size, gutSize) {\n    var style = {};\n\n    if (!isString(size)) {\n        style[dim] = calc + \"(\" + size + \"% - \" + gutSize + \"px)\";\n    } else {\n        style[dim] = size;\n    }\n\n    return style\n};\n\nvar defaultGutterStyleFn = function (dim, gutSize) {\n    var obj;\n\n    return (( obj = {}, obj[dim] = (gutSize + \"px\"), obj ));\n};\n\n// The main function to initialize a split. Split.js thinks about each pair\n// of elements as an independant pair. Dragging the gutter between two elements\n// only changes the dimensions of elements in that pair. This is key to understanding\n// how the following functions operate, since each function is bound to a pair.\n//\n// A pair object is shaped like this:\n//\n// {\n//     a: DOM element,\n//     b: DOM element,\n//     aMin: Number,\n//     bMin: Number,\n//     dragging: Boolean,\n//     parent: DOM element,\n//     direction: 'horizontal' | 'vertical'\n// }\n//\n// The basic sequence:\n//\n// 1. Set defaults to something sane. `options` doesn't have to be passed at all.\n// 2. Initialize a bunch of strings based on the direction we're splitting.\n//    A lot of the behavior in the rest of the library is paramatized down to\n//    rely on CSS strings and classes.\n// 3. Define the dragging helper functions, and a few helpers to go with them.\n// 4. Loop through the elements while pairing them off. Every pair gets an\n//    `pair` object and a gutter.\n// 5. Actually size the pair elements, insert gutters and attach event listeners.\nvar Split = function (idsOption, options) {\n    if ( options === void 0 ) options = {};\n\n    if (ssr) { return {} }\n\n    var ids = idsOption;\n    var dimension;\n    var clientAxis;\n    var position;\n    var positionEnd;\n    var clientSize;\n    var elements;\n\n    // Allow HTMLCollection to be used as an argument when supported\n    if (Array.from) {\n        ids = Array.from(ids);\n    }\n\n    // All DOM elements in the split should have a common parent. We can grab\n    // the first elements parent and hope users read the docs because the\n    // behavior will be whacky otherwise.\n    var firstElement = elementOrSelector(ids[0]);\n    var parent = firstElement.parentNode;\n    var parentStyle = getComputedStyle ? getComputedStyle(parent) : null;\n    var parentFlexDirection = parentStyle ? parentStyle.flexDirection : null;\n\n    // Set default options.sizes to equal percentages of the parent element.\n    var sizes = getOption(options, 'sizes') || ids.map(function () { return 100 / ids.length; });\n\n    // Standardize minSize and maxSize to an array if it isn't already.\n    // This allows minSize and maxSize to be passed as a number.\n    var minSize = getOption(options, 'minSize', 100);\n    var minSizes = Array.isArray(minSize) ? minSize : ids.map(function () { return minSize; });\n    var maxSize = getOption(options, 'maxSize', Infinity);\n    var maxSizes = Array.isArray(maxSize) ? maxSize : ids.map(function () { return maxSize; });\n\n    // Get other options\n    var expandToMin = getOption(options, 'expandToMin', false);\n    var gutterSize = getOption(options, 'gutterSize', 10);\n    var gutterAlign = getOption(options, 'gutterAlign', 'center');\n    var snapOffset = getOption(options, 'snapOffset', 30);\n    var snapOffsets = Array.isArray(snapOffset) ? snapOffset : ids.map(function () { return snapOffset; });\n    var dragInterval = getOption(options, 'dragInterval', 1);\n    var direction = getOption(options, 'direction', HORIZONTAL);\n    var cursor = getOption(\n        options,\n        'cursor',\n        direction === HORIZONTAL ? 'col-resize' : 'row-resize'\n    );\n    var gutter = getOption(options, 'gutter', defaultGutterFn);\n    var elementStyle = getOption(\n        options,\n        'elementStyle',\n        defaultElementStyleFn\n    );\n    var gutterStyle = getOption(options, 'gutterStyle', defaultGutterStyleFn);\n\n    // 2. Initialize a bunch of strings based on the direction we're splitting.\n    // A lot of the behavior in the rest of the library is paramatized down to\n    // rely on CSS strings and classes.\n    if (direction === HORIZONTAL) {\n        dimension = 'width';\n        clientAxis = 'clientX';\n        position = 'left';\n        positionEnd = 'right';\n        clientSize = 'clientWidth';\n    } else if (direction === 'vertical') {\n        dimension = 'height';\n        clientAxis = 'clientY';\n        position = 'top';\n        positionEnd = 'bottom';\n        clientSize = 'clientHeight';\n    }\n\n    // 3. Define the dragging helper functions, and a few helpers to go with them.\n    // Each helper is bound to a pair object that contains its metadata. This\n    // also makes it easy to store references to listeners that that will be\n    // added and removed.\n    //\n    // Even though there are no other functions contained in them, aliasing\n    // this to self saves 50 bytes or so since it's used so frequently.\n    //\n    // The pair object saves metadata like dragging state, position and\n    // event listener references.\n\n    function setElementSize(el, size, gutSize, i) {\n        // Split.js allows setting sizes via numbers (ideally), or if you must,\n        // by string, like '300px'. This is less than ideal, because it breaks\n        // the fluid layout that `calc(% - px)` provides. You're on your own if you do that,\n        // make sure you calculate the gutter size by hand.\n        var style = elementStyle(dimension, size, gutSize, i);\n\n        Object.keys(style).forEach(function (prop) {\n            // eslint-disable-next-line no-param-reassign\n            el.style[prop] = style[prop];\n        });\n    }\n\n    function setGutterSize(gutterElement, gutSize, i) {\n        var style = gutterStyle(dimension, gutSize, i);\n\n        Object.keys(style).forEach(function (prop) {\n            // eslint-disable-next-line no-param-reassign\n            gutterElement.style[prop] = style[prop];\n        });\n    }\n\n    function getSizes() {\n        return elements.map(function (element) { return element.size; })\n    }\n\n    // Supports touch events, but not multitouch, so only the first\n    // finger `touches[0]` is counted.\n    function getMousePosition(e) {\n        if ('touches' in e) { return e.touches[0][clientAxis] }\n        return e[clientAxis]\n    }\n\n    // Actually adjust the size of elements `a` and `b` to `offset` while dragging.\n    // calc is used to allow calc(percentage + gutterpx) on the whole split instance,\n    // which allows the viewport to be resized without additional logic.\n    // Element a's size is the same as offset. b's size is total size - a size.\n    // Both sizes are calculated from the initial parent percentage,\n    // then the gutter size is subtracted.\n    function adjust(offset) {\n        var a = elements[this.a];\n        var b = elements[this.b];\n        var percentage = a.size + b.size;\n\n        a.size = (offset / this.size) * percentage;\n        b.size = percentage - (offset / this.size) * percentage;\n\n        setElementSize(a.element, a.size, this[aGutterSize], a.i);\n        setElementSize(b.element, b.size, this[bGutterSize], b.i);\n    }\n\n    // drag, where all the magic happens. The logic is really quite simple:\n    //\n    // 1. Ignore if the pair is not dragging.\n    // 2. Get the offset of the event.\n    // 3. Snap offset to min if within snappable range (within min + snapOffset).\n    // 4. Actually adjust each element in the pair to offset.\n    //\n    // ---------------------------------------------------------------------\n    // |    | <- a.minSize               ||              b.minSize -> |    |\n    // |    |  | <- this.snapOffset      ||     this.snapOffset -> |  |    |\n    // |    |  |                         ||                        |  |    |\n    // |    |  |                         ||                        |  |    |\n    // ---------------------------------------------------------------------\n    // | <- this.start                                        this.size -> |\n    function drag(e) {\n        var offset;\n        var a = elements[this.a];\n        var b = elements[this.b];\n\n        if (!this.dragging) { return }\n\n        // Get the offset of the event from the first side of the\n        // pair `this.start`. Then offset by the initial position of the\n        // mouse compared to the gutter size.\n        offset =\n            getMousePosition(e) -\n            this.start +\n            (this[aGutterSize] - this.dragOffset);\n\n        if (dragInterval > 1) {\n            offset = Math.round(offset / dragInterval) * dragInterval;\n        }\n\n        // If within snapOffset of min or max, set offset to min or max.\n        // snapOffset buffers a.minSize and b.minSize, so logic is opposite for both.\n        // Include the appropriate gutter sizes to prevent overflows.\n        if (offset <= a.minSize + a.snapOffset + this[aGutterSize]) {\n            offset = a.minSize + this[aGutterSize];\n        } else if (\n            offset >=\n            this.size - (b.minSize + b.snapOffset + this[bGutterSize])\n        ) {\n            offset = this.size - (b.minSize + this[bGutterSize]);\n        }\n\n        if (offset >= a.maxSize - a.snapOffset + this[aGutterSize]) {\n            offset = a.maxSize + this[aGutterSize];\n        } else if (\n            offset <=\n            this.size - (b.maxSize - b.snapOffset + this[bGutterSize])\n        ) {\n            offset = this.size - (b.maxSize + this[bGutterSize]);\n        }\n\n        // Actually adjust the size.\n        adjust.call(this, offset);\n\n        // Call the drag callback continously. Don't do anything too intensive\n        // in this callback.\n        getOption(options, 'onDrag', NOOP)(getSizes());\n    }\n\n    // Cache some important sizes when drag starts, so we don't have to do that\n    // continously:\n    //\n    // `size`: The total size of the pair. First + second + first gutter + second gutter.\n    // `start`: The leading side of the first element.\n    //\n    // ------------------------------------------------\n    // |      aGutterSize -> |||                      |\n    // |                     |||                      |\n    // |                     |||                      |\n    // |                     ||| <- bGutterSize       |\n    // ------------------------------------------------\n    // | <- start                             size -> |\n    function calculateSizes() {\n        // Figure out the parent size minus padding.\n        var a = elements[this.a].element;\n        var b = elements[this.b].element;\n\n        var aBounds = a[getBoundingClientRect]();\n        var bBounds = b[getBoundingClientRect]();\n\n        this.size =\n            aBounds[dimension] +\n            bBounds[dimension] +\n            this[aGutterSize] +\n            this[bGutterSize];\n        this.start = aBounds[position];\n        this.end = aBounds[positionEnd];\n    }\n\n    function innerSize(element) {\n        // Return nothing if getComputedStyle is not supported (< IE9)\n        // Or if parent element has no layout yet\n        if (!getComputedStyle) { return null }\n\n        var computedStyle = getComputedStyle(element);\n\n        if (!computedStyle) { return null }\n\n        var size = element[clientSize];\n\n        if (size === 0) { return null }\n\n        if (direction === HORIZONTAL) {\n            size -=\n                parseFloat(computedStyle.paddingLeft) +\n                parseFloat(computedStyle.paddingRight);\n        } else {\n            size -=\n                parseFloat(computedStyle.paddingTop) +\n                parseFloat(computedStyle.paddingBottom);\n        }\n\n        return size\n    }\n\n    // When specifying percentage sizes that are less than the computed\n    // size of the element minus the gutter, the lesser percentages must be increased\n    // (and decreased from the other elements) to make space for the pixels\n    // subtracted by the gutters.\n    function trimToMin(sizesToTrim) {\n        // Try to get inner size of parent element.\n        // If it's no supported, return original sizes.\n        var parentSize = innerSize(parent);\n        if (parentSize === null) {\n            return sizesToTrim\n        }\n\n        if (minSizes.reduce(function (a, b) { return a + b; }, 0) > parentSize) {\n            return sizesToTrim\n        }\n\n        // Keep track of the excess pixels, the amount of pixels over the desired percentage\n        // Also keep track of the elements with pixels to spare, to decrease after if needed\n        var excessPixels = 0;\n        var toSpare = [];\n\n        var pixelSizes = sizesToTrim.map(function (size, i) {\n            // Convert requested percentages to pixel sizes\n            var pixelSize = (parentSize * size) / 100;\n            var elementGutterSize = getGutterSize(\n                gutterSize,\n                i === 0,\n                i === sizesToTrim.length - 1,\n                gutterAlign\n            );\n            var elementMinSize = minSizes[i] + elementGutterSize;\n\n            // If element is too smal, increase excess pixels by the difference\n            // and mark that it has no pixels to spare\n            if (pixelSize < elementMinSize) {\n                excessPixels += elementMinSize - pixelSize;\n                toSpare.push(0);\n                return elementMinSize\n            }\n\n            // Otherwise, mark the pixels it has to spare and return it's original size\n            toSpare.push(pixelSize - elementMinSize);\n            return pixelSize\n        });\n\n        // If nothing was adjusted, return the original sizes\n        if (excessPixels === 0) {\n            return sizesToTrim\n        }\n\n        return pixelSizes.map(function (pixelSize, i) {\n            var newPixelSize = pixelSize;\n\n            // While there's still pixels to take, and there's enough pixels to spare,\n            // take as many as possible up to the total excess pixels\n            if (excessPixels > 0 && toSpare[i] - excessPixels > 0) {\n                var takenPixels = Math.min(\n                    excessPixels,\n                    toSpare[i] - excessPixels\n                );\n\n                // Subtract the amount taken for the next iteration\n                excessPixels -= takenPixels;\n                newPixelSize = pixelSize - takenPixels;\n            }\n\n            // Return the pixel size adjusted as a percentage\n            return (newPixelSize / parentSize) * 100\n        })\n    }\n\n    // stopDragging is very similar to startDragging in reverse.\n    function stopDragging() {\n        var self = this;\n        var a = elements[self.a].element;\n        var b = elements[self.b].element;\n\n        if (self.dragging) {\n            getOption(options, 'onDragEnd', NOOP)(getSizes());\n        }\n\n        self.dragging = false;\n\n        // Remove the stored event listeners. This is why we store them.\n        global[removeEventListener]('mouseup', self.stop);\n        global[removeEventListener]('touchend', self.stop);\n        global[removeEventListener]('touchcancel', self.stop);\n        global[removeEventListener]('mousemove', self.move);\n        global[removeEventListener]('touchmove', self.move);\n\n        // Clear bound function references\n        self.stop = null;\n        self.move = null;\n\n        a[removeEventListener]('selectstart', NOOP);\n        a[removeEventListener]('dragstart', NOOP);\n        b[removeEventListener]('selectstart', NOOP);\n        b[removeEventListener]('dragstart', NOOP);\n\n        a.style.userSelect = '';\n        a.style.webkitUserSelect = '';\n        a.style.MozUserSelect = '';\n        a.style.pointerEvents = '';\n\n        b.style.userSelect = '';\n        b.style.webkitUserSelect = '';\n        b.style.MozUserSelect = '';\n        b.style.pointerEvents = '';\n\n        self.gutter.style.cursor = '';\n        self.parent.style.cursor = '';\n        document.body.style.cursor = '';\n    }\n\n    // startDragging calls `calculateSizes` to store the inital size in the pair object.\n    // It also adds event listeners for mouse/touch events,\n    // and prevents selection while dragging so avoid the selecting text.\n    function startDragging(e) {\n        // Right-clicking can't start dragging.\n        if ('button' in e && e.button !== 0) {\n            return\n        }\n\n        // Alias frequently used variables to save space. 200 bytes.\n        var self = this;\n        var a = elements[self.a].element;\n        var b = elements[self.b].element;\n\n        // Call the onDragStart callback.\n        if (!self.dragging) {\n            getOption(options, 'onDragStart', NOOP)(getSizes());\n        }\n\n        // Don't actually drag the element. We emulate that in the drag function.\n        e.preventDefault();\n\n        // Set the dragging property of the pair object.\n        self.dragging = true;\n\n        // Create two event listeners bound to the same pair object and store\n        // them in the pair object.\n        self.move = drag.bind(self);\n        self.stop = stopDragging.bind(self);\n\n        // All the binding. `window` gets the stop events in case we drag out of the elements.\n        global[addEventListener]('mouseup', self.stop);\n        global[addEventListener]('touchend', self.stop);\n        global[addEventListener]('touchcancel', self.stop);\n        global[addEventListener]('mousemove', self.move);\n        global[addEventListener]('touchmove', self.move);\n\n        // Disable selection. Disable!\n        a[addEventListener]('selectstart', NOOP);\n        a[addEventListener]('dragstart', NOOP);\n        b[addEventListener]('selectstart', NOOP);\n        b[addEventListener]('dragstart', NOOP);\n\n        a.style.userSelect = 'none';\n        a.style.webkitUserSelect = 'none';\n        a.style.MozUserSelect = 'none';\n        a.style.pointerEvents = 'none';\n\n        b.style.userSelect = 'none';\n        b.style.webkitUserSelect = 'none';\n        b.style.MozUserSelect = 'none';\n        b.style.pointerEvents = 'none';\n\n        // Set the cursor at multiple levels\n        self.gutter.style.cursor = cursor;\n        self.parent.style.cursor = cursor;\n        document.body.style.cursor = cursor;\n\n        // Cache the initial sizes of the pair.\n        calculateSizes.call(self);\n\n        // Determine the position of the mouse compared to the gutter\n        self.dragOffset = getMousePosition(e) - self.end;\n    }\n\n    // adjust sizes to ensure percentage is within min size and gutter.\n    sizes = trimToMin(sizes);\n\n    // 5. Create pair and element objects. Each pair has an index reference to\n    // elements `a` and `b` of the pair (first and second elements).\n    // Loop through the elements while pairing them off. Every pair gets a\n    // `pair` object and a gutter.\n    //\n    // Basic logic:\n    //\n    // - Starting with the second element `i > 0`, create `pair` objects with\n    //   `a = i - 1` and `b = i`\n    // - Set gutter sizes based on the _pair_ being first/last. The first and last\n    //   pair have gutterSize / 2, since they only have one half gutter, and not two.\n    // - Create gutter elements and add event listeners.\n    // - Set the size of the elements, minus the gutter sizes.\n    //\n    // -----------------------------------------------------------------------\n    // |     i=0     |         i=1         |        i=2       |      i=3     |\n    // |             |                     |                  |              |\n    // |           pair 0                pair 1             pair 2           |\n    // |             |                     |                  |              |\n    // -----------------------------------------------------------------------\n    var pairs = [];\n    elements = ids.map(function (id, i) {\n        // Create the element object.\n        var element = {\n            element: elementOrSelector(id),\n            size: sizes[i],\n            minSize: minSizes[i],\n            maxSize: maxSizes[i],\n            snapOffset: snapOffsets[i],\n            i: i,\n        };\n\n        var pair;\n\n        if (i > 0) {\n            // Create the pair object with its metadata.\n            pair = {\n                a: i - 1,\n                b: i,\n                dragging: false,\n                direction: direction,\n                parent: parent,\n            };\n\n            pair[aGutterSize] = getGutterSize(\n                gutterSize,\n                i - 1 === 0,\n                false,\n                gutterAlign\n            );\n            pair[bGutterSize] = getGutterSize(\n                gutterSize,\n                false,\n                i === ids.length - 1,\n                gutterAlign\n            );\n\n            // if the parent has a reverse flex-direction, switch the pair elements.\n            if (\n                parentFlexDirection === 'row-reverse' ||\n                parentFlexDirection === 'column-reverse'\n            ) {\n                var temp = pair.a;\n                pair.a = pair.b;\n                pair.b = temp;\n            }\n        }\n\n        // Determine the size of the current element. IE8 is supported by\n        // staticly assigning sizes without draggable gutters. Assigns a string\n        // to `size`.\n        //\n        // Create gutter elements for each pair.\n        if (i > 0) {\n            var gutterElement = gutter(i, direction, element.element);\n            setGutterSize(gutterElement, gutterSize, i);\n\n            // Save bound event listener for removal later\n            pair[gutterStartDragging] = startDragging.bind(pair);\n\n            // Attach bound event listener\n            gutterElement[addEventListener](\n                'mousedown',\n                pair[gutterStartDragging]\n            );\n            gutterElement[addEventListener](\n                'touchstart',\n                pair[gutterStartDragging]\n            );\n\n            parent.insertBefore(gutterElement, element.element);\n\n            pair.gutter = gutterElement;\n        }\n\n        setElementSize(\n            element.element,\n            element.size,\n            getGutterSize(\n                gutterSize,\n                i === 0,\n                i === ids.length - 1,\n                gutterAlign\n            ),\n            i\n        );\n\n        // After the first iteration, and we have a pair object, append it to the\n        // list of pairs.\n        if (i > 0) {\n            pairs.push(pair);\n        }\n\n        return element\n    });\n\n    function adjustToMin(element) {\n        var isLast = element.i === pairs.length;\n        var pair = isLast ? pairs[element.i - 1] : pairs[element.i];\n\n        calculateSizes.call(pair);\n\n        var size = isLast\n            ? pair.size - element.minSize - pair[bGutterSize]\n            : element.minSize + pair[aGutterSize];\n\n        adjust.call(pair, size);\n    }\n\n    elements.forEach(function (element) {\n        var computedSize = element.element[getBoundingClientRect]()[dimension];\n\n        if (computedSize < element.minSize) {\n            if (expandToMin) {\n                adjustToMin(element);\n            } else {\n                // eslint-disable-next-line no-param-reassign\n                element.minSize = computedSize;\n            }\n        }\n    });\n\n    function setSizes(newSizes) {\n        var trimmed = trimToMin(newSizes);\n        trimmed.forEach(function (newSize, i) {\n            if (i > 0) {\n                var pair = pairs[i - 1];\n\n                var a = elements[pair.a];\n                var b = elements[pair.b];\n\n                a.size = trimmed[i - 1];\n                b.size = newSize;\n\n                setElementSize(a.element, a.size, pair[aGutterSize], a.i);\n                setElementSize(b.element, b.size, pair[bGutterSize], b.i);\n            }\n        });\n    }\n\n    function destroy(preserveStyles, preserveGutter) {\n        pairs.forEach(function (pair) {\n            if (preserveGutter !== true) {\n                pair.parent.removeChild(pair.gutter);\n            } else {\n                pair.gutter[removeEventListener](\n                    'mousedown',\n                    pair[gutterStartDragging]\n                );\n                pair.gutter[removeEventListener](\n                    'touchstart',\n                    pair[gutterStartDragging]\n                );\n            }\n\n            if (preserveStyles !== true) {\n                var style = elementStyle(\n                    dimension,\n                    pair.a.size,\n                    pair[aGutterSize]\n                );\n\n                Object.keys(style).forEach(function (prop) {\n                    elements[pair.a].element.style[prop] = '';\n                    elements[pair.b].element.style[prop] = '';\n                });\n            }\n        });\n    }\n\n    return {\n        setSizes: setSizes,\n        getSizes: getSizes,\n        collapse: function collapse(i) {\n            adjustToMin(elements[i]);\n        },\n        destroy: destroy,\n        parent: parent,\n        pairs: pairs,\n    }\n};\n\nexport default Split;\n"],"names":["global","window","ssr","document","undefined","addEventListener","removeEventListener","getBoundingClientRect","gutterStartDragging","aGutterSize","bGutterSize","HORIZONTAL","NOOP","calc","filter","prefix","el","createElement","style","cssText","length","shift","isString","v","String","elementOrSelector","ele","querySelector","Error","getOption","options","propName","def","value","getGutterSize","gutterSize","isFirst","isLast","gutterAlign","defaultGutterFn","i","gutterDirection","gut","className","defaultElementStyleFn","dim","size","gutSize","defaultGutterStyleFn","obj","idsOption","dimension","clientAxis","position","positionEnd","clientSize","elements","ids","Array","from","parent","parentNode","parentStyle","getComputedStyle","parentFlexDirection","flexDirection","sizes","map","minSize","minSizes","isArray","maxSize","Infinity","maxSizes","expandToMin","snapOffset","snapOffsets","dragInterval","direction","cursor","gutter","elementStyle","gutterStyle","setElementSize","Object","keys","forEach","prop","getSizes","element","getMousePosition","e","touches","adjust","offset","a","this","b","percentage","drag","dragging","start","dragOffset","Math","round","call","calculateSizes","aBounds","bBounds","end","trimToMin","sizesToTrim","parentSize","computedStyle","parseFloat","paddingLeft","paddingRight","paddingTop","paddingBottom","innerSize","reduce","excessPixels","toSpare","pixelSizes","pixelSize","elementGutterSize","elementMinSize","push","newPixelSize","takenPixels","min","stopDragging","self","stop","move","userSelect","webkitUserSelect","MozUserSelect","pointerEvents","body","startDragging","button","preventDefault","bind","pairs","adjustToMin","pair","id","temp","gutterElement","setGutterSize","insertBefore","computedSize","setSizes","newSizes","trimmed","newSize","collapse","destroy","preserveStyles","preserveGutter","removeChild"],"sourceRoot":""}